3D map performance optimization method based on custom geometric figure one-sided structure

Abstract

The invention provides a 3D map performance optimization method based on a custom geometric figure one-sided structure, and the method comprises the steps: carrying out the one-sided structure disassembly of a three-dimensional model, injecting the field information of color, transparency, layer number and the like for each one-sided structure, and constructing a structured vertex and an index buffer object; performing spatial rearrangement on the structure through Morton coding; rewriting the WebGL shader logic to support the differentiated rendering of the field drive; combining the one-sided surfaces into a unified geometry to bind a single material, and completing multi-layer rendering through one-time drawing and calling; in combination with view angle scheduling and an LOD mechanism, dynamic loading and unloading of the visual blocks are realized, the GPU rendering efficiency is improved, and the drawing calling number is reduced.

Description

Technical Field

[0001] The present invention relates to the field of computer graphics processing technology, and in particular to a 3D map performance optimization method based on a custom geometric graphic facet structure. Background Art

[0002] With the widespread adoption of 3D mapping and visualization applications, particularly in campus navigation, architectural visualization, and digital twin systems, users are placing higher demands on the accuracy and real-time performance of indoor 3D maps. Indoor 3D maps must simultaneously present multiple floors, tens of thousands of rooms, and complex graphic objects, posing a severe challenge to the performance of graphics rendering systems.

[0003] Among existing optimization methods, a common approach is to reduce the number of rendering calls by merging multiple geometries into a single object. However, this approach assumes that the merged geometries have the same color and material, which is often not true in real-world applications. Different primitives in 3D maps often need to exhibit different colors, transparencies, or other material characteristics. Therefore, traditional geometry merging strategies are limited in effectiveness or even inapplicable in such scenarios. This results in increased GPU calls during graphics rendering, page lag, and a poor user experience.

[0004] Therefore, a 3D map performance optimization method based on custom geometric facet structure is proposed. Summary of the Invention

[0005] In view of this, the present invention provides a 3D map performance optimization method based on a custom geometric figure facet structure to solve or alleviate the technical problems existing in the prior art and at least provide a beneficial option.

[0006] The technical solution of the present invention is implemented as follows: a 3D map performance optimization method based on a custom geometric figure facet structure comprises the following steps:

[0007] S1. Obtain a set of three-dimensional geometric bodies of one or more floors in a three-dimensional map, and decompose each geometric body into a plurality of facet structures, wherein the facet structures include triangular faces, quadrilateral faces, or polygonal faces;

[0008] S2. Bind custom graphics to the color vector, transparency parameter, layer index, and material category of each facet structure field, and inject the fields into the vertex data structure in the GPU memory as vertex attributes;

[0009] S3. Construct a vertex buffer object (VBO) and an index buffer object (EBO) to store all facet structures and their field information, and rearrange the facet structures using a spatial sorting function to optimize the cache hit rate.

[0010] S4. Build a WebGL shader that adapts to the field, rewrite the vertex and fragment shaders, read the facet structure fields during rendering, and implement visual differentiation.

[0011] S5. Merge all processed facet structures into one or more geometric objects, bind the materials uniformly, and complete GPU rendering through a single draw call;

[0012] S6. Perform frustum cropping and floor scheduling based on the user's perspective to achieve high-performance dynamic rendering of 3D maps.

[0013] Further preferably, in step S2, the color vector is a four-dimensional floating point vector [R, G, B, A], where A represents transparency and has a range of [0, 1], and is written into the VBO using 32-bit floating point format encoding.

[0014] Further preferably, in step S4, the WebGL shader is implemented in GLSL language, and the vertex shader reads the color value C from each vertex field. v = [R, G, B, A] and passed to the fragment shader, which uses the following pixel calculation formula:

[0015] F fr =UC×C v .rgb×C v .a

[0016] Among them, F fr Represents the final pixel color value fragment color output by the fragment shader, that is, the color presented on the screen;

[0017] UC represents the base color vector set in the geometry's unified material;

[0018] C v .rgb represents the RGB part of the custom color vector injected into the vertex field in the current facet structure, that is, the real color attribute of the facet;

[0019] C v .a represents the transparency parameter injected into the vertex field of the current facet structure, ranging from [0,1], which is used to control the opacity of the facet in the overall rendering.

[0020] Further preferably, in step S3, the VBO includes the following field order: vertex coordinates, normal vectors, texture coordinates, color vectors, transparency, material ID and layer number, and the EBO sorts the facet structure by spatial Hilbert coding or Morton coding to match the spatial locality of the GPU cache.

[0021] Further preferably, in step S3, the one-sided structure is sorted using Morton coding, and the sorting index M(i) is calculated as follows:

[0022] M(i)=ins(x i ,y i ,z i )

[0023] Among them, x i ,y i ,z i Represents the spatial coordinates of the center point of the i-th facet;

[0024] ins means bit-interleaved three-axis coordinate xyz low-bit first encoding.

[0025] Further preferably, in step S6, the scheduling includes a loading strategy based on visibility and priority:

[0026] (1) Determine whether the merged geometry corresponding to the floor to be rendered is within the viewing cone of the current user's perspective. The viewing cone visibility function V(L i ) is expressed as:

[0027]

[0028] Among them, L i Indicates the floor number;

[0029] PVB i Indicates floor L i The corresponding bounding box of the merged geometry;

[0030] Frustum represents the frustum space under the current user's perspective;

[0031] (2) For the case where V(L i )=1, the loading priority is calculated by the following function:

[0032]

[0033] Among them, te(L i ) indicates floor L i The time interval since the last view was accessed by the user;

[0034] d(L i ) indicates floor L i The distance from the center point to the user's viewing point;

[0035] Based on the priority sorting results, the floors in the current view are loaded in order from high to low. When the GPU memory or the number of draw calls reaches the upper threshold, the lowest priority floor is automatically removed and the floor to be loaded is loaded.

[0036] Further preferably, in step S6, the merged geometry is matched with a geometry version of a corresponding accuracy level according to the spatial distance d from the user's viewpoint before loading, and three-level LOD switching is adopted, which is determined as follows:

[0037] LOD(d)={Full Detail,d<

[0038] Where d represents the three-dimensional distance from the geometric center of the floor to the user's viewing point;

[0039] d1 represents the close-range detail threshold; d2 represents the long-range contour loading threshold;

[0040] The fields included in each LOD level are gradually reduced. Full Detail includes all fields, Simplified removes some material information fields, and Bounding Volume only retains the outline volume.

[0041] Further preferably, in steps S1 to S5, the method divides the floors or spatial areas into task units {T1, T2, ..., Tn}, executes one-sided structure extraction, field injection, sorting and merge cache construction in parallel, and the main thread integrates the geometry uniformly on the GPU side.

[0042] Further preferably, in step S5, when any field changes, the corresponding one-sided structure is located through the maintained change identification list, its Morton encoding is recalculated and the corresponding segments in VBO and EBO are updated, and then the GPU local redraw operation is triggered to refresh only the target area.

[0043] The embodiment of the present invention adopts the above technical solution, which has the following advantages:

[0044] 1. The present invention adopts a one-sided structure + field injection approach, allowing each primitive to maintain its independent visual properties while being unified and merged. By uniformly passing fields into the GPU and dynamically parsing them in the shader, the rendering of a large number of different layers and different color fragments is completed in a single drawing process. This not only avoids the splitting of geometry by material, but also greatly reduces the number of draw calls, improving the problems of graphics stuttering and response lag.

[0045] 2. The present invention optimizes the layout of one-sided structures through spatial sorting and Morton coding, improves GPU cache access efficiency, and combines perspective-driven scheduling strategies with LOD switching to achieve on-demand loading and hierarchical rendering control of different floors or spatial areas, enabling the system to adjust the loaded content and rendering granularity in real time according to the user's perspective, thereby improving GPU rendering efficiency and reducing the number of draw calls.

[0046] The above summary is for illustrative purposes only and is not intended to be limiting in any way. In addition to the illustrative aspects, embodiments and features described above, further aspects, embodiments and features of the present invention will be readily apparent by reference to the accompanying drawings and the following detailed description. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0048] Figure 1 Rendering flow chart of the three-dimensional map rendering optimization method of the present invention;

[0049] Figure 2 It is a spatial position mapping and sorting logic diagram based on Morton coding;

[0050] Figure 3 Logic diagram for LOD switching based on view distance. DETAILED DESCRIPTION

[0051] Hereinafter, only certain exemplary embodiments are briefly described. As will be appreciated by those skilled in the art, the described embodiments may be modified in various ways without departing from the spirit or scope of the present invention. Therefore, the drawings and description are to be considered as illustrative in nature and not restrictive.

[0052] The embodiments of the present invention are described in detail below with reference to the accompanying drawings.

[0053] like Figure 1-3 As shown, this embodiment provides a 3D map performance optimization method based on a custom geometric graphic one-sided structure, which is suitable for complex indoor maps, campus-level building models or multi-layer structured three-dimensional data scenes. During the graphics rendering process, while ensuring diversified visual expression capabilities, the number of GPU drawing calls is minimized to the greatest extent, thereby improving the overall rendering performance and user interaction response speed.

[0054] This implementation process consists of six steps: S1-partial structure construction, S2-field injection and video memory writing, S3-spatial sorting and structure optimization, S4-shader design and rendering adaptation, S5-merged rendering and local update, and S6-view-driven scheduling loading.

[0055] S1-facet structure construction. During the initialization phase of the 3D map system, 3D geometric data representing the building model needs to be loaded from the data source. The data can come from BIM modeling results, laser point cloud scanning reconstruction models, or 3D voxel structures converted from CAD floor plans. The initial model is structurally divided by floors, functional areas, or building partitions. Each unit space structure contains several 3D Mesh objects. This step converts the original object-oriented Mesh organization method into a finer-grained "facet structure" representation. The facet structure is the smallest renderable unit in the 3D model, usually a triangle or quadrilateral. For polygonal facets, the Delaunay triangulation algorithm will first be used to convert them into multiple triangles to unify the data structure.

[0056] During execution, the Mesh objects are traversed one by one and each object is processed as follows:

[0057] Extract its vertex array and index array, and identify the vertex index and geometric properties of each face. Then generate an independent face object for each face. The object contains information such as vertex coordinates, normal vector, face center point, original model ID, and floor ID. Each face structure will additionally record its bounding box and center of gravity coordinates in the world coordinate system.

[0058] S2 - Field injection and memory writing. After completing the construction of the S1 one-sided structure, the field injection phase begins. Various visual, semantic, and structural attribute fields are attached to the one-sided structure data and finally written synchronously to the GPU memory as information for subsequent rendering. Field injection includes the following types of information:

[0059] The color field [R, G, B, A] defines the basic color and transparency of the patch in the form of a four-dimensional floating-point vector, where the transparency A is between [0, 1];

[0060] Layer number LayerId, which identifies the building level, structural semantics or map logical partition to which the face belongs;

[0061] Material identifier MaterialId, which represents the material number or logical channel used by the surface, and implements material logic branch control in Shader;

[0062] Pickup identifier FeatureId, used to distinguish each independent selectable element when supporting interactive operations;

[0063] After the injection is completed, the vertex buffer object VBO and index buffer object EBO that can be recognized by the GPU are constructed. All fields will be arranged in a structured order: Position→Normal→Color→Alpha→MaterialId→LayerId→FeatureId, and a unified TypedArray structure will be constructed. Non-position fields are stored in a compressed manner.

[0064] The entire dataset will be written in batches on the GPU side by floor or function, and a field offset mapping relationship will be established through the cache manager to ensure that the shader can read the corresponding content by field index. After the video memory is written, the one-sided structure can enter the spatial sorting and structured cache optimization stage. This step realizes the effective conversion from semantic information to graphics rendering parameters.

[0065] S3-spatial sorting and structure optimization, after completing the field injection of the facet structure and the preparation of the video memory data, Morton coding is used to re-sort all facet structures according to their spatial distribution, and the arrangement order in the vertex buffer object VBO and the index buffer object EBO is updated synchronously. The coordinate value (x i ,y i ,z i ), and quantize the floating-point coordinates into fixed-precision integer values ​​to meet the bit operation requirements, and use the bit interleaving algorithm to encode the triplet coordinates into a single Morton code:

[0066] M(i)=ins(x i ,y i ,z i )

[0067] Through this encoding, close structures in three-dimensional space are mapped to adjacent encoding values ​​in one-dimensional space. After sorting, one-sided structures with similar positions will be arranged in a continuous address space in the GPU video memory, improving the cache hit rate during rendering. After the sorting is completed, all one-sided structures are renumbered according to the Morton value, and the VBO and EBO data buffers are rewritten. During the reordering process, the vertex attributes and index data will be moved synchronously as a whole to ensure the continuity of each structural unit in the graphics pipeline.

[0068] S4-Shader design and rendering adaptation. In the vertex shader, declare the fields in each vertex data structure as attribute variables and pass them to the fragment shader;

[0069] In the fragment shader stage, the received field values ​​are used for final color calculation, using the following blending formula: fr =UC×C v .rgb×Cv .a, for semi-transparent rendering and occlusion control, where UC represents the basic color vector set in the unified material of the geometry; C v .rgb represents the RGB part of the custom color vector injected into the vertex field in the current facet structure, that is, the real color attribute of the facet; C v .a represents the transparency parameter injected into the vertex field of the current facet structure, in the range [0,1], which is used to control the opacity of the facet in the overall rendering. It achieves the maximum color difference expression with the minimum number of materials, thus avoiding the problem of multiplication of draw calls caused by frequent color or material changes in traditional solutions.

[0070] S5-Merge rendering and local update. After field injection, spatial sorting and shader adaptation, all facet structures have a unified cache format, distinguishable field information and compatible shading pipeline. This step batch merges multiple pre-processed facet structures into a small number of large geometric objects, uniformly binds a single material and submits them to GPU rendering execution through a single draw call. During the merging process, "merge blocks" are first established based on floors or spatial partitions. All facet structures in each merge block share the same VBO / EBO buffer, use a unified shader program and basic material, and the generation of merge blocks makes the facet structures in each block highly spatially aggregated and logically consistent, which facilitates subsequent frustum clipping and LOD management.

[0071] By building a large-scale vertex cache and reconstructing the global index cache, unified mapping of multi-faceted structures is achieved. In the WebGL environment, this process is manifested as constructing a single BufferGeometry object and using custom attributes fields to carry injected parameters such as color, transparency, and material number. Each merged object is encapsulated as a drawing unit that can be called once by the GPU and can be directly added to the rendering queue in the scene.

[0072] In addition, this step uses "local update" to track the field status change mark of each fragment structure, mark it as the area to be updated, locate the corresponding VBO segment according to the mark, and only update the vertex data and index data areas involved in the change. After the update is completed, the GPU sub-area refresh is triggered by the local shader redraw call, which is completed through the low-cost WebGL API interface bindBufferSubData, achieving a responsive change effect without affecting the drawing status of other areas.

[0073] In steps S1 to S5, the method divides the floor or space area into task units {T1, T2, ..., Tn}, performs facet structure extraction, field injection, sorting and merge cache construction in parallel, and the main thread integrates the geometry on the GPU side.

[0074] S6-View-driven scheduled loading. After completing the construction and local update deployment of the merged rendering object, this embodiment uses a view-driven loading and unloading strategy to perform visibility judgment, priority scoring, and LOD accuracy matching on the constructed merged geometry based on the user's current view and frustum space, achieving targeted loading and progressive unloading, thereby achieving the goal of real-time performance optimization;

[0075] By monitoring the user's camera's viewing angle matrix and projection cone in real time, visibility detection is performed on each merged block. This process is done by determining the merged block bounding box PVB. i The intersection relationship with the current Frustum is realized, and its visibility function can be expressed as

[0076]

[0077] If it is determined that the object V(L i ), the system continues to calculate the priority score of the floor block. The priority calculation function integrates the user's most recent visit time to the floor and the three-dimensional distance between the viewing point and the floor. The calculation formula is as follows:

[0078]

[0079] Among them, te(L i ) indicates floor L i The time interval since the last user view access; d(L i ) indicates floor L i The distance from the center point to the user's viewing point ensures that floors that are frequently browsed by users and are close to the user are loaded first, while floors that are far away and have not been visited for a long time are loaded later or unloaded;

[0080] By setting the video memory usage threshold and the draw call limit, when the set value is exceeded, the low-priority floor will be automatically removed from the video memory queue according to the above priority function, and a new high-priority floor will be loaded. All loading / unloading processes are completed through the buffer pool management mechanism and unified asynchronous scheduling thread to ensure that the main thread rendering process is not blocked.

[0081] Furthermore, to control the drawing load of distant objects, different precision versions of the geometry are selected for loading based on the spatial distance d between the merged block and the viewpoint through LOD:

[0082]

[0083] Full Detail contains all fields and is suitable for close-range observation; Simplified removes some materials and semantic fields and is suitable for medium distances; Bounding Volume only contains the bounding box structure and is used for fast drawing judgment and placeholder in the distant view. The LOD switching logic prepares various versions of objects in advance through a pre-caching mechanism and can quickly replace reference pointers on the GPU to adjust rendering accuracy.

[0084] This embodiment builds a high-performance rendering optimization solution for 3D GIS application scenarios by meticulously deconstructing the structural hierarchy of 3D map data, injecting graphic fields, optimizing graphics memory structures, reconstructing rendering channels, and designing a full process for scheduling logic control. Compared with traditional methods, this method shifts from "object-centric" to "facet-centric" logic at the data granularity level, significantly improving rendering control accuracy and merging capabilities.

[0085] First, during the structure construction phase, the original model data is partially decomposed and standardized with unified field specifications to ensure that each minimum rendering unit has independent expression capabilities. In actual deployment, the extraction, field injection, and sorting of the partial structure can be executed in parallel. Task units are divided by floor or space blocks, and multi-threading or GPU computing resources are used to accelerate the processing process and improve initialization performance.

[0086] Second, during the GPU data layout and sorting phase, Morton encoding is used to maintain spatial order, effectively improving cache access hit rates. Combined with field compression and structure alignment optimization, this reduces video memory usage and improves rendering throughput.

[0087] Third, in the shader compilation logic, flexible coloring of unified materials and custom fields is implemented, so that different faces within the same geometry can still express personalized color, layer transparency, material changes and other visual effects without splitting the drawing objects, reducing the frequency of draw calls;

[0088] Fourth, by merging a large number of facets into a unified geometry and combining it with local field updates, we ensure real-time feedback in dynamic interactive scenarios and avoid the performance waste of repeated construction of the entire structure.

[0089] Fifth, through cone clipping and space-time joint priority scoring, adaptive loading / unloading with viewing angle is achieved, and LOD multi-level precision control is combined.

[0090] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any person skilled in the art can easily conceive of various modifications and substitutions within the technical scope disclosed in the present invention, and such modifications and substitutions are intended to be within the scope of protection of the present invention. Therefore, the scope of protection of the present invention shall be subject to the scope of protection of the claims.

Claims

1. A 3D map performance optimization method based on a custom geometric facet structure, characterized by: The following steps are involved: S1. Obtain a set of three-dimensional geometric bodies of one or more floors in a three-dimensional map, and decompose each geometric body into a plurality of facet structures, wherein the facet structures include triangular faces, quadrilateral faces, or polygonal faces; S2. Bind custom graphics to the color vector, transparency parameter, layer index, and material category of each facet structure field, and inject the fields into the vertex data structure in the GPU memory as vertex attributes; S3. Construct a vertex buffer object (VBO) and an index buffer object (EBO) to store all facet structures and their field information, and rearrange the facet structures using a spatial sorting function to optimize the cache hit rate. S4. Build a WebGL shader that adapts to the field, rewrite the vertex and fragment shaders, read the facet structure fields during rendering, and implement visual differentiation. S5. Merge all processed facet structures into one or more geometric objects, bind the materials uniformly, and complete GPU rendering through a single draw call; S6. Perform frustum cropping and floor scheduling based on the user's perspective to achieve high-performance dynamic rendering of 3D maps.

2. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 1, characterized in that: In step S2, the color vector is a four-dimensional floating point vector [R, G, B, A], where A represents transparency and has a range of [0, 1], and is written into the VBO using 32-bit floating point format encoding.

3. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 1, characterized in that: In step S4, the WebGL shader is implemented in GLSL language, and the vertex shader reads the color value C from each vertex field. v = [R, G, B, A] and passed to the fragment shader, which uses the following pixel calculation formula: F fr =UC×C v .rgb×C v .a Among them, F fr Represents the final pixel color value fragment color output by the fragment shader, that is, the color presented on the screen; UC represents the base color vector set in the geometry's unified material; G v .rgb represents the RGB part of the custom color vector injected into the vertex field in the current facet structure, that is, the real color attribute of the facet; C v .a represents the transparency parameter injected into the vertex field of the current facet structure, ranging from [0,1], which is used to control the opacity of the facet in the overall rendering.

4. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 1, characterized in that: In step S3, the VBO includes the following field order: vertex coordinates, normal vectors, texture coordinates, color vectors, transparency, material ID and layer number, and the EBO sorts the facet structure by spatial Hilbert coding or Morton coding to match the spatial locality of the GPU cache.

5. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 1, characterized in that: In step S3, the one-sided structure is sorted using Morton coding, and the sorting index M(i) is calculated as follows: M(i)=ins(x i ,y i ,z i ) Among them, x i ,y i ,z i Represents the spatial coordinates of the center point of the i-th facet; ins means bit-interleaved three-axis coordinate xyz low-bit first encoding.

6. The 3D map performance optimization method based on a custom geometric facet structure according to claim 1, characterized in that: In step S6, the scheduling includes a loading strategy based on visibility and priority: (1) Determine whether the merged geometry corresponding to the floor to be rendered is within the viewing cone of the current user's perspective. The viewing cone visibility function V(L i ) is expressed as: Among them, L i Indicates the floor number; PVB i Indicates floor L i The corresponding bounding box of the merged geometry; Frustum represents the frustum space under the current user's perspective; (2) For the case where V(L i )=1, the loading priority is calculated by the following function: Among them, te(L i ) indicates floor L i The time interval since the last view was accessed by the user; d(L i ) indicates floor L i The distance from the center point to the user's viewing point; Based on the priority sorting results, the floors in the current view are loaded in order from high to low. When the GPU memory or the number of draw calls reaches the upper threshold, the lowest priority floor is automatically removed and the floor to be loaded is loaded.

7. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 6, characterized in that: In step S6, the merged geometry is matched with the geometry version of the corresponding accuracy level according to the spatial distance d from the user's viewpoint before loading, and three-level LOD switching is adopted. The judgment is as follows: Where d represents the three-dimensional distance from the geometric center of the floor to the user's viewing point; d1 represents the close-range detail threshold; d2 represents the long-range contour loading threshold; The fields included in each LOD level gradually decrease. Full Detail includes all fields, Simplified removes some material information fields, and Bounding Volume only retains the outline volume.

8. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 7, characterized in that: In steps S1 to S5, the method divides the floor or space area into task units {T1, T2, ..., Tn}, performs facet structure extraction, field injection, sorting and merge cache construction in parallel, and the main thread integrates the geometry on the GPU side.

9. The 3D map performance optimization method based on a custom geometric figure facet structure according to claim 8, characterized in that: In step S5, when any field changes, the corresponding one-sided structure is located through the maintained change identification list, its Morton code is recalculated and the corresponding segments in VBO and EBO are updated, and then the GPU local redraw operation is triggered to refresh only the target area.

Images