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

coolbox/core/track/bed/plot.py

@@ -13,60 +13,67 @@ from coolbox.utilities.genome import GenomeRange
 log = get_logger(__name__)
 
 
-class PlotBed(object):
-    def init_for_plot(self):
-        from matplotlib import font_manager
+class PlotGenes(object):
 
+    def __init__(self, *args, **kwargs):
+        self.init_colormap()
+        from matplotlib import font_manager
         properties = self.properties
         self.len_w = None  # this is the length of the letter 'w' given the font size
         self.counter = None
         self.small_relative = None
         self.is_draw_labels = properties['labels'] == 'on'
         self.fp = font_manager.FontProperties(size=properties['fontsize'])
-        # set the distance between rows
         self.row_scale = properties['interval_height'] * 2.3
-        # set colormap if possible, else None, wait for setting when plot
-        self.colormap = None
-        if not matplotlib.colors.is_color_like(self.properties['color']) and self.properties['color'] != 'bed_rgb':
-            # check if the color is a valid colormap name
-            if self.properties['color'] not in matplotlib.cm.datad:
-                log.warning("*WARNING* color: '{}' for Track {} is not valid. Color has "
-                            "been set to {}".format(self.properties['color'], self.properties['name'],
-                                                    self.COLOR))
-                self.properties['color'] = self.COLOR
-            else:
-                self.colormap = self.properties['color']
+        self.cache_gr = None
+        self.cache_res = None
 
-    def plot_genes(self, ax, gr: GenomeRange, ov_genes: pd.DataFrame):
+    def fetch_plot_data(self, gr: GenomeRange, **kwargs) -> pd.DataFrame:
+        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_track_height(self, frame_width, current_range):
+        props = self.properties
+        if (props.get('height', 'auto') == 'auto') and\
+           ('row_height' in props) and\
+           (props.get('display', 'stacked') == 'stacked'):
+            ov_genes = self.fetch_plot_data(current_range)
+            self.plot_genes(None, current_range, ov_genes, dry_run=True, fig_width=frame_width)
+            return max(props['row_height'] * self.current_row_num, props['row_height'])
+        else:
+            try:
+                height = float(self.properties['height'])
+            except:
+                height = 1.0
+            return height
+
+    def __set_plot_params(self, gr: GenomeRange, ov_genes: pd.DataFrame):
         properties = self.properties
         # bed_type
         self.properties['bed_type'] = properties['bed_type'] or self.infer_bed_type(ov_genes)
-        # as min_score and max_score change every plot, we compute them for every plot
-        min_score, max_score = properties['min_score'], properties['max_score']
-        has_score_col = properties['bed_type'] in ('bed6', 'bed9', 'bed12')
-        if has_score_col and len(ov_genes):
-            min_score = (min_score != 'inf') or ov_genes['score'].min()
-            max_score = (max_score != '-inf') or ov_genes['score'].max()
-        min_score, max_score = float(min_score), float(max_score)
-
-        # set colormap
-        if self.colormap is not None:
-            norm = matplotlib.colors.Normalize(vmin=min_score, vmax=max_score)
-            cmap = matplotlib.cm.get_cmap(properties['color'])
-            self.colormap = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)
-        if properties['color'] == 'bed_rgb' and properties['bed_type'] not in ['bed12', 'bed9']:
-            log.warning("*WARNING* Color set to 'bed_rgb', but bed file does not have the rgb field. The color has "
-                        "been set to {}".format(self.COLOR))
-            self.properties['color'] = self.COLOR
-            self.colormap = None
+        self.set_colormap(ov_genes)
+        # turn labels off when too many intervals are visible.
+        if properties['labels'] == 'auto':
+            if len(ov_genes) > 60:
+                self.is_draw_labels = False
+            else:
+                self.is_draw_labels = True
+        self.small_relative = 0.004 * (gr.end - gr.start)
+        self.counter = 0
 
+    def plot_genes(self, ax, gr: GenomeRange, ov_genes: pd.DataFrame, dry_run = False, fig_width = None):
+        properties = self.properties
+        self.__set_plot_params(gr, ov_genes)
 
-        self.counter = 0
-        self.small_relative = 0.004 * (gr.end - gr.start)
-        self.get_length_w(ax.get_figure().get_figwidth(), gr.start, gr.end)
-        # turn labels off when too many intervals are visible.
-        if properties['labels'] == 'on' and len(ov_genes) > 60:
-            self.is_draw_labels = False
+        assert (not dry_run) or (fig_width is not None)
+        if dry_run:
+            self.__get_length_w(fig_width, gr.start, gr.end)
+        else:
+            self.__get_length_w(ax.get_figure().get_figwidth(), gr.start, gr.end)
 
         num_rows = properties['num_rows']
         max_num_row_local = 1
@@ -145,43 +152,45 @@ class PlotBed(object):
                 max_num_row_local = free_row
             if ypos > max_ypos:
                 max_ypos = ypos
-
-            if properties['bed_type'] == 'bed12':
-                if properties['gene_style'] == 'flybase':
-                    self.draw_gene_with_introns_flybase_style(ax, bed, ypos, rgb, edgecolor)
+            
+            if not dry_run:
+                if properties['bed_type'] == 'bed12':
+                    if properties['gene_style'] == 'flybase':
+                        self.draw_gene_with_introns_flybase_style(ax, bed, ypos, rgb, edgecolor)
+                    else:
+                        self.draw_gene_with_introns(ax, bed, ypos, rgb, edgecolor)
                 else:
-                    self.draw_gene_with_introns(ax, bed, ypos, rgb, edgecolor)
-            else:
-                self.draw_gene_simple(ax, bed, ypos, rgb, edgecolor)
+                    self.draw_gene_simple(ax, bed, ypos, rgb, edgecolor)
 
-            if self.is_draw_labels and bed.start > gr.start and bed.end < gr.end:
-                ax.text(bed.end + self.small_relative,
-                        ypos + (float(properties['interval_height']) / 2),
-                        bed.name,
-                        horizontalalignment='left',
-                        verticalalignment='center',
-                        fontproperties=self.fp)
+                if self.is_draw_labels and bed.start > gr.start and bed.end < gr.end:
+                    ax.text(bed.end + self.small_relative,
+                            ypos + (float(properties['interval_height']) / 2),
+                            bed.name,
+                            horizontalalignment='left',
+                            verticalalignment='center',
+                            fontproperties=self.fp)
 
         if self.counter == 0:
-            log.warning(f"*Warning* No intervals were found for file {properties['file']} "
+            log.debug(f"*Warning* No intervals were found for file {properties['file']} "
                         f"in Track \'{properties['name']}\' for the interval plotted ({gr}).\n")
 
         ymax = 0
         if num_rows:
             ymin = float(num_rows) * self.row_scale
+            self.current_row_num = num_rows
         else:
             ymin = max_ypos + properties['interval_height']
+            self.current_row_num = len(row_last_position)
 
         log.debug("ylim {},{}".format(ymin, ymax))
         # the axis is inverted (thus, ymax < ymin)
-        ax.set_ylim(ymin, ymax)
+        if not dry_run:
+            ax.set_ylim(ymin, ymax)
 
-        if properties['display'] == 'domain':
-            ax.set_ylim(-5, 205)
-        elif properties['display'] == 'collapsed':
-            ax.set_ylim(-5, 105)
+            if properties['display'] == 'collapsed':
+                ax.set_ylim(-5, 105)
 
-        ax.set_xlim(gr.start, gr.end)
+            ax.set_xlim(gr.start, gr.end)
 
     def draw_gene_with_introns(self, ax, bed, ypos, rgb, edgecolor):
         """
@@ -369,7 +378,7 @@ class PlotBed(object):
 
         return vertices
 
-    def get_length_w(self, fig_width, region_start, region_end):
+    def __get_length_w(self, fig_width, region_start, region_end):
         """
         to improve the visualization of the genes it is good to have an estimation of the label
         length. In the following code I try to get the length of a 'W' in base pairs.
@@ -410,162 +419,3 @@ class PlotBed(object):
         else:
             return free_row * self.row_scale
 
-    def get_rgb_and_edge_color(self, bed):
-        # TODO need simplification
-        rgb = self.properties['color']
-        edgecolor = self.properties['border_color']
-
-        if self.colormap:
-            # translate value field (in the example above is 0 or 0.2686...) into a color
-            rgb = self.colormap.to_rgba(bed.score)
-
-        # for tad coverage
-        if self.properties['style'] == 'tad' and self.properties['border_only'] == 'yes':
-            rgb = 'none'
-        elif self.properties['color'] == 'bed_rgb':
-            # if rgb is set in the bed line, this overrides the previously
-            # defined colormap
-            if self.properties['bed_type'] in ['bed9', 'bed12'] and len(bed.rgb) == 3:
-                try:
-                    rgb = [float(x) / 255 for x in bed.rgb]
-                    if 'border_color' in self.properties:
-                        edgecolor = self.properties['border_color']
-                    else:
-                        edgecolor = self.properties['color']
-                except IndexError:
-                    rgb = self.COLOR
-            else:
-                rgb = self.COLOR
-        return rgb, edgecolor
-
-    @staticmethod
-    def infer_bed_type(df: pd.DataFrame) -> Union[str, None]:
-        #  bed_type of dataframe are store in dataframe's __dict__ in FetchBed.fetch_intervals
-        if 'bed_type' in df.__dict__:
-            bed_type = df.bed_type
-        else:
-            bed_types = {
-                12: 'bed12',
-                9: 'bed9',
-                6: 'bed6',
-                3: 'bed3'
-            }
-            num_col = len(df.columns)
-            bed_type = bed_types[num_col] if num_col in bed_types else 'bed3'
-            if bed_type == 'bed3' and num_col < 3:
-                raise ValueError(f"Invalid dataframe for bed3 with columns: {df.columns}")
-        return bed_type
-
-    def plot_tads(self, ax, gr: GenomeRange, tads: pd.DataFrame):
-        """
-        Plots the boundaries as triangles in the given ax.
-        """
-        from coolbox.core.track.hicmat import HicMatBase
-        # coverage only
-        assert 'track' in self.__dict__ and 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:
-                depth = (gr.end - gr.start) / 2
-                ymax = (gr.end - gr.start)
-                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}")
-
-        if len(tads) == 0:
-            log.warning("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)

coolbox/core/track/gtf.py

@@ -33,7 +33,7 @@ class GTF(Track):
     color : {str, 'random'}, optional
         When the color is random, color for each gene will be randomly selected.
 
-    name_attribute : {'auto', 'gene_name', 'gene_id', str}, optional
+    name_attr : {'auto', 'gene_name', 'gene_id', str}, optional
         Use which attribute to show feature's name.
         Default use 'auto'(try 'gene_name' -> 'gene_id' -> 'position_string')
     """
@@ -50,7 +50,7 @@ class GTF(Track):
         "color": "random",
         "row_filter": 'feature == "gene"',
         "length_ratio_thresh": 0.005,
-        "name_attribute": "auto",
+        "name_attr": "auto",
     }
 
     def __init__(self, file, **kwargs):
@@ -112,14 +112,16 @@ class GTF(Track):
             if gene_name.hasnans:
                 gene_id = df['attribute'].str.extract(".*gene_id (.*?) ").iloc[:, 0].str.strip('\";')
                 gene_name.fillna(gene_id, inplace=True)
-                if gene_name.hasnans:
-                    pos_str = df['seqname'].astype(str) + ":" +\
-                              df['start'].astype(str) + "-" +\
-                              df['end'].astype(str)
-                    gene_name.fillna(pos_str, inplace=True)
-            df['feature_name'] = gene_name
         else:
-            df['feature_name'] = df['attribute'].str.extract(f".*{name_attr} (.*?) ").iloc[:, 0].str.strip('\";')
+            gene_name = df['attribute'].str.extract(f".*{name_attr} (.*?)(?:[ ;])").iloc[:, 0].str.strip('\";')
+
+        if gene_name.hasnans:
+            pos_str = df['seqname'].astype(str) + ":" +\
+                      df['start'].astype(str) + "-" +\
+                      df['end'].astype(str)
+            gene_name.fillna(pos_str, inplace=True)
+
+        df['feature_name'] = gene_name
         return df
 
     def plot(self, ax, gr: GenomeRange, **kwargs):

coolbox/core/track/hicmat/base.py

@@ -54,6 +54,10 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
     process_func : {callable, str, False}, optional
         Process matrix with a user-defined function(receive a matrix, return a processed matrix). default False.
 
+    aspect_ratio : {'equal', 'auto'}, optional
+        When set to 'equal', it ensures that matrix pixels are actually squares. When set to 'auto', it allows
+        matrix pixels to be stretched to completely fill the subplot. Ignored when height parameter is
+        provided. default 'equal'.
 
     """
 
@@ -77,6 +81,7 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
         'height': 'hic_auto',
         'cmap': "JuiceBoxLike",
         "color_bar": "vertical",
+        "aspect_ratio": "equal",
         "max_value": "auto",
         "min_value": "auto",
         "depth_ratio": DEPTH_FULL,
@@ -93,7 +98,7 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
         self.fetched_gr = None
         self.fetched_gr2 = None
 
-    def fetch_data(self, gr: GenomeRange, **kwargs) -> np.ndarray:
+    def fetch_data(self, gr: GenomeRange, gr2=None, **kwargs) -> np.ndarray:
         """
         Fetch the raw matrix should be plotted. Normally it's a matrix with raw contacts
 
@@ -109,7 +114,7 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
         """
         raise NotImplementedError
 
-    def fetch_plot_data(self, gr: GenomeRange, **kwargs) -> np.ndarray:
+    def fetch_plot_data(self, gr: GenomeRange, gr2=None, **kwargs) -> np.ndarray:
         """
         Fetch 2d contact matrix, the matrix may be processed in case
         'transform', 'normalize', 'gaussian_sigma', 'process_func' exits in properties.
@@ -127,17 +132,15 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
         matrix : np.array
             Processed hic matrix used for plotting.
         """
-        gr2 = kwargs.get('gr2')
         if self.properties['style'] == self.STYLE_WINDOW and not kwargs.get("gr_updated", False):
             gr, gr2 = self.fetch_window_genome_range(gr, gr2)
-            kwargs.update({'gr2': gr2})
-        arr = self.fetch_data(gr, **kwargs)
+        arr = self.fetch_data(gr, gr2=gr2, **kwargs)
         # store fetched_gr
         self.fetched_gr = gr
         self.fetched_gr2 = gr2
         return self.process_matrix(arr)
 
-    def plot(self, ax, gr: GenomeRange, **kwargs):
+    def plot(self, ax, gr: GenomeRange, gr2=None, **kwargs):
         """
         Plot matrix
 
@@ -148,10 +151,10 @@ class HicMatBase(Track, PlotHiCMat, ProcessHicMat):
         """
         self.ax = ax
         # fetch processed plot_data
-        self.matrix = self.fetch_plot_data(gr, **kwargs)
+        self.matrix = self.fetch_plot_data(gr, gr2=gr2, **kwargs)
         # plot matrix
-        img = self.plot_matrix(gr, kwargs.get('gr2'))
-        self.adjust_figure(gr, kwargs.get('gr2'))
+        img = self.plot_matrix(gr, gr2)
+        self.adjust_figure(gr, gr2)
         self.draw_colorbar(img)
         self.plot_label()
 

coolbox/core/track/hicmat/cool.py

@@ -34,19 +34,19 @@ class Cool(HicMatBase):
         })
         super().__init__(**properties)
 
-    def fetch_data(self, gr: GenomeRange, **kwargs) -> np.ndarray:
+    def fetch_data(self, gr: GenomeRange, gr2=None, **kwargs) -> np.ndarray:
         from coolbox.utilities.hic.wrap import CoolerWrap
 
         path = self.properties['file']
         binsize = kwargs.get('resolution', self.properties.get('resolution', 'auto'))
         wrap = CoolerWrap(path, balance=self.balance, binsize=binsize)
-        arr = wrap.fetch(gr, kwargs.get('gr2'))
+        arr = wrap.fetch(gr, gr2)
 
         self.fetched_binsize = wrap.fetched_binsize  # expose fetched binsize
 
         return self.fill_zero_nan(arr)
 
-    def fetch_pixels(self, gr: GenomeRange, **kwargs):
+    def fetch_pixels(self, gr: GenomeRange, gr2=None, **kwargs):
         """
         Fetch the pixels table of upper triangle of the original contact matrix(not processed).
 
@@ -80,7 +80,7 @@ class Cool(HicMatBase):
         balance = kwargs.get('balance', self.is_balance)
         wrap = CoolerWrap(path, balance=balance, binsize=kwargs.get('resolution', 'auto'))
 
-        return wrap.fetch_pixels(gr, kwargs.get('gr2'), join=kwargs.get('join', True))
+        return wrap.fetch_pixels(gr, gr2, join=kwargs.get('join', True))
 
     def infer_binsize(self, gr: GenomeRange, **kwargs) -> int:
         from coolbox.utilities.hic.wrap import CoolerWrap

coolbox/core/track/hicmat/dothic.py

@@ -33,14 +33,14 @@ class DotHiC(HicMatBase):
         })
         super().__init__(**properties)
 
-    def fetch_data(self, genome_range, genome_range2=None, **kwargs) -> np.ndarray:
+    def fetch_data(self, gr, gr2=None, **kwargs) -> np.ndarray:
         from coolbox.utilities.hic.wrap import StrawWrap
 
         path = self.properties['file']
         binsize = kwargs.get('resolution', self.properties.get('resolution', 'auto'))
         wrap = StrawWrap(path, normalization=self.balance, binsize=binsize)
 
-        arr = wrap.fetch(genome_range, genome_range2)
+        arr = wrap.fetch(gr, gr2)
 
         self.fetched_binsize = wrap.fetched_binsize  # expose fetched binsize
 

coolbox/core/track/hicmat/plot.py

@@ -58,6 +58,11 @@ class PlotHiCMat(object):
         ax = self.ax
         arr = self.matrix
         c_min, c_max = self.matrix_val_range
+
+        aspect = self.properties['aspect_ratio']
+        if self.properties.get('height'):
+            aspect = 'auto'
+
         if gr2 is None and self.style == self.STYLE_TRIANGULAR:
             # triangular style
             scale_r = 1 / math.sqrt(2)
@@ -71,7 +76,7 @@ class PlotHiCMat(object):
             img = ax.matshow(arr, cmap=cmap,
                              transform=tr + ax.transData,
                              extent=(gr.start, gr.end, gr.start, gr.end),
-                             aspect='auto')
+                             aspect=aspect)
         elif gr2 is None and self.style == self.STYLE_WINDOW:
             # window style
             # exist in HicMatBase
@@ -88,14 +93,14 @@ class PlotHiCMat(object):
             img = ax.matshow(arr, cmap=cmap,
                              transform=tr + ax.transData,
                              extent=(gr.start, gr.end, gr.start, gr.end),
-                             aspect='auto')
+                             aspect=aspect)
         else:
             if gr2 is None:
                 gr2 = gr
             # matrix style
             img = ax.matshow(arr, cmap=cmap,
                              extent=(gr.start, gr.end, gr2.end, gr2.start),
-                             aspect='auto')
+                             aspect=aspect)
 
         if self.norm == 'log':
             img.set_norm(colors.LogNorm(vmin=c_min, vmax=c_max))
@@ -170,7 +175,7 @@ class PlotHiCMat(object):
 
             c_bar.ax.yaxis.set_ticks_position('left')
 
-    def get_track_height(self, frame_width):
+    def get_track_height(self, frame_width, *args):
         """
         calculate track height dynamically.
         """
@@ -182,7 +187,7 @@ class PlotHiCMat(object):
             else:
                 height = frame_width * 0.5
         else:
-            height = frame_width * 0.8
+            height = frame_width
 
         if (
             'depth_ratio' in self.properties
@@ -192,7 +197,8 @@ class PlotHiCMat(object):
             height = height * self.properties['depth_ratio']
 
         if 'color_bar' in self.properties and self.properties['color_bar'] != 'no':
-            height += 1.5
+            if self.properties["aspect_ratio"] != 'equal':
+                height += 1.5
 
         return height
 

coolbox/core/track/hist/__init__.py

@@ -1,6 +1,6 @@
 from .base import HistBase
 from .bedgraph import BedGraph
-from .bigwig import BigWig, ABCompartment
+from .bigwig import BigWig
 from .hicfeature import DiScore, InsuScore, Virtual4C
 from .bam import BAMCov
 from .snp import SNP
@@ -12,11 +12,18 @@ def Hist(file, *args, **kwargs) -> HistBase:
     """
     if file.endswith((".bw", ".bigwig", ".bigWig")):
         return BigWig(file, *args, **kwargs)
-    elif file.endswith(('.bedgraph', ".bg", ".bedgraph.bgz", ".bg.bgz")):
+    elif file.endswith(('.bedgraph', ".bg", ".bedgraph.bgz", ".bg.bgz", ".bedGraph", "bedGraph.bgz")):
         return BedGraph(file, *args, **kwargs)
     elif file.endswith((".snp", ".vcf")):
         return SNP(file, *args, **kwargs)
-    elif file.endswith(".bam", ".sam"):
+    elif file.endswith((".bam", ".sam")):
         return BAMCov(file, *args, **kwargs)
     else:
         raise NotImplementedError("Hist only support .bigwig or .bedgraph file now.")
+
+
+def ABCompartment(file, *args, **kwargs):
+    kwargs['threshold'] = 0
+    kwargs['color'] = '#0000ff'
+    kwargs['threshold_color'] = '#ff0000'
+    return Hist(file, *args, **kwargs)

coolbox/core/track/hist/bigwig.py

@@ -104,19 +104,3 @@ class BigWig(HistBase):
                         "{}\n\nPlease check that the chromosome name is part of the bigwig file "
                         "and that the region is valid".format(str(genome_range), self.properties['file']))
 
-
-class ABCompartment(BigWig):
-    """
-    A/B Compartment BigWig track.
-    """
-
-    DEFAULT_PROPERTIES = {
-        "color": "#66ccff",
-        "threshold_color": "#ff9c9c",
-        "threshold": 0,
-    }
-
-    def __init__(self, file, **kwargs):
-        properties = ABCompartment.DEFAULT_PROPERTIES.copy()
-        properties.update(kwargs)
-        super().__init__(file, **properties)

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: