Method and device for fast loading of real scene three-dimensional model based on multi-level optimization strategy

Abstract

The application relates to the technical field of three-dimensional visualization, and provides a real-scene three-dimensional model rapid loading method and device based on a multistage optimization strategy. Through preprocessing, a lightweight model data is output from a three-dimensional model of oblique photography, so that the model data scale is greatly reduced; through root node merging, data reorganization and space index construction, the number of node traversals and the number of data requests are reduced, and the data organization efficiency and scene loading performance are improved; through visual field analysis and tile preloading mechanism, model tiles are loaded in a demand-oriented and pre-judgment manner, and the loading and rendering overhead of massive invalid model data is avoided; meanwhile, in combination with a dynamic cache pool priority scheduling mechanism, the rendering calculation pressure is effectively relieved; and through a near-far scene differentiation rendering control strategy, hierarchical rendering regulation and control are realized on different levels of models, near-scene guaranteeing high-precision display effect of the models, far-scene minimizing hardware computing power consumption, and the overall scene frame rate and interactive fluency being improved.

Description

Technical Field

[0001] This application relates to the field of 3D visualization technology, and in particular to a method and apparatus for rapidly loading real-scene 3D models based on a multi-level optimization strategy. Background Technology

[0002] Oblique photogrammetry 3D models, due to their high scene fidelity and realism, have been widely used in fields such as digital twins and smart cities. However, with the increasing demands for scene simulation and visualization precision, the volume of 3D model data has surged dramatically, leading to the following common problems: First, high-precision models contain massive amounts of vertex, facet, and texture data, resulting in slow network transmission and long browser loading times, severely impacting system access and user experience. Second, loading massive, detailed models on the Cesium platform significantly increases rendering computational overhead, easily causing frame rate drops, stuttering, and interactive delays, resulting in poor scene rendering stability. Third, model rendering places high demands on hardware resources such as CPU, graphics card, and memory, making it difficult for low-spec terminals and lightweight devices to adapt, easily leading to loading anomalies and stuttering, thus limiting terminal compatibility.

[0003] Existing single-point technologies, including model compression, static LOD optimization, texture compression, and 3D Tiles slicing, can only alleviate some performance issues at a single stage. These fragmented optimization solutions lack a collaborative optimization mechanism across the entire process, encompassing model preprocessing, data organization, intelligent scheduling, and rendering control. Their optimization ceiling is low, failing to balance model fidelity, loading efficiency, rendering performance, and cross-platform compatibility, making it difficult to meet the high-performance requirements of massive, high-precision, real-world 3D digital twin scenes. Summary of the Invention

[0004] Therefore, it is necessary to provide a method and apparatus for rapid loading of real-scene 3D models based on a multi-level optimization strategy to address the aforementioned technical problems.

[0005] A method for rapidly loading real-world 3D models based on a multi-level optimization strategy, the method comprising: The original oblique photogrammetry 3D model is acquired and preprocessed to output lightweight model data. Read the lightweight model data, analyze the model node hierarchy, merge the root nodes, reorganize the vertex, face, and texture data, construct the spatial index structure, and generate the optimized dataset; The camera position and view parameters are acquired in real time. The tile loading strategy and currently visible tiles are determined through view area analysis. The area that may be accessed in the next moment is predicted, the target tiles are loaded in advance, and real-time rendering is completed. Build a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only the accessed resources with a priority greater than a preset threshold, and update the cache status. Based on the model node hierarchy and tile loading strategy, differentiated rendering control is performed on models of different levels to achieve high-precision display of near-views and low-overhead rendering of far-views.

[0006] In one embodiment, the original oblique photogrammetry 3D model is acquired and preprocessed to output lightweight model data, including: Obtain the original oblique photogrammetry 3D model; Identify and remove redundant data in the original oblique photogrammetry 3D model, including duplicate vertices and duplicate faces; Reduce the number of model faces using a mesh simplification algorithm; Compress the texture data; The processed oblique photogrammetry 3D model output data is converted into a data format suitable for 3D Tiles publishing.

[0007] In one embodiment, the number of model patches is reduced using a mesh simplification algorithm, including: S1. Construct the error matrix for each vertex in the current model; S2. Traverse the edges in the model, calculate the error value of each edge after performing the edge folding operation, select the edge with the smallest error value to fold, merge the two vertices into a new vertex, and synchronously update the mesh structure around the new vertex and the error matrix of the new vertex to obtain the updated model. S3. Determine whether the updated model meets the simplification rate requirement. If it does, complete the mesh simplification. If it does not, return to S1.

[0008] In one embodiment, lightweight model data is read, the model node hierarchy is analyzed, root nodes are merged, and vertex, face, and texture data are reorganized to construct a spatial index structure and generate an optimized dataset, including: Read lightweight model data, aggregate the model according to spatial regions, and merge the root nodes; The lightweight model data is spatially hierarchically organized using an octree. The hierarchy depth and node fan-out are dynamically adjusted based on the number of models contained in the nodes, geometric complexity, and spatial range to obtain an optimized hierarchical structure. The vertex, face, and texture data of the model are uniformly reorganized and optimized. Data with similar spatial locations are reorganized into a contiguous storage structure, and a spatial indexing system is established to generate an optimized dataset, thereby realizing hierarchical management and fast retrieval of model data.

[0009] In one embodiment, the spatial indexing system is established according to the following steps: Using the bounding box of the lightweight model data as the root node, the three-dimensional space is recursively divided using an octree. When the amount of model data in a node exceeds a threshold, the subdivision continues until the preset termination condition is met. A mapping relationship is established between model blocks and corresponding nodes to form a spatial index structure.

[0010] In one embodiment, a tile loading strategy and currently visible tiles are determined through view area analysis, and the area that may be accessed in the next moment is predicted, including: The view frustum, orientation, and occlusion relationship are calculated using camera parameters. Areas outside the view frustum are directly removed to obtain the visible field of view. Calculate screen space error based on distance, screen error, and user viewpoint, and dynamically load 3D tiles. Based on real-time acquisition of the user's current viewpoint, camera position, viewing direction, and spatial index structure information, a priority queue is established for the 3D tiles to be loaded, and they are then sorted according to the current field of view. Approaching the field of vision Requests for long-distance regions are scheduled sequentially. By analyzing camera movement, behavior trajectory, and perspective trends, and combining current location, movement speed, direction of movement, and historical browsing information, the system predicts the spatial area that may enter the user's field of vision in the next moment, and preloads the corresponding 3D tiles into the request queue in advance.

[0011] In one embodiment, a dynamic cache pool is constructed, the tile access frequency is recorded in the dynamic cache pool, the cache priority is calculated based on the tile access frequency, only accessed resources with a priority greater than a preset threshold are retained, and the cache status is updated, including: Build a dynamic cache pool and record the tile access frequency in the dynamic cache pool; The Least Recently Used (LRU) strategy is adopted. The cache priority is calculated based on the tile access frequency. Only accessed resources with a priority greater than a preset threshold are retained, accessed resources with a priority lower than the preset threshold are deleted, and the cache status is updated.

[0012] In one embodiment, a dynamic cache pool is constructed, the tile access frequency is recorded in the dynamic cache pool, the cache priority is calculated based on the tile access frequency, only access resources with a priority greater than a preset threshold are retained, and the cache status is updated, further including: A multi-threaded task pool is built using Web Workers for CPU scheduling. The main thread is only responsible for scene rendering, UI interaction and task scheduling, while each Worker is responsible for computationally intensive tasks. After each Worker completes its processing, it returns the results to the main thread for model building and display. GPU resources are dynamically allocated based on scene complexity, prioritizing the rendering of currently visible areas and promptly releasing resources in distant or invisible areas. Monitor GPU memory usage and dynamically manage resources based on user perspective and model visibility.

[0013] In one embodiment, based on the model node hierarchy and tile loading strategy, differentiated rendering control is performed on models at different levels to achieve high-precision display of near-views and low-overhead rendering of distant views, including: The model display accuracy requirement is evaluated in real time based on the distance between the camera and the model and the screen space error. When the model occupies a large portion of the screen and exceeds the preset high-precision judgment threshold, a high-precision LOD model is automatically loaded; when the model occupies a smaller portion of the screen and is less than the preset high-precision judgment threshold, it is switched to a low-precision LOD model. When the distance between the model and the camera is less than a preset close-up threshold, a high-precision LOD model is loaded, along with high-precision mesh and high-resolution texture data for rendering; when the distance between the model and the camera is greater than the preset close-up threshold, a low-precision LOD model is loaded, using simplified texture data.

[0014] A device for rapidly loading real-scene 3D models based on a multi-level optimization strategy, the device comprising: The lightweight module is used to acquire the original oblique photogrammetry 3D model and preprocess it to output lightweight model data from the oblique photogrammetry 3D model. The data reorganization module is used to read lightweight model data, analyze the hierarchical structure of model nodes, merge root nodes, reorganize vertex, face, and texture data, construct a spatial index structure, and generate an optimized dataset. The intelligent scheduling module is used to acquire camera position and viewing angle parameters in real time, determine the tile loading strategy and currently visible tiles through visual field analysis, predict the area that may be accessed in the next moment, load the target tiles in advance, and complete real-time rendering. The cache management module is used to build a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only the accessed resources with a priority greater than a preset threshold, and update the cache status. The multi-level rendering module is used to perform differentiated rendering control on models of different levels based on the model node hierarchy and tile loading strategy, so as to achieve high-precision display of near view and low-overhead rendering of far view.

[0015] The aforementioned method and apparatus for rapid loading of real-scene 3D models based on a multi-level optimization strategy, through preprocessing, enables the output of lightweight model data from oblique photogrammetry 3D models, thereby significantly reducing the model data size and effectively improving network transmission efficiency and model loading speed. Through root node merging, data reorganization, and spatial index construction, model vertex, face, and texture resources are uniformly organized, reducing node traversal times and data request counts, thus improving data organization efficiency and scene loading performance. Through viewpoint analysis and tile preloading mechanisms, model tiles are loaded on demand and predictively, avoiding the loading and rendering overhead of massive amounts of invalid model data. Simultaneously, combined with a dynamic cache pool priority scheduling mechanism, frequently accessed tile resources are accurately retained, and redundant cache data is cleaned up, effectively alleviating rendering computation pressure and ensuring the stability and smoothness of scene rendering. Furthermore, through a differentiated rendering control strategy for near and far views, hierarchical rendering control is achieved for different levels of models. Near views ensure high-precision model display effects, while far views minimize hardware computing power consumption, effectively reducing the dependence of model rendering on terminal hardware resources and improving overall scene frame rate and interactive smoothness. Attached Figure Description

[0016] Figure 1 This is a flowchart illustrating a method for rapidly loading a real-world 3D model based on a multi-level optimization strategy in one embodiment. Figure 2 This is a schematic diagram of the architecture of a method for rapidly loading real-world 3D models based on a multi-level optimization strategy in one embodiment; Figure 3 This is a comparison image showing the loading process after the real-scene 3D model is processed by a fast loading method based on a multi-level optimization strategy in one embodiment. Figure 4 This is a structural block diagram of a real-scene 3D model rapid loading device based on a multi-level optimization strategy in one embodiment. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0018] In one embodiment, refer to Figure 1 , Figure 2 As shown, a method for rapidly loading real-world 3D models based on a multi-level optimization strategy is provided. The method includes: Step 201: Obtain the original oblique photogrammetry 3D model and perform preprocessing to output lightweight model data from the oblique photogrammetry 3D model.

[0019] Step 202: Read the lightweight model data, analyze the model node hierarchy, merge the root nodes, reorganize the vertex, face, and texture data, construct the spatial index structure, and generate the optimized dataset.

[0020] Step 203: Obtain camera position and view parameters in real time, determine the tile loading strategy and currently visible tiles through view area analysis, predict the area that may be accessed in the next moment, load the target tiles in advance, and complete real-time rendering.

[0021] Step 204: Construct a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only access resources with a priority greater than a preset threshold, and update the cache status.

[0022] Step 205: Based on the model node hierarchy and tile loading strategy, perform differentiated rendering control on different levels of the model to achieve high-precision display of near-view and low-overhead rendering of far-view.

[0023] In the aforementioned method for rapid loading of real-scene 3D models based on multi-level optimization strategies, preprocessing enables the output of lightweight model data from oblique photogrammetry 3D models, thereby significantly reducing the model data size and effectively improving network transmission efficiency and model loading speed. Through root node merging, data reorganization, and spatial index construction, model vertices, faces, and texture resources are uniformly organized, reducing node traversal times and data request counts, thus improving data organization efficiency and scene loading performance. Through viewpoint analysis and tile preloading mechanisms, model tiles are loaded on demand and predictively, avoiding the loading and rendering overhead of massive amounts of invalid model data. Simultaneously, a dynamic cache pool priority scheduling mechanism accurately retains frequently accessed tile resources and cleans up redundant cache data, effectively alleviating rendering computation pressure and ensuring the stability and smoothness of scene rendering. Furthermore, through a differentiated rendering control strategy for near and far views, hierarchical rendering control is achieved for different levels of models. Near views ensure high-precision model display effects, while far views minimize hardware computing power consumption, effectively reducing the dependence of model rendering on terminal hardware resources and improving overall scene frame rate and interactive smoothness.

[0024] In one embodiment, the original oblique photogrammetry 3D model is acquired and preprocessed to output lightweight model data, including: Obtain the original oblique photogrammetry 3D model; Identify and remove redundant data in the original oblique photogrammetry 3D model, including duplicate vertices and duplicate faces; Reduce the number of model faces using a mesh simplification algorithm; Compress the texture data; The processed oblique photogrammetry 3D model output data is converted into a data format suitable for 3D Tiles publishing.

[0025] It should be noted that after the output data is converted to a data format suitable for 3D Tiles publishing, the converted data has the ability to be streamed and spatially indexed. Specifically, the conversion process involves converting OSGB to glTF and then to 3D Tiles.

[0026] Specifically, redundant data is identified and removed using techniques such as vertex blending, mesh cleanup, and hidden face removal. This redundant data includes duplicate vertices and duplicate faces, as well as isolated and hidden faces, thus achieving data removal. Textures are compressed and resampled to optimize the texture size from 4096×4096 to 2048×2048.

[0027] In this embodiment, the model data size is reduced by eliminating redundant data, simplifying the mesh, compressing the texture, and optimizing the format. This reduces storage space usage and improves network transmission efficiency and model loading speed while ensuring the model's visual effect and spatial accuracy.

[0028] In one embodiment, the number of model patches is reduced using a mesh simplification algorithm, including: S1. Construct the error matrix for each vertex in the current model; S2. Traverse the edges in the model, calculate the error value of each edge after performing the edge folding operation, select the edge with the smallest error value to fold, merge the two vertices into a new vertex, and synchronously update the mesh structure around the new vertex and the error matrix of the new vertex to obtain the updated model. S3. Determine whether the updated model meets the simplification rate requirement. If it does, complete the mesh simplification. If it does not, return to S1.

[0029] It should be noted that the error matrix for each vertex is used to record the geometric error caused by the vertex deviating from the original mesh surface.

[0030] In this embodiment, the number of triangles is reduced while maintaining the overall shape of the model through a mesh simplification algorithm, thereby effectively reducing the number of model faces and reducing storage space usage.

[0031] In one embodiment, lightweight model data is read, the model node hierarchy is analyzed, root nodes are merged, and vertex, face, and texture data are reorganized to construct a spatial index structure and generate an optimized dataset, including: Read lightweight model data, aggregate the model according to spatial regions, and merge the root nodes; The lightweight model data is spatially hierarchically organized using an octree. The hierarchy depth and node fan-out are dynamically adjusted based on the number of models contained in the nodes, geometric complexity, and spatial range to obtain an optimized hierarchical structure. The vertex, face, and texture data of the model are uniformly reorganized and optimized. Data with similar spatial locations are reorganized into a contiguous storage structure, and a spatial indexing system is established to generate an optimized dataset, thereby realizing hierarchical management and fast retrieval of model data.

[0032] The hierarchy depth and node fan-out are dynamically adjusted based on the number of models contained in a node, its geometric complexity, and its spatial range. Specifically, when the number of models in a node exceeds a preset threshold, its geometric complexity exceeds a preset threshold, or its spatial range exceeds a preset threshold, the current node is further subdivided, increasing the tree's hierarchy depth and dividing the models into multiple child nodes to reduce the data size of a single node. When the number of models in a node is less than a preset threshold, its geometric complexity is less than a preset threshold, and its spatial range is less than a preset threshold, further subdivision stops. If necessary, adjacent child nodes can be merged to reduce the tree's hierarchy depth and the number of empty nodes, avoiding the index overhead caused by an excessively deep tree structure, thereby forming a hierarchically balanced and spatially distributed octree structure.

[0033] It should be noted that for root node merging, methods such as Spatial-Merge and Batch-Merge can be used. When organizing lightweight model data spatially using an octree, further subdivision is carried out when the amount of data in a node is too large, and splitting stops when the amount of data is small. This avoids the tree structure becoming too deep, which would lead to a decrease in query efficiency, or the nodes becoming too large, which would result in coarse loading granularity.

[0034] Understandably, the optimized hierarchical structure enables fast spatial retrieval, LOD selection, and visibility pruning, reducing unnecessary traversals and data requests. The hierarchical structures before and after optimization are illustrated below:

[0035] In this embodiment, by uniformly reorganizing and optimizing the vertex, face, and texture data of the model and establishing a spatial indexing system, the locality of data and index query efficiency are improved, invalid data access is reduced, the model loading, visibility clipping, and LOD scheduling processes are accelerated, and the real-time rendering performance of large-scale 3D scenes is enhanced.

[0036] In one embodiment, the spatial indexing system is established according to the following steps: Using the bounding box of the lightweight model data as the root node, the three-dimensional space is recursively divided using an octree. When the amount of model data in a node exceeds a threshold, the subdivision continues until the preset termination condition is met. A mapping relationship is established between model blocks and corresponding nodes to form a spatial index structure.

[0037] It should be noted that the resulting spatial index structure enables fast querying, visibility pruning, and LOD scheduling.

[0038] In one embodiment, a tile loading strategy and currently visible tiles are determined through view area analysis, and the area that may be accessed in the next moment is predicted, including: The view frustum, orientation, and occlusion relationship are calculated using camera parameters. Areas outside the view frustum are directly removed to obtain the visible field of view. Calculate screen space error based on distance, screen error, and user viewpoint, and dynamically load 3D tiles. Based on real-time acquisition of the user's current viewpoint, camera position, viewing direction, and spatial index structure information, a priority queue is established for the 3D tiles to be loaded, and they are then sorted according to the current field of view. Approaching the field of vision Requests for long-distance regions are scheduled sequentially. By analyzing camera movement, behavior trajectory, and perspective trends, and combining current location, movement speed, direction of movement, and historical browsing information, the system predicts the spatial area that may enter the user's field of vision in the next moment, and preloads the corresponding 3D tiles into the request queue in advance.

[0039] It should be noted that the prediction of the spatial area that may enter the user's field of vision in the next moment is a comprehensive prediction based on the current position, movement speed, movement direction and historical browsing information. Specifically, it can be implemented using deep learning models (such as Transformer and diffusion models).

[0040] Understandably, compared to the traditional method of responsive loading based solely on the current view frustum, this embodiment, by fusing camera motion features with user browsing behavior, accurately predicts the area the user is about to visit, improves preloading hit rate, reduces invalid data requests and network transmission overhead, effectively reduces loading latency during rapid viewpoint switching, alleviates model loading blanks and LOD mutations, thereby improving the continuity and rendering smoothness of large-scale 3D scene browsing.

[0041] Specifically, regarding the order of request scheduling, tiles located within the user's current field of view and occupying more than a preset percentage of the screen are given the highest priority (i.e., the current field of view area) and network requests are initiated first. Based on the camera's movement direction, speed, and historical browsing trajectory, the area that the user may observe is predicted, and tiles that are about to enter the field of view are preloaded (i.e., the area that is about to enter the field of view area). For areas that are far away, not currently visible, and will not enter the field of view in a short time (i.e., distant areas), the request priority is reduced or loading is postponed.

[0042] In this embodiment, a priority queue of 3D tiles is established, based on the current field of view. Approaching the field of vision Requests to distant regions are scheduled sequentially, employing on-demand loading and hierarchical scheduling mechanisms. This avoids network congestion and resource contention caused by simultaneous requests for a large amount of invalid data, prioritizing the loading of currently relevant regions. This significantly shortens the initial screen loading time, reduces CPU, GPU, and memory usage, and improves cache hit rate and rendering frame rate.

[0043] In one embodiment, a dynamic cache pool is constructed, the tile access frequency is recorded in the dynamic cache pool, the cache priority is calculated based on the tile access frequency, only accessed resources with a priority greater than a preset threshold are retained, and the cache status is updated, including: Build a dynamic cache pool and record the tile access frequency in the dynamic cache pool; The Least Recently Used (LRU) strategy is adopted. The cache priority is calculated based on the tile access frequency. Only accessed resources with a priority greater than a preset threshold are retained, accessed resources with a priority lower than the preset threshold are deleted, and the cache status is updated.

[0044] Specifically, dynamic cache pools of Tile Cache, Texture Cache, and Geometry Cache are established. Tile Cache caches downloaded 3D Tiles data, avoiding repeated network requests and data parsing; Texture Cache caches texture resources, supports texture reuse, avoids repeated uploading to the GPU, and reduces GPU memory bandwidth consumption; Geometry Cache caches model vertex data, index data, and GPU buffer objects, reducing the overhead of repeated model parsing and buffer creation.

[0045] In this embodiment, by constructing a dynamic cache management mechanism, only access resources with a priority greater than a preset threshold are retained, while access resources with a priority lower than the preset threshold are deleted. This enables intelligent caching and on-demand release of loaded model resources, improving the cache hit rate and alleviating the rendering computation pressure on the Cesium platform. It effectively solves problems such as frame rate drop, screen stuttering, and interaction latency in large scenes.

[0046] In one embodiment, a dynamic cache pool is constructed, the tile access frequency is recorded in the dynamic cache pool, the cache priority is calculated based on the tile access frequency, only access resources with a priority greater than a preset threshold are retained, and the cache status is updated, further including: A multi-threaded task pool is built using Web Workers for CPU scheduling. The main thread is only responsible for scene rendering, UI interaction and task scheduling, while each Worker is responsible for computationally intensive tasks. After each Worker completes its processing, it returns the results to the main thread for model building and display. GPU resources are dynamically allocated based on scene complexity, prioritizing the rendering of currently visible areas and promptly releasing resources in distant or invisible areas. Monitor GPU memory usage and dynamically manage resources based on user perspective and model visibility.

[0047] Specifically, for CPU scheduling, a multi-threaded task pool is built using Web Workers. Computationally intensive tasks such as data parsing, network request management, and spatial index querying, which were originally concentrated in the browser's main thread, are separated into multiple background threads for execution. The main thread is only responsible for scene rendering, UI interaction, and task scheduling. After each worker completes its processing, it returns the results to the main thread for model building and display. Through the multi-threaded collaboration mechanism, the utilization rate of CPU resources is effectively improved, the risk of main thread blocking is reduced, the stuttering phenomenon during scene loading is reduced, and the efficiency of data processing and real-time rendering of large-scale 3D scenes is improved.

[0048] For GPU scheduling, based on WebGL and WebGPU technologies, model vertex data and texture data are uploaded to GPU memory, and the GPU performs rendering tasks such as vertex transformation, coordinate calculation, rasterization and texture mapping in parallel. GPU resources are dynamically allocated according to scene complexity, prioritizing the rendering of the currently visible area of ​​the model and releasing resources in distant or invisible areas in a timely manner, thereby reducing CPU load and improving rendering efficiency and scene display smoothness.

[0049] The system monitors GPU memory usage and dynamically manages resources based on user perspective and model visibility. Specifically, it prioritizes loading and uploading model textures and mesh data for the currently displayed area to GPU memory, while promptly releasing GPU memory resources for data that is far away, invisible, or has not been accessed for a long time. When the user's perspective changes, it loads new textures and mesh data as needed, avoiding the long-term retention of large amounts of resources in GPU memory. Through this dynamic upload and release mechanism, it effectively controls GPU memory usage, prevents memory overflow, and improves the rendering stability and operational efficiency of large-scale 3D scenes.

[0050] In one embodiment, based on the model node hierarchy and tile loading strategy, differentiated rendering control is performed on models at different levels to achieve high-precision display of near-views and low-overhead rendering of distant views, including: The model display accuracy requirement is evaluated in real time based on the distance between the camera and the model and the screen space error. When the model occupies a large portion of the screen and exceeds the preset high-precision judgment threshold, a high-precision LOD model is automatically loaded; when the model occupies a smaller portion of the screen and is less than the preset high-precision judgment threshold, it is switched to a low-precision LOD model. When the distance between the model and the camera is less than a preset close-up threshold, a high-precision LOD model is loaded, along with high-precision mesh and high-resolution texture data for rendering; when the distance between the model and the camera is greater than the preset close-up threshold, a low-precision LOD model is loaded, using simplified texture data.

[0051] In this embodiment, a differentiated rendering control strategy for near and far views is adopted to achieve hierarchical rendering control of models at different levels. Near views ensure high-precision display of the models, while far views minimize hardware computing power consumption, thereby improving the overall scene frame rate and interactive smoothness.

[0052] In one embodiment, the rendering priority is determined according to the following steps: Object priority rules are established based on object visibility, distance from the camera, screen projection area ratio, business importance, and interaction status. Priorities are then arranged according to these rules. First, it's determined whether the object is in a user interaction state; objects selected, queried, or currently being interacted with are assigned the highest priority. Second, it's determined whether the object belongs to a key building or critical facility; if so, it's assigned a higher basic priority. Next, it's determined whether the object is within the current field of view; objects within the field of view have higher priority than those outside. For objects within the field of view, further subdivision is made based on distance from the camera and screen projection area. When the object's distance is less than a preset distance threshold and its screen projection area ratio exceeds a preset ratio threshold, its LOD loading priority is increased. Finally, a rendering queue is established based on the arranged priorities, and models are loaded and rendered in priority order.

[0053] It should be noted that rendering follows the principles of prioritizing the current field of view, foreground objects, key objects, and interactive objects, and prioritizes the allocation of GPU resources.

[0054] Experimental verification was conducted to confirm the beneficial effects of the present invention.

[0055] The computer used in the experiment was a domestically produced Phytium D2000 (8-core) processor with a clock speed of 2.3GHz, 16GB of DDR4 memory, a 2GB dedicated graphics card, and a domestically produced operating system. The original model data was 776MB, which was reduced to 263MB after processing and weight reduction. (Reference...) Figure 3The method described in this invention allows for rapid and smooth loading and display on a computer. Before model lightweighting, loading took 1.28 seconds; after lightweighting, it took 0.42 seconds. The comparison before and after optimization shows that, under the same computer hardware configuration and network environment, the multi-level optimization strategy proposed in this invention significantly improves the loading efficiency and rendering performance of the realistic 3D model. Model lightweighting effectively reduces the model data size, decreasing network data transmission and browser parsing overhead. Data organization structure reconstruction optimizes the 3DTiles data hierarchy and spatial index structure, reducing the number of node traversals and data requests during model loading. Runtime intelligent scheduling, cache management, and a multi-level rendering collaborative optimization mechanism improve resource utilization efficiency and rendering scheduling capabilities.

[0056] Experimental results show that the system's initial loading time is significantly shortened, the response speed to model data requests is improved, and the system can dynamically load the required data according to the user's perspective during scene browsing, effectively reducing invalid loading and redundant calculations. During continuous roaming, scaling, and rotation of large-scale scenes, the scene frame rate remains stable, and the smoothness of the visuals is significantly improved, essentially eliminating problems such as model loading delays, screen stuttering, and discontinuous perspective switching.

[0057] It should be understood that, although Figure 1 The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order in which these steps are executed, and they can be performed in other orders. Figure 1 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0058] In one embodiment, such as Figure 4 As shown, a device for rapid loading of real-scene 3D models based on a multi-level optimization strategy is provided. The device includes: The lightweight module 901 is used to acquire the original oblique photogrammetry 3D model and perform preprocessing to output lightweight model data from the oblique photogrammetry 3D model.

[0059] The data reorganization module 902 is used to read lightweight model data, analyze the hierarchical structure of model nodes, merge root nodes, reorganize vertex, face, and texture data, construct a spatial index structure, and generate an optimized dataset.

[0060] The intelligent scheduling module 903 is used to acquire camera position and viewing angle parameters in real time, determine the tile loading strategy and currently visible tiles through visual field analysis, predict the area that may be accessed in the next moment, load the target tiles in advance, and complete real-time rendering.

[0061] The cache management module 904 is used to build a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only the accessed resources with a priority greater than a preset threshold, and update the cache status.

[0062] The multi-level rendering module 905 is used to perform differentiated rendering control on different levels of models based on the model node hierarchy and tile loading strategy, so as to achieve high-precision display of near view and low-overhead rendering of far view.

[0063] Specific limitations regarding the rapid loading device for real-scene 3D models based on multi-level optimization strategies can be found in the limitations of the rapid loading method for real-scene 3D models based on multi-level optimization strategies described above, and will not be repeated here. Each module in the aforementioned rapid loading device for real-scene 3D models based on multi-level optimization strategies can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device, or stored in the memory of a computer device as software, so that the processor can call and execute the corresponding operations of each module.

[0064] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0065] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of the invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A method for rapid loading of real-scene 3D models based on a multi-level optimization strategy, characterized in that, The method includes: The original oblique photogrammetry 3D model is acquired and preprocessed to output lightweight model data. Read the lightweight model data, analyze the model node hierarchy, merge the root nodes, reorganize the vertex, face, and texture data, construct the spatial index structure, and generate the optimized dataset; The camera position and view parameters are acquired in real time. The tile loading strategy and currently visible tiles are determined through view area analysis. The area that may be accessed in the next moment is predicted, the target tiles are loaded in advance, and real-time rendering is completed. Build a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only the accessed resources with a priority greater than a preset threshold, and update the cache status. Based on the model node hierarchy and tile loading strategy, differentiated rendering control is performed on models of different levels to achieve high-precision display of near-views and low-overhead rendering of far-views.

2. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 1, characterized in that, The original oblique photogrammetry 3D model is acquired and preprocessed to output lightweight model data, including: Obtain the original oblique photogrammetry 3D model; Identify and remove redundant data in the original oblique photogrammetry 3D model, including duplicate vertices and duplicate faces; Reduce the number of model faces using a mesh simplification algorithm; Compress the texture data; The processed oblique photogrammetry 3D model output data is converted into a data format suitable for 3D Tiles publishing.

3. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 2, characterized in that, The number of model faces is reduced through mesh simplification algorithms, including: S1. Construct the error matrix for each vertex in the current model; S2. Traverse the edges in the model, calculate the error value of each edge after performing the edge folding operation, select the edge with the smallest error value to fold, merge the two vertices into a new vertex, and synchronously update the mesh structure around the new vertex and the error matrix of the new vertex to obtain the updated model. S3. Determine whether the updated model meets the simplification rate requirement. If it does, complete the mesh simplification. If it does not, return to S1.

4. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 2, characterized in that, Read the lightweight model data, analyze the model node hierarchy, merge root nodes, reorganize vertex, face, and texture data, construct a spatial index structure, and generate an optimized dataset, including: Read lightweight model data, aggregate the model according to spatial regions, and merge the root nodes; The lightweight model data is spatially hierarchically organized using an octree. The hierarchy depth and node fan-out are dynamically adjusted based on the number of models contained in the nodes, geometric complexity, and spatial range to obtain an optimized hierarchical structure. The vertex, face, and texture data of the model are uniformly reorganized and optimized. Data with similar spatial locations are reorganized into a contiguous storage structure, and a spatial indexing system is established to generate an optimized dataset, thereby realizing hierarchical management and fast retrieval of model data.

5. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 4, characterized in that, The spatial indexing system is established according to the following steps: Using the bounding box of the lightweight model data as the root node, the three-dimensional space is recursively divided using an octree. When the amount of model data in a node exceeds a threshold, the subdivision continues until the preset termination condition is met. A mapping relationship is established between model blocks and corresponding nodes to form a spatial index structure.

6. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 1, characterized in that, The tile loading strategy and currently visible tiles are determined through view area analysis, and the area that may be accessed in the next time step is predicted, including: The view frustum, orientation, and occlusion relationship are calculated using camera parameters. Areas outside the view frustum are directly removed to obtain the visible field of view. Calculate screen space error based on distance, screen error, and user viewpoint, and dynamically load 3D tiles. Based on real-time acquisition of the user's current viewpoint, camera position, viewing direction, and spatial index structure information, a priority queue is established for the 3DTiles tiles to be loaded, and they are then sorted according to the current field of view. Approaching the field of vision Requests for long-distance regions are scheduled sequentially. By analyzing camera movement, behavior trajectory, and perspective trends, and combining current location, movement speed, direction of movement, and historical browsing information, the system predicts the spatial area that may enter the user's field of vision in the next moment, and preloads the corresponding 3D tiles into the request queue in advance.

7. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 1, characterized in that, A dynamic cache pool is constructed, recording the tile access frequency. Cache priority is calculated based on the tile access frequency, retaining only accessed resources with a priority greater than a preset threshold, and updating the cache state, including: Build a dynamic cache pool and record the tile access frequency in the dynamic cache pool; The Least Recently Used (LRU) strategy is adopted. The cache priority is calculated based on the tile access frequency. Only accessed resources with a priority greater than a preset threshold are retained, accessed resources with a priority lower than the preset threshold are deleted, and the cache status is updated.

8. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 7, characterized in that, A dynamic cache pool is constructed, recording the tile access frequency. Cache priority is calculated based on the tile access frequency, retaining only accessed resources with a priority greater than a preset threshold, and updating the cache state. This also includes: Web Workers are used to build a multi-threaded task pool for CPU scheduling. The main thread is only responsible for scene rendering, UI interaction and task scheduling, while each Worker is responsible for computationally intensive tasks. After each Worker completes its processing, it returns the results to the main thread for model building and display. GPU resources are dynamically allocated based on scene complexity, prioritizing the rendering of currently visible areas and promptly releasing resources in distant or invisible areas. Monitor GPU memory usage and dynamically manage resources based on user perspective and model visibility.

9. The method for rapid loading of real-scene 3D models based on multi-level optimization strategy according to claim 6, characterized in that, Based on the model node hierarchy and tile loading strategy, differentiated rendering control is applied to models at different levels to achieve high-precision display of near-views and low-overhead rendering of distant views, including: The model display accuracy requirement is evaluated in real time based on the distance between the camera and the model and the screen space error. When the model occupies a large portion of the screen and exceeds the preset high-precision judgment threshold, a high-precision LOD model is automatically loaded; when the model occupies a smaller portion of the screen and is less than the preset high-precision judgment threshold, it is switched to a low-precision LOD model. When the distance between the model and the camera is less than a preset close-up threshold, a high-precision LOD model is loaded, along with high-precision mesh and high-resolution texture data for rendering; when the distance between the model and the camera is greater than the preset close-up threshold, a low-precision LOD model is loaded, using simplified texture data.

10. A rapid loading device for real-scene 3D models based on a multi-level optimization strategy, characterized in that, The device includes: The lightweight module is used to acquire the original oblique photogrammetry 3D model and preprocess it to output lightweight model data from the oblique photogrammetry 3D model. The data reorganization module is used to read lightweight model data, analyze the hierarchical structure of model nodes, merge root nodes, reorganize vertex, face, and texture data, construct a spatial index structure, and generate an optimized dataset. The intelligent scheduling module is used to acquire camera position and viewing angle parameters in real time, determine the tile loading strategy and currently visible tiles through visual field analysis, predict the area that may be accessed in the next moment, load the target tiles in advance, and complete real-time rendering. The cache management module is used to build a dynamic cache pool, record the tile access frequency in the dynamic cache pool, calculate the cache priority based on the tile access frequency, retain only the accessed resources with a priority greater than a preset threshold, and update the cache status. The multi-level rendering module is used to perform differentiated rendering control on models of different levels based on the model node hierarchy and tile loading strategy, so as to achieve high-precision display of near view and low-overhead rendering of far view.

Images