LOD construction method and device for GIS large-range live-action model

Abstract

According to the LOD construction method and device for the GIS large-range live-action model, the nodes are generated through adaptive iterative segmentation in the HLOD tree construction process, the triangular patch data amount of each node is kept within the threshold value range, and the nodes with the too large triangular patch number cannot be generated; meanwhile, the textures of all the nodes are limited to be kept in a similar range, too large textures cannot be generated, and the optimal configuration effect can be achieved in the rendering scheduling process of the result; meanwhile, after the triangular patches in all the nodes are simplified, the texture features in the texture pyramid are merged, and the method can effectively simplify the grids, maintain the features of the grids, reduce the deformation of the textures to the maximum extent, and ensure the visual effect of the grids. In addition, main memory occupation data is stored in a temporary file by using a memory mapping technology, so that the scheme can process large data volume data exceeding computer memory limitation.

Description

Technical Field

[0001] This disclosure relates to the field of image processing, and in particular to a method and apparatus for constructing LOD (Level of Detail) models for large-scale real-world GIS scenes. Background Technology

[0002] Levels of Detail (LOD) technology primarily addresses the balance between rendering performance and visual quality. When a user observes a 3D scene at different viewing distances, the system automatically selects a model of appropriate precision for display. A high-precision model is used for close-up viewing to ensure detail, while a low-precision model is used for distant viewing to improve rendering efficiency. This mechanism significantly reduces GPU load, increases frame rates, and ensures smooth interaction in large-scale 3D scenes. LOD technology also optimizes data transmission and storage. In web GIS applications, the system can load data of appropriate precision as needed based on the user's current viewpoint, avoiding the transmission of unnecessary high-precision models and reducing bandwidth consumption. Simultaneously, multi-level data organization facilitates progressive loading, improving the user experience.

[0003] Current technologies often consider geometric simplification or texture processing separately during the model LOD process, lacking a collaborative optimization mechanism between the two. This makes it difficult for the simplified model to achieve an optimal balance between visual quality and data volume. Summary of the Invention

[0004] This disclosure provides at least one method and apparatus for constructing LOD (Level of Detail) models for large-scale real-world GIS scenes, achieving high-efficiency rendering performance while maintaining visual quality.

[0005] According to one aspect of this disclosure, a method for constructing Level of Detail (LOD) models for large-scale real-world GIS scenes is provided, comprising:

[0006] Generate a textured triangular mesh model; the triangular mesh model comprises multiple triangular facets;

[0007] The bounding box information of the root node is determined based on the GIS information of the triangular mesh model. Based on the preset maximum number of triangles and maximum texture weight, the triangular facets are traversed and the leaf node of each triangular facet in the HLOD tree is determined. The triangular facet data in the nodes of the HLOD tree is stored in a temporary file using memory mapping.

[0008] The number of layers in the texture pyramid is determined based on the number of layers in the HLOD tree; the 0th texture layer of the texture pyramid is initialized as the original image corresponding to the triangular mesh model; the Nth texture layer of the texture pyramid is generated in ascending order according to the following steps: Gaussian filtering is applied to the image of the previous texture layer; the Gaussian-filtered image is downsampled to obtain the image of the current texture layer; the texture pyramid is completed when the resolution of the current texture layer image is less than a preset threshold or the value of N is greater than a preset value; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology;

[0009] Following the HLOD tree from bottom to top, the triangular faces in each node of each level are simplified and merged level by level.

[0010] For each node after simplification and merging, the texture features corresponding to that node are extracted from the image of the texture layer corresponding to the texture pyramid. The extracted texture features are packaged into a texture image, and the texture image is associated with the node. This process continues until all nodes are associated with their corresponding texture images, resulting in an HLOD tree filled with texture data. The HLOD tree filled with texture data is then exported in the 3D Tiles standard format.

[0011] In one possible implementation, the step of traversing the triangular faces and determining the leaf node of each triangular face in the HLOD tree based on a preset maximum number of triangles and maximum texture weight includes:

[0012] Determine the tree structure of the HLOD tree; wherein the tree structure is a quadtree or an octree;

[0013] For the current triangle, if, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is not greater than the maximum number of triangles, and the texture weight of the current leaf node is not greater than the maximum texture weight, then the current triangle is assigned to the current leaf node, and the texture weight of the current leaf node is increased by the texture weight of the current triangle. If, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is greater than the maximum number of triangles, or the texture weight of the current leaf node is greater than the maximum texture weight, then the current leaf node is designated as the node to be split. The range and hierarchy information of the child nodes of the node to be split are determined. Each triangle within the node to be split is traversed, and the triangles within the node to be split are assigned to matching child nodes based on their center positions.

[0014] This continues until all triangular faces within the triangular mesh model are assigned to the leaf nodes of the HLOD tree;

[0015] The data of a node in the HLOD tree includes a pointer to the parent node, an array of pointers to child nodes, a node identifier, a node texture weight, a node range, and data of the triangular facets contained within the node; the node identifier contains the level and position information of the HLOD tree in which the node is located.

[0016] In one possible implementation, the texture weight W of the triangular facet f Calculate using the following formula:

[0017]

[0018]

[0019] Where Area represents the texture coordinate area of ​​the triangular facet, and width and height represent the width and height of the texture layer image corresponding to the triangular facet. The preset texture weights are defined by v0, v1, and v2, which are the three vertices of the triangle facet, and u and v are the texture coordinates corresponding to the vertices.

[0020] In one possible implementation, the image of the previous texture layer is Gaussian filtered using the following formula:

[0021]

[0022] Among them, G k This represents the image of the previous texture layer; It is a two-dimensional Gaussian kernel;

[0023] The filtered image is downsampled using the following formula:

[0024]

[0025] Where S is the scaling factor; the relationship between adjacent texture layers is as follows:

[0026]

[0027]

[0028] in, , The width and height of the previous texture layer. , This represents the width and height of the current texture layer.

[0029] In one possible implementation, the step of simplifying and merging the triangular faces in each node of each layer in the order of the HLOD tree from bottom to top includes:

[0030] Perform the following simplified merge operation for each node:

[0031] Calculate the folding cost for each edge in the node;

[0032] Insert the folding cost of all edges into a priority queue;

[0033] The following operations are performed repeatedly until the number of triangles in the node is equal to or less than the maximum number of triangles: take the edge with the minimum folding cost from the priority queue; fold the two vertices of the taken edge into a new vertex; update the folding cost of the edge connected to the new vertex, and update the priority queue based on the updated folding cost;

[0034] Pass the simplified and merged data from this node to the parent node;

[0035] The cost of edge folding is a weighted sum of geometric error and texture error. Texture error is determined by the change between the texture gradient of each triangle facet connected to the vertex of the edge to be folded before simplification and the texture gradient of the triangle facet connected to the corresponding vertex after folding after simplification.

[0036] Among them, the geometric coordinates and texture coordinates of the new vertices are optimized with the goal of minimizing the folding cost of the edges;

[0037] Specifically, for edges that belong to boundaries or texture seams, the corresponding folding cost is set to a maximum value.

[0038] In one possible implementation, extracting the texture features corresponding to the node from the image of the texture layer corresponding to the texture pyramid includes:

[0039] Divide the triangular facets in this node into multiple non-connected component regions;

[0040] For each component region, traverse the vertices in that component region, and determine the minimum bounding box of the texture corresponding to the component region based on the texture coordinates of the vertex in the texture layer of the texture pyramid; determine the texture rectangle region corresponding to the component region based on the texture coordinates of the minimum point and the maximum point in the minimum bounding box, and the width and height of the image of the texture layer corresponding to the node in the texture pyramid.

[0041] The data within the texture rectangle corresponding to all component regions in the texture layer is used as the texture feature corresponding to that node.

[0042] The step of packaging the extracted texture features into a texture image includes:

[0043] The MaxRects algorithm is used to pack the texture features corresponding to each component region into a single texture image. After packing, the vertex texture coordinates of the triangular facets are calculated according to the following formula:

[0044]

[0045]

[0046] in, , The width and height of the packaged texture image. , The texture coordinates of the vertices of the triangular facet in the texture layer. , The texture coordinates of the vertices of the triangular facet in the texture image.

[0047] A method for constructing Level of Detail (LOD) models for large-scale real-world GIS scenes, wherein exporting an HLOD tree filled with texture data into the standard 3D Tiles format includes:

[0048] Starting from the root node, the HLOD tree is traversed using a breadth-first traversal method. The data corresponding to each node is saved as a gltf file, and the file name is based on the position of the corresponding node in the HLOD tree.

[0049] The nested structure of the HLOD tree is used to generate an entry file tilesset.json in the standard format of 3D Tiles; wherein the nested structure of the HLOD tree includes the necessary fields corresponding to each node; the necessary fields include the minimum bounding box information of the node, the file name of the node, refine, and the texture error information of the node;

[0050] The texture error information of the node is calculated using the following formula:

[0051]

[0052] Let be the length of the i-th edge within the node. The length of the texture coordinates corresponding to the i-th edge. is the width of the texture layer image corresponding to the node, and n is the number of inner edges of the node.

[0053] In one possible implementation, the LOD construction method for large-scale reality models in GIS also includes:

[0054] Starting from the root node of the HLOD tree filled with texture data, traverse the nodes and calculate the screen space error of the current node. If the screen space error is greater than the maximum screen space error threshold, the data corresponding to the next level node of the current node needs to be displayed; otherwise, the data corresponding to the current node is displayed.

[0055] The screen space error (SSE) of a node is calculated using the following formula:

[0056] SSE = (geometricError × screenHeight) / (2 × distance × tan(fov / 2))

[0057] geometricErro is the geometric error of the node, screenHeight is the height of the current display screen, distance is the distance from the viewpoint to the node, and fov is the vertical field of view angle.

[0058] In one possible implementation, generating the textured triangular mesh model includes:

[0059] Acquire multiple images with a preset overlap;

[0060] An initial triangular mesh model is constructed using the multiple images;

[0061] Texture extraction is performed on the multiple images, and the extracted texture is mapped onto the initial triangular mesh model to obtain the textured triangular mesh model.

[0062] According to another aspect of this disclosure, a Level of Detail (LOD) construction apparatus for large-scale real-world models in GIS is provided, comprising:

[0063] A model generation module is used to generate a textured triangular mesh model; the triangular mesh model includes multiple triangular facets.

[0064] The HLOD construction module is used to determine the bounding box information of the root node based on the GIS information of the triangular mesh model, and to traverse the triangular facets and determine the leaf node of each triangular facet in the HLOD tree according to the preset maximum number of triangles and maximum texture weight; wherein, the data of the triangular facets in the nodes of the HLOD tree are stored in a temporary file using memory mapping.

[0065] The texture construction module is used to determine the number of layers in the texture pyramid based on the number of layers in the HLOD tree; initialize the 0th texture layer of the texture pyramid as the original image corresponding to the triangular mesh model; generate the Nth texture layer of the texture pyramid in ascending order according to the following steps: apply Gaussian filtering to the image of the previous texture layer; downsample the Gaussian-filtered image to obtain the image of the current texture layer; until the resolution of the current texture layer image is less than a preset threshold or the value of N is greater than a preset value, the constructed texture pyramid is obtained; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology;

[0066] The node simplification module is used to simplify and merge the triangular faces in each node of each layer in the order from bottom to top of the HLOD tree.

[0067] The texture merging module is used to extract the texture features corresponding to each node from the texture layer image corresponding to the texture pyramid for each simplified and merged node, pack the extracted texture features into a texture image, and establish an association between the texture image and the node; until all nodes have established an association with the corresponding texture image, an HLOD tree filled with texture data is obtained;

[0068] The model export module is used to export HLOD trees filled with texture data to the standard 3D Tiles format.

[0069] This disclosure discloses a method and apparatus for constructing Level of Detail (LOD) models for large-scale real-world GIS scenes. During the HLOD tree construction process, nodes are generated through adaptive iterative segmentation based on a preset maximum number of triangles and a maximum texture weight. This method keeps the amount of triangular facet data in each node within a threshold range, preventing nodes with excessively large triangular facets. Simultaneously, due to the maximum texture weight limitation, the textures of each node are kept within a similar range, preventing excessively large textures. This result achieves optimal configuration during rendering scheduling. Furthermore, after simplifying the triangular facets within all nodes, this disclosure merges the texture features in the texture pyramid of the simplified nodes. This method effectively simplifies the mesh, preserving its features (including edges and texture seams) while minimizing texture deformation and ensuring the visual quality of the mesh. Additionally, this disclosure uses memory mapping technology to store the main memory-consuming data (including triangular facet data within nodes and atlases in the texture pyramid) in temporary files, enabling this solution to handle large amounts of data exceeding computer memory limits. Furthermore, this disclosure utilizes parallel technology, resulting in high LOD generation efficiency and low hardware requirements, enabling efficient construction of large-scale real-world model LODs even on low-end hardware. Moreover, the computer application logic corresponding to the solution disclosed in this disclosure is simple to understand, easy to reproduce, and readily promoted and widely applied.

[0070] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0071] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0072] Figure 1 This is a flowchart of a method for constructing LOD (Level of Detail) for large-scale real-world models in GIS according to an embodiment of this disclosure;

[0073] Figure 2 This is a schematic diagram of an HLOD tree in one embodiment of this disclosure;

[0074] Figure 3 This is a schematic diagram of multiple independent non-connected regions in one embodiment of this disclosure;

[0075] Figure 4A This is a schematic diagram of the original texture in one embodiment of this disclosure;

[0076] Figure 4B This is a schematic diagram of the texture after the root node is packaged in one embodiment of this disclosure;

[0077] Figure 5 This is the representation of a node in a tileset file in one embodiment of this disclosure;

[0078] Figure 6A This is a schematic diagram of rendering on the LOD0 layer using the scheme of this disclosure in one embodiment;

[0079] Figure 6B This is a rendering diagram of the original model at the LOD0 layer in one embodiment of this disclosure;

[0080] Figure 7A This is a schematic diagram of rendering on the LOD1 layer using the scheme of this disclosure in one embodiment;

[0081] Figure 7B This is a rendering diagram of the original model at the LOD1 layer in one embodiment of this disclosure;

[0082] Figure 8A This is a schematic diagram of rendering at the LOD2 layer using the scheme of this disclosure in one embodiment;

[0083] Figure 8B This is a rendering diagram of the original model at the LOD2 layer in one embodiment of this disclosure;

[0084] Figure 9AThis is a schematic diagram of rendering at the LOD3 layer using the scheme of this disclosure in one embodiment;

[0085] Figure 9B This is a rendering diagram of the original model at the LOD3 layer in one embodiment of this disclosure;

[0086] Figure 10A This is a schematic diagram of rendering at the LOD4 layer using the scheme of this disclosure in one embodiment;

[0087] Figure 10B This is a rendering diagram of the original model at the LOD4 layer in one embodiment of this disclosure;

[0088] Figure 11A This is a schematic diagram of rendering at the LOD5 layer using the scheme of this disclosure in one embodiment;

[0089] Figure 11B This is a rendering diagram of the original model at the LOD5 layer in one embodiment of this disclosure;

[0090] Figure 12A This is a schematic diagram of rendering at the LOD6 layer using the scheme of this disclosure in one embodiment;

[0091] Figure 12B This is a rendering diagram of the original model at LOD6 layer in one embodiment of this disclosure;

[0092] Figure 13 This is a schematic diagram of the structure of a LOD (Level of Detail) construction device for large-scale real-world models of GIS according to an embodiment of the present disclosure. Detailed Implementation

[0093] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0094] This disclosure addresses the shortcomings of traditional methods in model LOD (Level of Detail) where geometric simplification or texture processing is often considered in isolation, lacking a collaborative optimization mechanism between the two. This results in a difficulty in achieving an optimal balance between visual quality and data volume in the simplified model. Therefore, this disclosure proposes a method and apparatus for LOD construction of large-scale real-world models in GIS. This method employs an adaptive HLOD tree construction method that considers texture to establish a multi-resolution hierarchical structure. A corresponding texture pyramid is constructed based on the maximum level of the HLOD tree. Then, the HLOD tree is simplified and merged layer by layer from the leaf nodes upwards, ultimately deriving standard 3D Tiles data, thus achieving efficient LOD construction of large-scale real-world models.

[0095] The technical solution of this disclosure will be described below through specific embodiments.

[0096] like Figure 1 The diagram shown is a flowchart of the LOD construction method for large-scale real-world models in GIS according to this embodiment. The execution subject of this embodiment is a computing device or component with data processing capabilities. Specifically, the method of this embodiment may include the following steps:

[0097] S110. Generate a textured triangular mesh model; the triangular mesh model includes multiple triangular facets.

[0098] Specifically, generating a textured triangular mesh model includes:

[0099] Acquire multiple images with a preset overlap;

[0100] An initial triangular mesh model is constructed using the multiple images;

[0101] Texture extraction is performed on the multiple images, and the extracted texture is mapped onto the initial triangular mesh model to obtain the textured triangular mesh model.

[0102] S120. Determine the bounding box information of the root node based on the GIS information of the triangular mesh model. Based on the preset maximum number of triangles and maximum texture weight, traverse the triangular facets and determine the leaf node of each triangular facet in the HLOD tree. The triangular facet data in the nodes of the HLOD tree is stored in a temporary file using memory mapping.

[0103] In the process of splitting to generate an HLOD tree, the tree structure of the HLOD tree is first determined; wherein the tree structure is a quadtree or an octree; then, all triangles are traversed. For the currently traversed triangle, if, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is not greater than the maximum number of triangles, and the texture weight of the current leaf node is not greater than the maximum texture weight, then the current triangle is assigned to the current leaf node, and the texture weight of the current leaf node is increased by the texture weight of the current triangle; if, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is greater than the maximum number of triangles, or the texture weight of the current leaf node is greater than the maximum texture weight, then the current leaf node is designated as the node to be split; the range and level information of the child nodes of the node to be split are determined; each triangle within the node to be split is traversed, and the triangles within the node to be split are assigned to matching child nodes according to the center position of the triangles. The HLOD tree is completed when all triangular faces within the triangular mesh model are assigned to the leaf nodes of the HLOD tree.

[0104] The data of a node in the HLOD tree includes a pointer to the parent node, an array of pointers to child nodes, the node's identifier, the node's texture weight, the node's range, and the data of the triangular facets contained within the node; the node's identifier contains the node's level and position information in the HLOD tree.

[0105] Texture weight W of the triangular facet f Calculate using the following formula:

[0106]

[0107]

[0108] Where Area represents the texture coordinate area of ​​the triangular facet, and width and height represent the width and height of the texture layer image corresponding to the triangular facet. The preset texture weights are defined by v0, v1, and v2, which are the three vertices of the triangle facet, and u and v are the texture coordinates corresponding to the vertices.

[0109] S130. Determine the number of layers in the texture pyramid based on the number of layers in the HLOD tree; initialize the 0th texture layer of the texture pyramid as the original image corresponding to the triangular mesh model; generate the Nth texture layer of the texture pyramid in ascending order according to the following steps: apply Gaussian filtering to the image of the previous texture layer; downsample the Gaussian-filtered image to obtain the image of the current texture layer; continue until the resolution of the current texture layer image is less than a preset threshold or the value of N is greater than a preset value, to obtain the completed texture pyramid; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology.

[0110] Apply Gaussian filtering to the image of the previous texture layer using the following formula:

[0111]

[0112] Among them, G k This represents the image of the previous texture layer; It is a two-dimensional Gaussian kernel;

[0113] The filtered image is downsampled using the following formula:

[0114]

[0115] Where S is the scaling factor; the relationship between adjacent texture layers is as follows:

[0116]

[0117]

[0118] in, , The width and height of the previous texture layer. , This represents the width and height of the current texture layer.

[0119] S140. Following the HLOD tree from bottom to top, simplify and merge the triangular faces in each node of each level.

[0120] Specifically, the following simplified merge operation is performed for each node:

[0121] Calculate the folding cost for each edge in the node;

[0122] Insert the folding cost of all edges into a priority queue;

[0123] The following operations are performed repeatedly until the number of triangles in the node is equal to or less than the maximum number of triangles: take the edge with the minimum folding cost from the priority queue; fold the two vertices of the taken edge into a new vertex; update the folding cost of the edge connected to the new vertex, and update the priority queue based on the updated folding cost;

[0124] The simplified and merged data from this node is then passed to the parent node.

[0125] The edge folding cost is a weighted sum of geometric and texture errors. The texture error is determined by the change between the texture gradient of each triangle connected to the vertex of the edge to be folded before simplification and the texture gradient of the triangle connected to the corresponding vertex after simplification. The geometric and texture coordinates of the new vertices are optimized to minimize the edge folding cost. For edges that belong to boundaries or texture seams, the corresponding folding cost is set to a maximum value.

[0126] S150. For each node after simplification and merging, extract the texture features corresponding to the node from the image of the texture layer corresponding to the texture pyramid, pack the extracted texture features into a texture image, and establish an association between the texture image and the node; until all nodes have established an association with the corresponding texture image, an HLOD tree filled with texture data is obtained.

[0127] In some instances, extracting the texture features corresponding to a node from the image of the texture layer corresponding to the texture pyramid can specifically include: dividing the triangular facets in the node into multiple non-connected component regions; for each component region, traversing the vertices in the component region, and determining the minimum bounding box of the texture corresponding to the component region based on the texture coordinates of the vertices in the texture layer corresponding to the texture pyramid; determining the texture rectangle region corresponding to the component region based on the texture coordinates of the minimum point and the maximum point in the minimum bounding box, and the width and height of the image of the texture layer corresponding to the node in the texture pyramid; and using the data within the texture rectangle regions corresponding to all component regions in the texture layer as the texture features corresponding to the node.

[0128] The above-mentioned process of packaging the extracted texture features into a single texture image may include:

[0129] The MaxRects algorithm is used to pack the texture features corresponding to each component region into a single texture image. The vertex texture coordinates of the packed triangle are calculated according to the following formula:

[0130]

[0131]

[0132] in, , The width and height of the packaged texture image. , The texture coordinates of the vertices of the triangular facet in the texture layer. , The texture coordinates of the vertices of the triangular facet in the texture image.

[0133] S160. Export the HLOD tree filled with texture data to the 3D Tiles standard format.

[0134] Specifically, starting from the root node, the HLOD tree is traversed using a breadth-first search method. The data corresponding to each node is saved as a glTF file, and the file name uses the position of the corresponding node in the HLOD tree. The nested structure of the HLOD tree is used to generate an entry file tilesset.json in the standard format of 3D Tiles. The nested structure of the HLOD tree includes the necessary fields corresponding to each node. The necessary fields include the minimum bounding box information of the node, the file name of the node, refine, and the texture error information of the node.

[0135] The texture error information of the node is calculated using the following formula:

[0136]

[0137] Let be the length of the i-th edge within the node. The length of the texture coordinates corresponding to the i-th edge. is the width of the texture layer image corresponding to the node, and n is the number of inner edges of the node.

[0138] After obtaining the HLOD tree filled with texture data, the following steps can be used for rendering:

[0139] Starting from the root node of the HLOD tree filled with texture data, traverse the nodes and calculate the screen space error of the current node. If the screen space error is greater than the maximum screen space error threshold, then the data corresponding to the next level node of the current node needs to be displayed; otherwise, the data corresponding to the current node is displayed.

[0140] The screen space error (SSE) of a node is calculated using the following formula:

[0141] SSE = (geometricError × screenHeight) / (2 × distance × tan(fov / 2))

[0142] geometricErro is the geometric error of the node, screenHeight is the height of the current display screen, distance is the distance from the viewpoint to the node, and fov is the vertical field of view angle.

[0143] The solution disclosed herein will now be illustrated through a specific embodiment. Specifically, it may include the following steps:

[0144] Step 1: Adaptive HLOD tree construction considering texture

[0145] The input is a textured real-world model (i.e., a triangular mesh model). The HLOD tree structure is adaptively selected based on the model's features, choosing either a quadtree or an octree structure. The octree structure has greater versatility and is the preferred choice in most cases. Specifically, when the z-dimensional dimension is much smaller than the x and y-dimensional dimensions, such as in large-scale terrain data, a quadtree structure is preferable. The node data structure design includes: a pointer to the parent node, an array of pointers to child nodes, a node identifier (containing the node's HLOD tree level and position information), the node's total texture weight, the node's range, and the data of the triangular faces contained within the node. The triangular face data is stored in a temporary file using memory mapping technology and is only read when needed.

[0146] The texture mentioned above refers to the visual details of the object's surface, such as RGB information. The RGB information in this disclosure comes from the image corresponding to the triangular mesh model. Such a triangular mesh model can be constructed by the following photogrammetric methods: (1) acquiring images with a certain degree of overlap; (2) generating an initial triangular mesh model using SfM / MVS and mesh reconstruction algorithms; (3) generating a textured triangular mesh model through texture extraction and texture mapping.

[0147] HLOD trees are created in a top-down manner. The root node's range is determined based on the bounding box of the input data (i.e., the triangular mesh model), and the tree splits downwards sequentially until the splitting condition is no longer met. The splitting condition is the maximum number of triangular faces contained in a node. and the maximum texture weight of the node The center of the triangular facet is used as the criterion for determining which node the triangular facet belongs to. The specific steps are as follows:

[0148] Determine the bounding box information of the root node, and set the maximum number of triangles and maximum texture weight that the node can accept;

[0149] Traverse the triangular facets and determine the leaf node where the triangular facet is located in the current HLOD tree;

[0150] If the number of triangles contained in the current leaf node is not greater than the preset maximum number of triangles and the weight of the current leaf node plus the texture weight of the triangle to be assigned is not greater than the preset maximum texture weight, then the triangle is assigned to the current leaf node, the number of triangles contained in the current leaf node is incremented by 1, and the texture weight of the current node is increased by the texture weight corresponding to the triangle.

[0151] If the number of triangles contained in the leaf node is greater than the preset maximum number of triangles, or if the texture weight of the leaf node is greater than the preset maximum texture weight, then the leaf node is split. The range and hierarchy of child nodes are determined based on the node to be split. The triangles within the node to be split are traversed, and each triangle is assigned to a child node based on its center position.

[0152] Repeat steps (2), (3), and (4) until all triangular faces are assigned to the leaf nodes of the HLOD tree, where the triangular faces contained in all leaf nodes together form the most original and refined triangular mesh model.

[0153] In step (3) above, the texture weight of each triangular facet is calculated as follows:

[0154]

[0155]

[0156] Where Area represents the texture area of ​​the triangular facet, and width and height represent the width and height of the texture image corresponding to the triangular facet. For the preset texture weights, v0, v1, and v2 are the three vertices of the triangular facet, and u and v are the texture coordinates corresponding to the vertices, with values ​​ranging from [0-1]. The original triangular mesh model facets have information about which texture image they correspond to, which can be directly determined.

[0157] Through the above process, an adaptive hierarchical multi-resolution tree structure has been initially constructed. A basic schematic diagram of the adaptive HLOD tree can be obtained from... Figure 2 express.

[0158] Step 2: Texture Pyramid Construction

[0159] The hierarchy of the texture pyramid atlas is determined based on the hierarchy of the HLOD tree structure constructed in step one. This disclosure uses the commonly used Gaussian pyramid to construct a texture pyramid for each image. The Gaussian pyramid is a multi-scale image representation method whose core idea is to create a series of images with progressively decreasing resolution through progressive downsampling. The bottom layer of the pyramid is the original high-resolution image, and the top layer is a highly compressed low-resolution image, forming a pyramid-like structure. The detailed construction process is as follows:

[0160] (1) Initialize the 0th layer of the pyramid. This layer is the base layer (bottom layer) of the pyramid and corresponds to the original image. It is denoted as . .

[0161] (2) Iteratively build the upper layer, and build the current layer. Perform Gaussian filtering:

[0162]

[0163] in A two-dimensional Gaussian kernel can be represented as

[0164]

[0165] x, y represent the row and column coordinates of a pixel.

[0166] (3) Downsample the filtered image

[0167] Where S is the scaling factor. The relationships between adjacent texture pyramid textures are as follows:

[0168]

[0169]

[0170] above , The width and height of the previous layer texture. , This represents the width and height of the current level.

[0171] (4) Construction stops when the image resolution is less than the preset threshold or the pyramid level reaches the target level.

[0172] Based on the above steps, a pyramid is constructed for each image, forming a texture pyramid atlas. Similarly, memory mapping technology is used to store the texture atlas in a temporary file, which is then quickly mapped into memory only when needed to reduce runtime memory usage.

[0173] The third step involves simplifying and merging layers, extracting and packaging textures to generate the texture mesh data for each node.

[0174] In contrast to constructing the HLOD tree structure, the generation of the actual tile data for each node adopts a bottom-up approach. Starting from the leaf nodes, node data is generated by progressively simplifying and merging layers and packaging node textures. The leaf nodes represent the most original model data. The model simplification employs a texture-considering QEM (Quadric Error Metrics) algorithm. While traditional QEM algorithms primarily consider geometric errors, the algorithm used in this disclosure also incorporates texture distortion introduced by simplification into the error metric, defining vertex error as a weighted combination of geometric and texture errors.

[0175]

[0176] in, This represents the geometric error of the traditional QEM algorithm, which is the sum of squared distances from a vertex to its adjacent plane. The degree of texture distortion caused by simplification is measured in this disclosure by the change in texture gradient. That is, before the simplification operation, the texture gradient (i.e., the partial derivative of the texture coordinates on the triangle) is calculated on each triangle; after simplification, the texture gradient on the new triangle is recalculated; the texture error can be defined as the norm of the gradient change (such as the L2 norm).

[0177] The simplification process employs an edge-folding operation, folding two vertices v1 and v2 of an edge into a new vertex v. During the edge-folding operation, the geometric and texture coordinates of the new vertex v need to be determined using the following formula to minimize the total error.

[0178]

[0179] The specific process of the algorithm can be described as follows:

[0180] (1) Initialization: Calculate the initial folding cost (including geometric error and texture error) for each edge.

[0181] (2) Insert all edges into a priority queue (min-heap) according to the folding cost.

[0182] (3) Repeat the following steps until the maximum number of triangles is reached. : Take the edge with the minimum cost from the queue; perform the edge folding operation to generate a new vertex; update the folding cost of the edges adjacent to the new vertex; update the priority queue.

[0183] Specifically, during the initial edge folding cost calculation, boundary edges and texture seam edges are detected. The cost of these types of edges is set to a maximum value to prevent them from being simplified, thus avoiding gaps caused by simplification at the edges of adjacent nodes. Setting the folding cost to the maximum floating-point value (maximum value) will place it at the end of the priority queue. When folding, it is checked whether the cost is at the maximum value; if so, simplification is stopped.

[0184] Maximum number of triangles used in simplification process The maximum number of triangles used here is the termination condition. Consistent with the maximum number of triangles that a node in the HLOD tree structure constructed in step one can accept, only when the number of triangles in the current node is greater than... At that time, the number of node faces is simplified to Therefore, the amount of data during the leaf node partitioning of the HLOD tree will not exceed [a certain threshold]. Leaf nodes retain the most refined original model. Based on the current node's parent node pointer, the simplified or simplified data is passed to the parent node for merging. When executing on the parent node, the same strategy is used to perform simplification until the root node or the required maximum number of levels is reached.

[0185] After simplification, each node needs to have its corresponding texture extracted from the texture pyramid atlas. The specific process is as follows:

[0186] First, decompose the triangular facets within the node into multiple independent non-connected regions, such as Figure 3 As shown, the triangular facets within this node can be divided into four independent component regions: A, B, C, and D. Connectivity analysis (ADI) is used in graph algorithms to partition the mesh components (i.e., component regions). An adjacency list is used to construct an undirected graph representing the model. The triangular facets are traversed, and their edges are added to the undirected graph as edges. Then, a common graph connectivity analysis algorithm is used to obtain the connected component IDs corresponding to each vertex of the model to segment the independent component regions. Due to the presence of texture seams, the texture of a triangular facet within a component region should originate from the same texture image.

[0187] Next, the minimum bounding box of each component is calculated based on the divided component regions. Specifically, this involves traversing the vertices within the component region. The minimum bounding box of the component is then calculated as follows:

[0188] in This is the smallest texture bounding box corresponding to the component region. As vertices Texture coordinates, This represents the number of vertices within the component region.

[0189] Next, based on the smallest texture bounding box of each component region, the image of the corresponding texture layer for each component region is calculated. and the required pyramid levels Texture rectangular area The calculation method is as follows:

[0190]

[0191]

[0192]

[0193]

[0194] in, , , , These represent the origin coordinates (x and y) of the texture rectangle region, as well as the width and height of the texture rectangle region. , , , These are the minimum and maximum texture coordinates of the smallest and largest points of the smallest texture bounding box corresponding to the component region, respectively. , The pyramid level The width and height of the image.

[0195] Then, the MaxRects algorithm is used to pack the texture rectangles corresponding to each component region into a single texture image. After packaging, the model vertices are in the new texture image. The texture coordinates need to be recalculated, and the calculation method is as follows:

[0196]

[0197]

[0198] in, , For the packaged texture image Width and height, , The original texture coordinates of the model vertices. , For model vertices in texture image The corresponding texture coordinates. For example... Figure 4A , 4B The diagram shows the original texture and the repackaged texture at level 0.

[0199] After the above simplified merging and texture extraction and packaging process, an HLOD tree filled with texture data is obtained.

[0200] Step 4: Export the HLOD tree as a 3D Tiles standard format.

[0201] An open standard for large-scale heterogeneous 3D geospatial datasets (such as point clouds, buildings, and photogrammetry) is widely used in the geographic information industry. This disclosure ultimately uses this format to store the results. Starting from the root node, a breadth-first traversal method is used to traverse the HLOD tree, and the data corresponding to each node is saved as a gltf file in turn. The file name is based on the current node's position in the HLOD tree; for example, the file of the node located at depth 3 in the octree with coordinates (3, 4, 2) is ultimately named 3-3-4-2.gltf. At the same time, the nested structure of the HLOD tree is generated into an entry file tilesset.json in the standard format of 3D Tiles. In the nested structure, each node tile requires the following fields: boundingVolume.box, geometryError, refine, and content.uri. In this disclosure, refine corresponds to the "REPLACE" method. The boundingVolume field uses the box field to calculate the minimum bounding box of each node tile, resulting in boundingVolume.box. The uri field of content is the filename of the corresponding node; in the above interpretation, the corresponding node uri is "3-3-4-2.gltf". The final representation of the node tile in the tileset file is as follows: Figure 5 As shown.

[0202] It's worth noting that the geometryError calculation method for each node tile takes into account texture errors. The specific calculation formula is as follows:

[0203]

[0204]

[0205]

[0206] in, Let be the length of the i-th side within the node. The length of the texture coordinates corresponding to the i-th edge. This refers to the width of the texture image. Following the above steps, a final model file meeting the standards is generated. A comparison is made between the final model's LOD level rendering at different viewpoint distances and the original model's rendering results at the same distance. Figures 6A-12B As shown; where, Figure 6A This is a schematic diagram of rendering on the LOD0 layer using the scheme of this disclosure in one embodiment; Figure 6B This is a rendering diagram of the original model at the LOD0 layer in one embodiment of this disclosure; Figure 7A This is a schematic diagram of rendering on the LOD1 layer using the scheme of this disclosure in one embodiment; Figure 7BThis is a rendering diagram of the original model at the LOD1 layer in one embodiment of this disclosure; Figure 8A This is a schematic diagram of rendering at the LOD2 layer using the scheme of this disclosure in one embodiment; Figure 8B This is a rendering diagram of the original model at the LOD2 layer in one embodiment of this disclosure; Figure 9A This is a schematic diagram of rendering at the LOD3 layer using the scheme of this disclosure in one embodiment; Figure 9B This is a rendering diagram of the original model at the LOD3 layer in one embodiment of this disclosure; Figure 10A This is a schematic diagram of rendering at the LOD4 layer using the scheme of this disclosure in one embodiment; Figure 10B This is a rendering diagram of the original model at the LOD4 layer in one embodiment of this disclosure; Figure 11A This is a schematic diagram of rendering at the LOD5 layer using the scheme of this disclosure in one embodiment; Figure 11B This is a rendering diagram of the original model at the LOD5 layer in one embodiment of this disclosure; Figure 12A This is a schematic diagram of rendering at the LOD6 layer using the scheme of this disclosure in one embodiment; Figure 12B This is a rendering diagram of the original model at LOD6 level in one embodiment of this disclosure. By comparing the LOD model at various distances with the original rendering, it can be seen that the LOD model constructed by the method of this disclosure has a negligible impact on the visual appearance of the model.

[0207] Based on the same inventive concept, this disclosure provides a Level of Detail (LOD) construction device for large-scale real-world models in GIS. The steps performed by the components of this device are the same as or similar to those described above, therefore, similar details will not be repeated. Figure 13 As shown, the LOD construction device for large-scale real-world models in GIS in this embodiment includes:

[0208] The model generation module 1301 is used to generate a textured triangular mesh model; the triangular mesh model includes multiple triangular facets.

[0209] The HLOD construction module 1302 is used to determine the bounding box information of the root node based on the GIS information of the triangular mesh model, and to traverse the triangular facets and determine the leaf node of each triangular facet in the HLOD tree according to the preset maximum number of triangles and maximum texture weight; wherein, the data of the triangular facets in the nodes of the HLOD tree are stored in a temporary file using memory mapping.

[0210] The texture construction module 1303 is used to determine the number of layers of the texture pyramid according to the number of layers of the HLOD tree; initialize the 0th texture layer of the texture pyramid as the original image corresponding to the triangular mesh model; generate the Nth texture layer of the texture pyramid in ascending order according to the following steps: perform Gaussian filtering on the image of the previous texture layer; downsample the Gaussian-filtered image to obtain the image of the current texture layer; until the resolution of the image of the current texture layer is less than a preset threshold or the value of N is greater than a preset value, the constructed texture pyramid is obtained; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology.

[0211] The node simplification module 1304 is used to simplify and merge the triangular faces in each node of each layer in the order from bottom to top of the HLOD tree.

[0212] The texture merging module 1305 is used to extract the texture features corresponding to each node from the texture layer image corresponding to the texture pyramid for each node after simplification and merging, pack the extracted texture features into a texture image, and establish an association between the texture image and the node; until all nodes have established an association with the corresponding texture image, an HLOD tree filled with texture data is obtained.

[0213] Model export module 1306 is used to export HLOD trees filled with texture data to the 3D Tiles standard format.

[0214] The various embodiments of the techniques described above can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include: implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0215] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0216] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0217] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0218] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0219] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0220] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0221] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A method for constructing Level of Detail (LOD) models for large-scale real-world GIS scenes, characterized in that, include: Generate a textured triangular mesh model; the triangular mesh model comprises multiple triangular facets; The bounding box information of the root node is determined based on the GIS information of the triangular mesh model. Based on the preset maximum number of triangles and maximum texture weight, the triangular facets are traversed and the leaf node of each triangular facet in the HLOD tree is determined. The triangular facet data in the nodes of the HLOD tree is stored in a temporary file using memory mapping. The number of layers in the texture pyramid is determined based on the number of layers in the HLOD tree; the 0th texture layer of the texture pyramid is initialized as the original image corresponding to the triangular mesh model; the Nth texture layer of the texture pyramid is generated in ascending order according to the following steps: Gaussian filtering is applied to the image of the previous texture layer; the Gaussian-filtered image is downsampled to obtain the image of the current texture layer; the texture pyramid is completed when the resolution of the current texture layer image is less than a preset threshold or the value of N is greater than a preset value; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology; Following the HLOD tree from bottom to top, the triangular faces in each node of each level are simplified and merged level by level. For each node after simplification and merging, the texture features corresponding to that node are extracted from the image of the texture layer corresponding to the texture pyramid. The extracted texture features are packaged into a texture image, and the texture image is associated with the node. This process continues until all nodes are associated with their corresponding texture images, resulting in an HLOD tree filled with texture data. The HLOD tree filled with texture data is then exported in the 3D Tiles standard format.

2. The method according to claim 1, characterized in that, The step of traversing triangular faces and determining the leaf node of each triangular face in the HLOD tree based on the preset maximum number of triangles and maximum texture weight includes: Determine the tree structure of the HLOD tree; wherein the tree structure is a quadtree or an octree; For the current triangle, if, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is not greater than the maximum number of triangles, and the texture weight of the current leaf node is not greater than the maximum texture weight, then the current triangle is assigned to the current leaf node, and the texture weight of the current leaf node is increased by the texture weight of the current triangle. If, after placing the current triangle into the current leaf node, the number of triangles contained in the current leaf node is greater than the maximum number of triangles, or the texture weight of the current leaf node is greater than the maximum texture weight, then the current leaf node is designated as the node to be split. The range and hierarchy information of the child nodes of the node to be split are determined. Each triangle within the node to be split is traversed, and the triangles within the node to be split are assigned to matching child nodes based on their center positions. This continues until all triangular faces within the triangular mesh model are assigned to the leaf nodes of the HLOD tree; The data of a node in the HLOD tree includes a pointer to the parent node, an array of pointers to child nodes, a node identifier, a node texture weight, a node range, and data of the triangular facets contained within the node; the node identifier contains the node's level and position information in the HLOD tree. The method according to claim 2, characterized in that the texture weight W of the triangular facet f Calculate using the following formula: ； ； Where Area represents the texture coordinate area of ​​the triangle, and width and height represent the width and height of the texture image corresponding to the triangle. The preset texture weights are defined by v0, v1, and v2, which are the three vertices of the triangle facet, and u and v are the texture coordinates corresponding to the vertices.

3. The method according to claim 1, characterized in that, Apply Gaussian filtering to the image of the previous texture layer using the following formula: ； Among them, G k This represents the image of the previous texture layer; It is a two-dimensional Gaussian kernel; The filtered image is downsampled using the following formula: ； Where S is the scaling factor; the relationship between adjacent texture layers is as follows: ； ； in, , The width and height of the previous texture layer. , This represents the width and height of the current texture layer.

4. The method according to claim 1, characterized in that, The process of simplifying and merging triangular faces in each node of each layer in the HLOD tree, following the top-down order, includes: Perform the following simplified merge operation for each node: Calculate the folding cost for each edge in the node; Insert the folding cost of all edges into a priority queue; The following operations are performed repeatedly until the number of triangles in the node is equal to or less than the maximum number of triangles: take the edge with the minimum folding cost from the priority queue; fold the two vertices of the taken edge into a new vertex; update the folding cost of the edge connected to the new vertex, and update the priority queue based on the updated folding cost; Pass the simplified and merged data from this node to the parent node; The cost of edge folding is a weighted sum of geometric error and texture error. Texture error is determined by the change between the texture gradient of each triangle facet connected to the vertex of the edge to be folded before simplification and the texture gradient of the triangle facet connected to the corresponding vertex after folding after simplification. Among them, the geometric coordinates and texture coordinates of the new vertices are optimized with the goal of minimizing the folding cost of the edges; Specifically, for edges that belong to boundaries or texture seams, the corresponding folding cost is set to a maximum value.

5. The method according to claim 1, characterized in that, Extracting the texture features corresponding to the node from the image of the texture layer corresponding to the texture pyramid includes: Divide the triangular facets in this node into multiple non-connected component regions; For each component region, traverse the vertices in that component region, and determine the minimum bounding box of the texture corresponding to the component region based on the texture coordinates of the vertex in the texture layer of the texture pyramid; determine the texture rectangle region corresponding to the component region based on the texture coordinates of the minimum point and the maximum point in the minimum bounding box, and the width and height of the image of the texture layer corresponding to the node in the texture pyramid. The data within the texture rectangle corresponding to all component regions in the texture layer is used as the texture feature corresponding to that node. The step of packaging the extracted texture features into a texture image includes: The MaxRects algorithm is used to pack the texture features corresponding to each component region into a single texture image. The vertex texture coordinates of the packed triangle are calculated according to the following formula: ； ； in, , The width and height of the packaged texture image. , The texture coordinates of the vertices of the triangular facet in the texture layer. , The texture coordinates of the vertices of the triangular facet in the texture image.

6. The method according to claim 6, characterized in that, The process of exporting the HLOD tree filled with texture data to the 3DTiles standard format includes: Starting from the root node, the HLOD tree is traversed using a breadth-first traversal method. The data corresponding to each node is saved as a gltf file, and the file name is based on the position of the corresponding node in the HLOD tree. The nested structure of the HLOD tree is used to generate an entry file tilesset.json in the standard format of 3D Tiles; wherein the nested structure of the HLOD tree includes the necessary fields corresponding to each node; the necessary fields include the minimum bounding box information of the node, the file name of the node, refine, and the texture error information of the node; The texture error information of the node is calculated using the following formula: ； Let be the length of the i-th edge within the node. The length of the texture coordinates corresponding to the i-th edge. is the width of the texture layer image corresponding to the node, and n is the number of inner edges of the node.

7. The method according to claim 7, characterized in that, Also includes: Starting from the root node of the HLOD tree filled with texture data, perform node traversal and calculate the screen space error of the current node. If the screen space error is greater than the maximum screen space error threshold, the data corresponding to the next level node of the current node needs to be displayed; otherwise, the data corresponding to the current node is displayed. The screen space error (SSE) of a node is calculated using the following formula: SSE = (geometricError × screenHeight) / (2 × distance × tan(fov / 2)) geometricErro is the geometric error of the node, screenHeight is the height of the current display screen, distance is the distance from the viewpoint to the node, and fov is the vertical field of view angle.

8. The method according to claim 1, characterized in that, The generation of the textured triangular mesh model includes: Acquire multiple images with a preset overlap; An initial triangular mesh model is constructed using the multiple images; Texture extraction is performed on the multiple images, and the extracted texture is mapped onto the initial triangular mesh model to obtain the textured triangular mesh model.

9. A LOD (Level of Detail) construction device for large-scale real-world models in GIS, characterized in that, include: A model generation module is used to generate a textured triangular mesh model; the triangular mesh model includes multiple triangular facets. The HLOD construction module is used to determine the bounding box information of the root node based on the GIS information of the triangular mesh model, and to traverse the triangular facets and determine the leaf node of each triangular facet in the HLOD tree according to the preset maximum number of triangles and maximum texture weight; wherein, the data of the triangular facets in the nodes of the HLOD tree are stored in a temporary file using memory mapping. The texture construction module is used to determine the number of layers in the texture pyramid based on the number of layers in the HLOD tree; initialize the 0th texture layer of the texture pyramid as the original image corresponding to the triangular mesh model; generate the Nth texture layer of the texture pyramid in ascending order according to the following steps: apply Gaussian filtering to the image of the previous texture layer; downsample the Gaussian-filtered image to obtain the image of the current texture layer; until the resolution of the current texture layer image is less than a preset threshold or the value of N is greater than a preset value, the constructed texture pyramid is obtained; where N is a positive integer, and the image set of the texture pyramid is stored in a temporary file using memory mapping technology; The node simplification module is used to simplify and merge the triangular faces in each node of each layer in the order from bottom to top of the HLOD tree. The texture merging module is used to extract the texture features corresponding to each node from the texture layer image corresponding to the texture pyramid for each simplified and merged node, pack the extracted texture features into a texture image, and establish an association between the texture image and the node; until all nodes have established an association with the corresponding texture image, an HLOD tree filled with texture data is obtained; The model export module is used to export HLOD trees filled with texture data to the standard 3D Tiles format.

Images