Point-cell relationship driven voronoi diagram parallel computing method and system

Abstract

This invention provides a method and system for parallel computation of Voronoi graphs driven by cell relationships. The method includes: acquiring a seed point set and a solution domain, and pre-allocating space for cell results in the GPU's video memory; setting each cell computation to be handled by a thread; and during the initialization phase of the i-th thread, setting the seed point v... i Ω cell i|M Set to M; during the pruning 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 Iteratively select points and construct clipping planes to perform clipping until Ω is reached. i|M All vertices in v i Within the Voronoi cell; the cell result Ω i|M The data is stored in pre-allocated GPU memory. This embodiment of the invention can significantly improve the computational efficiency of Voronoi diagrams while ensuring the accuracy of the results.

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 computation method, characterized in that, The method comprises: Step 1: Obtain the seed point set and solution domain According to the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space; Step 2, setting the calculation of each cell to be responsible for by a thread, and the task of each thread comprising three parts of initialization, clipping and result storage of the cell; Step 3, initialize the cells in all threads simultaneously, i.e. in the initialization phase of the i-th thread, let the seed point be the cell ; Step 4, clip each cell in all threads simultaneously, that is, in the clipping phase of the i-th thread, if there exists a vertex in the Voronoi cell of , record its nearest neighbor seed point , construct a clipping plane based on a preset rule, and clip with , and the result is still recorded as , at this time, one effective clipping has been completed, and the selection of points and the construction of clipping planes for clipping are iteratively executed, until all vertices in the Voronoi cell of are in the Voronoi cell of . Step 5, store the cell result in all threads at the same time, that is, the i-th thread will store the cell result to the pre-allocated GPU side memory space to output the cell of all seed points .

2. The cell-based relation-driven Voronoi diagram parallel computation method of claim 1, wherein, The seed point set is acquired And the solution domain According to the seed point set Construct a neighbor search structure, and pre-allocate space for the cell result in the GPU memory The step of pre-allocating space includes: Step 11, setting a group of lattices, and placing each seed point into a corresponding lattice according to coordinates; Step 12, transmit the lattice and seed point coordinates to the GPU side global memory, and store the cell results in the GPU side global memory Pre-allocate space.

3. The cell-based relation-driven Voronoi diagram parallel computation method of claim 1, wherein, determining whether the seed point is inside the Voronoi cell of the seed point Step 41, query the most recent seed point, denoted by ; Step 42, if or then determine within the Voronoi cell of the seed point wherein denotes a positive real number for offsetting errors resulting from the computer floating-point number representation; Step 43, if and then determine that the seed point is outside the Voronoi cell.

4. The cell-based relation-driven Voronoi diagram parallel computation method of claim 1, wherein, The step of constructing the clipping plane based on the preset rule includes: Step 43, record the most recent seed point as ; Step 44, take where n denotes the number of input seed points, represents the bounding box volume of all seed points; if , directly go to Step 45; otherwise, find a new point on the surface of the bounding box , and record its nearest seed point as , if , let the point continue to translate 2 distance along the direction of , and re-query the nearest neighbor seed point , until , update to and go to Step 45. Step 45, construct median plane of two seed points , calculate intersection of , query the nearest seed point of , determine whether the intersection point e is in the Voronoi cell of the seed point ​​​ Step 46: If the intersection point e is at the seed point In addition to the Voronoi cell, Updated to And re-enter step 45; Step 47, if the intersection point e is inside the Voronoi cell of the seed point then the last is the constructed clipping plane.

5. The cell relationship driven Voronoi diagram parallel computation method according to claim 4, wherein, the step of determining whether the intersection point e is within the Voronoi cell of the seed point includes: Step 451, query the latest seed point of e, denoted as ; Step 452, if or then determine intersection point within the Voronoi cell of seed point where, denotes a positive real number used to offset errors produced by the computer floating-point number representation; Step 453, if or then determine intersection is outside the Voronoi cell of the seed point .

6. A point-cell relationship driven Voronoi diagram parallel computing system, characterized in that, The system comprises: The spatial pre-allocation module is used to obtain the seed point set. and solution domain According to the seed point set Construct a neighbor search structure and store the cell results in GPU memory. Pre-allocate space; A thread allocation module, configured to set the calculation of each cell to be responsible for by a thread, and the task of each thread comprising three parts of initialization, clipping and result storage of the cell; The cell initialization module is configured to initialize the cells in all threads simultaneously, that is, in the initialization stage of the i-th thread, the seed point is set as the cell of the seed point. The cell trimming module is used to trim cells simultaneously in all threads. Specifically, during the trimming phase of the i-th thread, if... There are vertices in it exist Outside of the Voronoi cell, denote its nearest neighbor seed point. Then, a clipping plane is constructed based on preset rules. and use right Perform the cropping, and the result will still be recorded as... At this point, one effective clipping has been completed. This process of selecting points and constructing clipping planes is repeated iteratively until... All vertices in Within the Voronoi cell; A cell storage module is configured to store the cell results in all threads at the same time, i.e. the i-th thread stores the cell results of the i-th thread into the pre-allocated GPU display memory space to output the cell results of all seed points. .​ 7. A storage medium, characterized by The storage medium stores one or more programs, and the programs are executed by the processor to implement the point-cell relationship driven Voronoi diagram parallel calculation method according to any one of claims 1-5. 8.A computer device, comprising a memory and a processor, wherein: The memory is used to store a computer program; The processor is used to execute the computer program stored on the memory to implement the point-cell relationship driven Voronoi diagram parallel calculation method according to any one of claims 1-5.

Images