Merging tree enhancement method for large-scale data set based on pointer doubling and parallelization

Abstract

The invention discloses a merge tree enhancement method for a large-scale data set based on pointer doubling and parallelization. The method comprises the steps of obtaining a steepest rising path so as to determine a control area, proposing a horizontal enhancement method and a vertical enhancement method, determining a point set needing to be processed according to different enhancement methods, calculating a binary ancestor table of each key point (saddle point and extreme point), and parallelizing a binary ancestor table construction process so as to quickly find ancestor nodes of the key points. A key interval to which each rule point belongs is positioned by utilizing a multiplication algorithm, point sets corresponding to the key points are sequenced in parallel, the rule points are accurately integrated into a merge tree, and merge tree enhancement is quickly and effectively performed on a large-scale data set. According to the method, a merge tree enhancement process is optimized and innovated by combining a binary ancestor table, a pointer doubling algorithm and a parallelization technology, complex large-scale data can be processed, and horizontal enhancement and vertical enhancement of the merge tree are realized. The overall process is as shown in Figure 1.

Description

Technical Field

[0001] This invention relates to the field of topology data analysis (TDA) and visualization technology, and in particular to a method for parallelized merging tree enhancement for large-scale datasets. Background Technology

[0002] Topological data analysis (TDA) aims to extract robust global structural features from complex data. Unlike traditional statistical or geometric methods, TDA emphasizes identifying the shape, connectivity, and key structures of data, thus maintaining a strong representation of the data's intrinsic structure even in the presence of noise. Commonly used topological structures include persistent homology, Reeb graphs, contour trees, and merge trees, which provide new perspectives for modeling and interpreting complex data. Merge trees capture the property that the connectivity of super-level sets or sub-level sets in a scalar field evolves with scalar values. Merge trees can be extended to contour trees. Merge trees have been widely used in scientific visualization and data analysis. For example, in fluid dynamics, quantifying the topological similarity of point clouds has been shown to improve simulation accuracy; in medical imaging, the use of persistent homology for topological visualization of brain tumor MRI / CT scans has achieved a major breakthrough, enabling the quantification of tumor invasion patterns.

[0003] However, merging tree computation still faces many complex and non-trivial challenges. First, its computation is inherently complex, especially when dealing with large-scale datasets or high-dimensional scalar fields, where constructing a merging tree can require significant computational resources. Second, the augmentation process involves incorporating regular vertices into the construction, which can further exacerbate the overall algorithm's complexity. Early research on merging tree computation mainly focused on serial algorithms; for example, Carr et al. proposed a disjoint-set data structure-based scan and merge algorithm, but it is slow for large-scale datasets. Currently, many existing parallel algorithms have been proposed to improve the efficiency of merging tree augmentation. For example, the FTM-Tree algorithm uses Fibonacci heaps and task parallelism to achieve dynamic load balancing, but this incurs significant memory overhead; the PPP algorithm significantly improves computational performance through data parallelism and hyperstructure optimization, but its parallelism decreases when dealing with chain-like structures; the TMT algorithm combines comparison-swap operations and triple representation, performing well in shared memory environments, but encountering memory bottlenecks when processing large-scale data; the ExTreeM algorithm reduces computational complexity through extremum graphs, but it is still a CPU-based parallel algorithm, and the problem of how to leverage GPU capabilities for merging tree augmentation on large-scale datasets remains to be solved. Summary of the Invention

[0004] In view of this, and in response to the problems of high computational complexity, low enhancement efficiency, and excessive resource consumption in existing technologies for enhancing merge trees on large-scale datasets, this invention aims to provide an efficient, low-resource-consumption, and parallel-supporting merge tree enhancement computation method. It aims to reduce computational overhead and effectively enhance merge trees on large-scale datasets while ensuring the robustness of global structural features, and accurately describe the characteristics of the connectivity of super-level sets or sub-level sets in a scalar field as the scalar value changes.

[0005] The purpose of this invention is to provide a merge tree augmentation method for large-scale datasets based on pointer doubling and parallelization. This method proposes two augmentation methods—horizontal and vertical—through a series of sequentially executed steps. It integrates binary ancestor tables, pointer doubling algorithms, and parallelization techniques to optimize and innovate the merge tree augmentation process. It can handle complex, large-scale data and achieve both horizontal and vertical augmentation of the merge tree. The method includes the following main steps: obtaining the control region, filtering the point set according to the augmentation method, constructing a binary ancestor table, locating the interval of each regular point, and performing parallel connections.

[0006] Preferably, the step of obtaining the control area involves obtaining the steepest ascent path and determining the control area based on the steepest ascent path. The steps include:

[0007] The first step is to traverse the scalar value of each vertex and the scalar values ​​of its neighbors in the input merge tree, obtain the edge with the largest difference in scalar value, and add it to the steepest ascending path. Each path eventually connects to a certain extreme point.

[0008] The second step is to determine the control region after constructing all the steepest ascent paths. That is, the set of all vertices attracted by the same extreme point belongs to the same control region.

[0009] Preferably, the point set filtering step involves taking the input unenhanced merged tree and determining different function value ranges based on different enhancement methods to filter point sets that meet the conditions. The steps include:

[0010] The first step is to adopt different strategies for determining the function value range based on different enhancement methods. For vertical enhancement, the range of the point set to be selected needs to be determined based on the function values ​​of the two vertices on the branch. For horizontal enhancement, the range of function values ​​of the point set to be enhanced needs to be specified before enhancement.

[0011] The second step is to traverse the entire point set based on the determined range of function values, and filter the point sets whose function values ​​are within the filter range, in order to reduce the data scale that needs to be processed in subsequent steps and reduce computational and memory overhead.

[0012] Preferably, the step of constructing the binary ancestor table includes:

[0013] The first step is to determine the direct parent node of the key points (including saddle points and extreme points). For each key point, set the saddle point node connected to that point in the non-enhanced merge tree as its direct parent node, and set its 0-hop ancestor node as that node.

[0014] The second step is to iteratively calculate the ancestor nodes at each level starting from the 1-hop ancestor node. Using the doubling algorithm recursive formula, the k-1 hop ancestor node of the node is set as the k-hop parent node of the node. Combining the binary characteristics, the doubling algorithm is used to efficiently calculate the ancestor nodes at higher levels.

[0015] The third step involves iteratively calculating the ancestor nodes of each layer without affecting the calculation of the ancestor nodes of each vertex in each layer. Therefore, parallel computing technology is supported to accelerate the calculation of large-scale datasets. After each layer of calculation is completed, a global synchronization function is called to ensure that all threads have completed their calculations before proceeding to the next layer.

[0016] Preferably, the step of locating the interval of each rule point includes:

[0017] The first step is to traverse the point set of the non-enhanced merge tree and set the temporary parent node of the regular point to the extreme point it is mapped to through manifold mapping, so as to ensure that the regular point can be correctly inserted into the appropriate position of the merge tree, thereby maintaining the topological integrity of the merge tree.

[0018] The second step is to use reverse binary boosting search. Starting from the temporary parent node of the rule point, update the current jump node. For each jump length, compare the function value of the current rule point with the function value of the corresponding binary ancestor node of the current jump node. If the function value of the current rule point is less than the function value of the corresponding binary ancestor node of the current jump node, then update the jump node to its corresponding binary ancestor node.

[0019] The third step is to gradually reduce the jump length to 0 and then complete the iterative update. At this point, the node pointed to by the jump node is the key interval to which the rule point belongs, and the point is integrated into the point set of the key interval to determine the insertion position of each regular point.

[0020] The parallel connection step includes:

[0021] The first step is to construct the corresponding point set for each saddle point as the intersection of the saddle point, the parent node of the saddle point in the merge tree, and the set of regular points of the key interval of the saddle point. The points in each set are sorted in ascending order according to the function value. Since it is determined that each point will not appear in different sets, the sorting process can be optimized in parallel to accelerate the processing of large-scale datasets.

[0022] The second step is to iterate through the elements in each set after sorting, and update the parent-child relationship according to the sorting order. The adjacent node with the larger function value of a point in the set is taken as its parent node to ensure that the relationship between the function values ​​of the parent and child nodes is correct.

[0023] The third step is to integrate all rule points according to the latest parent-child relationship and add them to the merge tree to complete the enhancement process of the merge tree. The output is the enhanced merge tree obtained by enhancing the unenhanced merge tree according to the vertical enhancement or horizontal enhancement method.

[0024] The method described in this invention can efficiently enhance merged trees in large-scale data. By combining advanced point set filtering, pointer doubling algorithm, binary boosting search, and GPU parallelization technology, it effectively overcomes the shortcomings of existing technologies in terms of merged tree structure recognition accuracy, algorithm efficiency, resource overhead, and ability to analyze complex structures, providing a more powerful and accurate analysis tool for topology research and engineering applications.

[0025] The above and other objects, advantages and features of the present invention will become more apparent to those skilled in the art from the following detailed description of specific embodiments of the invention in conjunction with the accompanying drawings. Attached Figure Description

[0026] The following description will detail some specific embodiments of the invention by way of example and not limitation, with reference to the accompanying drawings. The same reference numerals in the drawings denote the same or similar parts or portions. Those skilled in the art will understand that these drawings are not necessarily drawn to scale. The objectives and features of the invention will become more apparent from the following description taken in conjunction with the accompanying drawings, in which:

[0027] Figure 1 This is the overall process of the present invention and a brief description of each step.

[0028] Figure 2 This is a schematic diagram of a two-dimensional piecewise linear scalar field according to an embodiment of the present invention, wherein red dots represent extreme points, green dots represent boundary saddle points, blue dots represent critical saddle points, black dots represent regular points, and the area enclosed by the dashed line is an independent region in parallel computing.

[0029] Figure 3 This is a schematic diagram of an unenhanced merged tree and the corresponding function values ​​of key points according to an embodiment of the present invention.

[0030] Figure 4 This is a schematic diagram of the vertically enhanced branch from node 15 to node 50 according to an embodiment of the present invention, where the yellow nodes are the enhanced nodes.

[0031] Figure 5This is a schematic diagram of a node with a horizontal enhancement scalar value between 15 and 65 according to an embodiment of the present invention, wherein the yellow node is the enhanced node. Detailed Implementation

[0032] To make the key points of this invention clearer and easier to understand, the invention will be further described below with reference to specific steps. This invention provides a merge tree enhancement method for large-scale datasets based on pointer doubling and parallelization. The overall process is as follows: Figure 1 As shown, the specific implementation includes obtaining the control region, filtering the point set according to the enhancement method, constructing a binary ancestor table, locating the interval of each rule point, and performing parallel connection steps. The detailed algorithm flow is as follows:

[0033] The process of obtaining the control region includes the following operations: traversing the scalar values ​​of the neighboring points of each vertex to obtain the steepest ascent path, and determining the control region based on the steepest ascent path. The steps of each operation are described in detail below:

[0034] The method of traversing the scalar values ​​of the neighboring vertices of each vertex to obtain the steepest ascending path includes the following steps:

[0035] The first step is to traverse the scalar value of each vertex and the scalar values ​​of its neighbors in the input merge tree, obtain the edge with the largest difference in scalar value, and add it to the steepest ascending path. Each path eventually connects to a certain extreme point.

[0036] The method of determining the control area based on the steepest ascent path includes the following steps:

[0037] The first step is to construct all the steepest ascent paths and then determine the control region, which is the set of all vertices attracted by the same extreme point that belong to the same control region.

[0038] The point set selection includes the following operations: determining different function value ranges for the input unenhanced merged tree based on different enhancement methods, and selecting point sets that meet the conditions. The steps of each operation are described in detail below:

[0039] The process of determining different function value ranges based on different enhancement methods includes the following steps:

[0040] The first step is to determine which enhancement method to use. The determination method is based on the input parameters. If the input parameter is a branch, it is determined to be vertical enhancement, that is, enhancing the regular points on a branch. If the input parameter is a function value range, it is determined to be horizontal enhancement, that is, enhancing the regular points whose function values ​​are within a certain range.

[0041] The second step is to traverse the two vertices on the branch and read the function value range of the corresponding nodes.

[0042] The process of filtering point sets that meet the conditions includes the following steps:

[0043] The first step is to traverse all point sets, including rule points and key points, based on the known range of function values, for horizontal enhancement methods or vertical enhancement methods that have already traversed all branches, and retain the points whose function values ​​are within this range.

[0044] The construction of the binary ancestor table includes the following operations: determining the direct parent node of key points, iteratively calculating higher-level ancestor nodes by doubling, and globally synchronizing thread information after each level of calculation. The steps of each operation are described in detail below:

[0045] The process of determining the direct parent node of the key point includes:

[0046] The first step is to pre-compute a binary lifting ancestor table (FaBit) for each keypoint (including Real Saddle Points (RSPs) and Extremum Points (EPs)). This table records the number of points from each keypoint that can be lifted by traversing a jump length of... (where 𝑘 is a non-negative integer) the parent nodes that can be reached.

[0047] The second step is to address each key point. set up Its direct parent node (i.e., connected to in the non-enhanced merge tree) (The saddle point node). The formula is expressed as: ,in Indicates in a non-enhanced merge tree The parent node.

[0048] The iterative doubling calculation process for higher-level ancestor nodes includes:

[0049] The first step, for arrive

[0050] Using recursive formulas Calculate higher-level ancestor nodes. The formula is expressed as follows: in, It is the number of binary bits for the preset maximum jump length.

[0051] The global synchronization process includes:

[0052] The first step involves iteratively calculating the ancestor nodes of each layer without interfering with the calculations of ancestor nodes of each vertex across different layers. This supports parallel computing techniques to accelerate the computation of large-scale datasets. After each layer's computation is completed, a global synchronization function is called to ensure that all threads have finished their computations before proceeding to the next layer. This step is to avoid race conditions caused by data dependencies.

[0053] The positioning rule point interval includes the following operations: determining the temporary parent node of the rule point, updating the parent node of the rule point by jumping according to the function value, and determining the key interval of the rule point. The steps of each operation are described in detail below:

[0054] The process of determining the temporary parent node of the rule point includes:

[0055] The first step is to traverse the merged tree and set the parent node of each node to itself. In other words, in the initial state, each vertex is considered to be its own parent node.

[0056] The second step involves iterative processing using path compression, for each vertex... Each vertex u will attempt to find its true parent node. For each vertex u, check all its adjacent vertices v. If the scalar value of v is greater than the scalar value of u, then update the temporary parent node of u to v.

[0057] The third step, to accelerate the path compression process, employs a pointer doubling technique. That is, for each vertex u, it checks whether its temporary parent node is equal to u. If it is not equal to u, then u's temporary parent node is updated to the parent node of its parent node.

[0058] Fourthly, during the pointer doubling process, parallelization techniques can be used to accelerate the process. Therefore, after each iteration, a global synchronization function is called to ensure that all threads have completed the update of the current round before entering the next iteration. After all iterations are completed, the temporary parent node of the rule point has been determined.

[0059] The process of updating the parent node of the rule point based on the function value includes:

[0060] The first step is to determine the insertion position of the rule point u by using the reverse binary lifting search method, starting from the maximum jump length k = MAXBIT-1 and gradually decreasing the jump length k to k=0, and then initializing the temporary parent node v to eCA(u).

[0061] The second step is to calculate FaBit[v][k] for each jump length k in each iteration, which is the jump from node v. The parent node that can be reached in one step. Compare the size of val[FaBit[v][k]] and val[u]. If val[FaBit[v][k]] > val[u], then update v to FaBit[v][k] and continue to check for smaller jump lengths.

[0062] Third, stop the search when the jump length k=0 or val[FaBit[v][k]] <= val[u]. At this point, node v is the insertion position of rule point u.

[0063] The process of determining the key interval of the rule points includes:

[0064] In the first step, through the inverse binary lifting search described above, the insertion position of the rule point u is finally determined to be node v. At this point, the rule point u is inserted into the interval where node v is located.

[0065] The parallel connection includes the following operations: sorting the rule points within the interval corresponding to each key point, updating the parent-child relationship of the rule points, and integrating information. The steps of each operation are described in detail below:

[0066] The process of sorting the rule points within the interval corresponding to each key point includes:

[0067] The first step is to use the Thrust library to perform parallel sorting of the CriticalSet[v] for each keypoint v, ensuring that the regular points in each set are sorted in ascending order.

[0068] The process of updating the parent-child relationship of the rule points includes:

[0069] The first step is to use each real saddle point as the set of points to be processed, along with its parent node in the contour and the subsequent CriticalSet.

[0070] The second step is to iterate through the elements in the set and update the parent-child relationship according to the sorting order to ensure that the parent node of the rule point is the adjacent node that is greater than it in the sorted array.

[0071] The information integration process includes:

[0072] The first step involves updating the parent node of each rule point in each branch and then adding the rule point to the branch, ensuring that key points can be connected to rule points in their corresponding intervals. After all the sets of points to be processed have been processed, the merging tree enhancement process is complete.

Claims

1. A merge tree augmentation method for large-scale datasets based on pointer doubling and parallelization, characterized in that: Includes the following steps: (1) Steps for obtaining the control region: Traverse the scalar value of each vertex and the scalar values ​​of its neighbors in the input merge tree, obtain the edge with the largest difference in scalar value, and add it to the steepest ascending path. Each path eventually connects to a certain extreme point. After constructing all the steepest ascending paths, determine the control region, that is, all the sets of vertices attracted by the same extreme point belong to the same control region. (2) Steps for selecting the point set based on the enhancement method: Determine the range of function values ​​for the point set to be processed later based on the different enhancement methods used. If it is vertical enhancement, it is considered to be enhancing a certain branch, and the range of function values ​​for the point set to be processed later needs to be determined based on the points on the branch, and points with function values ​​within that range are selected from the entire point set. If it is horizontal enhancement, it is considered to be enhancing points within a certain range, and points with function values ​​within that range need to be selected from the entire point set. (3) Steps for constructing the binary ancestor table: Construct a binary ancestor list for each key point (including saddle points and extreme points) in the input unenhanced original merged tree. The binary ancestor table is constructed quickly by using the pointer doubling algorithm to find the ancestor nodes of the key points, and parallelization is supported to accelerate the use of large-scale datasets. (4) Steps for locating the interval of each rule point: Using the constructed binary ancestor list, the insertion position of each rule point is determined by continuously performing reverse binary boosting search through the doubling algorithm. Starting from the temporary parent node of the rule point, the interval to which the rule point belongs is continuously updated by comparing the function value of the current rule point with that of the temporary node. When the function value of the temporary node is greater than that of the current rule point, the temporary node is updated, and the smaller jump length is checked. Finally, the temporary node is the key interval to which the rule point belongs. (5) Parallel connection steps: Use the Thrust library to sort the rule point set corresponding to each key point in parallel to ensure that the rule points in each set are arranged in ascending order. By looping and updating the parent-child relationship of the points in the point set according to the sorting order, all rule points are accurately integrated into the merge tree to complete the enhancement process.

2. The method according to claim 1, characterized in that, The specific steps for obtaining the control region include: Step 1: Traverse the scalar value of each vertex and the scalar values ​​of its neighbors in the input merge tree, find the edge with the largest difference in scalar value, and add it to the steepest ascending path. Each path eventually connects to a certain extreme point. Step 2: After constructing all the steepest ascent paths, determine the control region, that is, the set of all vertices attracted by the same extreme point belongs to the same control region.

3. The method according to claim 1, characterized in that, The specific steps for filtering the point set include: Step 1: Different strategies for determining the range of function values ​​are adopted according to different enhancement methods. If it is vertical enhancement, the range of the point set to be screened needs to be determined based on the function values ​​of the two vertices on the branch. If it is horizontal enhancement, the range of function values ​​of the point set to be enhanced needs to be specified before enhancement. Step 2: Based on the determined range of function values, traverse the entire point set and filter the point sets whose function values ​​are within the filter range to reduce the data scale that needs to be processed in subsequent steps and reduce computational and memory overhead.

4. The method according to claim 1, characterized in that, The steps for constructing the binary ancestor table specifically include: Step 1: Determine the direct parent node of key points (including saddle points and extreme points). For each key point, set the saddle point node connected to that point in the non-enhanced merge tree as its direct parent node, and set its 0-hop ancestor node as that node. Step 2: Starting from the 1-hop ancestor node, iteratively calculate the ancestor node at each level. Using the doubling algorithm recursive formula, set the k-1 hop ancestor of the node's k-1 hop ancestor node as the node's k-hop parent node. Combining binary features, efficiently calculate higher-level ancestor nodes using the doubling algorithm. Step 3: When iteratively calculating the ancestor nodes of each layer, the calculation of the ancestor nodes of each vertex in each layer does not affect each other. Therefore, parallel computing technology is supported to accelerate the calculation of large-scale datasets. After the calculation of each layer is completed, a global synchronization function is called to ensure that all threads have completed their calculations before entering the next layer.

5. The method according to claim 1, characterized in that, The specific steps for locating rule point intervals include: Step 1: Traverse the point set of the non-enhanced merge tree and set the temporary parent node of the regular point to the extreme point it is mapped to through manifold mapping to ensure that the regular point can be correctly inserted into the appropriate position in the merge tree, thereby maintaining the topological integrity of the merge tree. Step 2: Use reverse binary boosting search. Start updating the current jump node from the temporary parent node of the rule point. For each jump length, compare the function value of the current rule point with the function value of the corresponding binary ancestor node of the current jump node. If the function value of the current rule point is less than the function value of the corresponding binary ancestor node of the current jump node, then update the jump node to its corresponding binary ancestor node. Step 3: After gradually reducing the jump length to 0, complete the iterative update. At this point, the node pointed to by the jump node is the key interval to which the rule point belongs, and integrate the point into the point set of the key interval to determine the insertion position of each regular point.

6. The method according to claim 1, characterized in that, The parallel connection step is specifically implemented as follows: Step 1: For each saddle point, construct its corresponding point set as the intersection of the saddle point, the parent node of the saddle point in the merge tree, and the set of regular points of the key interval of the saddle point. Sort the points in each set in ascending order according to the function value. Since it is determined that each point will not appear in different sets, the sorting process can be parallelized to accelerate the processing of large-scale datasets. Step 2: After sorting, iterate through the elements in each set and update the parent-child relationship according to the sorting order. Take the neighboring node with the larger function value of a point in the set as its parent node to ensure that the relationship between the function values ​​of parent and child nodes is correct. Step 3: Integrate all rule points into the merge tree according to the latest parent-child relationship to complete the enhancement process of the merge tree. The output is the enhanced merge tree obtained by enhancing the unenhanced merge tree according to the vertical enhancement or horizontal enhancement method.

Images