trackplot 0.6.3__tar.gz → 0.6.5__tar.gz

{trackplot-0.6.3/trackplot.egg-info → trackplot-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trackplot
-Version: 0.6.3
+Version: 0.6.5
 Summary: The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/
 Author-email: ygidtu <ygidtu@gmail.com>
 License-Expression: BSD-3-Clause

{trackplot-0.6.3 → trackplot-0.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trackplot"
-version = "0.6.3"
+version = "0.6.5"
 description = "The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/"
 authors = [
     { name = "ygidtu", email = "ygidtu@gmail.com" }
@@ -29,6 +29,9 @@ dependencies = [
 ]
 
 
+[project.scripts]
+trackplot = "trackplot.cli:main"  # 假设入口在 trackplot/cli.py 的 main 函数
+
 [build-system]
 requires = ["setuptools>=65.0", "wheel"]
 build-backend = "setuptools.build_meta"

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot/cli.py

@@ -1214,6 +1214,30 @@ def _add_interval(p, f):
 @optgroup.option(
     "--title", type=click.STRING, default=None, help="Title", show_default=True
 )
+@optgroup.option(
+    "--no-title",
+    type=click.BOOL,
+    is_flag=True,
+    default=False,
+    help="Disable the plot title entirely",
+    show_default=True,
+)
+@optgroup.option(
+    "--no-region-text",
+    type=click.BOOL,
+    is_flag=True,
+    default=False,
+    help="Disable the --event region text on the x-axis ruler",
+    show_default=True,
+)
+@optgroup.option(
+    "--junctions-on-top",
+    type=click.BOOL,
+    is_flag=True,
+    default=False,
+    help="Force all junction arcs to be drawn above the density plot (only effective when --density-by-strand is not set)",
+    show_default=True,
+)
 @optgroup.option(
     "--font", type=click.STRING, default=None, help="Fonts", show_default=True
 )
@@ -1362,6 +1386,10 @@ def main(**kwargs):
         normalize_format=kwargs.get("normalize_format"),
         fill_step=kwargs.get("fill_step", "post"),
         smooth_bin=kwargs["smooth_bin"],
+        title=kwargs["title"],
+        no_title=kwargs["no_title"],
+        no_region_text=kwargs["no_region_text"],
+        junctions_on_top=kwargs["junctions_on_top"],
     )
 
 

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot/plot/coord.py

@@ -40,31 +40,45 @@ def init_graph_coords(
 
     if exons:
         if intron_scale <= 1:
+            # 填充首个外显子前的内含子区域
             for i in range(0, exons[0][0] - region.start):
                 graph_coords[i] = (i - 0) * intron_scale
             exons = __merge_exons__(exons)
             for i in range(0, len(exons)):
                 exon = exons[i]
+
+                # 外显子间内含子（从上一个外显子结束的下一碱基开始，避免重叠）
                 if i > 0:
-                    intron = [exons[i - 1][1], exons[i][0]]
-                    for j in range(intron[0], intron[1]):
+                    intron_start = exons[i - 1][1] + 1
+                    intron_end = exons[i][0]
+                    for j in range(intron_start, intron_end):
                         if j >= region.start:
                             graph_coords[j - region.start] = (
-                                graph_coords[intron[0] - region.start - 1]
-                                + (j - intron[0] + 1) * intron_scale
+                                graph_coords[intron_start - region.start - 1]
+                                + (j - intron_start + 1) * intron_scale
                             )
+
+                # 填充外显子区域
                 for j in range(exon[0], exon[1] + 1):
                     if j >= region.start:
-                        graph_coords[j - region.start] = (
-                            graph_coords[exon[0] - region.start - 1]
-                            + (j - exon[0] + 1) * exon_scale
-                        )
-            intron = [exons[-1][-1], region.end]
-            for i in range(intron[0], intron[1]):
+                        base_idx = exon[0] - region.start - 1
+                        if base_idx < 0:
+                            # 外显子起始位置在区域起点之前或等于起点，从 0 开始
+                            graph_coords[j - region.start] = (j - region.start) * exon_scale
+                        else:
+                            graph_coords[j - region.start] = (
+                                graph_coords[base_idx]
+                                + (j - exon[0] + 1) * exon_scale
+                            )
+
+            # 填充最后一个外显子之后的内含子（从下一碱基开始，到 region.end 结束）
+            intron_start = exons[-1][-1] + 1
+            intron_end = region.end + 1  # +1 确保包含 region.end
+            for i in range(intron_start, intron_end):
                 if i >= region.start:
                     graph_coords[i - region.start] = (
-                        graph_coords[intron[0] - region.start - 1]
-                        + (i - intron[0] + 1) * intron_scale
+                        graph_coords[intron_start - region.start - 1]
+                        + (i - intron_start + 1) * intron_scale
                     )
         else:
             exons = __merge_exons__(exons)
@@ -85,14 +99,14 @@ def init_graph_coords(
                 for i in range(exons[0][0]):
                     steps[i] = step
             for e in range(1, len(exons)):
-                interval = exons[e][0] - exons[e - 1][1] - 2
+                interval = exons[e][0] - exons[e - 1][1] - 1
                 step = intron_scale / interval
-                for i in range(exons[e - 1][1], exons[e][0]):
+                for i in range(exons[e - 1][1] + 1, exons[e][0]):
                     steps[i] = step
 
             if last_interval := len(region) - exons[-1][1] - 1:
                 step = intron_scale / last_interval
-                for i in range(exons[1][1] + 1, len(region)):
+                for i in range(exons[-1][1] + 1, len(region)):
                     steps[i] = step
             graph_coords = list(map(int, itertools.accumulate(steps)))
     else:
@@ -134,14 +148,17 @@ def set_x_ticks(
         x_label = f"{x_label}, y axis is {log_trans} transformed"
 
     ax.hlines(y=0, xmin=0, xmax=max(graph_coords), color="black", lw=1)
-    ax.text(
-        x=graph_coords[len(graph_coords) // 2],
-        y=-2.8,
-        s=x_label,
-        fontsize=font_size,
-        ha="center",
-        va="top",
-    )
+
+    no_region_text = kwargs.pop("no_region_text", False)
+    if not no_region_text:
+        ax.text(
+            x=graph_coords[len(graph_coords) // 2],
+            y=-2.8,
+            s=x_label,
+            fontsize=font_size,
+            ha="center",
+            va="top",
+        )
 
     bk = 1
     if not sequence and nx_ticks > 1:

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot/plot/core.py

@@ -866,20 +866,25 @@ class Plot(object):
         return default_y
 
     def _precompute_plot_y_limits(
-        self, p, max_used_y_dict, min_used_y_dict, same_y_by_groups, default_y, **kwargs
+        self, p, max_used_y_dict, min_used_y_dict, base_max_dict, same_y_by_groups, default_y, **kwargs
     ):
-        """Compute and store y-limits for all objects in a plot."""
+        """Compute and store y-limits for all objects in a plot.
+
+        Also collects base_max (raw data maximum) per object path for use as
+        a global arc-height reference in --same-y mode.
+        """
         if p.type not in ("density", "site-plot", "line"):
             return
 
         for obj in p.obj:
-            _max, _min = precompute_y_limits(
+            _max, _min, _base = precompute_y_limits(
                 obj,
                 data=obj.data,
                 region=self.region,
                 graph_coords=self.graph_coords,
                 **kwargs,
             )
+            base_max_dict[obj.path] = max(_base, base_max_dict.get(obj.path, 0))
 
             if obj.label in same_y_by_groups:
                 key = same_y_by_groups[obj.label]
@@ -890,10 +895,11 @@ class Plot(object):
                     if obj.data.minus is None
                     else min_used_y_dict.get(obj.path, 0),
                 )
+                base_max_dict[key] = max(_base, base_max_dict.get(key, 0))
 
             if isinstance(obj.data, dict):
                 for key, readDepth in obj.data.items():
-                    _max, _min = precompute_y_limits(
+                    _max, _min, _base = precompute_y_limits(
                         obj,
                         data=readDepth,
                         graph_coords=self.graph_coords,
@@ -907,6 +913,7 @@ class Plot(object):
                         if readDepth.minus is None
                         else min_used_y_dict.get(obj.path, 0),
                     )
+                    base_max_dict[key] = max(_base, base_max_dict.get(key, 0))
 
                 continue
 
@@ -928,21 +935,29 @@ class Plot(object):
                     min_used_y_dict[key] = min_used_y_dict[obj.path]
 
     def _resolve_plot_y_limits(
-        self, p, max_used_y_val, min_used_y_val, same_y_by_groups, default_y, **kwargs
+        self, p, max_used_y_val, min_used_y_val, base_max_val, same_y_by_groups, default_y, **kwargs
     ):
-        """Determine y-limits for a single plot based on same-y / default-y settings."""
+        """Determine y-limits for a single plot based on same-y / default-y settings.
+
+        Returns (max_y, min_y, global_base_max).
+        global_base_max is the max of all base_max values (for --same-y mode),
+        used as the arc height reference so all panels share consistent arc heights.
+        """
         same_y_sc = kwargs.get("same_y_sc")
         same_y = kwargs.get("same_y")
 
         if same_y_sc and p.obj[0].is_single_cell:
-            return max_used_y_val.get(p.obj[0].path), min_used_y_val.get(p.obj[0].path)
+            _bm = base_max_val.get(p.obj[0].path) if base_max_val else None
+            return max_used_y_val.get(p.obj[0].path), min_used_y_val.get(p.obj[0].path), _bm
 
         if same_y_by_groups and p.obj[0].label in same_y_by_groups:
             key = same_y_by_groups[p.obj[0].label]
-            return max_used_y_val.get(key), min_used_y_val.get(key)
+            _bm = base_max_val.get(key) if base_max_val else None
+            return max_used_y_val.get(key), min_used_y_val.get(key), _bm
 
         if same_y and max_used_y_val:
-            return max(max_used_y_val.values()), min(min_used_y_val.values())
+            _bm = max(base_max_val.values()) if base_max_val else None
+            return max(max_used_y_val.values()), min(min_used_y_val.values()), _bm
 
         if default_y and p.type in ("density", "site-plot", "line"):
             for obj in p.obj:
@@ -956,8 +971,8 @@ class Plot(object):
                     if same_y_by_groups and obj.label in same_y_by_groups:
                         max_y = max_used_y_val.get(obj.path, max_y)
                         min_y = min_used_y_val.get(obj.path, min_y)
-                    return max_y, min_y
-        return None, None
+                    return max_y, min_y, None
+        return None, None, None
 
     # ------------------------------------------------------------------
     # Main plot method
@@ -986,6 +1001,11 @@ class Plot(object):
 
         igv_height_scale = kwargs.get("igv_height_scale")
 
+        # Extract / pop custom params before they flow into downstream **kwargs
+        title = kwargs.pop("title", None)
+        no_title = kwargs.pop("no_title", False)
+        junctions_on_top = kwargs.pop("junctions_on_top", False)
+
         # ====== Phase 1: Load data ======
         self._load_plot_data(n_jobs, *args, **kwargs)
 
@@ -1010,7 +1030,7 @@ class Plot(object):
         )
 
         # ====== Phase 4: Precompute global y-limits ======
-        max_used_y_val, min_used_y_val = {}, {}
+        max_used_y_val, min_used_y_val, base_max_val = {}, {}, {}
         same_y_by_groups = {}
         default_y = self._load_default_y(kwargs.get("y_limit"))
 
@@ -1034,6 +1054,7 @@ class Plot(object):
                     p,
                     max_used_y_val,
                     min_used_y_val,
+                    base_max_val,
                     same_y_by_groups,
                     default_y,
                     **kwargs,
@@ -1048,25 +1069,30 @@ class Plot(object):
             else:
                 ax_var = plt.subplot(gs[curr_idx, 0])
 
-            if curr_idx == 0:
-                ax_var.set_title(str(self.region), loc="left")
+            if curr_idx == 0 and not no_title:
+                ax_var.set_title(title or str(self.region), loc="left")
 
-            max_y_val_, min_y_val_ = self._resolve_plot_y_limits(
+            max_y_val_, min_y_val_, base_max_ = self._resolve_plot_y_limits(
                 p,
                 max_used_y_val,
                 min_used_y_val,
+                base_max_val,
                 same_y_by_groups,
                 default_y,
                 same_y_sc=kwargs.get("same_y_sc"),
                 same_y=kwargs.get("same_y"),
             )
-            
+
             if max_y_val_ is not None:
                 max_y_val_ *= 1.1
-            
+
             if min_y_val_ is not None:
                 min_y_val_ *= 1.1
 
+            # For --same-y mode: use global base_max as arc height reference
+            # so all panels draw junctions at a consistent scale.
+            global_arc_ref = base_max_
+
             logger.info(
                 f"plotting {p.type} at idx: {curr_idx} with height_ratio: {height_ratio[curr_idx]}"
             )
@@ -1088,6 +1114,8 @@ class Plot(object):
                             distance_between_label_axis=distance_between_label_axis,
                             raster=raster,
                             fill_step=fill_step,
+                            junctions_on_top=junctions_on_top,
+                            global_arc_ref=global_arc_ref,
                             **temp_params,
                         )
                         curr_idx += 1
@@ -1103,6 +1131,8 @@ class Plot(object):
                         distance_between_label_axis=distance_between_label_axis,
                         raster=raster,
                         fill_step=fill_step,
+                        junctions_on_top=junctions_on_top,
+                        global_arc_ref=global_arc_ref,
                         **self.params.get(p, {}),
                     )
             elif p.type == "hic":
@@ -1123,6 +1153,8 @@ class Plot(object):
                     min_used_y_val=min_y_val_,
                     distance_between_label_axis=distance_between_label_axis,
                     raster=raster,
+                    junctions_on_top=junctions_on_top,
+                    global_arc_ref=global_arc_ref,
                     **self.params.get(p, {}),
                 )
                 curr_idx += 1

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot/plot/limits.py

@@ -26,14 +26,17 @@ def _compute_y_limits(
     density_by_strand: bool = False,
     fill_step: str = "post",
     show_mean_jxn_number: bool = False,
-) -> Tuple[float, float]:
+    junctions_on_top: bool = False,
+) -> Tuple[float, float, float]:
     """
     Compute y-axis limits from ReadDepth data, including junction arc extents.
 
     This is the shared core used by both precompute_y_limits() and plot_density()
     to avoid code duplication.
 
-    Returns (max_used_y_val, min_used_y_val).
+    Returns (max_used_y_val, min_used_y_val, base_max).
+    base_max is the raw data maximum before junction arc expansion, used as
+    arc height reference for --same-y cross-panel consistency.
     """
     # --- Determine data-driven baseline values for arc height ---
     # These baselines capture the "true" data range before junction expansion.
@@ -69,19 +72,15 @@ def _compute_y_limits(
     if min_used_y_val is None:
         min_used_y_val = base_min
 
-    # --- Arc heights: use the LARGER of (data baseline, incoming y-limit) ---
-    # In --same-y mode, max_used_y_val may be the global limit (much larger than
-    # this panel's own baseline).  We want the arcs to look proportional to the
-    # visible axis range, so we take max(baseline, incoming_limit).
+    # --- Arc heights: always based on the data baseline ---
+    # Previously this used max(base_max, max_used_y_val) which caused
+    # arc height inflation when max_used_y_val was already expanded by
+    # the precompute step.  The inflated arc peak then exceeded the
+    # y-axis limit and overflowed the panel.
+    # Use base_max / base_min exclusively — the limit expansion logic
+    # below still ensures the axis range grows to accommodate the arcs.
     _arc_ref_max = base_max
-    if max_used_y_val is not None:
-        _arc_ref_max = max(base_max, max_used_y_val)
-
     _arc_ref_min = base_min
-    if min_used_y_val is not None:
-        _arc_ref_min = min(
-            base_min, min_used_y_val
-        )  # both negative → pick the more negative
 
     top_arc_height = abs(3 * _arc_ref_max / 4)
     bot_arc_height = abs(3 * _arc_ref_min / 4) if _arc_ref_min != 0 else top_arc_height
@@ -119,6 +118,8 @@ def _compute_y_limits(
 
             if density_by_strand:
                 jxn_on_top = jxn.strand == "+"
+            elif junctions_on_top:
+                jxn_on_top = True
             else:
                 jxn_on_top = jxn_idx % 2 == 0
                 if abs(min_used_y_val) < max_used_y_val:
@@ -163,7 +164,7 @@ def _compute_y_limits(
         if density_by_strand:
             max_used_y_val = max(abs(min_used_y_val), max_used_y_val)
             min_used_y_val = -max_used_y_val
-    elif not density_by_strand and not jxns:
+    elif not density_by_strand and (junctions_on_top or not jxns):
         min_used_y_val = 0
 
     # Small expansion so the top / bottom arcs have visual breathing room
@@ -171,7 +172,7 @@ def _compute_y_limits(
     max_used_y_val *= 1.1
     min_used_y_val *= 1.1
 
-    return max_used_y_val, min_used_y_val
+    return max_used_y_val, min_used_y_val, base_max
 
 
 def precompute_y_limits(
@@ -198,7 +199,7 @@ def precompute_y_limits(
     if data is None:
         data = obj.data
 
-    return _compute_y_limits(
+    _max, _min, _base = _compute_y_limits(
         data=data,
         region=region,
         graph_coords=graph_coords,
@@ -207,4 +208,7 @@ def precompute_y_limits(
         density_by_strand=kwargs.get("density_by_strand", False),
         fill_step=fill_step,
         show_mean_jxn_number=False,
+        junctions_on_top=kwargs.get("junctions_on_top", False),
     )
+
+    return _max, _min, _base

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot/plot/render.py

@@ -406,6 +406,87 @@ def _plot_local_domain(
 # ============================================================================
 
 
+def _auto_adjust_horizontal(
+    text_objs: List,
+    ax,
+    padding_px: float = 4.0,
+    max_iter: int = 20,
+):
+    """
+    水平碰撞检测与自动调整 —— 替代 adjust_text 的 2D 随意移动。
+    将所有文本沿弧线水平排列，通过贪婪算法确保相邻标签互不重叠。
+
+    原理：
+      1. 获取每个文本在显示坐标中的包围盒，计算其数据坐标宽度。
+      2. 按 x 坐标排序，从左到右逐对检查。
+      3. 如果前一个的右边缘 + 间距 > 后一个的左边缘，则把后一个向右推。
+      4. 重复迭代直到没有标签需要移动为止。
+
+    :param text_objs: matplotlib.text.Text 对象列表
+    :param ax: matplotlib Axes
+    :param padding_px: 标签之间的最小间距（像素）
+    :param max_iter: 最大迭代次数
+    """
+    if len(text_objs) < 2:
+        return
+
+    try:
+        fig = ax.figure
+        fig.canvas.draw()
+    except Exception:
+        return  # 无法渲染时直接跳过调整
+
+    inv_trans = ax.transData.inverted()
+
+    # ---- 收集每个标签的数据坐标宽度 ----
+    items = []
+    for t in text_objs:
+        x_data, y_data = t.get_position()
+        bbox = t.get_window_extent()
+
+        # 像素 → 数据坐标
+        left_data = inv_trans.transform((bbox.x0, bbox.y0))[0]
+        right_data = inv_trans.transform((bbox.x1, bbox.y0))[0]
+        half_w = (right_data - left_data) / 2.0
+
+        # 间距（像素 → 数据坐标）
+        p0 = inv_trans.transform((0, 0))[0]
+        p1 = inv_trans.transform((padding_px, 0))[0]
+        pad = abs(p1 - p0)
+
+        items.append({
+            "obj": t,
+            "x": x_data,
+            "y": y_data,
+            "half": half_w,
+            "pad": pad,
+        })
+
+    # 按 x 排序
+    items.sort(key=lambda d: d["x"])
+
+    # ---- 贪婪水平调整 ----
+    for _ in range(max_iter):
+        any_adjusted = False
+
+        for i in range(len(items) - 1):
+            cur = items[i]
+            nxt = items[i + 1]
+
+            cur_right = cur["x"] + cur["half"]
+            nxt_left = nxt["x"] - nxt["half"]
+            min_gap = max(cur["pad"], nxt["pad"])
+
+            need = cur_right + min_gap - nxt_left
+            if need > 0:
+                nxt["x"] += need
+                nxt["obj"].set_position((nxt["x"], nxt["y"]))
+                any_adjusted = True
+
+        if not any_adjusted:
+            break
+
+
 def plot_density(
     ax,
     obj: Optional[File] = None,
@@ -460,6 +541,11 @@ def plot_density(
     # drawn junction arcs have exactly the same height that was used to expand
     # the y-axis limits.  Using the already-expanded max_used_y_val for arc
     # height causes non-convergent growth and truncated junction arcs.
+
+    # Determine whether y-limits were externally provided (e.g. from --same-y).
+    # Must be computed here BEFORE the arc-height block below uses it.
+    fixed_max_used_y = max_used_y_val is not None
+
     if isinstance(data, dict):
         _base_max = max(max(v.plus) if v.plus is not None else 0 for v in data.values())
         _minus_maxes = [
@@ -473,17 +559,20 @@ def plot_density(
     if _base_max % 2 == 1:
         _base_max += 1
 
-    # Arc height reference: use the LARGER of (data baseline, incoming y-limit)
-    # so arcs look proportional to the visible axis range (especially in
-    # --same-y / --same-y-sc mode).  If we only used the data baseline, panels
-    # with small data would have tiny arcs hugging the x-axis when a large
-    # global y-limit is shared across panels.
-    _arc_ref_max = (
-        max(_base_max, max_used_y_val) if max_used_y_val is not None else _base_max
-    )
-    _arc_ref_min = (
-        min(_base_min, min_used_y_val) if min_used_y_val is not None else _base_min
-    )
+    # Arc height reference: use global_arc_ref (from --same-y) when available
+    # and when y-limits were externally provided.  This ensures panels with
+    # small data ranges don't get tiny arcs flattened against the x-axis when
+    # the panel's y-range is scaled up to match a larger panel.
+    #
+    # NOTE: we only use global_arc_ref when fixed_max_used_y is True so that
+    # standalone panels (no --same-y) preserve their original behavior.
+    global_arc_ref = kwargs.get("global_arc_ref")
+    if fixed_max_used_y and global_arc_ref is not None:
+        _arc_ref_max = max(_base_max, global_arc_ref)
+        _arc_ref_min = max(abs(_base_min), global_arc_ref) if _base_min != 0 else _arc_ref_max
+    else:
+        _arc_ref_max = _base_max
+        _arc_ref_min = _base_min
 
     _top_arc_height = abs(3 * _arc_ref_max / 4)
     _bot_arc_height = (
@@ -491,9 +580,9 @@ def plot_density(
     )
 
     # Compute y limits using shared logic
-    fixed_max_used_y = max_used_y_val is not None
+    junctions_on_top = kwargs.get("junctions_on_top", False)
 
-    max_used_y_val, min_used_y_val = _compute_y_limits(
+    max_used_y_val, min_used_y_val, _base = _compute_y_limits(
         data=data,
         region=region,
         graph_coords=graph_coords,
@@ -502,6 +591,7 @@ def plot_density(
         density_by_strand=kwargs.get("density_by_strand", False),
         fill_step=fill_step,
         show_mean_jxn_number=show_mean_jxn_number,
+        junctions_on_top=junctions_on_top,
     )
     
     # Draw fill
@@ -557,6 +647,8 @@ def plot_density(
 
             if kwargs.get("density_by_strand"):
                 jxn_on_top = jxn.strand == "+"
+            elif junctions_on_top:
+                jxn_on_top = True
             else:
                 jxn_on_top = jxn_idx % 2 == 0
                 if abs(min_used_y_val) < max_used_y_val:
@@ -623,17 +715,15 @@ def plot_density(
                     va="center",
                     backgroundcolor="w",
                 )
-                t.set_bbox(dict(alpha=0))
+                t.set_bbox(dict(alpha=0, pad=0.5))
                 text_objs.append(t)
 
         if show_junction_number and len(text_objs) > 1:
-            adjust_text(
+            _auto_adjust_horizontal(
                 text_objs,
                 ax=ax,
-                force_text=(0.5, 0.5),
-                expand=(1.2, 1.2),
-                arrowprops=None,
-                lim=100,
+                padding_px=4.0,
+                max_iter=20,
             )
 
     if obj and obj.title:
@@ -659,7 +749,7 @@ def plot_density(
     ):
         max_used_y_val = max(abs(min_used_y_val), max_used_y_val)
         min_used_y_val = -max_used_y_val
-    elif not kwargs.get("density_by_strand") and not jxns:
+    elif not kwargs.get("density_by_strand") and (junctions_on_top or not jxns):
         min_used_y_val = 0
 
     set_y_ticks(

{trackplot-0.6.3 → trackplot-0.6.5/trackplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trackplot
-Version: 0.6.3
+Version: 0.6.5
 Summary: The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/
 Author-email: ygidtu <ygidtu@gmail.com>
 License-Expression: BSD-3-Clause

{trackplot-0.6.3 → trackplot-0.6.5}/trackplot.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ trackplot/server.py
 trackplot.egg-info/PKG-INFO
 trackplot.egg-info/SOURCES.txt
 trackplot.egg-info/dependency_links.txt
+trackplot.egg-info/entry_points.txt
 trackplot.egg-info/requires.txt
 trackplot.egg-info/top_level.txt
 trackplot/anno/AxLabel.py

trackplot-0.6.5/trackplot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trackplot = trackplot.cli:main