Voronoi graph parallel computing method and system driven by cell relation

Abstract

The invention provides a Voronoi diagram parallel computing method and system driven by a point-cell relation, and the method comprises the steps: obtaining a seed point set and a solution domain, and pre-distributing a space for a cell result in a video memory of a GPU end; the calculation of each cell element is set to be responsible for one thread; in an initialization stage of the ith thread, setting a cell element Omega < iM > of a seed point vi as M; in the clipping stage of the ith thread, if a vertex pi in the Omega iM is outside a Voronoi cell element of vi and is recorded as a nearest seed point vj of the vertex pi, constructing a clipping plane Bi, j based on a preset rule, clipping the Omega iM by using Bi, j, and recording the result as Omega iM; iteratively executing point selection and clipping plane construction for clipping until all vertexes in the Omega iM are in Voronoi cell elements of the vi; and storing the cell result omega iM in a pre-allocated GPU end video memory space. According to the embodiment of the invention, the calculation efficiency of the Voronoi diagram can be greatly improved while the result accuracy is ensured.

Description

Technical Field

[0001] This invention relates to the field of Voronoi diagram generation technology in geometric processing, and in particular to a parallel computation method and system for Voronoi diagrams driven by point-cell relationships. Background Technology

[0002] Voronoi diagrams, determined by a set of seed points and Euclidean distance metric, are one of the most important geometric structures for domain partitioning. They divide space into several smaller sub-regions, with each seed point corresponding to a sub-region, called its Voronoi cell. Voronoi diagrams have a wide range of applications, such as sampling, remeshing, mesh generation, and fluid simulation. Therefore, calculating Voronoi diagrams is a fundamental task, and improving their efficiency is of great significance for downstream applications.

[0003] Voronoi diagrams are typically partitions of an infinite space, so some cells contain points at infinity. However, many applications are usually confined to a finite region, called the solution domain. People are generally interested in Voronoi diagrams within the solution domain.

[0004] Currently, algorithms for calculating Voronoi diagrams include serial schemes implemented on the CPU and parallel schemes implemented on the GPU:

[0005] (1) Serial approach on the CPU: The mainstream methods include the following two: (a) The method based on the duality of Delaunay triangulation (DT). Delaunay triangulation (DT) and Voronoi diagram are two structures that are dual to each other. Each seed point can obtain explicit adjacency relationships from the DT. It is only necessary to traverse all its adjacent points and cut the space with the perpendicular plane formed with it to obtain the Voronoi cell of the seed point. Therefore, the key to this Voronoi diagram calculation method is how to quickly generate the DT for a given set of points. However, the construction of the DT is very time-consuming, and its cost increases rapidly with the increase of the number of seed points. (b) The method based on k-nearest neighbors (kNN). Each Voronoi cell can be regarded as the intersection of the half-space between the corresponding seed point and all other seed points. Based on this, the method can calculate the cell Ω. i First, obtain the corresponding seed point v. i An ordered queue, i.e., based on v i Sort the other seed points from nearest to farthest in order of distance, and then select queue elements one by one with v. iThe vertical plane is used to iteratively prune the space. In practice, each cell is only related to its nearest neighbors (nearest neighbors) and therefore does not need to traverse all elements in the ordered queue. The pruning termination condition is met when the farthest distance from the seed point to its cell is less than half the distance to a neighbor, and the cell generation process can end prematurely. Therefore, the cell pruning process only requires the k nearest neighbors of each seed point. Furthermore, research shows that the distribution of seed points has a significant impact on the efficiency of this method; that is, the efficiency is higher when the distribution exhibits blue noise characteristics, and lower when the distribution exhibits white noise characteristics. This is because the pruning termination condition for most cells is met later in the latter case.

[0006] (2) GPU-based parallel solutions: The process of calculating each Voronoi cell using the kNN-based method described above is independent, thus exhibiting good parallelism. Therefore, the mainstream parallel Voronoi graph calculation method is the kNN-based method. However, as mentioned above, the distribution of seed points has a significant impact on the efficiency of this type of method. In addition, since this method requires the k-nearest neighbor information for each seed point, this can usually be obtained through KD-trees or grid-based data structures. The characteristics of these two data structures determine that as the value of k increases, the time required to find the k-nearest neighbor also increases. In order to obtain accurate cell pruning results, a larger value of k is usually required, which is also a problem that limits the efficiency of this type of method. Summary of the Invention

[0007] The purpose of this invention is to provide a parallel computation method and system for Voronoi diagrams driven by cell relationships, aiming to solve the problem of low computational efficiency in traditional techniques when calculating exact solutions.

[0008] In a first aspect, the present invention provides a method for parallel computation of Voronoi diagrams driven by cell relations, the method comprising:

[0009] Step 1: Obtain the seed point set And the solution domain M, based on the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space;

[0010] Step 2: Set each cell's computation to be handled by a thread. Each thread's task includes three parts: cell initialization, pruning, and result storage.

[0011] Step 3: Simultaneously initialize cells in all threads, that is, during the initialization phase of the i-th thread, let the seed point v i Ω cell i|M =M;

[0012] Step 4: Simultaneously prune the cells in all threads, that is, in the pruning stage of the i-th thread, if Ω i|M There exists a vertex p in the middle. i In v i Outside the voronoi cell, denote its nearest neighbor seed point v. j Then, the clipping plane B is constructed based on the preset rules. i，j and use B i，j For Ω i|M The result of the trimming is still denoted as Ω. i|M At this point, one effective clipping has been completed. This process of selecting points and constructing clipping planes is repeated iteratively until Ω is reached. i|M All vertices in v i Within the Voronoi cell;

[0013] Step 5: Simultaneously store the cell result in all threads, that is, the i-th thread stores the cell result Ω. i|M Store the data in the pre-allocated GPU memory space to output the cells of all seed points.

[0014] Furthermore, the acquisition of the seed point set And the solution domain M, based on the seed point set Construct a neighbor search structure and store the cell results in GPU memory. The steps for pre-allocating space include:

[0015] Step 11: Set up a grid and place each seed point into the corresponding grid according to its coordinates;

[0016] Step 12: Transfer the grid and seed point coordinates to the GPU's global memory, and generate cell results in the GPU's global memory. Pre-allocate space.

[0017] Furthermore, determine p i Is it at seed point v? i The steps within the Voronoi cell unit include:

[0018] Step 41, query p i The nearest seed point, denoted as v j ;

[0019] Step 42, if v j =v i , or ||p i -v i || 2 -||p i -v j || 2If ≤β, then determine p i At seed point v i Within the Voronoi cell;

[0020] Step 43, if v j ≠v i And ||p i -v i || 2 -||p i -v j || 2 If >β, then determine p i At seed point v i Outside of the Voronoi cell.

[0021] Furthermore, the cutting plane B is constructed based on preset rules. i，j The steps include:

[0022] Step 43, record p i The nearest seed point is v j ;

[0023] Step 44, take Where n represents the number of input seed points, and Vol represents the bounding box volume of all seed points. If ||v i -p i If ||≤4λ, then proceed directly to step 45; otherwise, in v i p i Find a new capture point Let its nearest seed point be v. q If v q =v i Then let point q continue along Shift the direction by 2λ and re-query the nearest neighbor seed point v. q until v q ≠v i Then v j Updated to v q Proceed to step 45;

[0024] Step 45, construct v i v j The perpendicular bisector B of the two seed points i，j Calculate B i，j With v i p i Given the intersection point e, find the nearest seed point v of e. e Determine whether the intersection point e is at the seed point v. i Within the Voronoi cell;

[0025] Step 46: If the intersection point e is at the seed point v iIn addition to the Voronoi cell, v j Updated to v e And re-enter step 45;

[0026] Step 47: If the intersection point e is at the seed point v i Within the Voronoi cell, the latest B i，j This is the constructed cutting plane.

[0027] Furthermore, the determination of whether intersection point e is at seed point v i The steps within the Voronoi cell unit include:

[0028] Step 451: Query the nearest seed point of e, denoted as v. e ;

[0029] Step 452, if v e =v i , or ||ev i || 2 -||ev e || 2 If ≤β, then the intersection point e is determined to be at the seed point v. i Within the Voronoi cell;

[0030] Step 453, if v e ≠v i , or ||ev i || 2 -||ev e || 2 If the value is greater than β, then the intersection point e is determined to be at the seed point v. i Outside of the Voronoi cell.

[0031] Secondly, the present invention provides a point-cell relation-driven Voronoi graph parallel computing system, the system comprising:

[0032] The spatial pre-allocation module is used to obtain the seed point set. And the solution domain M, based on the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space;

[0033] The thread allocation module is used to set each cell's computation to be handled by a thread. Each thread's task includes three parts: cell initialization, pruning, and result storage.

[0034] The cell initialization module is used to initialize cells simultaneously in all threads. Specifically, during the initialization phase of the i-th thread, the seed point v is set... i Ω cell i|M =M;

[0035] The cell trimming module is used to trim cells in all threads simultaneously. Specifically, during the trimming phase of the i-th thread, if Ω... i|M There exists a vertex p in the middle. i In v i Outside the Voronoi cell, denote its nearest neighbor seed point v. j Then, the clipping plane B is constructed based on the preset rules. i，j and use B i，j For Ω i|M The result of the trimming is still denoted as Ω. i|M At this point, one effective clipping has been completed. This process of selecting points and constructing clipping planes is repeated iteratively until Ω is reached. i|M All vertices in v i Within the Voronoi cell;

[0036] The cell storage module is used to store cell results in all threads simultaneously, that is, the i-th thread stores the cell result Ω. i|M Store the data in the pre-allocated GPU memory space to output the cells of all seed points.

[0037] Thirdly, the present invention provides a storage medium that stores one or more programs that, when executed by a processor, implement the above-described cell relation-driven Voronoi graph parallel computation method.

[0038] Fourthly, the present invention provides a computer device, the computer device comprising a memory and a processor, wherein:

[0039] The memory is used to store computer programs;

[0040] When the processor executes the computer program stored in the memory, it implements the above-described point-cell relation-driven Voronoi graph parallel computing method.

[0041] In summary, based on the aforementioned point-cell relationship-driven parallel computation method for Voronoi graphs, this invention designs a novel cell generation scheme based on the attribution relationship between spatial points and cells. Specifically, for cells during the pruning process, at most one effective pruning plane is determined for each vertex, so that after this pruning, the edges / faces of a Voronoi cell can be determined, which can be quickly determined through several nearest neighbor searches. Therefore, this invention only involves pruning that contributes to the result. Verification has shown that the method disclosed in this invention has higher computational efficiency than all current mainstream methods. Attached Figure Description

[0042] Figure 1This is a schematic diagram illustrating the cell trimming process in each thread of this invention.

[0043] Figure 2 This is an example of the Voronoi diagram results in a 2D rectangular solution domain according to the present invention;

[0044] Figure 3 This is an example of the invention showing a locally magnified 10-fold result of the Voronoi diagram in a 2D rectangular solution domain;

[0045] Figure 4 This is an example of the Voronoi diagram results in a 3D hexahedral solution domain according to the present invention;

[0046] Figure 5 This is an example of the Voronoi diagram results in a 3D tetrahedral solution domain according to the present invention;

[0047] Figure 6 This is an example of the Voronoi diagram results in the solution domain of a 3D 14-sided cube, as exemplified by this invention.

[0048] Figure 7 This is a schematic diagram of a Voronoi graph parallel computing system driven by cell relations according to an embodiment of the present invention.

[0049] The following detailed description, in conjunction with the accompanying drawings, will further illustrate the present invention. Detailed Implementation

[0050] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention. Unless otherwise defined, the technical or scientific terms used herein should have the ordinary meaning understood by those skilled in the art. The terms "comprising" and similar expressions used herein mean that the element or object preceding the word covers the element or object listed after the word and its equivalents, but does not exclude other elements or objects.

[0051] An embodiment of the present invention provides a parallel computation method for Voronoi graphs driven by cell relations, the method comprising steps 1 to 6, wherein:

[0052] Step 1: Obtain the seed point set And the solution domain M, based on the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space;

[0053] It should be noted that in this step, a simple polygon / polyhedron M and n seed points are input. Then, a set of grids is set up, and each seed point is placed into the corresponding grid according to its coordinates to obtain the neighbor search structure, which is used for subsequent nearest neighbor queries.

[0054] Specifically, the process of pre-allocating space is as follows:

[0055] Step 11: Set up a grid and place each seed point into the corresponding grid according to its coordinates;

[0056] Step 12: Transfer the grid and seed point coordinates to the GPU's global memory, and generate cell results in the GPU's global memory. Pre-allocate space.

[0057] In addition, record each seed point v i The corresponding Voronoi cell is Ω i Its mathematical definition is It means Ω i Any point in the vector vector is connected to the corresponding seed point v. i The distance between any two points is no greater than the distance from that point to any other seed point. A Voronoi diagram can be represented as a set of cells. What needs to be calculated is Ω for each cell. i The intersection with M, that is, each seed point corresponds to a subregion Ω of M. i|M =Ω i ∩M.

[0058] Step 2: Set each cell's computation to be handled by a thread. Each thread's task includes three parts: cell initialization, pruning, and result storage.

[0059] Step 3: Simultaneously initialize cells in all threads, that is, during the initialization phase of the i-th thread, let the seed point v i Ω cell i|M =M;

[0060] Step 4: Simultaneously prune the cells in all threads, that is, in the pruning stage of the i-th thread, if Ω i|M There exists a vertex p in the middle. i In v i Outside the Voronoi cell, denote its nearest neighbor seed point v. j Then, the clipping plane B is constructed based on the preset rules. i，j and use B i，j For Ω i|M The result of the trimming is still denoted as Ω.i|M At this point, one effective clipping has been completed. This process of selecting points and constructing clipping planes is repeated iteratively until Ω is reached. i|M All vertices in v i Within the Voronoi cell;

[0061] In some embodiments, determine p i Is it at seed point v? i The steps within the Voronoi cell unit include:

[0062] Step 41, query p i The nearest seed point, denoted as v j ;

[0063] Step 42, if v j =v i , or ||p i -v i || 2 -||p i -v j || 2 If ≤β, then determine p i At seed point v i Within the Voronoi cell, p is determined. i At seed point v i Outside the Voronoi cell, where β is a very small positive real number, such as 10. -12 10 -11 10 -13 Etc., used to compensate for errors caused by computer floating-point representation, can be adjusted according to the application;

[0064] Step 43, if v j ≠v i And ||p i -v i || 2 -||p i -v j || 2 If >β, then determine p i At seed point v i Outside of the Voronoi cell.

[0065] Furthermore, in some embodiments, the cutting plane B is constructed based on preset rules. i，j The steps include:

[0066] Step 43, record p i The nearest seed point is v j ;

[0067] Step 44, take Where n represents the number of input seed points, and Vol represents the bounding box volume of all seed points. If ||v i -p i If ||≤4λ, then proceed directly to step 45; otherwise, in v i p i Find a new point Let its nearest seed point be v. q If v q =v i Then let point q continue along Shift the direction by 2λ and re-query the nearest neighbor seed point v. q until v q ≠v i Then v j Updated to v q Proceed to step 45;

[0068] Step 45, construct v i v j The perpendicular bisector B of the two seed points i，j Calculate B i，j With v i p i Given the intersection point e, find the nearest seed point v of e. e Determine whether the intersection point e is at the seed point v. i Within the Voronoi cell;

[0069] Step 46: If the intersection point e is at the seed point v i In addition to the Voronoi cell, v j Updated to v e Then re-enter step 45, and repeat this process until it is determined that the intersection point e is at the seed point v. i Within the Voronoi cell;

[0070] Step 47: If the intersection point e is at the seed point v i Within the Voronoi cell, the latest B i，j This is the constructed cutting plane.

[0071] In some embodiments, it is determined whether the intersection point e is at the seed point v. i The steps within the Voronoi cell unit include:

[0072] Step 451: Query the nearest seed point of e, denoted as v. e ;

[0073] Step 452, if v e =v i , or ||ev i || 2 -||eve || 2 ≤β (where β is a very small positive real number, such as 10) -12 (This is used to compensate for errors caused by computer floating-point representation and can be adjusted according to the application). Then, it is determined that the intersection point e is at the seed point v. i Within the Voronoi cell;

[0074] Step 453, if v e ≠v i , or ||ev i || 2 -||ev e || 2 If the value is greater than β, then the intersection point e is determined to be at the seed point v. i Outside of the Voronoi cell.

[0075] like Figure 1 The image shown is a schematic diagram illustrating the example of cropping.

[0076] Step 6: Simultaneously store the cell result in all threads, that is, the i-th thread stores the cell result Ω. i|M Store the data in the pre-allocated GPU memory space to output the cells of all seed points.

[0077] Existing GPU-based solutions suffer from numerous invalid prunings during cell generation, and searching for k-nearest neighbors is extremely time-consuming, thus remaining inefficient. This embodiment, however, iteratively prunes vertices that do not belong to it, obtaining a final Voronoi edge with each pruning step. Therefore, it only involves pruning that contributes to the result, saving computational resources. The Voronoi graph computation results for arbitrary solution domains in two-dimensional and three-dimensional space in this embodiment are as follows: Figures 2 to 6 As shown.

[0078] In summary, based on the aforementioned point-cell relationship-driven parallel computation method for Voronoi graphs, this invention designs a novel cell generation scheme based on the attribution relationship between spatial points and cells. Specifically, for cells during the pruning process, at most one effective pruning plane is determined for each vertex, ensuring that an edge of a Voronoi cell can be determined after this pruning, which can be quickly determined through several nearest neighbor searches. Therefore, this invention only involves pruning that contributes to the result. Verification has shown that the method disclosed in this invention has higher computational efficiency than all current mainstream methods.

[0079] Test case

[0080] The experimental computing platform is shown in Table 1 below:

[0081] Table 1

[0082] CPU Intel(R)Core(TM)i7-14700F 2.10GHz GPU NVIDIA GeForce RTX 4060

[0083] (2) Construct 1 million seed points with three different distributions respectively, and solve the bounding box of a cube with a solution domain of size 1000.0*1000.0*1000.0.

[0084] (3) Run the program and measure the time consumed, as shown in Table 2 below:

[0085] Table 2

[0086]

[0087] As shown in Table 2, regardless of whether the seed points in the solution domain are randomly or uniformly distributed, the time required to generate the Voronoi diagram is much shorter than that of the existing GPU-based solutions, indicating that this embodiment can greatly improve the computational efficiency of the Voronoi diagram.

[0088] like Figure 7 As shown, an embodiment of the present invention also proposes a point-cell relation-driven Voronoi graph parallel computing system, the system comprising:

[0089] Spatial pre-allocation module 10 is used to obtain the seed point set. And the solution domain M, based on the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space;

[0090] The thread allocation module 20 is used to set each cell's calculation to be handled by a thread. Each thread's task includes three parts: cell initialization, pruning, and result storage.

[0091] Cell initialization module 30 is used to initialize cells simultaneously in all threads, that is, during the initialization phase of the i-th thread, let the seed point v i Ω cell i|M =M;

[0092] Cell trimming module 40 is used to trim cells in all threads simultaneously, that is, during the trimming stage of the i-th thread, if Ω i|M There exists a vertex p in the middle. i In v i Outside the Voronoi cell, denote its nearest neighbor seed point v. j Then, the clipping plane B is constructed based on the preset rules. i，j and use B i，j For Ω i|M The result of the trimming is still denoted as Ω. i|M At this point, one effective clipping has been completed. This process of selecting points and constructing clipping planes is repeated iteratively until Ω is reached. i|M All vertices in vi Within the Voronoi cell;

[0093] Cell storage module 50 is used to store cell results in all threads simultaneously, that is, the i-th thread stores the cell result Ω. i|M Store the data in the pre-allocated GPU memory space to output the cells of all seed points.

[0094] In another aspect, the present invention also proposes a storage medium on which one or more programs are stored, which, when executed by a processor, implement the above-described cell relation-driven Voronoi graph parallel computation method.

[0095] In another aspect, the present invention also proposes a computer device, including a memory and a processor, wherein the memory is used to store a computer program, and the processor is used to execute the computer program stored in the memory to implement the above-mentioned point-cell relation-driven Voronoi graph parallel computing method.

[0096] Those skilled in the art will understand that the logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a ordered list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can mean any means that can contain stored, communicated, propagated, or transmitted programs for use by, or in conjunction with, an instruction execution system, apparatus, or device.

[0097] More specific examples of computer-readable media (a non-exhaustive list) include: electrical connections (electronic devices) having one or more wires, portable computer disk drives (magnetic devices), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Furthermore, computer-readable media can even be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in computer memory.

[0098] It should be understood that various parts of the present invention can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0099] While embodiments of the present invention have been described in detail above, it will be apparent to those skilled in the art that various modifications and variations can be made to these embodiments. However, it should be understood that such modifications and variations fall within the scope and spirit of the invention as set forth in the claims. Furthermore, the invention described herein may have other embodiments and can be implemented or carried out in various ways.

Claims

1. A point-cell relationship driven Voronoi diagram parallel computing method, characterized in that: The method comprises: Step 1: Get a set of seed points And the solution domain M, according to the seed point set Build the neighbor search structure and store the cell results in the GPU memory. Pre-allocate space; Step 2: Set the calculation of each cell to be in charge of one thread. The tasks of each thread include initialization, clipping and result storage of the cell. Step 3: Initialize cells in all threads at the same time. That is, in the initialization phase of the i-th thread, let the seed point v i The cell Ω i|M =M; Step 4: Crop the cells in all threads at the same time. That is, in the pruning stage of the i-th thread, if Ω i|M There is a vertex p in i In v i Outside the Voronoi cell, its nearest neighbor seed point v j , then the clipping plane B is constructed based on the preset rules i,j and use B i,j For Ω i|M After trimming, the result is still recorded as Ω i|M , at this point, an effective clipping has been completed, and the point selection and clipping plane construction are performed iteratively until Ω i|M All vertices in v i The Voronoi cell; Step 5: Store the cell results in all threads at the same time, that is, the i-th thread stores the cell result Ω i|M Store in the pre-allocated GPU memory space to output the cells of all seed points 2. The point-cell relationship driven Voronoi diagram parallel computing method according to claim 1, characterized in that: The seed point set is obtained And the solution domain M, according to the seed point set Build the neighbor search structure and store the cell results in the GPU memory. The steps to pre-allocate space include: Step 11: Set a set of grids and place each seed point in the corresponding grid according to the coordinates; Step 12: Transfer the grid and seed point coordinates to the GPU global memory and store the cell result in the GPU global memory. Pre-allocate space.

3. The point-cell relationship driven Voronoi diagram parallel computing method according to claim 1, characterized in that: Determine p i Is it at the seed point v? i The steps within a Voronoi cell include: Step 41: Query p i The nearest seed point is denoted as v j ; Step 42: If v j =v i , or ‖p i -v i ‖ 2 -‖p i -v j ‖ 2 ≤β, then determine p i At the seed point v i The Voronoi cell; Step 43: If v j ≠v i And ‖p i -v i ‖ 2 -‖p i -v j ‖ 2 >β, then determine p i At the seed point v i Outside the Voronoi cell.

4. The point-cell relationship driven Voronoi diagram parallel computing method according to claim 1, characterized in that: The clipping plane B is constructed based on the preset rules i,j The steps include: Step 43, remember p i The nearest seed point is v j ; Step 44: Take Where n represents the number of input seed points, and Vol represents the bounding box volume of all seed points. i -p i ‖≤4λ, go directly to step 45; otherwise, i p i Find a new point Let the nearest seed point be v q , if v q =v i , then let point q continue along Direction translation distance 2λ, and re-query the nearest neighbor seed point v q , until v q ≠v i , then v j Update to v q Then go to step 45; Step 45: Construct v i v j The perpendicular plane B between the two seed points i,j , calculate B i,j With v i p i The intersection point e, query e's nearest seed point v e , determine whether the intersection point e is at the seed point v i The Voronoi cell; Step 46: If the intersection point e is at the seed point v i Outside the Voronoi cell, v j Update to v e And re-enter step 45; Step 47: If the intersection point e is at the seed point v i The Voronoi cell of the i,j This is the constructed clipping plane.

5. The point-cell relationship driven Voronoi diagram parallel computing method according to claim 4, characterized in that: The determination of whether the intersection point e is at the seed point v i The steps within a Voronoi cell include: Step 451: Query the nearest seed point of e, denoted as v e ; Step 452: If v e =v i , or ‖ev i ‖ 2 -‖ev e ‖ 2 ≤β, then the intersection point e is determined to be at the seed point v i The Voronoi cell; Step 453: If v e ≠v i , or ‖ev i ‖ 2 -‖ev e ‖ 2 >β, then the intersection point e is determined to be at the seed point v i Outside the Voronoi cell.

6. A point-cell relationship driven Voronoi diagram parallel computing system, characterized in that: The system comprises: Spatial pre-allocation module, used to obtain a set of seed points And the solution domain M, according to the seed point set Build the neighbor search structure and store the cell results in the GPU memory. Pre-allocate space; The thread allocation module is used to set the calculation of each cell to be handled by one thread. The tasks of each thread include initialization, pruning and result storage of cells. The cell initialization module is used to initialize cells in all threads at the same time. That is, in the initialization phase of the i-th thread, let the seed point v i The cell Ω i|M =M; The cell pruning module is used to prune the cells in all threads at the same time. That is, in the pruning stage of the i-th thread, if Ω i|M There is a vertex p in i In v i Outside the Voronoi cell, its nearest neighbor seed point v j , then the clipping plane B is constructed based on the preset rules i,j and use B i,j For Ω i|M After trimming, the result is still recorded as Ω i|N , at this point, an effective clipping has been completed, and the point selection and clipping plane construction are performed iteratively until Ω i|M All vertices in v i The Voronoi cell; The cell storage module is used to store the cell results in all threads at the same time, that is, the i-th thread stores the cell result Ω i|M Store in the pre-allocated GPU memory space to output the cells of all seed points 7. A storage medium, characterized in that: The storage medium stores one or more programs, which, when executed by a processor, implement the point-cell relationship driven Voronoi diagram parallel computing method as described in any one of claims 1 to 5.

8. A computer device comprising a memory and a processor, wherein: The memory is used to store computer programs; When the processor is used to execute the computer program stored in the memory, it implements the point-cell relationship driven Voronoi diagram parallel calculation method as described in any one of claims 1-5.

Images