Analysis of Hi-C Data for Discovery of Structural Variations in Cancer

Abstract

Structural variations (SVs) are large genomic rearrangements that can be challenging to identify with current short read sequencing technology due to various confounding factors such as existence of genomic repeats and complex SV structures. Hi-C breakfinder is the first computational tool that utilizes the technology of high-throughput chromatin conformation capture assay (Hi-C) to systematically identify SVs, without being interfered by regular confounding factors. SVs change the spatial distance of genomic regions and cause discontinuous signals in Hi-C, which are difficult to analyze by routine informatics practice. Here we provide step-by-step guidance for how to identify SVs using Hi-C data and how to reconstruct Hi-C maps in the presence of SVs.

1. Introduction

Structural variations (SVs) are large genomic rearrangements including inversions, deletions, duplications, aneuploidy, translocations, and chromoplexy. Every normal individual genome can harbor thousands of germline SVs. While the majority of them have neutral impact to human health, a small proportion of germline SVs that disrupt know tumor suppressor genes like BRCA2 and ATM can confer predisposition to certain cancers [1]. Meanwhile, the presence of a large number of somatic SVs can be found in most cancer genomes [2]. Oncogene activation events have been identified as the product of recurrent SVs, such as translocation-induced gene fusion events involving ABL1 and MLL1 that drive the development of leukemia [3]. SVs have provided clear diagnostic and prognostic information in the clinic [4], as well as successful targets for drug therapies [5–9].

SVs can be detected by various technologies. G-band karyotyping, fluorescence in situ hybridization, and microarray have been historically widely used [10, 11]. Due to their limited throughput and resolution, genome-wide-throughput sequencing-based technologies like whole genome sequencing (WGS) have emerged as attractive alternatives for SV detection in recent years [12, 13]. Despite its success, WGS is limited by its reliance on short sequence reads with much of the structural continuity of the genome being lost, calling for novel method that can effectively identify SVs on repetitive sequences in the genome and resolve complex SVs at affordable cost. In 2018, high-throughput chromosome conformation capture (Hi-C), a technology that had been initially invented for profiling chromatin spatial structure [14], was for the first time adopted for SV detection [15].

Hi-C is capable for SV detection due to its unique experiment design. It starts with fixation of the cells to preserve the spatial structure of chromatin, then the DNA is cleaved by restriction enzyme. DNA ends are marked with biotin treated with DNA ligase, such that the DNA that is spatially close to each other will have a higher chance to be religated and can be further enriched by biotin-selection. Then, reverse cross-linking is performed to free the reconnected DNA from proteins. Sequencing libraries from such DNA are finally constructed and sequenced to generate hundreds of millions of sequencing reads. Religated reads originated from two loci of the genome are mapped back as pairs, and numerous such pairs eventually form a square matrix to describe the frequency of chromatin contacts between any two given regions [14].

Hi-C showed the potential to be a good fit for SV detection, because SVs can alter the spatial distance of two genomic regions that are originally far apart, which greatly increases chance of DNA from those regions to be religated and such reads can be aberrantly enriched as in comparison to the background with similar genomic distance. Indeed, with more and more Hi-C data generated since 2009, it has been visually noticed that some cancer cell lines show specific patterns in Hi-C matrix and they are speculated to be caused by SVs [16]. Hi-C breakfinder is the first method that can systematically identify SVs genome-wide, including SVs’ type, loci, orientation, and confidence score. SVs are called when the increased number of Hi-C contacts significantly deviates from expectation by taking into account the genomic distance, A/B compartment, TADs, and interactions between small chromosomes and between sub-telomeric regions [15]. As an important advantage over WGS, Hi-C breakfinder can robustly identify largescale SVs utilizing reads mapped to anywhere of the joined SVs arms, without being interfered by complex genomic sequences like repeats around the SV breakpoints. The long insert reads also preserve the genetic contiguity for resolving and reconstructing clusters of complex SVs.

Recent studies showed that SVs induce aberrant gene expression by juxtaposing distal enhancers to important cancer genes, a phenomenon known as enhancer hijacking, and reorganizing local chromatin conformation [17]. Therefore, elucidating the SV-induced chromatin conformation change could shed light on novel mechanisms in gene regulation. However, difficulties remain to systematically identify novel chromatin conformation changes such as formation of novel TADs and loop domains. This is further confounded by the heterozygosity of SVs and copy number variations (CNV) at SV loci, and heterogeneity of tumor samples. More sophisticated computational methods are needed to address these questions in future work.

2. Materials

Materials used for the analysis of Hi-C data include computers running Unix or Mac OS operating systems and various software to perform preprocessing of raw data and identification and visualization of SVs. All the necessary softwares are listed in Sect. 2.1, along with the installation instructions on Sect. 2.2.

2.1. Computation Resource Requirement

Unix, Linux, or Mac OS X.

2.1.2. Software Requirement

Samtools: https://github.com/samtools/samtools/releases

Python version 3.x: https://www.python.org/download/releases/3.0/

Conda package: https://docs.conda.io/en/latest/miniconda.html

Pairtools: https://github.com/mirnylab/pairtools

Cooler package: https://github.com/mirnylab/cooler

HiGlass: https://github.com/higlass/higlass-manage

Hi-C breakfinder: https://github.com/dixonlab/hic_breakfinder

2.2. Tool Installation

You will need Unix-based system to install the following tools.

2.2.1. Install BWA

BWA is a fast short-read aligner. We will use it for Hi-C reads mapping.

git clone https://github.com/lh3/bwa.git
cd bwa; make

2.2.2. Install Samtools

Samtools is a tool for interacting with high-throughput sequencing data.

wget https://github.com/samtools/samtools/releases/download/
1.10/samtools-1.10.tar.bz2
tar xvfj samtools-1.10.tar.bz2
cd samtools-1.10
./configure --prefix=$PWD
make && make install

2.2.3. Install Conda

Conda is an open source package management system. We recommend installing conda through Miniconda. Miniconda is a minimal installer for conda which includes conda, Python, and a small number of useful packages. Miniconda installers for Python 3 can be found at: https://docs.conda.io/en/latest/miniconda.html

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86.sh
bash Miniconda3-latest-Linux-x86.sh

2.2.4. Install Pairtools

Pairtools is fast command-line tool to process aligned Hi-C reads and perform various operations on Hi-C pairs and matrix.

conda install -c conda-forge -c bioconda pairtools

2.2.5. Install Cooler

Cooler is a Python library for manipulating .cool/.mcool files for Hi-C maps.

conda install -c conda-forge -c bioconda cooler

2.2.6. Install HiGlass

HiGlass is a visualization tool for Hi-C maps in .cool/.mcool format. Here we install the higlass-manage Python package to visualize Hi-C maps on a local machine.

pip install higlass-manage

2.2.7. Install Hi-C Breakfinder

Hi-C breakfinder is a command line tools for identifying structural variants using Hi-C data. Hi-C breakfinder requires Eigen C++ library and the BamTools library.

First, we need to download and compile Eigen C++ library.

wget https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.tar.bz2
tar xvjf eigen-3.3.7.tar.bz2
cd eigen-3.3.7
mdkir build_dir
cd build_dir
cmake .. -DCMAKE_INSTALL_PREFIX=$PWD
make install

Next, we need to do the same thing for BamTools library. CMake (version >= 3.0) is required to build BamTools. Check CMake version before building BamTools. If CMake is missing or an older version, make sure to install the CMake version >= 3.0.

cmake --version
git clone git://github.com/pezmaster31/bamtools.git
cd bamtools
mdkir build_dir
cd build_dir
cmake -DCMAKE_INSTALL_PREFIX=$PWD ..
make

Last, we install Hi-C breakfinder by linking to the Eigen and Bamtools library.

git clone https://github.com/dixonlab/hic_breakfinder.git
cd hic_breakfinder
./configure CPPFLAGS=“-I /path/to/bamtools/include -I /path/
to/eigen” LDFLAGS=“-L/path/to/bamtools/lib/”
make
make install

2.3. Example Data Sets

In this chapter, we will use the Hi-C data for Caki2 cell line to illustrate the process of discovering SVs using Hi-C data. Caki2 is a human renal cancer cell line. We will download the publicly available Hi-C dataset for Caki2 from ENCODE (https://www.encodeproject.org/, accession number: ENCSR401TBQ). First, we will set up a working directory and then download the data into the directory, for example, creating a folder named “project” under your home directory.

mkdir ~/project
cd ~/project
wget -O Caki2.R1.fastq.gz https://www.encodeproject.org/
files/ENCFF190NLS/@@download/ENCFF190NLS.fastq.gz
wget -O Caki2.R2.fastq.gz https://www.encodeproject.org/
files/ENCFF914EQR/@@download/ENCFF914EQR.fastq.gz

3. Methods

Several computational methods have been proposed to detect structural variation and copy number variations (CNVs) using Hi-C as a tool (Table 1). Among these methods, Hi-C breakfinder developed by our lab detects the most types of SVs with a resolution as high as 1 kb. In this chapter, we will focus on discovering SVs using Hi-C breakfinder.

Table 1.

SV detection tools for Hi-C data

	SV type	Link	Publication
Hi-C breakfinder	Deletion, inversion, duplication, translocation	https://github.com/dixonlab/hic_breakfinder	Dixon et al. Nature Genetics, 2018 [15]
HiCtrans, HiCnv	Translocation, CNVs	https://github.com/ay-lab/HiCtrans https://github.com/ay-lab/HiCnv	Chakraborty et al. Bioinformatics, 2018 [29]
HiNT	Translocation, CNVs	https://github.com/parklab/HiNT	Wang et al. Genome Biology, 2020 [30]

The Hi-C data analysis generally involves the following procedures: (1) mapping Hi-C reads onto a reference genome; (2) generating and normalizing Hi-C matrices; and (3) detection of hierarchies of chromatin structures including A/B compartments [14], Topologically Associating Domains (TADs) [18], sub-TADs [19], or loop domains [20]. Many computational methods have been developed to streamline above procedures [21–24]. The comparison of different Hi-C analysis methods has been described elsewhere [25].

The only user-provided input for Hi-C breakfinder is the read alignment file. Therefore, one can utilize the alignment file (usually, the “bam” file) generated from various Hi-C analysis pipeline. Based on our observations, the differences of alignment files from different pipelines have no impact on the results of Hi-C breakfinder. In the following sections, we will show an in-house pipeline starting from Hi-C read alignment to SV discovery using Hi-C breakfinder and finally visualization of SVs on a Hi-C map.

3.1. Overview of the SV Discovery Pipeline Using Hi-C Breakfinder

We first process the raw Hi-C reads using a pipeline adapted from the 4D Nucleome Hi-C processing pipeline (https://data.4dnucleome.org/resources/data-analysis/hi_c-processing-pipeline). This step will generate an alignment file (.bam) which will be the input for the next step of SV detection, and a matrix file in cooler format from which we can plot Hi-C heatmaps at the SV loci (Fig. 1).

Fig. 1.

An overview of SV discovery with Hi-C data

3.2. Hi-C Read Alignment

We align the Caki2 raw reads to human genome reference GRCh38 using BWA aligner. Users can choose their reference version based on their needs. First, we need to download the reference data and index the reference.

mkdir -p project/ref; cd project/ref
wget ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCA/000/001/405/GCA_000001405.15_GRCh38/seqs_for_alignment_pipelines.ucsc_ids/GCA_000001405.15_GRCh38_no_alt_plus_hs38d1_analysis_set.fna.gz
gunzip GCA_000001405.15_GRCh38_no_alt_plus_hs38d1_analysis_set.fna.gz
bwa index -a bwtsw GCA_000001405.15_GRCh38_no_alt_plus_hs38d1_analysis_set.fna

Next, we align the Caki2 paired-end reads to the indexed reference genome. Note that older pipelines may require the user to align each pair of reads separately due to problematic estimation of insert size during the alignment. This is not necessary in newer versions (> 0.7.15) of BWA in which it is possible to align in one command two mates of a paired-end reads without forcing them to be from one single genomic segment.

cd project
REF= ref/GCA_000001405.15_GRCh38_no_alt_plus_hs38d1_analysis_set.fna
bwa mem -SP5M -t 8 $REF Caki2.R1.fastq.gz Caki2.R2.fastq.gz |
samtools view -bS > Caki2.bam

Next, we want to filter out unmapped/single-sided/duplicated/multi-mapped reads using Pairtools. The minimum mapping quality is set by --min-mapq. Two common values are 1 and 30 as used in Juicer. Here we will set --min-mapq to 1. Pairtools convert alignments to contact pairs. Pair type are denoted as “U” or “R” if the read is uniquely mapped (defined by –min-mapq) or “rescued” which are those derived from chimeric alignment but are informative Hi-C contacts. We will retain pairs marked as “UU,” “UR,” or “RU.”

CHROM_SIZES=/path/to/GRCh38.chrom.sizes
samtools view Caki2.bam | \
pairtools parse -c $CHROM_SIZES --min-mapq 1 --assembly hg38 |
pairtools sort | \
pairtools select ‘(pair_type == “UU” or pair_type == “UR” or
pair_type == “RU”)’ | \
pairtools dedup --max-mismatch 3 --output \
>( pairtools split --output-pairs Caki2.nodups.pairs.gz --
output-sam Caki2.nodups.bam )

The “Caki2.nodups.bam” from Pairtools will serve as input for Hi-C breakfinder. If the restriction enzyme information is available, one may want to filter out reads that fall in the same restriction fragment or self-circles. We will need to generate a restriction site file and then filter the pairs against this restriction site file. Here, we use the “MboI” restriction enzyme as an example.

cooler digest -o restrict_sites.MboI.hg38.bed $CHROM_SIZE $REF
MboI
pairtools select ‘len(chrom1) < 6 and len(chrom2) < 6 and
chrom1 != “chrM” and chrom2 != “chrM”‘ Caki2.nodups.pairs.gz |
\
paritools restrict -f restrict_sites.MboI.hg38.bed | \
awk ‘$0 ~ /^#/{print} $0 !~ /^#/ && $9 != $12{print}’ | bgzip
-c > Caki2.nodups.valid.pairs.gz

3.3. SV Discovery with Hi-C Breakfinder

Besides the alignment file, Hi-C breakfinder requires two expectation files as input. The expectation file is generated by averaging the expected chromatin contacts from a number of normal cell lines. These expected contacts will be used in a negative binomial model for detecting SV-induced chromatin contacts. We can download the expectation file from https://salkinstitute.app.box.com/s/m8oyv2ypf8o3kcdsybzcmrpg032xnrgx

hic_breakfinder --bam-file Caki2.nodups.bam --exp-file-inter inter_expect_1Mb.hg38.txt --exp-file-intra intra_expect_100kb.hg38.txt --name Caki2

Hi-C breakfinder can detect SVs at 1 kb final resolution by setting the option --min-1 kb. This requires frequent cutting enzyme such as MboI and DnpII. One caveat is that if the Hi-C sequencing depth is high, adding this option can significantly increase the run time.

The final SV predictions are in the file named “Caki2.breaks. txt”. The file contains 10 columns (Table 2, the actual result file does not contain the header row), where the “score” column describes the confidence of the SV call. The columns 2–4 denote the possible range of coordinates for the first SV breakpoint, and similarly column 6–8 for the second SV breakpoint. The strand indicates whether the predicted breakpoints are closer to the end (“+” strand) or the start (“−” strand) coordinates. Column 10 is the resolution at which the SV were detected.

Table 2.

Example SV predictions from Hi-C breakfinder

Score	chrl	startl	endl	strandl	chr2	start2	end2	strand2	Resolution
2145.07	chrl2	116800000	117920000	−	chrl 1	124590000	125170000	+	10 lcb
1953.23	chr4	53550000	55660000	−	chr6	55380000	56530000	+	10 kb
805.469	chr4	64330000	64630000	+	chrl 2	64980000	66570000	+	10 kb
146.297	chr5	69370000	72050000	+	chrl	197010000	197310000	−	10 kb
599.733	chr5	71800000	72070000	−	chrl	198420000	198540000	−	10 kb

SVs are often categorized into different types such as deletion, inversion, and translocation. The categorization of an SV can be derived from its coordinates and strands of two breakpoints. Here we provide a set of rules for classifying an SV (Table 3). Note that an inversion is called only if two SVs (four breakpoints) come from the same event. Translocations can be interchromosomal or intrachromosomal.

Table 3.

SV classification

Two breakpoints on the same chromosome?	Strand1/Strand2	SV type
Yes	+/−	Deletion
Yes	−/+	Duplication
Yes	+/+ and −/−	Inversion
Yes	+/+ or −/−	Translocation
No	Any	Translocation

3.4. Visualization of SVs on Normal Hi-C Maps

Now we have the SV predictions, we can visualize the SVs on a normal Hi-C map or a reconstructed Hi-C map. There are many visualization tools available for viewing Hi-C map including standalone software (e.g., Juicerbox, HiGlass) or web-based tools (e.g., 3D Genome Browser [26], WashU Epigenome Browser [27]). Each tool may require as input specific file format of Hi-C matrices. For simplicity, we choose HiGlass and in-house Python scripts for visualization of SVs on Hi-C maps.

First, we will need to generate Hi-C matrix in cooler format, and then normalize the matrix using ICE-normalization [28].

cooler cload pairs -c1 2 -p1 3 -c2 4 -p2 5 --assembly hg38 $CHROM_SIZE:10000 Caki2.nodups.valid.pairs.gz Caki2.10kb.cool cooler balance Caki2.10kb.cool
cooler zoomify -p 8 --balance -o Caki2.10kb.mcool –r 20000,40000,100000,250000,500000,1000000 Caki2.10kb.cool

To visualize the Hi-C matrix with HiGlass, we need to set up a local HiGlass instance. Note that Docker needs to be installed on the computer before running HiGlass instances. To add the Hi-C matrix to a HiGlass instance, we run the command “higlass-manage ingest.”

higlass-manage ingest Caki2.10kb.mcool
higlass-manage start

With a HiGlass instance running, we can access this tool by visiting localhost:8989 in a web browser. Click the “+” sign on the right upper corner and select Caki2.10kb.mcool we just added. It is easy to spot block-like signals in the interchromosomal regions which are different from a normal Hi-C map. Below is example of such signals between chr11 and chr12 (Fig. 2), which corresponds to the chr11-chr12 translocation in the Table 2.

Fig. 2.

Visualization of the chr11-chr12 translocation in HiGlass

The 3D Genome Browser (3dgenome.org) provides a more convenient way to visualize the SV on a Hi-C map. We can type in the region of interest in the “Inter-chrom” module of the website, e.g., the whole chr11 and chr12. We will see a similar Hi-C map as above (Fig. 3).

Fig. 3.

Visualization of the chr11-chr12 translocation in the 3D Genome Browser

Based on Dixon et al. 2018, the SV calls from Hi-C breakfinder is highly accurate and supported by orthogonal techniques such as BioNano optical mapping and whole genome sequencing. In the example in Fig. 2, the unusual signals in the Hi-C heatmap provide a partial proof that the SV detected by Hi-C breakfinder is correct. This SV is further validated by whole genome sequencing using data from Dixon et al. 2018. We observed WGS reads spanning the breakpoints by mapping WGS reads to the concatenated reference genome of chr11 and chr12 (Fig. 4).

Fig. 4.

WGS reads spanning the SV breakpoints. Reads spanning the breakpoint (Colored), Forward read (purple), reverse read (red); Reads not spanning the breakpoint (gray). (Figure generated by svviz)

3.5. Visualization of SVs on Reconstructed Hi-C Maps

The block-like signal in the interchromosomal regions is originated from the strong contact of two distal regions that was brought into proximity by the SV events. When we map the reads onto the reference genome, these contacts would look like “interchromosomal” contacts. We will need to reconstruct the Hi-C map to better understand the change of local chromosomal organization at the SV loci. However, reconstruction of Hi-C map is challenging due to the complexity of SV orientation combinations. An SV is typically composed of two breakpoint each having one of two possible orientations (5′ to 3′, or 3′ to 5′). Based on different combinations of breakpoint orientation, Hi-C map needs to flip or rotate to reflect the altered linear genome.

Here, we provide a Python script for reconstructing and plotting Hi-C map at SV loci (see Appendix). We rebuilt the local Hi-C map of the above chr11-chr12 translocation in Caki2 (Fig. 5). The fine continuity of Hi-C signals and TAD-like structure across the translocation breakpoint are indicative of chromatin reorganization and formation of novel interactions at this region.

Fig. 5.

Reconstructed Hi-C map at chr11-chr12 translocation

clr_path = ‘Caki2.10kb.mcool’
plotHiC_SV(clr_path, (‘chr11’, 125170000, ‘+’), (‘chr12’, 116800000, ‘-’), w=1500000, res=40000)

In the above code, the plotHiC_SV() function is loaded from the script in Appendix. The first parameter is the path to the cooler file, second and third parameters are just the SV breakpoints and orientation from Hi-C breakfinder. We also require the Hi-C map to be plotted at a region of 1.5 Mb up-or-downstream of the breakpoints with resolution of 40 kb.

Lastly, the reconstructed Hi-C map provides a paradigm for studying novel mechanisms of gene regulation in cancer genomics such as enhancer hijacking where a distal enhancer is brought to the proximity of its target gene by SVs. Therefore, we believe the method we described here will shed light on the process of tumorigenesis.

Appendix Python script for making reconstructed Hi-C map at SV loci

import cooler
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcol
from itertools import product
cmap = mcol.LinearSegmentedColormap.from_list(‘custom red’,
[(0, ‘white’), (0.15, ‘white’), (1, ‘#e60000’)], N=256)

def matrix_reader(cool_path, chrom, res, iced, chrom2=None):
   cool_handle = cooler.Cooler(cool_path + “::/resolutions/” +
str(res))
   cool_matrix = cool_handle.matrix(balance=iced).fetch
(chrom)[:]
   if chrom2 is not None:
      cool_matrix = cool_handle.matrix(balance=iced).fetch
(chrom, chrom2)[:]
   else:
      np.fill_diagonal(cool_matrix, 0)
   np.nan_to_num(cool_matrix, copy=False)
   return cool_matrix
   
def concat_matrix(cool_path, c1, o1, c2, o2, res, iced):
   m1 = matrix_reader(cool_path, c1, res, iced)
   m2 = matrix_reader(cool_path, c2, res, iced)
   mi = matrix_reader(cool_path, c1, res, iced, chrom2=c2)
   nrow_1 = m1.shape[0]
   nrow_2 = m2.shape[0]
   nrow_cm = nrow_1 + nrow_2
   cm = np.zeros((nrow_cm, nrow_cm))
   if o1 + o2 == “+-”:
      pass
   elif o1 + o2 == “++”:
      m2 = np.flip(np.flip(m2, 0), 1)
      mi = np.flip(mi, 1)
   elif o1 + o2 == “--”:
      m1 = np.flip(np.flip(m1, 0), 1)
      mi = np.flip(mi, 0)
   elif o1 + o2 == “-+”:
      m1 = np.flip(np.flip(m1, 0), 1)
      m2 = np.flip(np.flip(m2, 0), 1)
      mi = np.flip(np.flip(mi, 0), 1)
   cm[0:nrow_1, 0:nrow_1] = m1
   cm[nrow_1:nrow_cm, nrow_1:nrow_cm] = m2
   cm[0:nrow_1, nrow_1:nrow_cm] = mi * 2
   cm[nrow_1:nrow_cm, 0:nrow_1] = np.rot90(np.flip(mi, 1), 1) *
2
   return cm
   
def concat_tri(fig, ax, mat, c1, o1, c2, o2, res, cmap,
title=None, xlabel=None, ylabel=None):
   n = mat.shape[0]
   t = np.array([[1, 1], [−1, 1]])
   A = np.dot(np.array([(i[1], i[0]) for i in product(range(n
+1), range(n+1))]), t)

   vmax = np.percentile(mat, 92)
   if vmax == 0:
      while vmax == 0 and (perc - 5) > 0:
	 perc = perc - 5
	 vmax = np.percentile(mat, perc)
	 
   vmin = np.min(mat)
   
    img = ax.pcolormesh(A[:, 1].reshape(n+1, n+1), A[:, 0].
reshape(n+1, n+1), mat, cmap=cmap, vmax=vmax, vmin=vmin)
   img.set_rasterized(True)
   
   ax.set_frame_on(False)
   ax.set_ylim([0, n])
   ax.set_aspect(1)
   ax.yaxis.set_visible(False)
   
   # set ticks
   merge_point = 2 * (c1[2] - c1[1] ) // res
   ticks = [0, merge_point // 2, merge_point, merge_point//2+n,
2*n]
   ax.set_xticks(ticks)
   
   # set labels
   ax.set_xticklabels([“, c1[0], “, c2[0], “], size=16)
   
   # ax title
   title = f”{c1[0]}:{c1[1]}-{c1[2]}({o1})\n{c2[0]}:{c2[1]}-{c2
[2]}({o2})”
   ax.set_title(title, pad=20, size=15)
   if xlabel != None:
      ax.set_xlabel(xlabel, labelpad=10, fontsize=15)
   if ylabel != None:
      ax.set_ylabel(ylabel, labelpad=10, fontsize=15)
   # set color bar
   pos0 = ax.get_position()
      cax = fig.add_axes([pos0.x0+pos0.width*0.9, pos0.y0+pos0.
height*0.8, pos0.width*0.01, pos0.height*0.2])
   cbar = fig.colorbar(img, cax=cax, ticks=[vmin, vmax])
      cbar.ax.set_yticklabels([f”{vmin:.1f}”, f”{vmax:.1f}”],
fontsize=12)

   # add an arrow/dashed line at the merge_point
   xmin, xmax, ymin, _ = ax.axis()
   x1, y1 = xmin + merge_point, ymin
   x2, y2 = xmin + merge_point/2, ymin + merge_point/2
   x3, y3 = x1 + (xmax-xmin-merge_point)/2, ymin + (xmax-xmin-
merge_point)/2
      ax.plot((x1, x2), (y1, x2), linestyle=‘:’, linewidth=2,
color=“black”)
      ax.plot((x1, x3), (y1, y3), linestyle=‘:’, linewidth=2,
color=“black”)
   return None
   
def plotHiC_SV(clr, c1, c2, w, res, iced=False):
   o1 = c1[2]
   o2 = c2[2]
   if o1 == “+”:
      start = 0 if (c1[1] - w) < 0 else (c1[1] - w)
      end = c1[1]
   else:
      start = c1[1]
      end = c1[1] + w
   c1 = (c1[0], start, end)
   if o2 == “+”:
      start = 0 if (c2[1] - w) < 0 else (c2[1] - w)
      end = c2[1]
   else:
      start = c2[1]
      end = c2[1] + w
   c2 = (c2[0], start, end)
   mat = concat_matrix(clr, c1, o1, c2, o2, res, iced)
   fig, ax = plt.subplots(1, 1, figsize=(8, 4.3), constraine-
d_layout=True)
   concat_tri(fig, ax, mat, c1, o1, c2, o2, res, cmap=cmap)
   plt.show()