A GPU-based BRep model watertight mesh conversion and topology reconstruction method

Abstract

The application discloses a GPU-based BRep model watertight mesh conversion and topological reconstruction method, which comprises the following steps: generating a UV island corresponding to a two-dimensional parameter space of each face of a corresponding BRep model; constructing an initial UV atlas; obtaining an optimized UV atlas tending to a square layout; constructing a preliminary two-dimensional triangular mesh; removing false triangles crossing the boundary of the original UV island and only retaining internal triangles satisfying the validity condition to form a pure two-dimensional triangular mesh; constructing a preliminary three-dimensional triangular mesh model; obtaining a complete watertight three-dimensional mesh model; and constructing a memory continuous topological data structure. The application accelerates the conversion and topological reconstruction process through parallel computing, can efficiently process fine and complex geometric models, and significantly improves the efficiency and reliability of engineering design.

Description

Technical Field

[0001] The present invention relates to the field of GPU computing technology, and in particular to a GPU-based BRep model watertight mesh conversion and topology reconstruction method. Background Art

[0002] Currently, mainstream BRep model processing in the industry relies on a series of mature geometric algorithm libraries. The core computing tasks of OpenCASCADE in Example 2 are usually designed to be executed serially or in limited parallel on the central processing unit. Although some algorithms utilize multi-core CPU technology to perform a certain degree of parallel optimization, their parallel granularity and scalability are limited by the CPU architecture. As industrial design becomes increasingly complex, the scale of BRep models increases dramatically. Traditional CPU-based computing methods take too long to process these large-scale, high-complexity models, and performance bottlenecks are becoming increasingly prominent.

[0003] At the same time, graphics processors, with their massively parallel computing architecture, have demonstrated a strong computing advantage in scientific computing and graphics processing. However, existing BRep core processing algorithms fail to effectively utilize the parallel computing capabilities of GPUs. As a result, in today's rapidly developing hardware technology, the preprocessing speed of BRep models has become a shortcoming that restricts the overall workflow efficiency. Summary of the Invention

[0004] One purpose of the present invention is to propose a GPU-based BRep model watertight mesh conversion and topology reconstruction method. The present invention accelerates the conversion and reconstruction process through GPU parallel computing. It can efficiently process delicate and complex geometric models, significantly improving the efficiency and reliability of engineering design.

[0005] A GPU-based BRep model watertight mesh conversion and topology reconstruction method according to an embodiment of the present invention includes:

[0006] Perform face-level parsing on the input boundary representation model to generate UV islands corresponding to the two-dimensional parameter space;

[0007] Using the parallel computing architecture on the GPU to perform linear non-overlapping arrangement processing on the multiple independent UV islands, sequentially arranging the UV islands along the U axis, and constructing an initial UV atlas;

[0008] Performing a parallel compression optimization operation on the GPU based on the initial UV atlas to fill each UV island in the initial UV atlas into a square virtual grid area to obtain an optimized UV atlas with a nearly square layout;

[0009] Submitting the optimized UV atlas to the GPU for parallel constrained Delaunay triangulation, performing global triangulation on all vertices based on the boundary constraints of the UV islands, and constructing a preliminary two-dimensional triangular mesh;

[0010] Performing a parallel centroid ray intersection algorithm validity check on all triangles in the preliminary two-dimensional triangular mesh on the GPU, removing pseudo triangles that cross the original UV island boundary, and retaining only internal triangles that meet the validity conditions to form a pure two-dimensional triangular mesh;

[0011] Back-project each triangle in the pure 2D triangular mesh onto the BRep surface to which it belongs, and obtain the 3D spatial coordinates by resolving the 2D parameter coordinates on the original facet to construct a preliminary 3D triangular mesh model.

[0012] Perform watertightness repair operations on the preliminary 3D triangular mesh model on the GPU to obtain a complete watertight 3D mesh model;

[0013] The topological information of the complete watertight three-dimensional mesh model is reconstructed on the GPU, the edge list is deduplicated through a normalized edge representation method, and the number of adjacency relationships of all vertices, edges and triangles is counted based on atomic operations. Based on the number of adjacency relationships, a prefix sum operation is performed on the GPU to obtain a storage offset, and the corresponding adjacency index array is filled to construct a memory-continuous topological structure.

[0014] Optionally, the topological hierarchical parsing is to decompose the boundary representation model into multiple independent geometric surfaces, and generate a UV island corresponding to the two-dimensional parameter space for each geometric surface according to a preset sampling density and minimum edge length parameter, wherein the two-dimensional parameter space UV island is constructed by boundary points and internal points.

[0015] Optionally, the compression optimization operation is:

[0016] Calculate an approximately square M×M virtual grid that accommodates all UV islands, launch the CUDA kernel in parallel to treat each UV island as an independent block, rearrange and fill it into the virtual grid, so that the optimized UV atlas tends to be square, and generate the total UV island with optimized layout.

[0017] Optionally, the boundary constraint information is constructed by traversing each edge of the boundary representation model and sequentially sampling a series of points along its one-dimensional parameter space.

[0018] Optionally, the effectiveness of the centroid ray intersection algorithm is determined as follows:

[0019] Shoot a ray from the centroid. If the number of intersections between the ray and the boundary of the original UV island to which the triangle belongs is odd, it is considered a valid internal triangle and is retained.

[0020] On the contrary, if it is an even number, it is determined to be a false triangle and is eliminated.

[0021] Optionally, the watertightness repair operation includes:

[0022] By building a spatial acceleration structure to perform vertex neighbor search, all vertices within the preset tolerance range are merged into a single vertex, and the vertex indices of all related triangles are updated. After welding, parallel CUDA cores perform hole filling and normal direction uniform repair operations to produce a complete and watertight 3D mesh model that is completely watertight and manifold.

[0023] Optionally, the topology information reconstruction includes:

[0024] Based on a complete watertight 3D mesh model, all triangles are processed in parallel on the GPU. A canonical representation is used to uniformly encode the edges of each triangle. Edges formed by a vertex connecting to another vertex are uniformly represented. Parallel sorting and deduplication operations are then used to generate a unique edge list and count the total number of edges.

[0025] Launch the CUDA kernel to traverse all vertices, edges, and triangles of the complete watertight 3D mesh model, use atomic operations to record the number of adjacent edges and adjacent triangles of each vertex, as well as the number of adjacent triangles of each edge in parallel, and build a vertex, edge, and triangle adjacency count table;

[0026] Based on the adjacency count table, a prefix and scan operation is performed on the GPU to generate an array of starting storage offsets for the adjacency items corresponding to vertices, edges, and triangles, providing an offset basis for the write position of the adjacency index data structure;

[0027] Allocate video memory space that matches the prefix sum result to store the adjacency index array, and launch a second CUDA kernel on the GPU to traverse all vertices, edges, and triangles in parallel. Based on their adjacency relationship and prefix sum offset position, write the index of the corresponding adjacent element into the adjacency index array;

[0028] After the writing of the adjacency index array is completed, a memory continuous topological data structure consisting of the prefix sum array and the index array is formed in the GPU memory.

[0029] The beneficial effects of the present invention are:

[0030] The present invention uses the GPU to efficiently convert the BRep model into a watertight mesh and performs topological reconstruction on the GPU, solving the problem of slow processing of complex BRep models by traditional CPUs. By accelerating the conversion and reconstruction process through parallel computing, it can efficiently process fine and complex geometric models.

[0031] This paper transplants the BRep model mesh generation algorithm on the traditional CPU to the GPU and proposes an optimized UV layout method, which significantly improves the speed of mesh generation on the GPU and ensures the watertightness of mesh generation. In addition, a unique data structure and topology reconstruction method are designed for the mesh data on the GPU, which is suitable for GPU multi-threaded processing and supports multiple query methods. BRIEF DESCRIPTION OF THE DRAWINGS

[0032] The accompanying drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation of the present invention. In the accompanying drawings:

[0033] Figure 1 The GPU-based BRep model watertight mesh conversion and topology reconstruction method proposed in this invention successfully converts the BRep solid model into a high-quality watertight triangulated mesh.

[0034] Figure 2 This is the UV atlas generation process in the GPU-based BRep model watertight mesh conversion and topology reconstruction method proposed in this invention, that is, through aggregation and compression, the discrete UV islands of the model are integrated into a compact UV atlas.

[0035] Figure 3 This is the core process of generating 3D mesh from UV atlas in the GPU-based BRep model watertight mesh conversion and topology reconstruction method proposed by the present invention, including triangulation, invalid area elimination, 3D mapping and watertight stitching.

[0036] Figure 4 This is a topological data structure in a GPU-based BRep model watertight grid conversion and topology reconstruction method proposed by the present invention. The structure includes a prefix sum array and an index data block for each adjacency relationship.

[0037] Figure 5 This paper shows the parallel construction process of the topology structure in the GPU-based BRep model watertight mesh conversion and topology reconstruction method proposed in this paper, demonstrating key parallel stages such as prefix sum calculation and index filling.

[0038] Figure 6 This paper presents the topology query process in the GPU-based BRep model watertight mesh conversion and topology reconstruction method proposed by the present invention, and demonstrates the adjacent triangle process of the query point. DETAILED DESCRIPTION

[0039] Example 1:

[0040] refer to Figures 1-6, a GPU-based BRep model watertight mesh conversion and topology reconstruction method, including:

[0041] Perform topological hierarchical analysis on the input boundary representation model to generate UV islands corresponding to the two-dimensional parameter space;

[0042] Utilize the parallel computing architecture on the GPU to perform linear non-overlapping arrangement of multiple independent UV islands, arrange each UV island sequentially along the U axis, and construct the initial UV atlas;

[0043] Based on the initial UV atlas, a parallel compression optimization operation is performed on the GPU to fill each UV island in the initial UV atlas into a square virtual grid area to obtain an optimized UV atlas with a nearly square layout.

[0044] Perform parallel constrained Delaunay triangulation on the optimized UV atlas, perform global triangulation on all vertices based on the boundary constraints of the UV island, and construct a preliminary 2D triangular mesh.

[0045] On the GPU, a parallel centroid ray intersection algorithm is used to determine the validity of all triangles in the preliminary 2D triangular mesh. Pseudo triangles that cross the boundaries of the original UV island are removed, and only internal triangles that meet the validity criteria are retained to form a pure 2D triangular mesh.

[0046] Back-project each triangle in the pure 2D triangular mesh onto the BRep surface to which it belongs, and obtain the 3D spatial coordinates by resolving the 2D parameter coordinates on the original facet to construct a preliminary 3D triangular mesh model.

[0047] Perform watertightness repair operations on the preliminary 3D triangular mesh model on the GPU to obtain a complete watertight 3D mesh model;

[0048] The topological information of the complete watertight 3D mesh model is reconstructed on the GPU. The edge list is deduplicated using a normalized edge representation method, and the number of adjacency relationships of all vertices, edges, and triangles is counted based on atomic operations. Based on the number of adjacency relationships, a prefix sum operation is performed on the GPU to obtain the storage offset and fill the corresponding adjacency index array to construct a memory-contiguous topological structure.

[0049] In this embodiment, the patch-level parsing is to decompose the boundary representation model into multiple independent geometric surfaces, and for each geometric surface, generate a UV island corresponding to the two-dimensional parameter space according to the preset sampling density and minimum edge length parameters. The two-dimensional parameter space UV island is constructed by boundary points and internal points.

[0050] In this implementation, the compression optimization operation is:

[0051] Calculate an approximately square M×M virtual grid that accommodates all UV islands, launch the CUDA kernel in parallel to treat each UV island as an independent block, rearrange and fill it into the virtual grid, so that the optimized UV atlas tends to be square, and generate a layout-optimized UV atlas.

[0052] In this embodiment, the boundary constraint information is constructed by traversing each edge of the boundary representation model and sequentially sampling a series of points along its one-dimensional parameter space.

[0053] In this implementation, the effectiveness of the centroid ray intersection algorithm is determined as follows:

[0054] Shoot a ray from the centroid. If the number of intersections between the ray and the boundary of the original UV island to which the triangle belongs is odd, it is considered a valid internal triangle and is retained.

[0055] On the contrary, if it is an even number, it is determined to be a false triangle and is eliminated.

[0056] In this embodiment, the watertightness repair operation includes:

[0057] By building a spatial acceleration structure to perform vertex neighbor search, all vertices within the preset tolerance range are merged into a single vertex, and the vertex indices of all related triangles are updated. After welding, parallel CUDA cores perform hole filling and normal direction uniform repair operations to produce a complete and watertight 3D mesh model that is completely watertight and manifold.

[0058] In this embodiment, topology information reconstruction includes:

[0059] Based on a complete watertight 3D mesh model, all triangles are processed in parallel on the GPU. A canonical representation is used to uniformly encode the edges of each triangle. Edges formed by a vertex connecting to another vertex are uniformly represented. Parallel sorting and deduplication operations are then used to generate a unique edge list and count the total number of edges.

[0060] Launch the CUDA kernel to traverse all vertices, edges, and triangles of the complete watertight 3D mesh model, use atomic operations to record the number of adjacent edges and adjacent triangles of each vertex, as well as the number of adjacent triangles of each edge in parallel, and build a vertex, edge, and triangle adjacency count table;

[0061] Based on the adjacency count table, a prefix and scan operation is performed on the GPU to generate an array of starting storage offsets for the adjacency items corresponding to vertices, edges, and triangles, providing an offset basis for the write position of the adjacency index data structure;

[0062] Allocate video memory space that matches the prefix sum result to store the adjacency index array, and launch a second CUDA kernel on the GPU to traverse all vertices, edges, and triangles in parallel. Based on their adjacency relationship and prefix sum offset position, write the index of the corresponding adjacent element into the adjacency index array;

[0063] After the writing of the adjacency index array is completed, a memory continuous topological data structure consisting of the prefix sum array and the index array is formed in the GPU memory.

[0064] Example 2:

[0065] First, for the input BRep model, we traverse all its TopoDS_Face elements and extract the parameterized surface (Geom_Surface) corresponding to each patch and its (u,v) parameter range. By setting the sampling density (for example, 100 points per unit length) and the minimum edge length parameter, a regular or adaptive grid method is used to sample the point cloud of each face in the parameter space. The sampling points on the boundary are obtained by discretizing the boundary curve in the parameter space, while the internal sampling points are generated by meshing. These sampling points together form an independent UV island for each patch in the two-dimensional parameter space. The UV island defines its boundary in the form of polygons and comes with internal sampling points to support subsequent subdivision.

[0066] After UV unwrapping of all faces, a preliminary atlas layout is performed on the GPU for these independent UV islands. This layout strategy uses a linear, non-overlapping approach, ordering the UV islands along the U axis according to their area or bounding box size. Each island is assigned a starting U offset and a corresponding V height range, constructing a long, initial UV atlas. This is achieved by parallelizing the bounding box size of each UV island using CUDA cores and accumulating the global U offset using atomic addition operations to determine the exact placement of each UV island, ensuring that all UV islands remain non-overlapping in the initial atlas.

[0067] To further compress the UV atlas area and improve space utilization, atlas compression optimization is performed on the GPU. This process aims to construct a virtual grid that approximates a square, employing a concept similar to "rectangle packing" or "bin packing." First, an M×M virtual grid area is estimated (M is capped based on the total area of ​​all UV islands). Each UV island is then treated as a 2D rectangular block and rearranged within the CUDA kernel using parallel heuristics such as maximum gap-first filling or nearest neighbor filling.

[0068] The placement of each island searches for an accommodating area in units of thread blocks, and updates the virtual grid occupancy mark in an atomic write manner, thereby gradually building a UV atlas layout that approaches a square.

[0069] After obtaining the optimized atlas, constrained Delaunay triangulation is performed based on the boundary point information of each UV island. The specific algorithm is implemented in CUDA as triangulation subtasks executed in parallel by multiple thread blocks. Each task processes the point set and boundary constraints of one or more UV islands. The triangulation process uses the Bowyer-Watson framework or incremental methods, combined with the constraint preservation of boundary edges, to generate a triangular mesh in two-dimensional UV space. Each generated triangle consists of three (u, v) coordinate points, recording its position in the atlas and the index of the UV island to which it belongs.

[0070] Since constrained triangulation may generate pseudo triangles that cross the boundaries between different islands in the atlas, validity culling is required. We calculate the centroid coordinates for each triangle and emit a ray along a fixed direction in the atlas where the UV island to which it belongs is located. The number of intersections between the ray and the original UV island boundary is obtained through parallel segment intersection detection. If the number of intersections is odd, the centroid is considered to be inside the UV island and the corresponding triangle is valid; if it is even, the triangle crosses the boundary or is outside the island and is culled. This process is executed in CUDA threads per triangle, and is combined with fast bounding box culling of boundary edge segments and cross product judgment to accelerate intersection statistics, ultimately forming a pure two-dimensional triangulation result.

[0071] We then perform a backprojection on the clean 2D triangle mesh, mapping it back into 3D space. In CUDA, we query the (u,v) coordinates and associated UV island index for each triangle vertex to retrieve the corresponding TopoDS_Face object. Using the preloaded BRep face and Geom_Surface mapping table, we call the Geom_Surface::Value(u,v) interface to obtain the 3D coordinates of that point on the original CAD surface. The three vertices of the triangle are backprojected sequentially to form a 3D triangle mesh unit. All backprojection results are stored in a structured array on the GPU, forming a preliminary triangular mesh model.

[0072] Due to sampling errors or discontinuities at the surface joints, the triangular mesh may have tiny cracks at the seams, so a watertight repair operation needs to be performed on the GPU. We first build an acceleration structure based on spatial hashing or KD-tree and perform adjacent vertex pairing in CUDA, merging all vertices within a tolerance threshold (such as 1e-5) into a representative point with a unified number. After updating the index information of all triangles, we perform a topological structure analysis to find the edge sets that form boundary holes and fill the holes on the GPU based on the minimum area principle. In addition, through the normal vector consistency constraint, a unification operation is performed in the local area to ensure that the normal vectors of all triangles are in the same direction, and finally a completely watertight and manifold (2-manifold) three-dimensional triangular mesh model is obtained.

[0073] Finally, the topology information reconstruction operation is performed on the GPU for the watertight triangular mesh. First, the three edges of each triangle are normalized and encoded, and the edges are represented as the small numbered vertices in front.<min,max> form and record its associated triangle ID. In CUDA, a unique edge list is generated through global sorting and deduplication operations, and the number of adjacent triangles for each edge is counted (usually 2, and 1 for boundary edges). Next, we count the number of adjacency relationships for all vertices, edges, and triangles in parallel, and build an adjacency count table. To achieve an efficient index structure, we perform parallel prefix and scan operations on the count table to generate an offset array. Subsequently, continuous video memory is allocated, and the second-stage CUDA kernel is started to write the adjacent items into the adjacency index array according to the offset to form an adjacency list similar to the CSR format. The final output data structure is a topological information structure that is memory-contiguous and supports fast traversal, which can be used for subsequent simulation, deformation, feature extraction and other tasks.

[0074] Through the above process, we successfully converted the original BRep model into a three-dimensional triangular mesh model with complete topology, continuous faces, and good watertightness. All steps were highly parallelized on the GPU platform, achieving efficient processing of millions of faces while ensuring geometric accuracy, significantly improving the performance level of geometric preprocessing and simulation preparation.

[0075] In summary, this paper combines BRep precise geometry processing with GPU parallel computing to achieve fast and high-quality discrete mesh generation for complex CAD models. By leveraging CUDA's massive parallel capabilities, it achieves performance improvements dozens of times greater than CPU performance in floating-point-intensive geometric intersection and mesh construction. The mature OpenCascade geometry library is used to acquire model data, supplemented by uniform grids and kd-tree spatial data structures for acceleration, ensuring the algorithm's scalability and robustness.

[0076] The above description is only a preferred specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any technician familiar with the technical field, within the technical scope disclosed by the present invention, who makes equivalent replacements or changes based on the technical solution and inventive concept of the present invention, should be covered by the scope of protection of the present invention.

Claims

1. A GPU-based BRep model watertight mesh conversion and topology reconstruction method, characterized in that: include: Perform facet-level analysis on the input boundary representation model to generate UV islands corresponding to the two-dimensional parameter space; Utilize the parallel computing architecture on the GPU to perform linear non-overlapping arrangement of multiple independent UV islands to construct the initial UV atlas; Based on the initial UV atlas, parallel compression optimization operations are performed on the GPU to obtain an optimized UV atlas with a nearly square layout; Submit the optimized UV atlas to the GPU for parallel constrained Delaunay triangulation to construct a preliminary 2D triangular mesh; Performing a parallel centroid ray intersection algorithm validity check on all triangles in the preliminary two-dimensional triangular mesh on the GPU, and retaining only the internal triangles that meet the validity condition to form a pure two-dimensional triangular mesh; Back-project each triangle in the pure 2D triangular mesh onto the BRep surface to which it belongs to construct a preliminary 3D triangular mesh model; Perform watertightness repair operations on the preliminary 3D triangular mesh model on the GPU to obtain a complete watertight 3D mesh model; Reconstructing topological information of the complete watertight three-dimensional mesh model on a GPU to construct a memory-continuous topological structure; The topology information reconstruction includes: Based on a complete watertight 3D mesh model, all triangles are processed in parallel on the GPU. A canonical representation is used to uniformly encode the edges of each triangle. Edges formed by a vertex connecting to another vertex are uniformly represented. Parallel sorting and deduplication operations are then used to generate a unique edge list and count the total number of edges. Launch the CUDA kernel to traverse all vertices, edges, and triangles of the complete watertight 3D mesh model, use atomic operations to record the number of adjacent edges and adjacent triangles of each vertex, as well as the number of adjacent triangles of each edge in parallel, and build a vertex, edge, and triangle adjacency count table; Based on the adjacency count table, a prefix and scan operation is performed on the GPU to generate an array of starting storage offsets for the adjacency items corresponding to vertices, edges, and triangles, providing an offset basis for the write position of the adjacency index data structure; Allocate video memory space that matches the prefix sum result to store the adjacency index array, and launch a second CUDA kernel on the GPU to traverse all vertices, edges, and triangles in parallel. Based on their adjacency relationship and prefix sum offset position, write the index of the corresponding adjacent element into the adjacency index array; After the writing of the adjacency index array is completed, a memory continuous topological data structure consisting of the prefix sum array and the index array is formed in the GPU memory.

2. The GPU-based BRep model watertight mesh conversion and topology reconstruction method according to claim 1, characterized in that: The patch-level parsing is to decompose the boundary representation model into multiple independent geometric faces, and generate a UV island corresponding to the two-dimensional parameter space for each geometric face according to the preset sampling density and minimum edge length parameters. The two-dimensional parameter space UV island is constructed by boundary points and internal points.

3. The GPU-based BRep model watertight mesh conversion and topology reconstruction method according to claim 1, characterized in that: The compression optimization operation is: Calculate an approximately square M×M virtual grid that accommodates all UV islands, launch the CUDA kernel in parallel to treat each UV island as an independent block, rearrange and fill it into the virtual grid, so that the optimized UV atlas tends to be square, and generate the total UV island with optimized layout.

4. The method for watertight mesh conversion and topology reconstruction of a BRep model based on GPU according to claim 1, characterized in that: The boundary constraint information is constructed by traversing each edge of the boundary representation model and sequentially sampling a series of points along its one-dimensional parameter space.

5. The method for watertight mesh conversion and topology reconstruction of a BRep model based on GPU according to claim 1, characterized in that: The effectiveness of the centroid ray intersection algorithm is determined as follows: Shoot a ray from the centroid. If the number of intersections between the ray and the boundary of the original UV island to which the triangle belongs is odd, it is considered a valid internal triangle and is retained. On the contrary, if it is an even number, it is determined to be a false triangle and is eliminated.

6. The method for watertight mesh conversion and topology reconstruction of a BRep model based on GPU according to claim 3, characterized in that: The watertightness repair operation includes: By building a spatial acceleration structure to perform vertex neighbor search, all vertices within the preset tolerance range are merged into a single vertex, and the vertex indices of all related triangles are updated. After welding, parallel CUDA cores perform hole filling and normal direction uniform repair operations to produce a complete and watertight 3D mesh model that is completely watertight and manifold.

Images