custardpy 0.7.7__tar.gz

custardpy-0.7.7/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: custardpy
+Version: 0.7.7
+Summary: Hi-C analysis tools by Python3
+Home-page: https://github.com/rnakato/custardpy
+Author: Ryuichiro Nakato
+Author-email: rnakato@iqb.u-tokyo.ac.jp
+License: GPL3.0
+Keywords: Hi-C analysis,3D genome,NGS
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.18
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.3
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: matplotlib>=3.2.2
+Requires-Dist: seaborn>=0.11.1
+Requires-Dist: h1d>=0.2.0
+Requires-Dist: hic-straw>=1.3.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CustardPy: Docker image for 3D genome analysis
+
+<img src = "image/CustardPy.jpg" width = 700ptx>
+
+This repository contains
+- Source code of **CustardPy** (PyPI),
+- Dockerfile of **CustardPy** Docker image, 
+- [Full Manual](https://custardpy.readthedocs.io), and
+- Tutorial data of Hi-C and Micro-C analysis using demo data.
+
+## 0. Changelog
+
+See [Changelog](https://github.com/rnakato/CustardPy/blob/main/ChangeLog.md)
+
+## 1. Installation
+
+Docker image is available at [DockerHub](https://hub.docker.com/r/rnakato/custardpy).
+
+### 1.1 Docker
+
+To use the docker command, type:
+
+    # Pull docker image
+    docker pull rnakato/custardpy
+
+    # Container login
+    docker run --rm -it rnakato/custardpy /bin/bash
+    # Execute a command
+    docker run --rm -it -v (your directory):/opt/work rnakato/custardpy <command>
+
+When calling loops using Juicer HICCUPS, supply the ``--gpus all`` option to allow GPU computation (GPU card needed):
+
+    docker run --gpus all -it --rm -it -v (your directory):/opt/work rnakato/custardpy call_HiCCUPS.sh
+
+- user:password
+    - ubuntu:ubuntu
+
+### 1.2 Singularity/Apptainer
+
+Singularity is the alternative way to use CustardPy.
+With this command, you can build the singularity file (.sif) of CustardPy:
+
+    singularity build custardpy.sif docker://rnakato/custardpy
+    
+Instead, you can download the CustardPy singularity image from our [Dropbox](https://www.dropbox.com/scl/fo/lptb68dirr9wcncy77wsv/h?rlkey=whhcaxuvxd1cz4fqoeyzy63bf&dl=0) (We use singularity version 3.8.5).
+
+Then you can run CustardPy with the command:
+
+    singularity exec custardpy.sif <command>
+
+Singularity will automatically mount the current directory. If you want to access the files in the other directory, use the `--bind` option, for instance:
+
+    singularity exec --bind /work custardpy.sif <command>
+
+This command mounts the `/work` directory.
+
+When calling loops using Juicer HICCUPS, supply ``--nv`` option to allow GPU computation (GPU card needed):
+
+    singularity exec --bind /work custardpy.sif call_HiCCUPS.sh
+
+## 2. Quickstart
+
+    # download Churros/tutorial directory
+    git clone https://github.com/rnakato/CustardPy.git
+    cd CustardPy/tutorial/Hi-C/
+
+    # download fastq and genome data and make index
+    bash 00_getdata.sh
+
+    # Execute Juicer pipeline
+    bash QuickStart_juicer.sh
+
+## 3. Usage
+
+See https://custardpy.readthedocs.io for the detailed Manual.
+
+## 4. Build Docker image from Dockerfile
+
+First clone and move to the repository
+
+    git clone https://github.com/rnakato/CustardPy.git
+    cd CustardPy/Docker
+
+Then type:
+
+    docker build -f Dokerfile.<version> -t <account>/custardpy_juicer .
+
+## 5. Citation
+Please cite this reference when using CustardPy in your study.
+
+- Nakato R, Sakata T, Wang J, Nagai LAE, Nagaoka Y, Oba GM, Bando M, Shirahige K, Context-dependent perturbations in chromatin folding and the transcriptome by cohesin and related factors, *Nature Communications*, 2023. doi: [10.1038/s41467-023-41316-4](https://www.nature.com/articles/s41467-023-41316-4)

custardpy-0.7.7/README.md

@@ -0,0 +1,32 @@
+# CustardPy (PyPI)
+
+The core component of CustardPy can be installed using pip3:
+
+## Requirements
+
+The following are required before installing CustardPy:
+
+- Python 3.7+
+
+## Installation
+
+    pip3 install custardpy
+
+## ChangeLog
+
+- 0.7.7 (2026.3.16)
+   - Bug fix in `plotInsulationScore` where the matplotlib.pyplot was not imported.
+
+- 0.7.6 (2025-06-27)
+   - Lint check with Ruff.
+
+- 0.7.2 (2024-03-05)
+   - Fixed the error messages in `plotHiCfeature_module.py`
+
+- 0.7.1 (2024-03-03)
+   - Added the function `plot_SamplePair_triu`
+
+- 0.7.0 (2024-03-03)
+   - Added this ChangeLog
+   - Create `plotHiCfeature_module.py`
+   - Add `__version__` to __init__.py

custardpy-0.7.7/custardpy/CannyEdge.py

@@ -0,0 +1,75 @@
+# Copyright(c) Ryuichiro Nakato <rnakato@iqb.u-tokyo.ac.jp>
+# All rights reserved.
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+def getlinalg(gradient, wid):
+    data = []
+    for i in np.arange(gradient.size - wid):
+        array = gradient[i:i+wid]
+        data.append(np.linalg.norm(array))
+    return data
+
+def getMaxGradient(arr, val, order_argrelmax, wid, posi):
+    from scipy.signal import argrelmax
+    index = argrelmax(arr, order=order_argrelmax)
+    index = index[0][np.where(arr[index[0]] > val)]
+    index += wid # linalgのindexは元配列よりwidだけずれているため
+    index = index[np.where((index < posi - 5) | (index > posi + 5))] # 対角線周辺(±5bin)の勾配は無視
+    return index
+
+def imshowWithvLine(A, posi, index, title, cm):
+    fig = plt.figure(figsize=(6, 6))
+    ax1 = fig.add_subplot(1,1,1)
+    ax1.imshow(A, clim=(-2, 2), cmap=cm)
+    ax1.set_title(title)
+    plt.hlines(y=posi, xmin=0, xmax=190, colors='black', linewidths=1)
+    for x in index:
+        plt.vlines(x=x, ymin=0, ymax=190, colors='green', linewidths=1, linestyles='dashed')
+
+def getIndexMatrix(linalg, segment_len, limit_val, order_argrelmax, wid):
+    indexMatrix = []
+    length = int(linalg.shape[0]/segment_len)
+    for i in range(length):
+        lin = linalg[i*segment_len:(i+1)*segment_len].mean(axis=0)
+        index_merged = getMaxGradient(lin, limit_val, order_argrelmax, wid, (i+0.5)*segment_len)
+        indexMatrix.append(index_merged)
+        
+    return indexMatrix
+
+def imshowWithBoundary(A, indexMatrix, segment_len, cm):
+    fig = plt.figure(figsize=(8, 8))
+    ax1 = fig.add_subplot(1,1,1)
+    ax1.imshow(A, clim=(-2, 2), cmap=cm)
+    for x, array in enumerate(indexMatrix):
+        for y in array:
+            plt.vlines(x=y, ymin=x*segment_len, ymax=(x+1)*segment_len, colors='green', linewidths=1)
+    for x, array in enumerate(indexMatrix):
+        for y in array:
+            plt.hlines(y=y, xmin=x*segment_len, xmax=(x+1)*segment_len, colors='green', linewidths=1)
+
+def getPeakfromIndexMatrix(indexMatrix, order):
+    import collections
+    flatten = []
+    for array in indexMatrix:
+        flatten.extend(array)
+
+    dict = collections.Counter(flatten)
+    lists = sorted(dict.items())
+    x, y = zip(*lists)
+    array = np.zeros(max(x)+1)
+    for a, b in zip(x,y):
+        array[a] = b
+
+    from scipy.signal import argrelmax
+    index = argrelmax(array, order=order)
+    index = index[0]
+    
+    fig = plt.figure(figsize=(12, 4))
+    plt.plot(array)
+    for x in index:
+        plt.vlines(x=x, ymin=0, ymax=array.max(), colors='green', linewidths=1, linestyles='dashed')
+    plt.show()
+    
+    return index

custardpy-0.7.7/custardpy/Cluster.py

@@ -0,0 +1,198 @@
+# Copyright(c) Ryuichiro Nakato <rnakato@iqb.u-tokyo.ac.jp>
+# All rights reserved.
+
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+def KMeansPlot(matrix, title, ncluster):
+    import matplotlib.cm
+    from sklearn.cluster import MiniBatchKMeans
+    model = MiniBatchKMeans(random_state=0, n_clusters=ncluster, max_iter=10000)
+    kmeans = model.fit_predict(matrix)
+    color = matplotlib.cm.brg(np.linspace(0,1, np.max(kmeans) - np.min(kmeans)+1))
+
+    for i in range(np.min(kmeans), np.max(kmeans)+1):
+        plt.plot(matrix[kmeans == i][:,0],    matrix[kmeans == i][:,1], ".", color=color[i])
+        plt.text(matrix[kmeans == i][:,0][0], matrix[kmeans == i][:,1][0], str(i+1), color="black", size=16)
+    plt.title(title, size=16)
+
+    return kmeans
+
+# DBSCANでクラスタリング
+def DBSCANPlot(matrix, title, eps):
+    from sklearn.cluster import DBSCAN
+    import matplotlib.cm
+    model = DBSCAN(eps=eps)
+    dbscan = model.fit_predict(matrix)
+    color = matplotlib.cm.brg(np.linspace(0,1,np.max(dbscan) - np.min(dbscan)+1))
+
+    for i in range(np.min(dbscan), np.max(dbscan)+1):
+        plt.plot(matrix[dbscan == i][:,0],    matrix[dbscan == i][:,1], ".", color=color[i])
+        plt.text(matrix[dbscan == i][:,0][0], matrix[dbscan == i][:,1][0], str(i+1), color="black", size=16)
+    plt.title(title, size=16)
+    return dbscan
+
+def getSumMatrix(A, boundary):
+    submatrix = np.vsplit(A, boundary)
+    for i, mat in enumerate(submatrix):
+        ms = np.hsplit(mat, boundary)
+        for j, m in enumerate(ms):
+            if j==0:
+                data = m.mean()
+            else:
+                data = np.r_[data, m.mean()]
+        if i==0:
+            gs = data
+        else:
+            gs = np.c_[gs, data]
+    return gs
+
+def get_ellipse_coords(a=0.0, b=0.0, x=0.0, y=0.0, angle=0.0, k=2):
+    """ Draws an ellipse using (360*k + 1) discrete points
+    k = 1 means 361 points (degree by degree)
+    a = major axis distance,
+    b = minor axis distance,
+    x = offset along the x-axis
+    y = offset along the y-axis
+    angle = clockwise rotation [in degrees] of the ellipse;
+        * angle=0  : the ellipse is aligned with the positive x-axis
+        * angle=30 : rotated 30 degrees clockwise from positive x-axis
+
+    this function is obtained from : http://scipy-central.org/item/23/2/plot-an-ellipse
+    """
+    pts = np.zeros((int(180*k+1), 2))
+
+    beta = -angle * np.pi/180.0
+    sin_beta = np.sin(beta)
+    cos_beta = np.cos(beta)
+    alpha = -np.radians(np.r_[0.:180.:1j*(180*k+1)])
+
+    sin_alpha = np.sin(alpha)
+    cos_alpha = np.cos(alpha)
+
+    pts[:, 0] = x + (a * cos_alpha * cos_beta - b * sin_alpha * sin_beta)
+    pts[:, 1] = y + (a * cos_alpha * sin_beta + b * sin_alpha * cos_beta)
+
+    return pts
+
+def restore_mat(mat, ref_data, columnname):
+    a = pd.concat([ref_data, mat], axis=1, join='outer')
+    a = a.iloc[:, ref_data.shape[1]:a.shape[1]]
+    return a[columnname].unstack()
+
+def plotArc(s, e):
+    rad = (e - s)/2
+    center = (s + e)/2
+    pts = get_ellipse_coords(a=rad, b=1.0, x=center)
+    plt.plot(pts[:,0], pts[:,1])
+
+def plotVsegmentArc(vsegment, s, e, xstart, resolution):
+    def getBed(index, xstart, resolution):
+        s = index[0]/resolution - xstart
+        e = index[-1]/resolution + 1 - xstart
+        common = int((s+e)/2)
+        return s,e,common
+
+    if(s>e): return
+    sindex = vsegment[s]
+    eindex = vsegment[e]
+    s1, e1, c1 = getBed(sindex, xstart, resolution)
+    s2, e2, c2 = getBed(eindex, xstart, resolution)
+    plotArc(c1, c2)
+#    plt.axhline(y=0, xmin=s1, xmax=e1)
+#    plt.axhline(y=0, xmin=s2, xmax=e2)
+
+def plotVArc(s, e, xstart, resolution):
+    def getBed(index, xstart, resolution):
+        s = index/resolution - xstart
+        e = index/resolution + 1 - xstart
+        common = int((s+e)/2)
+        return s,e,common
+
+    if(s>e): return
+    s1, e1, c1 = getBed(s, xstart, resolution)
+    s2, e2, c2 = getBed(e, xstart, resolution)
+    plotArc(c1, c2)
+    plt.axhline(y=0, xmin=s1, xmax=e1)
+    plt.axhline(y=0, xmin=s2, xmax=e2)
+
+def getHead(labels):
+    nlabels = len(labels)
+    a = []
+    for i in range(nlabels):
+        for j in range(i+1,nlabels):
+            a.append(labels[i] + "-" + labels[j])
+    return a
+
+def get_corr_allcluster(sub3d, ncluster, kmeans, labels):
+    def getmat(df, nlabels):
+        corr_mat = df.corr(method='spearman')
+        corr_mat = corr_mat.values
+        a = []
+        for i in range(nlabels-1):
+            for x in corr_mat[i,i+1:nlabels]: a.append(x)
+        return a
+
+    nlabels = len(labels)
+    for cl in range(ncluster):
+        df = pd.DataFrame(sub3d[kmeans==cl])
+        a = getmat(df, nlabels)
+        if cl==0:
+            mat = a
+        else:
+            mat = np.c_[mat, a]
+
+    df = pd.DataFrame(sub3d)
+    a = getmat(df, nlabels)
+    mat = np.c_[mat, a]
+
+    corr_allcluster = pd.DataFrame(mat.T, columns=getHead(labels))
+    corr_allcluster = corr_allcluster.rename(index={ncluster: 'All'})
+    return corr_allcluster
+
+
+def draw_samples_whole(matrix, labels, cm):
+    nsample = matrix.shape[0]
+    plt.figure(figsize=(16, 6))
+    for i in range(nsample):
+        ax = plt.subplot(1, nsample+1, i+1)
+        plt.imshow(matrix[i], clim=(-2, 2), cmap=cm)
+        ax.set_title(labels[i])
+    plt.tight_layout()
+    plt.show()
+
+def addzero_to_3dmatrix(mat, difflength, resolution):
+    diff = difflength / resolution
+    lim_pzero = 0.1
+    mat[np.isnan(mat)] = 0
+    index_zero = np.sum(np.sum(mat, axis=0)>0, axis=1)/mat.shape[1] < lim_pzero
+    mat[:,index_zero] = 0
+    mat[:,:,index_zero] = 0
+    for i in range(mat.shape[1]):
+        for j in range(mat.shape[1]):
+            if j < i: mat[:,i,j] = 0
+            if j > i + diff: mat[:,i,j] = 0
+
+def make_refdata(ref_matrix, ref, labels, resolution, difflim, cm):
+    import copy
+    matrix = copy.deepcopy(ref_matrix)
+    # 0が多い行・列を0に
+    # 10M以上離れた領域も0に
+    addzero_to_3dmatrix(matrix, 10000000, resolution)
+
+    draw_samples_whole(matrix, labels, cm)
+
+    ref_data = matrix.reshape(ref_matrix.shape[0], ref_matrix.shape[1]*ref_matrix.shape[2]).T
+    ref_data = pd.DataFrame(ref_data, index=ref.index, columns=labels)
+    ref_data.index.names = ['position1', 'position2']
+    return ref_data
+
+def make_sub3d(_ref_data):
+    # 0を１つでも含む行を削除
+    mat = _ref_data
+    nonzero = np.logical_not((mat == 0).any(axis=1))
+    mat = mat[nonzero]
+#    plt.imshow(restore_mat(sub3d, _ref_data, "Rad21").iloc[550:650,550:650], clim=(-2, 2), cmap=cm)
+#    plt.show()
+    return mat

custardpy-0.7.7/custardpy/DEG_boundary_analysis

@@ -0,0 +1,155 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright(c) Ryuichiro Nakato <rnakato@iqb.u-tokyo.ac.jp>
+# All rights reserved.
+
+import argparse
+import os
+import sys
+import pandas as pd
+import subprocess
+import numpy as np
+import random
+from pybedtools import BedTool
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+
+def calculate_ratio(border_bed, gene_bed, allgene_bed):
+    gene_all = allgene_bed.intersect(border_bed, u=True)
+    gene_deg = gene_bed.intersect(border_bed, u=True)
+
+    gene_num = len(gene_all)
+    deg_num = len(gene_deg)
+
+    return deg_num / gene_num if gene_num != 0 else 0
+
+def back_function(border, gene_bed, permutation_times, len_border, allgene_bed):
+    dist_randomRatio = []
+    for _ in range(permutation_times):
+        randomBorder = border.sample(len_border)
+        randomBorder_bed = BedTool.from_dataframe(randomBorder)
+        randomRatio = calculate_ratio(randomBorder_bed, gene_bed, allgene_bed)
+        dist_randomRatio.append(randomRatio)
+
+    d = np.array(dist_randomRatio)
+    return [np.quantile(d, quantile) for quantile in [0.25, 0.75, 0.05, 0.95, 0.025, 0.975]]
+
+def plot_graph(df, outputname):
+    plt.rcParams['font.size'] = '12'
+
+    plt.plot(df["Distance"]/1000,df["Ratio"],"m")
+    plt.fill_between(df["Distance"]/1000,df["low50"],df["high50"],color="grey",alpha=0.5)
+    plt.fill_between(df["Distance"]/1000,df["low90"],df["high90"],color="grey",alpha=0.3)
+    plt.fill_between(df["Distance"]/1000,df["low95"],df["high95"],color="grey",alpha=0.1)
+    plt.xlabel("Distance from TAD boundary (kb)",fontsize=15)
+    plt.ylabel("Fraction of DEGs",fontsize=15)
+
+    q50 = mpatches.Patch(color='grey',alpha=0.5,label='50% quantile')
+    q90 = mpatches.Patch(color='grey',alpha=0.3,label='90% quantile')
+    q95 = mpatches.Patch(color='grey',alpha=0.1,label='95% quantile')
+    plt.legend(handles=[q50, q90, q95],fontsize=12)
+
+    plt.savefig(outputname)
+
+def set_border(border, i):
+    border_temp = border.copy()
+    border_temp[1] = np.maximum(border_temp[1] - i, 0)
+    border_temp[2] = border_temp[2] + i
+    return border_temp
+
+def permutation_test_ratio(border, allborder, gene_bed, allgene_bed, permutation_times, max_distance, distance_step):
+    select_ratios = []
+    random_ratios = []
+    positions = []
+
+    for i in range(0, max_distance +1, distance_step):
+        print(f"Distance {i} bp")
+        border_temp = set_border(border, i)
+        allborder_temp = set_border(allborder, i)
+
+        border_temp_bed = BedTool.from_dataframe(border_temp)
+        select_ratios.append(calculate_ratio(border_temp_bed, gene_bed, allgene_bed))
+
+        len_border = len(border)
+        random_ratios.append(back_function(allborder_temp, gene_bed, permutation_times, len_border, allgene_bed))
+        positions.append(i)
+
+    random_ratios = np.array(random_ratios)    # convert list of tuples to numpy array
+    random_ratios = random_ratios.transpose()  # transpose array to get separate arrays for each quantile
+
+    return select_ratios, random_ratios, positions
+
+def main():
+    parser = argparse.ArgumentParser()
+    tp = lambda x:list(map(str, x.split(':')))
+    parser.add_argument("--border_test",  help="<TAD boundary to be tested (BED format)>", type=str, default=None)
+    parser.add_argument("--border_control",  help="<TAD boundary as background (BED format)>", type=str, default=None)
+    parser.add_argument("--gene_test",  help="<Genes to be tested (BED format)>", type=str, default=None)
+    parser.add_argument("--gene_control",  help="<Genes as background (BED format)>", type=str, default=None)
+    parser.add_argument("-o", "--output", help="Output name (*.pdf or *.png, default: output.pdf)", type=str, default="output.pdf")
+    parser.add_argument("-n", help="Number of permutation (default: 1000)", type=int, default=1000)
+    parser.add_argument("--maxdistance", help="Max distance (bp, default: 300000)", type=int, default=300000)
+    parser.add_argument("--step", help="Step of distance (bp, default: 10000)", type=int, default=10000)
+
+    args = parser.parse_args()
+#    print(args)
+
+    if args.border_test is None:
+        print ("Error: specify --border_test.")
+        parser.print_help()
+        exit()
+    if args.border_control is None:
+        print ("Error: specify --border_control.")
+        parser.print_help()
+        exit()
+    if args.gene_test is None:
+        print ("Error: specify --gene_test.")
+        parser.print_help()
+        exit()
+    if args.gene_control is None:
+        print ("Error: specify --gene_control.")
+        parser.print_help()
+        exit()
+
+    print ("   TAD boundary to be tested: " + args.border_test)
+    print ("   TAD boundary as background: " + args.border_control)
+    print ("   Genes to be tested: " + args.gene_test)
+    print ("   Genes as background: " + args.gene_control)
+    print ("   Permutation time: " + str(args.n))
+    print ("   Max distance: " + str(args.maxdistance) + " bp")
+    print ("   Step of distance: " + str(args.step) + " bp")
+    print ("   Output file: " + args.output)
+
+    border = pd.read_csv(args.border_test, sep="\t", header=None)
+    allborder = pd.read_csv(args.border_control, sep="\t", header=None)
+    gene_bed = BedTool(args.gene_test)
+    allgene_bed = BedTool(args.gene_control)
+    permutation_times = args.n
+    outputname = args.output
+    max_distance = args.maxdistance
+    distance_step = args.step
+
+    select_ratios, random_ratios, positions = permutation_test_ratio(border,
+                                                                     allborder,
+                                                                     gene_bed,
+                                                                     allgene_bed,
+                                                                     permutation_times,
+                                                                     max_distance,
+                                                                     distance_step)
+
+    df = pd.DataFrame({
+        'Distance': positions,
+        'Ratio': select_ratios,
+        'low50': random_ratios[0],
+        'high50': random_ratios[1],
+        'low90': random_ratios[2],
+        'high90': random_ratios[3],
+        'low95': random_ratios[4],
+        'high95': random_ratios[5]
+    })
+
+    plot_graph(df, outputname)
+
+
+if(__name__ == '__main__'):
+    main()

custardpy-0.7.7/custardpy/DirectionalRelativeFreq.py

@@ -0,0 +1,102 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright(c) Ryuichiro Nakato <rnakato@iqb.u-tokyo.ac.jp>
+# All rights reserved.
+
+import numpy as np
+import pandas as pd
+from scipy import ndimage
+import argparse
+
+def make3dmatrixRatio(samples, smoooth=3):
+    n = len(samples)
+    Ct = ndimage.median_filter(samples[0].getlog(isNonZero=False), smoooth)
+    x, y = Ct.shape
+    for i, sample in enumerate(samples[1:]):
+        if i==0:
+            data = sample.getlog(isNonZero=False)
+            Matrix = ndimage.median_filter(data - Ct, smoooth)
+        else:
+            data = sample.getlog(isNonZero=False)
+            M = ndimage.median_filter(data - Ct, smoooth)
+            Matrix = np.concatenate((Matrix, M))
+    Matrix = Matrix.reshape(n-1,x,y)
+    return Matrix
+
+def getDirectionalRelativeFreq(mat, resolution, strand, *,
+                               startdistance=0, distance=2000000):
+    if (startdistance >= distance):
+        print ("getDirectionalRelativeFreq: Error: startdistance > enddistance")
+        exit(1)
+
+    arraysize = mat.shape[0]
+    array = np.zeros(arraysize)
+    nbin = int(distance/resolution)
+    startbin = int(startdistance/resolution) +1
+    for i in range(nbin, arraysize - nbin):
+        if (strand == "+"):
+            val = mat[i+startbin:i+nbin+1, i].mean()
+        else:
+            val = mat[i, i-nbin:i-startbin+1].mean()
+        array[i] = val
+
+    return array
+
+class DirectionalRelativeFreq:
+    def __init__(self, mat, resolution, *, startdistance=0, distance=2000000):
+        self.arrayplus  = getDirectionalRelativeFreq(mat, resolution, "+", startdistance=startdistance, distance=distance)
+        self.arrayminus = getDirectionalRelativeFreq(mat, resolution, "-", startdistance=startdistance, distance=distance)
+
+    def getarrayplus(self):
+        return self.arrayplus
+
+    def getarrayminus(self):
+        return self.arrayminus
+
+    def getarraydiff(self):
+        return self.arrayplus - self.arrayminus
+
+def output_DRF(args):
+    from custardpy.HiCmodule import JuicerMatrix
+    resolution = args.resolution
+    samples = []
+    samples.append(JuicerMatrix("RPM", args.control, resolution))
+    samples.append(JuicerMatrix("RPM", args.input, resolution))
+
+    smooth_median_filter = 3
+    EnrichMatrices = make3dmatrixRatio(samples, smooth_median_filter)
+
+#    import pdb; pdb.set_trace()
+
+    drf = DirectionalRelativeFreq(EnrichMatrices[0], resolution)
+    if (args.drf_right):
+        array = drf.getarrayplus()
+    elif (args.drf_left):
+        array = drf.getarrayminus()
+    else:
+        array = drf.getarraydiff()
+
+    df = pd.DataFrame(array)
+    df.columns = ["DRF"]
+    df["chr"] = args.chr
+    df["start"] = np.arange(len(array)) * resolution
+    df["end"] = df["start"] + resolution
+    df = df.loc[:,["chr","start","end","DRF"]]
+
+    df.to_csv(args.output + ".bedGraph", sep="\t", header=False, index=False)
+#    np.savetxt(args.output, array, fmt="%0.6f")
+
+if(__name__ == '__main__'):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="Input matrix", type=str)
+    parser.add_argument("control", help="Control matrix", type=str)
+    parser.add_argument("output", help="Output prefix", type=str)
+    parser.add_argument("chr", help="chromosome", type=str)
+    parser.add_argument("resolution", help="Resolution of the input matrix", type=int)
+    parser.add_argument("--drf_right",   help="(with --drf) plot DirectionalRelativeFreq (Right)", action='store_true')
+    parser.add_argument("--drf_left",   help="(with --drf) plot DirectionalRelativeFreq (Left)", action='store_true')
+
+    args = parser.parse_args()
+    print(args)
+
+    output_DRF(args)