coolbox 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

coolbox/core/track/hist/plot.py

@@ -55,10 +55,13 @@ class PlotHist(object):
         color = self.properties['color']
         size = self.properties['size']
         alpha = self.properties['alpha']
+        fmt = self.properties.get('fmt')
+        if fmt == '-':
+            fmt = '.'
         mask = values > threshold
-        ax.scatter(indexes[mask], values[mask], s=size, alpha=alpha, c=self.properties.get('threshold_color', color))
+        ax.scatter(indexes[mask], values[mask], marker=fmt, s=size, alpha=alpha, c=self.properties.get('threshold_color', color))
         mask = ~mask
-        ax.scatter(indexes[mask], values[mask], s=size, alpha=alpha, c=color)
+        ax.scatter(indexes[mask], values[mask], marker=fmt, s=size, alpha=alpha, c=color)
 
     def plot_line(self, ax, indexes, values):
         # reference for plotting with threshold: https://stackoverflow.com/a/30122991/10336496
@@ -71,10 +74,15 @@ class PlotHist(object):
         alpha = self.properties.get("alpha", 1.0)
         threshold = float(self.properties.get("threshold"))
         threshold_color = self.properties.get("threshold_color")
-        ax.plot(indexes, values, fmt, linewidth=line_width, color=color, alpha=alpha)
         if threshold and np.sum(values > threshold) > 0:
-            masked_values = np.ma.masked_greater_equal(values, threshold)
-            ax.plot(indexes, masked_values, fmt, linewidth=line_width, color=threshold_color, alpha=alpha)
+            masked_g = values.copy()
+            masked_g[masked_g < threshold] = np.nan
+            ax.plot(indexes, masked_g, fmt, linewidth=line_width, color=threshold_color, alpha=alpha)
+            masked_l = values.copy()
+            masked_l[masked_l >= threshold] = np.nan
+            ax.plot(indexes, masked_l, fmt, linewidth=line_width, color=color, alpha=alpha)
+        else:
+            ax.plot(indexes, values, fmt, linewidth=line_width, color=color, alpha=alpha)
 
     def plot_stairs(self, ax, gr, values, fill=True):
         if len(values.shape) == 2:

coolbox/core/track/ideogram.py

@@ -1,5 +1,5 @@
 import pandas as pd
-from matplotlib.collections import BrokenBarHCollection
+import matplotlib.pyplot as plt
 
 from coolbox.utilities import (
     get_logger, GenomeRange, file_to_intervaltree, hex2rgb,
@@ -24,7 +24,7 @@ class Ideogram(Track):
     color_scheme : dict, optional
         Color scheme of ideogram, default: Ideogram.DEFAULT_COLOR_SCHEME
 
-    show_name : bool, optional
+    show_band_name : bool, optional
         Show band name or not. default True.
 
     font_size : int, optional
@@ -55,7 +55,7 @@ class Ideogram(Track):
         properties_dict = {
             'file': file_,
             'color_scheme': Ideogram.DEFAULT_COLOR_SCHEME,
-            'show_name': True,
+            'show_band_name': True,
             'font_size': Ideogram.DEFAULT_FONT_SIZE,
             'border_color': '#000000',
             'border_width': Ideogram.DEFAULT_BORDER_WIDTH,
@@ -83,7 +83,7 @@ class Ideogram(Track):
             start, end = itv.begin, itv.end
             band_name, band_type = itv.data[:2]
             rows.append([gr.chrom, start, end, band_name, band_type])
-        fields = ['chrom', 'start', 'end', 'name', 'gieStain']
+        fields = ['chrom', 'start', 'end', 'band_name', 'band_type']
         return pd.DataFrame(rows, columns=fields)
 
     def plot(self, ax, gr: GenomeRange, **kwargs):
@@ -101,19 +101,28 @@ class Ideogram(Track):
                 self.properties['show_band_name'] != 'no'
                 and gr.length < 80_000_000
             ):
-                self.plot_text(band_name, start, end, band_color)
-        coll = BrokenBarHCollection(xranges, (0, band_height), facecolors=colors,
-                                    linewidths=self.properties['border_width'],
-                                    edgecolors=self.properties['border_color'])
+                self.plot_text(band_name, start, end, gr, band_color)
+        coll = plt.broken_barh(
+            xranges, (0, band_height), facecolors=colors,
+            linewidth=self.properties['border_width'],
+            edgecolor=self.properties['border_color'])
         ax.add_collection(coll)
         ax.set_ylim(-0.1, band_height + 0.1)
         ax.set_xlim(gr.start, gr.end)
         self.plot_label()
 
-    def plot_text(self, band_name, start, end, band_color):
+    def plot_text(self, band_name, start, end, gr, band_color):
         band_height = self.properties['height']
         x_pos = start + (end - start) * 0.15
+        if x_pos < gr.start:
+            x_pos = gr.start + 0.5 * (end - gr.start)
+            if (end - gr.start) < gr.length  * 0.10:
+                return
+        elif x_pos > gr.end:
+            x_pos = start + 0.5 * (gr.end - start)
+            if (gr.end - start) < gr.length * 0.10:
+                return
         y_pos = band_height / 2
         rgb = hex2rgb(band_color) if isinstance(band_color, str) else band_color
-        color = '#e2e2e2' if sum(rgb) < 100 else '#000000'
+        color = '#e2e2e2' if sum(rgb) < 200 else '#000000'
         self.ax.text(x_pos, y_pos, band_name, fontsize=self.properties['font_size'], color=color)

coolbox/core/track/pseudo.py

@@ -128,11 +128,15 @@ class XAxis(Track):
 
         ax.set_xlim(gr.start, gr.end)
         ticks = ax.get_xticks()
-        if ticks[-1] - ticks[1] <= 1e5:
+
+        if ticks[-1] - ticks[1] <= 1000:
+            labels = ["{:.0f}".format((x))
+                      for x in ticks]
+            labels[-2] += " bp"
+        elif ticks[-1] - ticks[1] <= 1e5:
             labels = ["{:,.0f}".format((x / 1e3))
                       for x in ticks]
             labels[-2] += " Kb"
-
         elif 1e5 < ticks[-1] - ticks[1] < 4e6:
             labels = ["{:,.0f}".format((x / 1e3))
                       for x in ticks]

coolbox/core/track/tad.py

@@ -0,0 +1,237 @@
+import numpy as np
+import pandas as pd
+
+from coolbox.utilities import (
+    get_logger
+)
+from coolbox.utilities.genome import GenomeRange
+from .bed.base import BedBase
+from .bed.fetch import FetchBed
+
+log = get_logger(__name__)
+
+
+class PlotTAD(object):
+    def __init__(self):
+        self.init_colormap()
+        self.cache_gr = None
+        self.cache_res = None
+
+    def fetch_plot_data(self, gr: GenomeRange, **kwargs):
+        if gr == self.cache_gr:
+            return self.cache_res
+        else:
+            self.cache_gr = gr
+            self.cache_res = self.fetch_data(gr, **kwargs)
+            return self.cache_res
+
+    def get_depth_ratio(self, gr=None):
+        if 'depth_ratio' not in self.properties:
+            return 1.0
+        dr = self.properties['depth_ratio']
+        if dr == 'full':
+            return 1.0
+        if dr == 'auto':
+            assert gr is not None
+            min_dr = 0.1
+            tads = self.fetch_plot_data(gr)
+            tads = tads[(tads['start'] >= gr.start) & (tads['end'] <= gr.end)]
+            if tads.shape[0] > 0:
+                dr = (tads['end'] - tads['start']).max() / (gr.end - gr.start)
+                return max(dr, min_dr)
+            else:
+                return min_dr
+        return dr
+
+    def get_track_height(self, frame_width, gr):
+        height = frame_width * 0.5
+        height *= self.get_depth_ratio(gr)
+        return height
+
+    def plot_tads(self, ax, gr: GenomeRange, tads: pd.DataFrame):
+        """
+        Plots the boundaries as triangles in the given ax.
+        """
+        self.set_colormap(tads)
+        depth = (gr.end - gr.start) / 2
+        ymax = (gr.end - gr.start)
+        if 'track' in self.__dict__:
+            from coolbox.core.track.hicmat import HicMatBase
+            assert isinstance(self.track, HicMatBase), f"The parent track should be instance of {HicMatBase}"
+
+            hicmat_tri_style = (HicMatBase.STYLE_WINDOW, HicMatBase.STYLE_TRIANGULAR)
+            hicmat_ma_style = (HicMatBase.STYLE_MATRIX,)
+
+            hictrack = self.track
+            hicmat_style = hictrack.properties['style']
+
+            # TODO Should we add plotting in BigWig, BedGraph, ABCCompartment, Arcs support?(The original codes supports)
+            for region in tads.itertuples():
+                if hicmat_style in hicmat_tri_style:
+                    self.plot_triangular(ax, gr, region, ymax, depth)
+                elif hicmat_style in hicmat_ma_style:
+                    self.plot_box(ax, gr, region)
+                else:
+                    raise ValueError(f"unsupported hicmat style {hicmat_style}")
+        else:
+            for region in tads.itertuples():
+                self.plot_triangular(ax, gr, region, ymax, depth)
+            dr = self.get_depth_ratio(gr)
+            if self.properties['orientation'] == 'inverted':
+                ax.set_ylim(depth * dr, 0)
+            else:
+                ax.set_ylim(0, depth * dr)
+            ax.set_xlim(gr.start, gr.end)
+
+        if len(tads) == 0:
+            log.debug("No regions found for Coverage {}.".format(self.properties['name']))
+
+    def plot_triangular(self, ax, gr, region, ymax, depth):
+        """
+              /\
+             /  \
+            /    \
+        _____________________
+           x1 x2 x3
+        """
+
+        from matplotlib.patches import Polygon
+        x1 = region.start
+        x2 = x1 + float(region.end - region.start) / 2
+        x3 = region.end
+        y1 = 0
+        y2 = (region.end - region.start)
+
+        y = (y2 / ymax) * depth
+
+        rgb, edgecolor = self.get_rgb_and_edge_color(region)
+
+        triangle = Polygon(np.array([[x1, y1], [x2, y], [x3, y1]]), closed=True,
+                           facecolor=rgb, edgecolor=edgecolor,
+                           alpha=self.properties['alpha'],
+                           linestyle=self.properties['border_style'],
+                           linewidth=self.properties['border_width'])
+        ax.add_artist(triangle)
+        self.plot_score(ax, gr, region, 'triangular', ymax, depth)
+
+    def plot_box(self, ax, gr, region):
+        from matplotlib.patches import Rectangle
+
+        x1 = region.start
+        x2 = region.end
+        x = y = x1
+        w = h = (x2 - x1)
+
+        rgb, edgecolor = self.get_rgb_and_edge_color(region)
+
+        fill = self.properties['border_only'] == 'no'
+
+        rec = Rectangle((x, y), w, h,
+                        fill=fill,
+                        facecolor=rgb,
+                        edgecolor=edgecolor,
+                        alpha=self.properties['alpha'],
+                        linestyle=self.properties['border_style'],
+                        linewidth=self.properties['border_width'])
+        ax.add_patch(rec)
+        self.plot_score(ax, gr, region, 'box')
+
+    def plot_score(self, ax, gr, region, style, ymax=None, depth=None):
+        properties = self.properties
+
+        if properties['show_score'] != 'yes':
+            return
+        bed = region
+        score = bed.score
+        if not isinstance(score, (float, int)):
+            # score is not number not plot
+            return
+        region_length = region.end - region.start
+        if region_length / gr.length < 0.05:
+            # region too small not plot score
+            return
+        font_size = properties['score_font_size']
+        if font_size == 'auto':
+            # inference the font size
+            from math import log2
+            base_size = 18
+            s_ = (region_length / gr.length) * 10
+            s_ = int(log2(s_))
+            font_size = base_size + s_
+        ratio = properties['score_height_ratio']
+        color = properties['score_font_color']
+        if style == 'box':
+            x1 = region.start
+            x2 = region.end
+            w = x2 - x1
+            x = x2 - w * ratio
+            y = x1 + w * ratio
+        else:  # triangular
+            x = region.begin + region_length * 0.4
+            y = (region_length / ymax) * depth * ratio
+        ax.text(x, y, "{0:.3f}".format(score), fontsize=font_size, color=color)
+
+
+class TAD(BedBase, PlotTAD, FetchBed):
+    """
+    Tad tack from bed file
+
+    Parameters
+    ----------
+    border_style: str, optional
+        Border style of tad. (Default: 'solid')
+
+    border_width: int, optional
+        Border width of tad. (Default: '2.0')
+
+    show_score : bool
+        Show bed score or not.
+        default False.
+
+    score_font_size : {'auto', int}
+        Score text font size.
+        default 'auto'
+
+    score_font_color : str
+        Score text color.
+        default '#000000'
+
+    score_height_ratio : float
+        (text tag height) / (TAD height). used for adjust the position of Score text.
+        default 0.5
+
+    border_only : bool
+        Only show border, default False
+
+    depth_ratio : {float, 'auto', 'full'}
+        Depth ratio of triangular, use 'full' for full depth, use 'auto' for calculate depth by current genome_range. default 'auto'.
+
+    orientation : {'normal', 'inverted'}
+        Invert y-axis or not, default 'normal'
+
+    """
+
+    DEFAULT_PROPERTIES = {
+        'alpha': 0.3,
+        'border_style': "--",
+        'border_width': 2.0,
+        "show_score": False,
+        "score_font_size": 'auto',
+        "score_font_color": "#000000",
+        "score_height_ratio": 0.4,
+        "border_only": False,
+        "depth_ratio": 'auto',
+        "orientation": 'inverted',
+    }
+
+    def __init__(self, file, **kwargs):
+        properties = TAD.DEFAULT_PROPERTIES.copy()
+        properties.update(kwargs)
+        super().__init__(file, **properties)
+        PlotTAD.__init__(self)
+
+    def plot(self, ax, gr: GenomeRange, **kwargs):
+        self.ax = ax
+        ov_intervals: pd.DataFrame = self.fetch_plot_data(gr, **kwargs)
+        self.plot_tads(ax, gr, ov_intervals)
+        self.plot_label()

coolbox/utilities/bed.py

@@ -170,7 +170,7 @@ class ReadBed(object):
         """
         fields = self.get_no_comment_line(iter=file_iter, count=False)
         fields = to_string(fields)
-        line_values = fields.split()
+        line_values = fields.split("\t")
 
         if len(line_values) == 3:
             self.file_type = 'bed3'