DeCGR: an interactive toolkit for deciphering complex genomic rearrangements from Hi-C data Authors: Junping Li, Minghui Sun, Yusen Ye, Lin Gao Published: 2024 ABSTRACT BackgroundComplex genomic rearrangements (CGRs) drive the restructuring of chromatin architecture, resulting in significant interactions among rearranged fragments, visible as anomalous interaction blocks in chromatin contact maps generated by chromosome conformation capture technologies such as Hi-C. These blocks not only offer the orientation and genome coordinates of rearranged fragments but also filter out false positive CGRs, thereby facilitating CGR assembly. Despite this, there is a lack of interactive graphical software tailored for this purpose.ResultsWe present DeCGR, a user-friendly Python toolbox specifically designed for deciphering CGRs in Hi-C data. DeCGR consists of four independent execution components. The Breakpoint Filtering module identifies and filters simple rearrangements, providing the coordinates of rearrangement breakpoints. The Fragment Assembly module automatically assembles CGRs and visualizes the assembly process, facilitating the direct association between anomalous interaction blocks and CGR events. The Validation CGRs module verifies the completeness and accuracy of CGRs by generating the Hi-C map with CGRs through a simulation process and examines the difference from the original Hi-C maps. This module displays both the original and the simulated Hi-C map with highlighted rearranged fragment boundaries for rapid review to assess the CGRs. Finally, the Reconstruct Hi-C Map module provides the reconstructed Hi-C map based on the determined CGRs, allowing users to directly observe the impact of rearrangements on chromatin structure.ConclusionsDeCGR is designed specifically for biologists who aim to explore CGRs from Hi-C data. It provides a validation module to ensure the completeness and correctness of CGRs. Additionally, it allows users to generate CGR assembly results and reconstruct the Hi-C map with just one click. DeCGR provides intuitive visualization results for each module, allowing users to easily associate CGRs with Hi-C maps. DeCGR is operable through a user-friendly graphical interface. Source codes are freely available at https://github.com/GaoLabXDU/DeCGR.Supplementary InformationThe online version contains supplementary material available at 10.1186/s12864-024-11085-5. Background Genomic rearrangements encompass mutational changes in the genome such as deletions, duplications, insertions, inversions, or translocations [1]. More recently, complex genomic rearrangements (CGRs), such as chromothripsis and chromoplexy, have been identified as novel features of cancer genomes [2, 3]. CGRs are intricate events characterized by three or more breakpoint junctions resulting from a mutational process. Interpreting these events is challenging yet essential for detecting oncogenic driver events [4]. Many of these rearrangements do not directly affect the DNA sequence of oncogenes (gene fusion or amplification) but modulate their regulatory mechanisms [5]. For example, the rearrangements disrupt the higher-order chromatin structure, resulting in the rewiring of pathogenic enhancer-promoter interactions [6]. Recent advances in chromatin conformation capture technologies, especially high-throughput chromosome conformation capture (Hi-C) [7], have facilitated the investigation of the pathogenic potential of these rearrangements [8]. Additionally, the Hi-C map can provide direct evidence for genomic rearrangements, as each type of rearrangement produces a distinctive observable contact signature at the breakpoint [9]. This visualization can greatly decrease the incidence of false positive rearrangements [10]. However, unlike simple rearrangement events, CGRs are challenging to characterize visually. CGRs severely destroy the Hi-C map due to the abnormal contact blocks formed by each breakpoint in CGRs. Therefore, a prerequisite for investigating the connection between CGRs and chromatin structure is the assembly of CGRs from the Hi-C map [11]. In recent studies, manual inspection has been employed to assemble CGRs, aiming to interpret the molecular mechanism underlying pathogenesis using a reconstructed altered Hi-C map [8, 12]. However, the complexity of CGR events makes manual assembly a time-consuming and labor-intensive process. More recently, NeoLoopFinder [13] has been developed to efficiently identify enhancer-hijacking events and can automatically reconstruct the Hi-C map with CGRs. However, it requires multiple steps, along with additional breakpoint information, including breakpoint orientation, which must be obtained from another tool like EagleC [14]. As a result, researchers need to combine both EagleC and NeoLoopFinder to explore CGRs. Therefore, a unified software solution is essential to streamline and enhance the exploration of CGR events in Hi-C maps. Furthermore, it is a challenge to fully characterize CGRs from the Hi-C map, as it requires determining the order and orientation of rearranged fragments with precise breakpoints. Whether assembled manually or through computational methods, CGRs are typically screened from the large-scale candidate simple rearrangement events. However, many simple rearrangements have already been neglected because of the impact of complicated mutational signals on existing rearrangement-detected methods [15]. Moreover, the conflicts between overlapping signals could obscure the order of rearranged fragments [12]. Therefore, a validation step is necessary to assess the completeness and correctness of the assembled CGRs. To address these challenges, we developed DeCGR, an open-source, modular and scalable software toolbox for deciphering CGRs in Hi-C data. The key functional module of DeCGR, the Validation CGRs, is employed for validating the completeness and correctness of assembled CGRs. This module generates the Hi-C map containing CGRs through a simulation process and verifies CGRs by visually comparing the simulated Hi-C map with the original Hi-C map. Users can fully attain CGR events through iterative visual exploration and adjustment of rearranged fragments. Additionally, the Breakpoint Filtering module identifies and filters breakpoints, while the Fragment Assembly module automatically assembles CGRs. The output graphics intuitively associate the assembled CGRs with the disordered chromatin contact map. Lastly, the Reconstruct Hi-C Map module visually renders the reconstructed Hi-C map based on determined CGRs, providing users with a direct and intuitive understanding of the impact of rearrangements on chromatin structure. Implementation DeCGR is implemented in Python and can be run through a graphical user interface (Fig. 1). It provides comprehensive user and developer documentation, along with a test dataset to assist users. DeCGR can be easily installed using standard package management tools (conda and PyPi). It runs seamlessly on Windows, Linux and macOS. DeCGR is organized into modules, with each module dedicated to a specific task, including Breakpoint Filtering, Fragment Assembly, Validation CGRs, and Reconstruct Hi-C Map modules. The modular design of DeCGR allows for flexibility in addressing the needs of different users. The Breakpoint Filtering module identifies and filters breakpoints, providing the coordinates of simple rearrangement breakpoints (Fig. 2a), which are then used in the Fragment Assembly module to reconstruct candidate CGR events (Fig. 2b). The Validation CGRs module generates a simulated Hi-C map with candidate CGR events and provides a visual comparison between the real and simulated contact maps, enabling users to manually refine the rearrangement events (Fig. 2c). Finally, the Reconstruct Hi-C Map module generates a reconstructed Hi-C map based on the confirmed rearrangement (Fig. 2d). Fig. 1A screenshot of the DeCGR user interface. DeCGR consists of four functional modules: Breakpoint filtering, Fragment Assembly, Validation CGRs, and Reconstruct Hi-C Map A screenshot of the DeCGR user interface. DeCGR consists of four functional modules: Breakpoint filtering, Fragment Assembly, Validation CGRs, and Reconstruct Hi-C Map Breakpoint Filtering The Breakpoint Filtering module offers two key functionalities: (1) Breakpoint identification with HiSV [16] for detecting simple rearrangement breakpoints, with customizable parameters (window size, weight, and cutoff). The results of HiSV are displayed immediately, allowing users to assess the identified breakpoints. (2) Visualization and false positive filtering: This tool provides an interactive visualization of identified simple rearrangements, allowing users to filter out false positives through visual inspection. By zooming in on abnormal regions and clicking on peaks, users can obtain more accurate breakpoint coordinates. For simple rearrangement identification using HiSV, users only need to input a cool or mcool tumor Hi-C file. For filtering pre-identified rearrangements, users can input previously identified rearrangements into the module. These rearrangements can be detected using other Hi-C data-based structural variation (SV) detection methods [14, 17–19] or other data types, such as WGS-based methods like LUMPY [20] (Figure S1). Fig. 2Overview of the DeCGR Workflow. This figure illustrates the modular architecture of DeCGR. (a) Breakpoint Filtering Module identifies and filters rearrangement breakpoints. (b) Fragment Assembly Module assembles candidate CGR events. (c) Validation CGRs Module validates the completeness and accuracy of the assembled CGRs. (d) Reconstruct Hi-C Map Module generates a reconstructed Hi-C map based on the identified CGRs Overview of the DeCGR Workflow. This figure illustrates the modular architecture of DeCGR. (a) Breakpoint Filtering Module identifies and filters rearrangement breakpoints. (b) Fragment Assembly Module assembles candidate CGR events. (c) Validation CGRs Module validates the completeness and accuracy of the assembled CGRs. (d) Reconstruct Hi-C Map Module generates a reconstructed Hi-C map based on the identified CGRs Fragment Assembly The Fragment Assembly module assembles candidate CGRs using the provided breakpoint coordinates. It requires a tumor Hi-C contact map and a breakpoint file as input. The results interface displays a slice of the Hi-C map corresponding to the rearrangement events, directional links between rearranged fragments, and schematic diagrams illustrating the assembled CGRs. It provides a clear visual association between CGRs and chromatin interaction maps (Figure S2). Validation CGRs The Validation CGRs module allows users to verify the completeness and accuracy of the assembled CGRs. This module follows the standard approach used in structural variation (SV) validation, where simulation or visualization is often employed to verify SV calls [21, 22]. Simulation is a particularly effective method for validating CGRs, as it generates simulated data that reflect the identified rearrangements. This allows for a direct comparison with real Hi-C data, ensuring the accuracy and reliability of the rearrangement. By embedding the identified CGRs into a normal sample that has not undergone rearrangements, we generate a simulated contact map containing the abnormal interaction patterns caused by the candidate rearrangements. This enables users to compare the simulated map with the abnormal regions observed in the real sample to confirm the CGR events. For example, users can assess whether specific abnormal regions are missing or excessive and whether the interaction patterns in these regions are consistent with the predicted rearrangements. This module requires the assembly result file and Hi-C data from both tumor and control samples as input. The simulated Hi-C map is displayed alongside the original Hi-C map in heatmap format, with rearranged fragments highlighted by dashed lines. This view provides clear images for reviewing CGRs, enabling users to visually compare abnormal interaction regions in the original and simulated Hi-C maps for validation. If the abnormal regions do not align, users can adjust the rearranged fragments and input them again. CGR events are confirmed when the abnormal interaction regions match precisely (Figure S3). Reconstruct Hi-C Map The Reconstruct Hi-C Map module uses the assembled CGR file and tumor Hi-C data to generate a reconstructed Hi-C map based on the identified CGR. In this process, CNV and allele bias are corrected to ensure consistent interaction visibility across loci, facilitating a clearer visualization of the impact of CGRs on chromatin structure. The output presents the reconstructed Hi-C map, with dashed lines marking the boundaries of rearranged fragments, providing a visual representation of the impact of CGRs on chromatin structure (Figure S4). Rearranged fragment detection and assembling To reconstruct CGRs from a given list of rearrangement breakpoints and the genome-wide Hi-C map, the coordinates and orientation of the rearranged fragment must be determined. We first identify the candidate abnormal interaction regions formed by the rearrangement around the breakpoints. Depending on the different types of rearrangement, these regions around the breakpoint exhibit distinct interaction patterns. Fig. 3Workflow for identifying and assembling rearranged fragments. The process includes identifying candidate abnormal interaction regions, determining fragment orientations, identifying fragment coordinates, and constructing the complete CGR Workflow for identifying and assembling rearranged fragments. The process includes identifying candidate abnormal interaction regions, determining fragment orientations, identifying fragment coordinates, and constructing the complete CGR Here, we extract a sub-matrix Mij centered on the breakpoint, extending 1 Mb in each direction. The candidate abnormal interaction region is defined as the quadrant within this sub-matrix with a standard deviation greater than twice of Mij. If none of the quadrants meet this threshold, the quadrant with the highest standard deviation is selected as the candidate region. Then, we employ the Strand Determination tool within HiC_breakfinder [18] to ascertain the orientation of rearrangement. This tool evaluates strandedness using multiple different correlation metrics and aggregates the results to predict the orientation. Following this, we use the Rearranged fragment detection tool in NeoloopFinder [13] to locate the other end of the rearranged fragment along the pre-determined orientation. Finally, each rearranged fragment is represented as two connected nodes in the graph, such as \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{N}_{i}^{1}$$\end{document} and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{N}_{i}^{2}$$\end{document}. The junction fragments can be described in consistent orientations as \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:\left({N}_{i}^{2},\:{N}_{i+1}^{1}\right)$$\end{document}. The starting node, either \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{N}_{start}^{1}$$\end{document} or \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{N}_{start}^{2}$$\end{document}, is selected as the node with the smallest genomic position and no incoming edges. From there, the path is traced through the graph, following the connections between nodes, until reaching a node with no outgoing edges, designated as the ending node. This sequence of nodes forms a complete CGR (Fig. 3). Generating the Hi-C map with specified rearrangements through simulation process Given reference Hi-C data as input, DeCGR first constructs the background chromatin contact interactions model using FitHiC2 [23]. FitHiC2 calculates the background model for Hi-C data by modeling the relationship between expected interaction frequency and genomic distance. First, it employs a spline regression model for modeling the relationship between observed contact counts and genomic distances based on a null model, identifying and excluding outliers. Then, a refined null model is generated using a second spline, providing a more accurate estimation of expected interaction frequencies based on genomic distance. Let the tuple (i, j) define a fixed-size bin pair, where i and j represent a pair of genomic intervals. Each bin pair has the expected contact interactions Ek for reference genomic distance k=|i-j|. Then, DeCGR maps the rearranged fragments to fixed-size bins and reorders these bins corresponding to the rearrangements. The original pair of genomic intervals is altered and each bin pair has a new expected interaction \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{E}_{{k}^{}}^{*}$$\end{document} based on the new genome distance k′. We define a scaling factor \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:\varphi\:={E}_{{k}^{}}^{*}/{E}_{k}$$\end{document} to quantify the impact of rearrangements on interactions. Finally, the new interaction of the bin pair (i, j) is calculated by multiplying the original interaction cij by the scaling factor, which is defined as \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\:{c}_{ij}^{*}={c}_{ij}\times\:\varphi\:$$\end{document} (Fig. 4). Fig. 4The simulation process of the Hi-C map with rearrangements. DeCGR calculates a scaling factor matrix that reflects the effect of rearrangements on contact interactions. The new interactions are calculated by multiplying the original interaction by the scaling factor matrix The simulation process of the Hi-C map with rearrangements. DeCGR calculates a scaling factor matrix that reflects the effect of rearrangements on contact interactions. The new interactions are calculated by multiplying the original interaction by the scaling factor matrix Visualization of reconstructed Hi-C map To better visualize the effect of rearrangements on chromatin structure in the reconstructed Hi-C map, we eliminate the effects of CNV and allele bias that have different visibility of interactions. For example, the duplication regions have stronger interactions than other regions, or some rearrangements may occur in a few alleles that have a lower probability of being captured. Here, we use NeoLoopFinder [13] to eliminate CNV and allele bias, utilizing a modified ICE procedure and a linear regression-based method to ensure consistent visibility of interactions across all loci, thereby enabling clearer visualization of the rearrangements in the reconstructed Hi-C map. This step requires parameters such as the number of cores, reference genome, and restriction enzymes, which users should specify based on their tumor Hi-C data and available hardware. Input files DeCGR requires the following inputs: a tumor Hi-C sample and its reference sample in mcool format, and a set of genomic rearrangements. The reference sample is a non-cancer sample without CGRs, used for generating simulated Hi-C data with candidate CGRs in the Validation CGRs module. The mcool format is a standard Hi-C format based on HDF5 that stores sparse matrices of contact frequencies at various resolutions, which has been adopted as a standard in Hi-C Datasets (4D Nucleome Data Portal) [24]. If the Hi-C sample is in another format, it can be converted into mcool format using tools, such as hic2cool [25] or HiCExplorer [26]. The genomic rearrangements can include both simple and complex genomic rearrangements, depending on the analysis module chosen by the user. If the user selects the Fragment Assembly module, the rearrangement events are a set of simple rearrangement breakpoints. Alternatively, if the user selects the Validation CGRs module, the rearrangement events include pre-determined CGRs, encompassing the order and orientation of rearrangement fragments. Results We utilized three cell lines to assess the functionality of Breakpoint Filtering, Fragment Assembly, Validation CGRs and Reconstruct Hi-C Map modules within DeCGR. Firstly, we demonstrated the effectiveness of the simulation process in the Validation CGRs module by simulating various types of validated rearrangements. Then, we highlighted the functionality of the Validation CGRs module using K562 cell line (myelogenous leukemia), illustrating its ability to validate the completeness and correctness of CGRs. Additionally, we provided a step-by-step demonstration of the four modules in the BM178 cell line. This cell line was generated in a previous study involving chromothripsis induced by doxorubicin treatment, with researchers manually assembling two CGRs on chromosome 12 [12]. To further demonstrate DeCGR’s versatility, we tested each module based on HiPore-C [27] data from the K562 cell line (Supplementary material). Finally, we included detailed benchmarking information to help users assess whether they have the necessary resources to run DeCGR. Validation of the simulation process To demonstrate that the simulation process can model changes in chromatin interactions caused by various types of rearrangements, we generated the simulated Hi-C map incorporating known rearrangements, contrasting it with original data from cancer cell lines. These events consist of deletion, duplication, inversion, and translocation identified in K562 and T47D (breast cancer) cell lines (Supplementary Table 1). For all types of rearrangements, the simulated Hi-C maps consistently aligned with the original map around the breakpoint region (Fig. 5). For example, the simulated deletion of fragment B resulted in an anomalous interaction block around the breakpoint, with the highest interaction frequency observed precisely at the breakpoint (Fig. 5a). In the simulated Hi-C map with the fragment B inversion, the breakpoint regions exhibited a distinct ‘butterfly shape’, consistent with the abnormal interaction pattern observed in the original data (Fig. 5b). Fig. 5Validation of the simulation process. DeCGR generates a simulated Hi-C map with known rearrangements and compares it to cancer cell lines. The types of rearrangements include (a) deletion, (b) inversion, (c) translocation, and (d) duplication. The figure displays Hi-C maps of the cancer cell line, reference cell line, and the simulation result respectively Validation of the simulation process. DeCGR generates a simulated Hi-C map with known rearrangements and compares it to cancer cell lines. The types of rearrangements include (a) deletion, (b) inversion, (c) translocation, and (d) duplication. The figure displays Hi-C maps of the cancer cell line, reference cell line, and the simulation result respectively Assessing the completeness and accuracy of CGRs with the validation CGRs module We began by using the Breakpoint Filtering module to identify five breakpoints on chromosome 18 in the K562 cell line. Then, we applied the Fragment Assembly module to assemble a CGR and two simple rearrangements from these breakpoints (Fig. 6a). When running HiSV, we set the window to 10, the weight to 0.2, and the cutoff to 0.6. For CNV and allele bias correction, we set the reference genome to hg38, used the restriction enzyme MboI, and set the number of cores to 4. In these assembled rearrangements, we observed that fragments D and E are adjacent but assigned to different rearrangements. To verify whether these two fragments were part of the same rearrangement events, we inputted two distinct lists of rearrangements into the Validation CGRs module. One of them contains fragments D and E as a CGR (Figure S5a), while the other separates them into two rearrangement events (Figure S5b). By comparing the simulated and original Hi-C maps, we observed that these rearrangements aligned with all five breakpoints but exhibited an additional abnormal interaction block at the end of E and the beginning of D when fragments D and E were considered part of a complex rearrangement. This discrepancy was not present in the separate events scenario. Therefore, the validation process indicates that these two fragments should be assigned to different rearrangements. Subsequently, in the heatmap of the simulated and original Hi-C map, we observed that three interaction regions did not precisely align with the original interaction regions (Fig. 6b). Specifically, an abnormal interaction block was absent in simulated contact maps, and the breakpoints of two rearranged fragments were shifted by an average of nearly two bins. For the missing rearrangement, we identified its breakpoints by analyzing the anomalous interaction block in the original Hi-C map. Specifically, we zoomed in on the anomalous interaction block by clicking with the mouse. The genomic positions with the highest interaction frequency at the corners of this anomalous block as the breakpoint for this rearrangement. Subsequently, we incorporated the breakpoint information into the previous inputs and re-ran the Fragment Assembly module to obtain the complete assembly results (Fig. 6c). Fig. 6Validation of CGRs by comparing original and simulated Hi-C maps. (a) DeCGR reconstructs a CGR and two simple rearrangements from chromosome 18 in the K562 cell line based on five breakpoints. The left panel displays the Hi-C map of the rearrangement region, while the right panel shows the orientation of rearranged fragments and the assembled CGRs results. (b) The upper right of the heatmap shows the simulated Hi-C map, while the lower left displays the original contact map. Dashed lines on the Hi-C map trace the positions of rearranged fragments back to the reference genome. Blue matrix boxes indicate unmatched regions and pentagram symbols mark missed rearrangements. (c) Assembly results were obtained after supplementing missed rearrangements and re-running the Fragment Assembly module. (d) Results of the validation CGRs module after adjusting rearranged fragments Validation of CGRs by comparing original and simulated Hi-C maps. (a) DeCGR reconstructs a CGR and two simple rearrangements from chromosome 18 in the K562 cell line based on five breakpoints. The left panel displays the Hi-C map of the rearrangement region, while the right panel shows the orientation of rearranged fragments and the assembled CGRs results. (b) The upper right of the heatmap shows the simulated Hi-C map, while the lower left displays the original contact map. Dashed lines on the Hi-C map trace the positions of rearranged fragments back to the reference genome. Blue matrix boxes indicate unmatched regions and pentagram symbols mark missed rearrangements. (c) Assembly results were obtained after supplementing missed rearrangements and re-running the Fragment Assembly module. (d) Results of the validation CGRs module after adjusting rearranged fragments Regarding unaligned regions, we scrutinized the edges of the rearranged fragments (represented by gray dashed lines) and compared them with the position of the anomalous block in the original contact map. If the dashed lines extended beyond the edges of the anomalous block, we narrowed the rearranged fragments. Conversely, if the dashed lines covered the anomalous block, we enlarged the rearranged fragments. By fine-tuning the offset of the rearranged fragments, we achieved a fully aligned assembly of the rearranged fragments (Fig. 6d). Tutorial demonstrations of DeCGR on BM178 cell line We used Hi-C samples in mcool format for both the BM178 and GM12878 cell lines, representing tumor and normal cell lines as input data. The resolution was set to 100Kb, and our analysis focused on chromosome 12. For the rearrangement breakpoint input file, we applied Breakpoint Filtering module to detect rearrangement breakpoints. When running HiSV, we set the window to 10, the weight to 0.2, and the cutoff to 0.6. For CNV and allele bias correction, we set the reference genome to hg38, set the restriction enzyme to uniform, and set the number of cores to 4. In the Fragment Assembly module, DeCGR created three plots to display the assembly results (Fig. 7a). The Hi-C map depicted rearrangements within Chromosome 12 (from 40.8 M to 96.2 M). The lower plot annotated the rearranged fragments and their joining orientations. The plot in the upper right corner depicted the result of assembled complex rearrangements. We observed that the rearranged fragments of Chromosome 12q were assembled into two CGRs with seemingly random orientations. It is worth noting that the assembled CGRs are consistent with the manually reconstructed results from the previous study [12]. Fig. 7Examples of DeCGR’s functional modules. (a) The result of the Fragment Assembly module. The heatmap illustrates Hi-C map slices based on user-defined rearrangement breakpoints. The gray bar denotes the positions of rearranged fragments on the reference genome, while below, the connection orientation of each simple rearrangement’s rearranged fragments is shown. In the upper right corner, the assembled CGRs are displayed. (b) The result of validation CGRs module. The upper right of the heatmap shows the simulated Hi-C map, while the lower left presents the original contact map. Dashed lines on the Hi-C map trace the position of the rearranged fragment calls back to the reference genome. The left and right sides represent pre- and post-adjusting results, respectively. (c) The result of the Reconstruct Hi-C Map module. The upper and lower images depict reconstructed Hi-C maps for two CGRs (G-B-A-D-C and E-F-H) Examples of DeCGR’s functional modules. (a) The result of the Fragment Assembly module. The heatmap illustrates Hi-C map slices based on user-defined rearrangement breakpoints. The gray bar denotes the positions of rearranged fragments on the reference genome, while below, the connection orientation of each simple rearrangement’s rearranged fragments is shown. In the upper right corner, the assembled CGRs are displayed. (b) The result of validation CGRs module. The upper right of the heatmap shows the simulated Hi-C map, while the lower left presents the original contact map. Dashed lines on the Hi-C map trace the position of the rearranged fragment calls back to the reference genome. The left and right sides represent pre- and post-adjusting results, respectively. (c) The result of the Reconstruct Hi-C Map module. The upper and lower images depict reconstructed Hi-C maps for two CGRs (G-B-A-D-C and E-F-H) Next, we employed the Validation CGRs module to validate the accuracy of the assembled CGRs. By comparing the simulated and original contact maps, we observed that the abnormal interaction blocks generated by the previously determined rearrangement fragments did not perfectly align with the interaction blocks in the original contact map. We adjusted the coordinates of these rearranged fragment breakpoints based on the discrepancies between the edges of the rearranged fragments (represented by dashed lines) and the anomalous block in the original contact map. These CGRs were fully determined when the dashed lines aligned completely with the boundary of the anomalous interaction block in the original contact map (Fig. 7b). Following the determination of CGRs, we stitched the Hi-C maps according to rearranged fragments. The reconstructed Hi-C map distinctly reveals the neo-TAD region induced by the rearrangement, providing insights into the mechanism of dysregulation of nearby genes (Fig. 7c). Users have the option to export the matrix to a TXT file for downstream analysis such as TAD boundaries and loops identification. Computational benchmarking To evaluate the computational requirements of DeCGR, we implemented a benchmarking analysis that evaluates RAM usage, CPU utilization, and total runtime under varying conditions, including different read coverages, resolutions, and the use of single versus multiple chromosomes. The RAM and CPU usage reported reflect the peak values during the execution of all DeCGR modules, while the total runtime accounts for the cumulative time taken by all four modules. The tests were performed on a Mac M3 computer with 8GB of memory and an 8-core processor, using datasets from the K562 cell line with resolutions ranging from 25 K to 50 K and read counts of 61.6 M, 238.8 M, and 907.1 M. For chromosome selection, single-chromosome (chr9) and multi-chromosome (chr9, chr13, chr22) were tested. As shown in Fig. 8, for both single and multiple chromosome settings, RAM usage and CPU utilization remained relatively consistent (Fig. 7b and c). For example, a sample with 907.1 M reads at 50 K resolution showed minimal memory variation, with 2.52 GB for a single chromosome and 2.53 GB for multiple chromosomes, and CPU utilization of 99.7% and 130%, respectively. This is due to DeCGR processing each chromosome independently. However, the runtime increased substantially, from 212.1 s for a single chromosome to 588.9 s for multiple chromosomes (Fig. 7a). Additionally, we observed that increasing read coverage led to higher resource consumption. Specifically, for a sample with 907.1 M reads at 50 K resolution, the memory usage for a single chromosome was 2.52 GB, while a sample with 61.6 M reads at the same resolution used 1.34 GB. These results indicate that as read coverage and resolution increase, the computational demands of DeCGR scale accordingly, underscoring the need for users to consider these factors in their analyses. Fig. 8Computational resource analysis of DeCGR. Runtime (a), memory usage (b) and CPU utilization (c) of DeCGR across different samples. The number of reads for 4DNFI18UHVRO, 4DNFIM4G3L5Q, and 4DNFI7CIF2JL are 907.1 M, 238.8 M, and 61.6 M, respectively Computational resource analysis of DeCGR. Runtime (a), memory usage (b) and CPU utilization (c) of DeCGR across different samples. The number of reads for 4DNFI18UHVRO, 4DNFIM4G3L5Q, and 4DNFI7CIF2JL are 907.1 M, 238.8 M, and 61.6 M, respectively Performance comparison of DeCGR and EagleC-NeoLoopFinder in CGR exploration To evaluate the resources and time required for CGR exploration, we compared the runtime and memory usage of the EagleC-NeoLoopFinder [13, 14] tandem and DeCGR. The analysis utilized the Hi-C sample from the K562 cell line, comprising a total of 907.1 million reads, specifically focusing on chromosomes 9, 13, and 22 at a resolution of 50 K. Each method was run with nproc set to 12 on the same hardware (a Linux server running Ubuntu 18.04). The EagleC-NeoLoopFinder workflow begins with CNV normalization using NeoLoopFinder, followed by breakpoint identification using EagleC, and concludes with the assembly process. DeCGR utilizes the Breakpoint Filtering Module for breakpoint identification and the Fragment Assembly module for CGR assembly. As shown in Table 1, the EagleC-NeoLoopFinder workflow took 1048.24 s with a memory usage of 2.5 GB, whereas the DeCGR approach was significantly more efficient, completing the task in 549.93 s but with a higher memory usage of 7 GB. Although both DeCGR and EagleC-NeoLoopFinder employ the same CNV normalization step, DeCGR focuses specifically on the designated chromosomes during the most time-consuming CNV correction phase, thereby saving a portion of the overall runtime. Table 1Runtime and memory usage comparison between EagleC-NeoLoopFinder and DeCGRRuntime (seconds)Memory usage (Gb)EagleC-NeoLoopFinder1048.242.5DeCGR Module 1&2549.937 Table 1Runtime and memory usage comparison between EagleC-NeoLoopFinder and DeCGRRuntime (seconds)Memory usage (Gb)EagleC-NeoLoopFinder1048.242.5DeCGR Module 1&2549.937 Runtime and memory usage comparison between EagleC-NeoLoopFinder and DeCGR Conclusions DeCGR is a versatile software toolbox designed to facilitate the exploration of CGRs from Hi-C data. The modules of DeCGRs include one-click assembly of CGRs, validation of the completeness and correctness of CGRs, and visualization of the reconstructed Hi-C map based on determined CGRs. Its user-friendly interface, and one-click result generation make it highly suitable for biologists aiming to investigate the impact of CGRs on chromatin structure. The clear visualization of results from each module facilitates the association of intricate CGRs with Hi-C maps, thereby further enhancing its utility. Additionally, we have expanded DeCGR’s potential applicability to other chromosome conformation capture technologies, such as HiPore-C, as long as the data can be converted into the required cool or mcool format, making it a versatile tool for various chromosome conformation capture technologies. While DeCGR offers significant automation, it still requires some manual steps, including visual inspection to filter out false positive simple rearrangements and visual comparison of simulated and real contact maps to evaluate the completeness and accuracy of CGRs. These processes could be automated by developing a classifier to identify false positive rearrangement events and calculating a similarity score to evaluate the match between the abnormal region of simulated and real contact maps. Such automation would reduce user intervention and enhance the software’s applicability. We will consider these enhancements in our future work. Electronic supplementary material Below is the link to the electronic supplementary material. Supplementary Material 1 Supplementary Material 1