BIM (Building Information Modeling) rapid lightweight method based on GPU (Graphic Processing Unit) high-performance calculation

Abstract

The invention discloses a BIM (Building Information Modeling) rapid lightweight method based on GPU (Graphics Processing Unit) high-performance calculation, which relates to the technical field of BIM data processing and comprises the following steps: S1, inputting model data; s2, reading data; s3, establishing a model; s4, initializing the model; s5, calculating an error matrix of each vertex; s6, collecting all vertex pairs for iteration; s7, calculating shrinkage of each vertex pair; s8, performing shrinkage iteration; s9, measuring errors; s10, the connectivity is improved; s11, generating an output model; and S12, outputting the data model. According to the method, the model is efficiently simplified by utilizing iterative shrinkage of vertex pairs, and a quadratic matrix is used for optimization by maintaining an approximate value of a surface error; the method is not limited to simple edge contraction, but can contract any vertex as required, so that the non-connected areas in the model are effectively connected, and the connectivity and consistency of the whole model are improved.

Description

Technical Field

[0001] The present invention relates to the technical field of BIM model data processing, and in particular to a BIM model fast lightweight method based on GPU high performance computing. Background Art

[0002] Building Information Modeling (BIM) is a new tool for architecture, engineering and civil engineering. BIM is used to describe computer-aided design that is mainly based on three-dimensional graphics, object-oriented, and related to architecture. With the widespread application of BIM technology, it plays an increasingly important role in the entire life cycle of engineering construction.

[0003] At present, the lightweight processing of BIM models mainly relies on CPU calculations, which has low processing efficiency and cannot meet the processing requirements of large and complex BIM models. BIM models usually contain a large amount of geometric and attribute information, resulting in a large model file size, which is not conducive to storage, transmission and real-time processing. Therefore, the lightweighting of BIM models has become an urgent problem to be solved. Summary of the invention

[0004] In view of the deficiencies in the prior art, the present invention aims to utilize the CUDA parallel computing platform and GPU acceleration technology to achieve efficient processing of BIM models to meet practical application needs, improve the processing speed and efficiency of BIM models, and reduce resource usage of models during storage, transmission and use.

[0005] The present invention provides the following technical solution, a method for fast lightweighting of BIM models based on GPU high performance computing, comprising the following steps:

[0006] S1. Input model data: obtain BIM model data from files or input sources;

[0007] S2, read data: read the parsed BIM model data;

[0008] S3, building a model: combining vertex and face data into a triangle network model;

[0009] S4, model initialization: Initialize the data structure of the model, including vertex, edge and face information;

[0010] S5. Calculate the error matrix for each vertex: For each vertex, calculate the approximate value of the surface error and use the quadratic matrix to optimize the error calculation to maintain the accuracy and details of the model;

[0011] S6. Collect all vertex pairs for iteration: identify and collect all vertex pairs that may be subjected to vertex pair contraction; these vertex pairs need to be subjected to iterative contraction operations;

[0012] S7, calculating the contraction of each vertex pair: calculating the contraction operation for each vertex pair, which includes determining the new vertex position after contraction to minimize the error;

[0013] S8, contraction iteration: Iteratively perform vertex pair contraction operations, perform vertex pair contraction, merge two vertices into one vertex, update the topology of the model, ensure that the new vertex position reduces errors and maintains model details, and when it is detected that the corners of two faces intersect at a point, define the two faces as sharing one vertex instead of using two independent vertices to avoid redundancy;

[0014] S9, Measure Error: After each iteration, recalculate and measure the model error to ensure that the simplification process does not cause significant geometric distortion, avoid unnecessary duplicate vertices in the model, and improve model simplification effect and rendering performance;

[0015] S10, Improve connectivity: When there are unconnected areas in the model, shrink any vertices to effectively connect these areas and improve the connectivity and consistency of the model;

[0016] S11. Generate output model: Generate an output model with a simpler and lighter structure while maintaining sufficient accuracy and details;

[0017] S12. Output data model: Output the simplified model data to ensure that it is suitable for real-time rendering and interactive applications on the GPU.

[0018] As an improvement of the above technical solution, the error is measured in S9, and the specific designs include quadratic surface design, quadratic error design, and mesh simplification design.

[0019] As an improvement of the above technical solution, in the quadratic surface design:

[0020] Quadratic surface equation:

[0021] Ax 2 +By 2 +Cz 2 +Dxy+Exz+Fyz+Gx+Hy+Iz+J=0;

[0022] Converted into a three-dimensional expression:

[0023] v T Rv+v T p+r=0 v=[v x , v y ,v z];

[0024]

[0025] As an improvement of the above technical solution, in the secondary error design:

[0026] Equation of a 3D plane:

[0027] ax+by+cZ+d=0

[0028] a 2 +b 2 +c 2 =1;

[0029] Plane parameters: p = [a, b, c, d] T ;

[0030] The distance from any point to the plane is

[0031] Any point to a series of planes p1, p2, p3…;

[0032] Sum of squared distances:

[0033]

[0034] As an improvement of the above technical solution, the mesh simplification includes selecting iteration points, calculating the shrinkage cost of the iteration points, performing a minimum heap according to the quadratic error value, and iterating.

[0035] As an improvement to the above technical solution, an iteration point is selected and all vertices in the triangle mesh are traversed. If v1 and v2 meet the following two conditions, they can form a pair of iteration points:

[0036] (v1,v2) is an edge;

[0037] ||v1-v2||<t, t is the selected threshold.

[0038] As an improvement to the above technical solution, the iterative point contraction cost is calculated, and for each (v1, v2) selected in the previous step, the quadratic error after contraction into a point is constructed:

[0039] Δ(v)=v T (Q v1 +Q v2 )v;

[0040] Select the contraction point v that minimizes the error Δ(v) as the optimal contraction point*, and the contraction cost is Δ(v);

[0041] If the optimal shrinkage point does not exist, you can choose v1, v2 or (v1+v2) / 2.

[0042] As an improvement to the above technical solution, iterate and take out the iteration point with the minimum cost from the current minimum heap for merging:

[0043] v←(v1,v2);

[0044] Update v's Q v matrix:

[0045] Q v =Q v1 +Q v2 ;

[0046] Recalculate the quadratic error of all iterative points in the minimum heap that are connected to v1 or v2, and maintain the minimum heap.

[0047] As an improvement to the above technical solution, it also includes a method of achieving high efficiency by utilizing the CUDA parallel computing platform and GPU acceleration technology: the core principle of GPU acceleration is to process computing tasks in parallel through a large number of processing cores of the GPU, thereby improving computing efficiency and performance. The processing core of the GPU can process a large number of parallel tasks at the same time.

[0048] As an improvement of the above technical solution, a CUDA program can be divided into three steps. The first step is to apply for memory from the host CPU, and then copy the content of the host memory to the device GPU. The second step is the kernel function on the device side to perform calculations. The third step is to copy the content of the device memory to the host, and finally release the video memory and memory.

[0049] The specific steps are as follows:

[0050] A1. Decompose the computing task into multiple parallel tasks and assign these parallel tasks to the processing cores of the GPU;

[0051] A2. Use the CUDA programming interface to write GPU programs and compile the programs into executable files;

[0052] A3. Load the data into the GPU memory and store the calculation results into the GPU memory;

[0053] A4. Run GPU programs and perform computing tasks on the GPU;

[0054] A5. Load the calculation results from the GPU memory into the CPU memory for subsequent processing.

[0055] Beneficial effects of the present invention:

[0056] 1. The algorithm uses iterative contraction of vertex pairs to efficiently simplify the model and optimizes it using a quadratic matrix by maintaining an approximation of the surface error; this method is not limited to simple edge contraction, but can contract any vertex when necessary, thereby effectively connecting unconnected areas in the model and improving the overall connectivity and consistency of the model.

[0057] 2. In this algorithm, the input BIM model is converted into a polygonal model composed of triangles, which helps with subsequent efficient processing and optimization; when the algorithm detects that the corners of two faces intersect at a point, it defines the two faces as sharing a vertex instead of simply using two independent vertices. This avoids unnecessary duplicate vertices in the model and further improves the model's simplification effect and rendering performance.

[0058] 3. With this approach, from a complex polygonal BIM model as input, a more structurally concise and lightweight output model can be generated while maintaining sufficient accuracy and details to make it more suitable for real-time rendering and interactive applications on GPUs. DETAILED DESCRIPTION

[0059] In order to make the purpose, technical solution and advantages of the present invention more clearly understood, the present invention is further described in detail below. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not used to limit the present invention.

[0060] The present invention provides a technical solution: a method for fast lightweighting of BIM models based on GPU high-performance computing, comprising the following steps:

[0061] S1. Input model data: obtain BIM model data from files or input sources;

[0062] S2, read data: read the parsed BIM model data;

[0063] S3, building a model: combining vertex and face data into a triangle network model;

[0064] S4, model initialization: Initialize the data structure of the model, including vertex, edge and face information;

[0065] S5. Calculate the error matrix for each vertex: For each vertex, calculate the approximate value of the surface error and use the quadratic matrix to optimize the error calculation to maintain the accuracy and details of the model;

[0066] S6. Collect all vertex pairs for iteration: identify and collect all vertex pairs that may be subjected to vertex pair contraction; these vertex pairs need to be subjected to iterative contraction operations;

[0067] S7, calculating the contraction of each vertex pair: calculating the contraction operation for each vertex pair, which includes determining the new vertex position after contraction to minimize the error;

[0068] S8, contraction iteration: Iteratively perform vertex pair contraction operations, perform vertex pair contraction, merge two vertices into one vertex, update the topology of the model, ensure that the new vertex position reduces errors and maintains model details, and when it is detected that the corners of two faces intersect at a point, define the two faces as sharing one vertex instead of using two independent vertices to avoid redundancy;

[0069] S9, Measure Error: After each iteration, recalculate and measure the model error to ensure that the simplification process does not cause significant geometric distortion, avoid unnecessary duplicate vertices in the model, and improve model simplification effect and rendering performance;

[0070] S10, Improve connectivity: When there are unconnected areas in the model, shrink any vertices to effectively connect these areas and improve the connectivity and consistency of the model;

[0071] S11. Generate output model: Generate an output model with a simpler and lighter structure while maintaining sufficient accuracy and details;

[0072] S12. Output data model: Output the simplified model data to ensure that it is suitable for real-time rendering and interactive applications on the GPU.

[0073] In this implementation, the process starts with reading the BIM model data, gradually simplifies and optimizes the model through multiple steps, and finally outputs a lightweight, optimized polygonal model suitable for real-time rendering and interactive applications while maintaining the necessary geometric details and accuracy. This method utilizes iterative contraction of vertex pairs and quadratic error matrix optimization. It is not limited to simple edge contraction, but can also contract arbitrary vertices when necessary, thereby effectively connecting unconnected areas in the model, further improving the overall connectivity and consistency of the model, and the final output model is more suitable for real-time rendering and interactive applications on the GPU.

[0074] Specifically, the error is measured in S9, and the specific designs include quadratic surface design, quadratic error design, and mesh simplification design. In quadratic surface design:

[0075] Quadratic surface equation:

[0076] Ax 2 +By 2 +Cz 2 +Dxy+Exz+Fyz+Gx+Hy+Iz+J=0;

[0077] Converted into a three-dimensional expression:

[0078] v T Rv+v T p+r=0 v=[v x , v y ,v z ];

[0079]

[0080] In quadratic error design:

[0081] Equation of a 3D plane:

[0082] ax+by+cz+d=0;

[0083] a 2 +b 2 +c 2 =1;

[0084] Plane parameters: p = [a, b, c, d] T ;

[0085] The distance from any point to the plane is

[0086] Any point to a series of planes p1, p2, p3…;

[0087] Sum of squared distances:

[0088]

[0089] Specifically, mesh simplification includes selecting iteration points, calculating the contraction cost of iteration points, performing minimum heap, iteration according to the quadratic error value, selecting iteration points, and traversing all vertices in the triangular mesh. If v1 and v2 meet the following two conditions, they can form a pair of iteration points:

[0090] (v1,v2) is an edge;

[0091] ||v1-v2||<t, t is the selected threshold;

[0092] Calculate the iterative point contraction cost, and for each (v1, v2) selected in the previous step, construct the quadratic error after contraction to a point:

[0093] Δ(v)=v T (Q v1 +Q v2 )v;

[0094] Select the contraction point v that minimizes the error Δ(v) as the optimal contraction point*, and the contraction cost is Δ(v);

[0095] If the optimal contraction point does not exist, you can choose v1, v2 or (v1+v2) / 2;

[0096] Iterate and take out the iteration point with the minimum cost from the current minimum heap for merging:

[0097] v←(v1,v2);

[0098] Update v's Q v matrix:

[0099] Q v =Q v1 +Q v2 ;

[0100] Recalculate the quadratic error of all iterative points in the minimum heap that are connected to v1 or v2, and maintain the minimum heap.

[0101] Specifically, it also includes methods to achieve high efficiency by using the CUDA parallel computing platform and GPU acceleration technology: the core principle of GPU acceleration is to process computing tasks in parallel through a large number of GPU processing cores, thereby improving computing efficiency and performance. The GPU processing core can process a large number of parallel tasks at the same time.

[0102] Specifically, a CUDA program can be divided into three steps. The first step is to apply for memory from the host CPU, and then copy the content of the host memory to the device GPU. The second step is the kernel function on the device side to perform calculations. The third step is to copy the content of the device memory to the host, and finally release the video memory and memory.

[0103] The specific steps are as follows:

[0104] A1. Decompose the computing task into multiple parallel tasks and assign these parallel tasks to the processing cores of the GPU;

[0105] A2. Use the CUDA programming interface to write GPU programs and compile the programs into executable files;

[0106] A3. Load the data into the GPU memory and store the calculation results into the GPU memory;

[0107] A4. Run GPU programs and perform computing tasks on the GPU;

[0108] A5. Load the calculation results from the GPU memory into the CPU memory for subsequent processing.

[0109] The algorithm uses iterative contraction of vertex pairs to efficiently simplify the model and optimizes it using a quadratic matrix by maintaining an approximation of the surface error; this method is not limited to simple edge contraction, but can contract any vertex when necessary, thereby effectively connecting unconnected areas in the model and improving the overall connectivity and consistency of the model.

[0110] In this algorithm, the input BIM model is converted into a polygonal model composed of triangles, which helps with subsequent efficient processing and optimization; when the algorithm detects that the corners of two faces intersect at a point, it defines the two faces as sharing a vertex instead of simply using two independent vertices. This avoids unnecessary duplicate vertices in the model and further improves the model's simplification effect and rendering performance.

[0111] In this way, from a complex polygonal BIM model as input, a more structurally concise and lightweight output model can be generated, while maintaining sufficient accuracy and details to make it more suitable for real-time rendering and interactive applications on GPUs.

[0112] The above embodiments are only used to illustrate the technical solutions of the present invention, but not to limit them.

Claims

1. A method for fast lightweighting of BIM models based on GPU high-performance computing, characterized in that: The following steps are involved: S1. Input model data: obtain BIM model data from files or input sources; S2, read data: read the parsed BIM model data; S3, building a model: combining vertex and face data into a triangle network model; S4, model initialization: Initialize the data structure of the model, including vertex, edge and face information; S5. Calculate the error matrix for each vertex: For each vertex, calculate the approximate value of the surface error and use the quadratic matrix to optimize the error calculation to maintain the accuracy and details of the model; S6. Collect all vertex pairs for iteration: identify and collect all vertex pairs that may be subjected to vertex pair contraction; these vertex pairs need to be subjected to iterative contraction operations; S7, calculating the contraction of each vertex pair: calculating the contraction operation for each vertex pair, which includes determining the new vertex position after contraction to minimize the error; S8, contraction iteration: Iteratively perform vertex pair contraction operations, perform vertex pair contraction, merge two vertices into one vertex, update the topology of the model, ensure that the new vertex position reduces errors and maintains model details, and when it is detected that the corners of two faces intersect at a point, define the two faces as sharing one vertex instead of using two independent vertices to avoid redundancy; S9, Measure Error: After each iteration, recalculate and measure the model error to ensure that the simplification process does not cause significant geometric distortion, avoid unnecessary duplicate vertices in the model, and improve model simplification effect and rendering performance; S10, Improve connectivity: When there are unconnected areas in the model, shrink any vertices to effectively connect these areas and improve the connectivity and consistency of the model; S11. Generate output model: Generate an output model with a simpler and lighter structure while maintaining sufficient accuracy and details; S12. Output data model: Output the simplified model data to ensure that it is suitable for real-time rendering and interactive applications on the GPU.

2. According to the method of claim 1, which is characterized by: The error is measured in S9, and the specific designs include quadratic surface design, quadratic error design, and mesh simplification design.

3. According to claim 2, a method for rapid lightweighting of BIM models based on GPU high performance computing is characterized in that: In quadratic surface design: Quadratic surface equation: Ax 2 +By 2 +Thu 2 +Dxy+Exz+Fyz+Gx+Hy+Iz+J=0; Convert to three-dimensional expression; v T Rv+v T p+r=0 v=[v x ,v y ,v z ]; 4. According to claim 2, a method for rapid lightweighting of BIM models based on GPU high performance computing is characterized in that: In quadratic error design: Equation of a 3D plane: ax+by+cz+d=0; a 2 +b 2 +c 2 =1; Plane parameters: p = [a, b, c, d] T ; The distance from any point to the plane is Any point to a series of planes p1, p2, p3…; Sum of squared distances:

5. The method for rapid lightweighting of BIM models based on GPU high performance computing according to claim 2 is characterized in that: Mesh simplification includes selecting iteration points, calculating the shrinkage cost of iteration points, performing minimum heap calculation based on quadratic error values, and iterating.

6. The method for rapid lightweighting of BIM models based on GPU high performance computing according to claim 5 is characterized in that: Select the iteration point and traverse all vertices in the triangle mesh. If v1 and v2 meet the following two conditions, they can form a pair of iteration points: (v1,v2) is an edge; ||v1-v2||<t, t is the selected threshold.

7. The method for rapid lightweighting of BIM models based on GPU high performance computing according to claim 5 is characterized in that: Calculate the iterative point contraction cost, and for each (v1, v2) selected in the previous step, construct the quadratic error after contraction to a point: Δ(v)=v T (Q v1 +Q v2 )v; Select the contraction point v that minimizes the error Δ(v) as the optimal contraction point*, and the contraction cost is Δ(v); If the optimal shrinkage point does not exist, you can choose v1, v2 or (v1+v2) / 2.

8. The method for rapid lightweighting of BIM models based on GPU high performance computing according to claim 5 is characterized in that: Iterate and take out the iteration point with the minimum cost from the current minimum heap for merging: v←(v1, v2); Update v's Q v matrix: Q v =Q v1 + Qv 2; Recalculate the quadratic error of all iterative points in the minimum heap that are connected to v1 or v2, and maintain the minimum heap.

9. A method for rapid lightweighting of BIM models based on GPU high performance computing according to any one of claims 1 to 8, characterized in that: It also includes methods to achieve high efficiency by using the CUDA parallel computing platform and GPU acceleration technology: the core principle of GPU acceleration is to process computing tasks in parallel through the large number of processing cores of the GPU, thereby improving computing efficiency and performance. The GPU's processing core can handle a large number of parallel tasks at the same time.

10. The method for rapid lightweighting of BIM models based on GPU high performance computing according to claim 9, characterized in that: A CUDA program can be divided into three steps. The first step is to apply for memory from the host CPU, and then copy the content of the host memory to the device GPU. The second step is the kernel function on the device to perform calculations. The third step is to copy the content of the device memory to the host, and finally release the video memory and memory. The specific steps are as follows: A1. Decompose the computing task into multiple parallel tasks and assign these parallel tasks to the processing cores of the GPU; A2. Use the CUDA programming interface to write GPU programs and compile the programs into executable files; A3. Load the data into the GPU memory and store the calculation results into the GPU memory; A4. Run GPU programs and perform computing tasks on the GPU; A5. Load the calculation results from the GPU memory into the CPU memory for subsequent processing.

Images