CN118691728A - A cluster-based IFC model component-level LOD generation and use method - Google Patents

Abstract

The present invention discloses a method for generating and using component-level LOD of an IFC model based on clusters. The method is applicable to IFC component models containing a large number of triangular faces. In an offline process, the component model is divided into groups and faces are reduced in a way that a fixed number of triangular faces are used as a cluster, and a multi-level LOD rough model is generated. Then, in the real-time rendering process, the number of triangular faces rendered of the component can be dynamically adjusted according to the visible range of the rendering camera to avoid the overhead caused by invalid rendering. The present invention also introduces the form of clusters in the process of LOD processing of the IFC model, improves the fine-grainedness of the model face reduction operation, and enables the coexistence of multiple levels of LOD for a single component, thereby ensuring that the model can smoothly transition between different LOD levels during camera movement; at the same time, the present invention also combines instantiation rendering and culling algorithms that conform to the operation mode of modern GPU hardware, greatly improving the rendering frame rate performance.

Description

A cluster-based IFC model component-level LOD generation and use method

Technical Field

The present invention relates to the field of industrial three-dimensional model display, and in particular to a cluster-based IFC model component-level LOD generation and use method.

Background Art

With the widespread application of 3D computer-aided design (CAD) in engineering, architecture, manufacturing and other fields, the demand for efficient and accurate expression of complex 3D models is increasing. There are some challenges in the traditional 3D CAD model expression method. For example, when the model is complex, it will lead to a large amount of data and the requirements for computer hardware and software are getting higher and higher. Therefore, in order to improve the performance and efficiency of the 3D CAD system and reduce the burden of data processing and transmission, a more intelligent and effective model expression method is needed.

To solve this problem, in recent years, more and more attention and research have focused on LOD (Level of Detail) technology. LOD technology is a method of dynamically adjusting the level of detail of a model, which allows the three-dimensional model to be presented with different degrees of precision at different distances or viewing angles. This technology was first used in the field of computer graphics for real-time rendering and optimized model display, and then gradually gained application in the field of CAD.

Normally, conventional LOD technology is sufficient to meet the needs of dynamically adjusting the model's precision to reduce rendering overhead, but CAD models such as IFC (Industry Foundation Classes) and BIM (Building Information Modeling) often have different interaction requirements from other fields. This problem is not the core of processing in other fields, such as games, because in a large scene, the user's operation unit is often not subtle to a very small part, but in the BIM field, it is completely the opposite. Meeting the component-level operation unit is a necessary condition. Even for an extremely complex water supply and drainage model, it is necessary to ensure the operability of a tiny component.

In addition, based on the tree-like generation structure, the generation of traditional LOD levels is relatively simple, but it is usually impossible to achieve the coexistence of multiple levels of LOD on a single object, because model simplification is destined to be accompanied by the loss of high-frequency information, and the edges of models between different levels will be difficult to fit. Forced merging will have obvious edge line problems, resulting in an unsmooth model; and if a single model only uses one level at a time, it will lead to obvious mutations in the visual effect of the model during browsing as the viewing distance and viewing angle change.

Summary of the invention

The purpose of the present invention is to address the shortcomings of the prior art and, based on the traditional LOD technology, provide a cluster-based LOD generation and use method, and apply it to the component monomers of the IFC model, so that the model can smoothly transition in the process of dynamically switching the LOD level as the user observes the state changes, and meet the component-level operation requirements in the BIM industry.

The objective of the present invention is achieved through the following technical solutions:

A cluster-based IFC model component-level LOD generation and use method comprises the following steps:

(1) Read the geometric information of the IFC model components, deduplicate the vertex data of the components, encapsulate the updated triangular face data, and traverse the geometric data; compare the number of triangular faces of each component with the preset face number threshold, and regard the components whose triangular faces do not exceed the threshold as simple mesh components and use the conventional rendering pipeline; regard the components whose triangular faces exceed the threshold as complex mesh components, obtain the adjacency relationship between the triangular faces of the components, and record them as a data structure;

(2) Traverse the building components in the model to identify the data structure of the adjacency relationship of the triangles, sort the triangles, divide them into clusters, and calculate the adjacency relationship of the clusters. Use this data to divide the clusters into cluster groups, and then obtain the cluster group data and encapsulate it into a data structure;

(3) traverse the cluster group data in the component identification step (2), traverse each group, extract the triangular surface data of all clusters therein, reduce the surface by combining the surface reduction algorithm, and record all newly generated triangular surface data and their adjacency relationship data in the group;

(4) Repeat steps (2) and (3) until a specified number of LOD levels are generated, and store the newly generated geometric data as an intermediate file;

(5) Read the geometric data in the intermediate file, and remove the corresponding parts in turn according to the visibility of the component mesh, component cluster group, and component cluster in the model to which the geometric data belongs, record the data of the visible cluster and the corresponding LOD level, and render it.

Furthermore, the step (1) is implemented by the following sub-steps:

(1.1) Parse the geometric data of the IFC model, obtain the vertex attributes and corresponding index numbers of each component, traverse all vertices corresponding to the index numbers, and compare them. If two numbers point to the same vertex attribute, remove the duplicates and store the updated data;

(1.2) It is assumed that the edge of each triangle has a direction. Through the vertex and index data obtained in step (1.1), all edges are traversed. When any two edges have the same vertices but opposite directions, there is a relationship between the two edges. This relationship is recorded in the data structure.

(1.3) Identify the data structure of the opposite edge relationship in step (1.2), read each set of opposite edges, calculate the index number of the triangle where the edge is located through the index number of the edge, and then obtain the adjacency relationship of the triangle, which is encapsulated into a data structure.

Furthermore, the step (2) is implemented by the following sub-steps:

(2.1) Identify the data structure that records the adjacency relationship of the triangles, use the index number size and adjacency relationship of the triangles as weights, sort the index numbers, then split them into a fixed size, encapsulate them into clusters in order, and record the edge data information of the clusters;

(2.2) Combined with the logic of the half-edge data structure algorithm, each undirected edge can be split into two half-edges with the same vertices but opposite directions. It can be assumed that each edge has a direction. Through the edge data of the cluster obtained in step (2.1), all edges are traversed. When any two edges have the same vertices but opposite directions, there is an opposite edge relationship between the two edges, and the opposite edge relationship is recorded in the data structure.

(2.3) Identify the data structure containing the edge relationship, read each set of edges, and map the index number of the edge back to the index number of the cluster to which it belongs, so as to obtain the adjacency relationship of the cluster and encapsulate it into a data structure;

(2.4) Identify the adjacency relationship of the clusters in step (2.3), use the index number size and adjacency relationship of the cluster as weights, sort the data by index number, and then split it into a fixed size, encapsulate it into cluster groups in order, and record the edge data information of the cluster groups.

Furthermore, step (3) is implemented by the following sub-steps:

(3.1) Identify the geometric data of the cluster group, traverse each group, obtain the vertex attributes and index data of the triangles of all clusters in it, and store them in a data structure respectively;

(3.2) Read the edge data of the group, identify the vertex attributes and index data generated in step (3.1), and mark the vertex corresponding to the edge as "locked" to ensure that it will not be changed during the face reduction process;

(3.3) Identify the vertex attributes and index data generated in step (3.1), combine with the face reduction algorithm, and traverse the face reduction cumulative error corresponding to each edge in turn. For the edge with the "locked" vertex set in step (3.2), set a maximum value for its face reduction cumulative error, and then store the error in a minimum heap data structure;

(3.4) Identify the minimum heap data structure in step (3.3), extract the edge with the smallest cumulative error of face reduction in turn, collapse the edge, adjust the vertex data of its adjacent triangles, and calculate the cumulative error of face reduction for the new edge generated after face reduction, and store it in the minimum heap at the same time;

(3.5) Repeat step (3.4) until the number of existing edges meets the preset conditions, then deduplicate the existing vertex attributes and index numbers, use the new vertex attributes and index numbers obtained after deduplication to construct new triangle surface geometry data, and encapsulate the result into a data structure;

(3.6) Identify the new triangular face geometry data obtained in step (3.5), traverse all edges, and when any two edges have the same vertices but opposite directions, there is an opposite-edge relationship between the two edges. Record all opposite-edge relationships in the data structure, and then use the data to obtain the adjacency relationship of the triangular face.

Furthermore, step (4) is implemented by the following sub-steps:

(4.1) Repeat steps (2) and (3) according to the preset number of LOD levels;

(4.2) Setting a coding structure, arranging the component LOD geometry data generated in step (4.1) in order, and storing them in an intermediate file.

Furthermore, step (5) is implemented by the following sub-steps:

(5.1) In combination with the encoding structure set in step (4.2), the intermediate file recording the LOD data is parsed and encapsulated into a data structure, which is stored in the buffer for rendering and reading, and the component geometry data in the buffer is generated;

(5.2) Read the component geometry data in the buffer generated in step (5.1), use the bounding box to calculate the visibility of the component model, and record the index number of the visible component;

(5.3) Identify the index number of the visible component obtained in step (5.2), use the index number to read the geometric information of its corresponding cluster group in the buffer generated in step (5.1), use the distance between it and the camera and the pixel ratio it occupies on the terminal interface as weights, calculate its corresponding LOD level, and then use the level to filter the corresponding cluster group index number and record it;

(5.4) Identify the cluster group index number obtained in step (5.3), read the clusters contained in the cluster group in the buffer generated in step (5.1), and traverse and compare the visibility of the clusters in turn, and then generate and record the index buffer of the visible cluster index number;

(5.5) Read the visible cluster index number data in the index buffer generated in step (5.4), obtain the corresponding index number, and then read the vertex data in the buffer generated in step (5.1) according to the index and render it.

The benefits of the present invention are as follows:

In the LOD generation process, the present invention introduces the concepts of clusters and cluster groups, and changes the tree-like generation structure of the traditional LOD into a generation structure of a directed acyclic graph, so that in the generation structure, the edges of the parent-level units and the edges of their corresponding child levels do not overlap, thereby avoiding the problem of "having to retain high-frequency edge information to ensure edge fit when merging grids of different levels", which enables the newly generated triangular faces to be distributed more evenly during the face reduction process, thereby achieving the effect that multiple levels of LOD can coexist and be displayed smoothly on the same monomer model; in addition, this technology is only applied to the monomer model of the component. Compared with the conventional LOD technology applied to the entire model, it can protect the operability of the monomer component, and each monomer component performs LOD switching independently, so that the browsing effect of the three-dimensional model will not produce obvious mutations.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG1 is a framework diagram of a cluster-based IFC model component-level LOD generation and use method of the present invention;

FIG2 is a schematic diagram of a LOD directed acyclic graph generation structure of the present invention;

FIG3 is a schematic diagram of cluster edges at different levels of the present invention;

FIG. 4 is a schematic diagram of the LOD levels of the sphere model of the present invention.

DETAILED DESCRIPTION

In order to enable those skilled in the art to better understand the solution of the present invention, the technical solution in the embodiment of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiment of the present invention. Obviously, the described embodiment is only a part of the embodiment of the present invention, not all of the embodiments. Based on the embodiment of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of the present invention.

It should be noted that the terms "first", "second", etc. in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so that the embodiments of the present invention described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example: a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

As shown in FIG1 , a cluster-based IFC model component-level LOD generation and use method includes the following steps:

Step 1: parse the IFC model, identify and extract the geometric property data of the components involved, set the division standard between simple components and complex components to 64 triangular faces, and divide all components in the IFC model into two categories: simple component models and complex component models according to the threshold. The simple component model adopts the traditional rendering method, and the complex component model is LOD processed.

This step is the technical basis of the present invention. It takes components as processing units and fundamentally meets the component-level operation requirements. In addition, it distinguishes the operating environments of simple components and complex components to avoid invalid optimization operations of LOD processing on simple components.

The step 1 includes the following sub-steps:

(1.1) Use the ifc-openshell third-party parsing library to parse and obtain the geometric data and semantic information of the IFC model, and encapsulate the vertex coordinates, normals, materials, indexes, and texture UV geometric data according to the component units;

(1.2) In view of the fact that the existing GPU architecture usually uses 32 or 64 cores as a scheduling unit, in order to give full play to the hardware performance and ensure the portability of the program as much as possible, and to avoid LOD processing of too many simple components, the component unit of the preset cluster is 64 triangles. Based on this, the 64 triangles are used as the basis for dividing simple components and complex components, and the encapsulated component geometry data is divided;

(1.3) Simple components are directly rendered using the traditional rendering pipeline, and the data of complex components are encapsulated for further processing.

Step 2: Process the complex components divided in step 1 one by one, read the vertex data, and remove duplicates. Then, based on the half-edge data structure, find the adjacency relationship of the triangles contained in the component. Use the adjacency relationship and the index number size of the triangle as weights. Combined with the METIS third-party segmentation library, sort and divide the triangle group, and encapsulate it into clusters with 60 to 64 triangles as a group. Record the cluster edges formed by the triangles, and continue to use the half-edge data structure to find the adjacency relationship of the cluster; continue to call the METIS library, sort and divide the clusters, with 12 to 16 clusters as groups, and record the group edges formed by the clusters.

Step 2 is one of the core invention parts. It introduces the grouping concept of clusters and cluster groups based on the traditional LOD technology. Its form is shown in the left and middle figures of Figure 2, which includes the following sub-steps.

(2.1) Read the geometric data of the complex component divided in step 1, traverse the index number of its vertex, read the attribute data of the vertex corresponding to the index, calculate the hash value using the murmur-32 hash function, and compare it with a preset hash function table. If the value already exists, change the index number to the index number recorded in the hash function table, otherwise store the index number in the hash function table;

(2.2) Based on the concept of half-edge data structure, set the direction of each edge, that is, if the two vertices of an edge are A and B respectively, then the edge has two half-edges AB and BA; traverse all edges in the component and compare them with a preset hash function table. If the edge recorded in the table is exactly in the opposite direction of the current edge, it is an opposite edge relationship, and the index number of the opposite edge is recorded in a mapping data structure;

(2.3) Read the mapping data structure that records the relationship between opposite edges. Since the edges have directions, the triangles where the two edges of the opposite edge relationship are located have an adjacency relationship. Based on this, the index numbers of the two edges are divided by 3 and rounded to the integer to obtain the index numbers of the triangles where they are located. The index numbers of the adjacent triangles are encapsulated into a new mapping data structure.

(2.4) Read the adjacency relationship and index number of the triangles, use them as weights, and submit them to the METIS segmentation library for recursive segmentation. The range of each group of segmentation is set to 60 to 64 triangles to allow a certain error adjustment. After segmentation, the sorted triangle index and the array recording each group range can be obtained;

(2.5) Read the array recording the grouping range, obtain the index number of each group of corresponding triangles, read the corresponding geometric information, encapsulate it into a cluster data structure, and calculate the bounding sphere of the cluster; in the process of encapsulating the triangles, determine in turn whether the triangle indexes of the opposite sides of the three sides of the triangle are in another grouping range. If so, it indicates that the edge is the edge of the cluster, and record the edge data;

(2.6) Create a mapping structure to record the mapping relationship between the index of the cluster and the index of its edge, and combine the concept of opposite edges in step (2.2) to further find the opposite edge relationship of the edge of the cluster and record it in a mapping data structure;

(2.7) Read the mapping data structure that records the edge relationship, obtain the cluster adjacency relationship through the data structure that records the cluster and cluster edge mapping relationship, and encapsulate it into a new mapping data structure;

(2.8) Read the adjacency relationship and index number of the cluster, use it as the weight, and hand it over to the METIS segmentation library for recursive partitioning. The range of each group of partitions is set to 12 to 16 clusters to allow a certain error adjustment. After the partition, the sorted cluster index and the array recording the range of each group can be obtained;

(2.9) Read the array that records the grouping range, obtain the index number of each group corresponding to the cluster, and read the corresponding geometric information, encapsulating it into a cluster group data structure. At the same time, determine in turn whether the index of the cluster to which the opposite edge of the cluster edge belongs is in another grouping range. If so, it indicates that the edge is the edge of the cluster group, and the edge data is recorded.

Step 3: Read the cluster group data obtained in step 2, traverse each cluster group, read the triangle face vertices and index data of all clusters therein, and integrate them into several arrays; traverse the edge information of the cluster group, mark the vertices where these edges are located as "locked", and then combine the QEM (Quadic Error Metrics) face reduction algorithm to calculate the cumulative face reduction error for all edges in the cluster group, and store the error in a minimum heap data structure; then take out the edges with the smallest cumulative error in turn for collapse, update the cumulative face reduction error of the newly generated edges and store them in the above minimum heap, and continue to reduce faces until the number of edges reaches the preset range.

Step three is the second part of the core invention. On the basis of step two, the face reduction part is completed, and its form is shown in the middle and right figures of Figure 2. Steps 2 and 3 introduce the form of clusters and cluster groups and reduce faces, so that the LOD generation structure of the directed acyclic graph replaces the traditional LOD tree-like generation structure. The advantage of the directed acyclic graph is that it breaks the limitation that the parent unit must be composed of a fixed number of child units in the tree structure, so that the newly generated triangular faces are distributed more freely and evenly; at the same time, the cluster group locking operation in step three makes it possible for multiple levels of LOD to coexist on the same model, which makes the edges of different LOD levels fit together, and thus obtains a smoother visual effect in the LOD level transition.

The step three includes the following sub-steps:

(3.1) Traverse each cluster group, read the triangle vertex attributes and index data of all clusters, and traverse the edge information of the cluster group, marking the vertices where these edges are located as "locked";

(3.2) One of the advantages of the QEM face reduction algorithm is that it uses quadratic matrix calculation to optimize the computational overhead of quadratic equations. It traverses all triangular faces in the cluster group, uses the three vertices of the triangular face, calculates the quadratic representation of the face where the triangular face is located, and records it in a matrix;

(3.3) Traverse all edges. If there is a "lock" mark at any point on the edge, the cumulative error of face reduction is set to a maximum value; if there is no "lock" mark, obtain all adjacent triangular faces around the two vertices contained in the edge, use the quadratic matrix pre-calculated in 2) to calculate the cumulative quadratic matrix of these adjacent triangular faces, and use this matrix combined with the QEM face reduction algorithm to obtain the newly generated vertex position;

(3.4) Determine the legality of the newly generated vertex, traverse all adjacent triangles obtained in step (3.3), first calculate the normal vector n1 by the cross product of the vectors of the original vertex and the other two vertices of the triangle, then calculate the new normal vector n2 by the cross product of the vectors of the newly generated vertex and the other two vertices of the triangle, calculate the dot product of the normal vectors n1 and n2, if it is negative, it means that the newly generated triangle is flipped, that is, the new vertex is illegal, then increase the accumulated error of the edge by 100.0 to reduce its weight;

(3.5) Record the mapping relationship between the index of all edges and their cumulative error of subtracting faces, and store them in a minimum heap data structure;

(3.6) Take out the index of the edge with the smallest cumulative error of face reduction from the minimum heap, remove the contents of the two vertices of the edge in the geometric data, and change the corresponding old vertices of all adjacent triangles of the edge to newly generated vertices calculated by the QEM algorithm, and add the vertex data to the geometric data, and calculate the cumulative error of face reduction of all newly generated edges, and store the mapping relationship between the index of the edge and the error value in the minimum heap of step (3.5);

(3.7) Repeat step (3.6) until the current number of edges does not exceed the preset target number of edges, traverse the indexes of all vertices, use the hash function to deduplicate the vertices, and encapsulate the updated vertex attributes and index data.

Step 4: Repeat steps 2 and 3, continuously process the newly generated triangular surface data, until a 4-level LOD structure is generated, organize this part of the geometric data, first record the number of clusters, the number of cluster groups, the offset value of the cluster group data, and the offset value of the next component data, then store the bounding box data of the component mesh, the geometric data of the cluster, and the geometric data of the cluster group in sequence, and finally encapsulate all LOD geometric data into a binary intermediate file.

Step 4 repeats steps 2 and 3 to generate a multi-level LOD structure. The directed acyclic graph structure brought by the clusters and cluster groups implanted in step 2 makes the edges of the upper and lower levels in the LOD models of each layer generated in step 4 have no obvious connection, as shown in Figure 3. This makes it so that in the LOD generation process, the high-frequency edge information will not accumulate as the level increases, eventually leading to a patch-like abrupt visual situation. In addition, step 4 encapsulates the LOD data as an intermediate file. When there is no further mesh adjustment, the intermediate file data can be directly called later to avoid repeated calculation and generation.

The step 4 includes the following sub-steps:

(4.1) Read the vertex attributes and index numbers of the newly generated triangle, loop steps 2 and 3 for 4 times, generate a 4-level LOD structure, and encapsulate the geometric data;

(4.2) Create a 32-bit unsigned integer array for data encapsulation and traverse the LOD data of all complex components;

(4.3) The number of clusters, the number of cluster groups, the offset value of cluster group data and the offset value of the next component data of the current component are stored in sequence, and then the bounding box data of the current component grid is stored;

(4.4) The number of cluster vertices, vertex attribute data offset value, number of triangles, vertex index data offset value, cluster bounding sphere data, cumulative surface reduction error, cluster group index, LOD level, etc. of the current component are stored in sequence;

(4.5) The number of clusters contained in the cluster group of the current component, the offset value of the related cluster data, the maximum cumulative surface reduction error in the cluster group, the LOD level of the cluster group, and the bounding sphere information of the cluster group are stored in sequence;

(4.6) storing the cluster vertex attribute data and vertex index label data of the current component in sequence;

(4.7) storing the index data of the clusters contained in the cluster group of the current component in sequence;

(4.8) Encapsulate the above array data into a binary file.

Step 5: Determine whether there is an LOD intermediate file or whether it needs to be rebuilt. If it already exists, use the encoding method of step 4 to read the geometric data of the intermediate file and store it in the buffer of the graphics interface; use the compute shader to perform frustum culling to determine the visibility of the component mesh; if it is visible, perform LOD level screening, and for the cluster group that passes the screening, extract the clusters it contains, perform frustum culling and occlusion culling. If both pass, it is considered visible, and the index numbers of these clusters are recorded in a buffer. Subsequently, use the vertex shader to read the buffer to obtain the index number, and use it to read the corresponding vertex attributes and vertex indices from the geometric data buffer for instantiated rendering.

Step five is the main process of giving full play to the advantages of the LOD structure. In the real-time browsing stage, the appropriate LOD level is dynamically selected and the invisible parts are culled to avoid the rendering overhead of redundant triangles and improve the rendering performance. The effect is shown in Figure 4.

The step five includes the following sub-steps:

(5.1) Determine whether there is an LOD intermediate file or whether the LOD intermediate file needs to be rebuilt. If it does not exist or the LOD structure needs to be rebuilt, return to step 1. Otherwise, read the geometric data of the intermediate file according to the encoding method of step 4 and store it in the buffer of the graphics interface;

(5.2) Call the compute shader execution instruction of the graphics interface. The number of tasks to be executed is the number of complex components divided by 32 and rounded up. In the compute shader, each task processing group uses 32 threads.

(5.3) In the compute shader, the index of the current component is obtained through the global thread index, and the bounding box information of the component is read in the buffer data through the index, and the frustum culling operation is performed. If it passes, it is considered visible, and if it fails, it is discarded;

(5.4) For visible components, read the cluster group bounding sphere data and the cumulative face reduction error data of the component in the buffer data through its index, and then calculate the target face reduction error at this distance through the distance between the bounding sphere and the camera in the camera space, the observation angle, and the terminal interface height, and then compare it with the cumulative face reduction error of the cluster group. At this time, there are two situations. One is that the cumulative face reduction error of the cluster group and its clusters is greater than or less than the target face reduction error, and the other is that the cumulative face reduction error of the cluster group is greater than and some of its clusters are less than. The former may lead to the selection of too high or too low LOD levels, and the latter just means the boundary situation. Therefore, when the cumulative face reduction error of the cluster group is greater than the target face reduction error, traverse the clusters of the cluster group to make error judgments, and after screening or, store the indexes of the valid clusters;

(5.5) Read the index data of the valid cluster, read its bounding sphere information from the buffer, perform frustum culling and occlusion culling on it, and if it passes, record its index in the index buffer of a cluster to be rendered;

(5.6) Read the number of indices in the index buffer of the cluster to be rendered, call the instantiation rendering instruction of the graphics interface, set the number of vertices to 64*3, because in step one it is preset that a cluster contains 64 triangles, and the number of instances is set to the number of indices read above. Then, read the index number in the index buffer of the cluster to be rendered in the vertex shader, and based on this, read the vertex attributes and index numbers of the cluster from the buffer of step (5.1), and then render.

The specific embodiments described herein are merely examples of the present invention. A person skilled in the art may make various modifications or additions to the specific embodiments described or replace them in a similar manner without departing from the spirit of the present invention or exceeding the scope defined by the appended claims.

Although the terms such as triangle face, cluster, cluster group etc. are used more frequently in this paper, the possibility of using other terms is not excluded. These terms are used only to more conveniently describe and explain the essence of the present invention; interpreting them as any additional limitation is contrary to the spirit of the present invention.

Claims (6)

1. A cluster-based IFC model component level LOD generation and use method, characterized by comprising the following steps: (1) Read the geometric information of the IFC model components, deduplicate the vertex data of the components, encapsulate the updated triangular face data, and traverse the geometric data; compare the number of triangular faces of each component with the preset face number threshold, and regard the components whose triangular faces do not exceed the threshold as simple mesh components and use the conventional rendering pipeline; regard the components whose triangular faces exceed the threshold as complex mesh components, obtain the adjacency relationship between the triangular faces of the components, and record them as a data structure; (2) Traverse the building components in the model to identify the data structure of the adjacency relationship of the triangles, sort the triangles, divide them into clusters, and calculate the adjacency relationship of the clusters. Use this data to divide the clusters into cluster groups, and then obtain the cluster group data and encapsulate it into a data structure; (3) traverse the cluster group data in the component identification step (2), traverse each group, extract the triangular surface data of all clusters therein, reduce the surface by combining the surface reduction algorithm, and record all newly generated triangular surface data and their adjacency relationship data in the group; (4) Repeat steps (2) and (3) until a specified number of LOD levels are generated, and store the newly generated geometric data as an intermediate file; (5) Read the geometric data in the intermediate file, and remove the corresponding parts in turn according to the visibility of the component mesh, component cluster group, and component cluster in the model to which the geometric data belongs, record the data of the visible cluster and the corresponding LOD level, and render it. 2. The method for generating and using component-level LOD of an IFC model based on clustering according to claim 1, wherein the step (1) is implemented by the following sub-steps: (1.1) Parse the geometric data of the IFC model, obtain the vertex attributes and corresponding index numbers of each component, traverse all vertices corresponding to the index numbers, and compare them. If two numbers point to the same vertex attribute, remove the duplicates and store the updated data; (1.2) It is assumed that the edge of each triangle has a direction. Through the vertex and index data obtained in step (1.1), all edges are traversed. When any two edges have the same vertices but opposite directions, there is a relationship between the two edges. This relationship is recorded in the data structure. (1.3) Identify the data structure of the opposite edge relationship in step (1.2), read each set of opposite edges, calculate the index number of the triangle where the edge is located through the index number of the edge, and then obtain the adjacency relationship of the triangle, which is encapsulated into a data structure. 3. The method for generating and using component-level LOD of an IFC model based on clustering according to claim 1, wherein the step (2) is implemented by the following sub-steps: (2.1) Identify the data structure that records the adjacency relationship of the triangles, use the index number size and adjacency relationship of the triangles as weights, sort the index numbers, then split them into a fixed size, encapsulate them into clusters in order, and record the edge data information of the clusters; (2.2) Combined with the logic of the half-edge data structure algorithm, each undirected edge can be split into two half-edges with the same vertices but opposite directions. It can be assumed that each edge has a direction. Through the edge data of the cluster obtained in step (2.1), all edges are traversed. When any two edges have the same vertices but opposite directions, there is an opposite edge relationship between the two edges, and the opposite edge relationship is recorded in the data structure. (2.3) Identify the data structure containing the edge relationship, read each set of edges, and map the index number of the edge back to the index number of the cluster to which it belongs, so as to obtain the adjacency relationship of the cluster and encapsulate it into a data structure; (2.4) Identify the adjacency relationship of the clusters in step (2.3), use the index number size and adjacency relationship of the cluster as weights, sort the data by index number, and then split it into a fixed size, encapsulate it into cluster groups in order, and record the edge data information of the cluster groups. 4. The method for generating and using component-level LOD of an IFC model based on clustering according to claim 1, wherein the step (3) is implemented by the following sub-steps: (3.1) Identify the geometric data of the cluster group, traverse each group, obtain the vertex attributes and index data of the triangles of all clusters in it, and store them in a data structure respectively; (3.2) Read the edge data of the group, identify the vertex attributes and index data generated in step (3.1), and mark the vertex corresponding to the edge as "locked" to ensure that it will not be changed during the face reduction process; (3.3) Identify the vertex attributes and index data generated in step (3.1), combine with the face reduction algorithm, and traverse the face reduction cumulative error corresponding to each edge in turn. For the edge with the "locked" vertex set in step (3.2), set a maximum value for its face reduction cumulative error, and then store the error in a minimum heap data structure; (3.4) Identify the minimum heap data structure in step (3.3), extract the edge with the smallest cumulative error of face reduction in turn, collapse the edge, adjust the vertex data of its adjacent triangles, and calculate the cumulative error of face reduction for the new edge generated after face reduction, and store it in the minimum heap at the same time; (3.5) Repeat step (3.4) until the number of existing edges meets the preset conditions, then deduplicate the existing vertex attributes and index numbers, use the new vertex attributes and index numbers obtained after deduplication to construct new triangle surface geometry data, and encapsulate the result into a data structure; (3.6) Identify the new triangular face geometry data obtained in step (3.5), traverse all edges, and when any two edges have the same vertices but opposite directions, there is an opposite-edge relationship between the two edges. Record all opposite-edge relationships in the data structure, and then use the data to obtain the adjacency relationship of the triangular face. 5. The method for generating and using component-level LOD of an IFC model based on clustering according to claim 1, wherein the step (4) is implemented by the following sub-steps: (4.1) Repeat steps (2) and (3) according to the preset number of LOD levels; (4.2) Setting a coding structure, arranging the component LOD geometry data generated in step (4.1) in order, and storing them in an intermediate file. 6. The method for generating and using component-level LOD of an IFC model based on clustering according to claim 1, wherein the step (5) is implemented by the following sub-steps: (5.1) In combination with the encoding structure set in step (4.2), the intermediate file recording the LOD data is parsed and encapsulated into a data structure, which is stored in the buffer for rendering and reading, and the component geometry data in the buffer is generated; (5.2) Read the component geometry data in the buffer generated in step (5.1), use the bounding box to calculate the visibility of the component model, and record the index number of the visible component; (5.3) Identify the index number of the visible component obtained in step (5.2), use the index number to read the geometric information of its corresponding cluster group in the buffer generated in step (5.1), use the distance between it and the camera and the pixel ratio it occupies on the terminal interface as weights, calculate its corresponding LOD level, and then use the level to filter the corresponding cluster group index number and record it; (5.4) Identify the cluster group index number obtained in step (5.3), read the clusters contained in the cluster group in the buffer generated in step (5.1), and traverse and compare the visibility of the clusters in turn, and then generate and record the index buffer of the visible cluster index number; (5.5) Read the visible cluster index number data in the index buffer generated in step (5.4), obtain the corresponding index number, and then read the vertex data in the buffer generated in step (5.1) according to the index and render it.