A method and system for rendering a city three-dimensional model

Abstract

The application discloses a kind of urban three-dimensional model rendering methods, this method is by establishing multilevel detail model system, create multiple different detail levels three-dimensional model for each building object in city scene, form from high precision to low precision continuous hierarchy structure;Comprehensively consider spatial distance, perspective factor and object importance, calculate the effective distance measure of view point to target object, according to the effective distance measure establish continuous LOD switching function, distance is mapped as continuous detail level value;Application based on time smooth interpolation algorithm, gradually switch between adjacent LOD hierarchy, eliminate visual jump when switching;Significantly reduce the visual jump of LOD switching in urban three-dimensional model rendering, improve the stability of rendering performance, realize smooth, continuous visual experience.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of computer graphics and three-dimensional rendering technology, in particular to a city three-dimensional model rendering method and system. BACKGROUND

[0002] In order to achieve smooth real-time rendering under limited hardware resources, multi-level of detail (LOD) technology is widely used in the rendering optimization of large-scale three-dimensional scenes; the traditional LOD technology creates different precision levels of geometric models for the same object, dynamically selects the appropriate level of detail for rendering according to the observation distance, thereby significantly reducing the rendering load under the premise of ensuring the visual effect.

[0003] However, the existing LOD switching method has the following technical defects: a simple Euclidean distance is used as the only criterion for LOD selection, and the influence of observation angle, object importance, screen projection area and other factors on visual perception is not fully considered, resulting in a too rough LOD selection strategy and unable to achieve precise detail control; the direct switching method is used between adjacent LOD levels, which will produce obvious geometric jumps and texture changes at the switching moment, seriously affecting the user's visual experience, especially when the camera moves quickly or zooms in and out, the visual discontinuity is more obvious; in addition, the existing technology lacks effective adaptive optimization mechanism, and cannot dynamically adjust the LOD switching strategy according to the device performance and scene complexity, resulting in a serious decrease in frame rate on performance-limited devices, while on performance-rich devices, hardware resources cannot be fully utilized. SUMMARY

[0004] In view of the above technical problems, the present application provides a city three-dimensional model rendering method and system, which establishes an effective distance measurement model considering spatial distance, angle of view, importance weight, and combines a time-based smoothing interpolation algorithm to achieve a visual continuous and performance stable LOD switching effect.

[0005] In order to achieve the above purpose, the present application adopts the following technical scheme:

[0006] In a first aspect, the present application provides a city three-dimensional model rendering method, which comprises the following steps:

[0007] Step S1, a multi-level detail model system is established, and a plurality of three-dimensional models with different levels of detail are created for each building object in the city scene to form a continuous level structure from high precision to low precision.

[0008] The plurality of different levels of detail is at least 3.

[0009] Step S2, considering the spatial distance, perspective factor and object importance, the effective distance metric from the viewpoint to the target object is calculated, and a continuous LOD switching function is established according to the effective distance metric, and the distance is mapped to a continuous level of detail value.

[0010] wherein, is the effective distance of the target object, is the Euclidean distance from the observation point to the object center, is the angle between the line of sight direction and the object principal axis, is the importance weight determined based on the object semantics and geometric features.

[0011] ; wherein, is the LOD switching function, and are the highest and lowest level of detail indexes, respectively, and are preset distance threshold boundaries;

[0012] Step S3, a time-based smoothing interpolation algorithm is applied to perform gradual switching between adjacent LOD levels, eliminating visual jumps during switching.

[0013] ; wherein, is the current actual rendered LOD level value, is the level before switching, is the target level, is a smoothing interpolation function that ensures first-order derivative continuity, is a normalized transition time parameter, which realizes visual smooth switching by controlling the transition time.

[0014] Further, the effective distance metric is adaptively corrected by the screen projection area to consider the influence of the actual visible size of the object on the screen on the LOD selection: wherein, is the total pixel area of the current rendering target screen, is the projection pixel area of the object on the screen plane; this correction factor ensures that smaller projected objects use lower levels of detail and larger projected objects use higher levels of detail, thereby optimizing the allocation efficiency of rendering resources.

[0015] Further, the object importance weight is calculated by weighted combination of multi-dimensional factors to realize differentiated LOD strategies for different types of buildings:

[0016] ,in, The semantic importance weight is preset with different values ​​according to the functional type of the building (such as landmark building, commercial building, residential building), and the landmark building has the highest weight; is the geometric complexity weight, which is calculated by the number of polygons and the complexity of geometric features of the building model. The higher the complexity, the greater the weight; is the user attention weight, which is calculated based on historical user interaction data (such as clicks, dwell time, and zoom operations). Buildings with higher attention have higher weights. The constraints are: , ensuring the normalization of weights, It is the constraint coefficient and can be adjusted dynamically according to the application scenario.

[0017] Furthermore, the smooth interpolation function The specific calculation is:

[0018] ,in, and are the tangent vector parameters of the starting point and the ending point respectively, 、 、 They are smooth interpolation functions Basis functions:

[0019] , , .

[0020] By adjusting these parameters, the shape of the transition curve can be controlled, so that the LOD switching process presents a change pattern that is more in line with the perception characteristics of the human eye.

[0021] Furthermore, real-time rendering is implemented based on the GPU parallel computing architecture, and the LOD processing flow is as follows:

[0022] Step S21: Divide the entire city model into Regular grid units, each unit performs LOD calculation and rendering processing independently, where The value is dynamically determined based on scene complexity and GPU performance, and the default value is 50 meters.

[0023] Step S22, parallel calculation of the LOD decision matrix for each grid cell , the decision matrix stores the optimal LOD level for each object in the cell .

[0024] in, represents the grid coordinates, for the candidate integer LOD level.

[0025] Step S23, batch geometry subdivision and vertex data blending are implemented in GPU shader, LOD interpolation calculation output of multiple vertices is realized by parallel processing .

[0026] wherein, is the Boolean index mask matrix of the LOD level, is the vertex attribute array corresponding to the LOD level, is the blending weight calculated based on the time parameter , all weights satisfy the normalization condition .

[0027] Further, the rendering performance indicators are continuously monitored, and the performance ratio is defined: wherein, is the preset target frame rate, which is 60fps or 30fps, is the actual rendering frame rate at the current time.

[0028] Based on the performance ratio, the distance threshold of all LOD levels is dynamically adjusted to realize adaptive control of rendering load:

[0029] ;

[0030] wherein, and are the old value and the new value of the threshold, is the adjustment intensity parameter, to ensure that the threshold changes smoothly and avoid sudden LOD level jumps.

[0031] The adjusted threshold is smoothed to prevent visual instability caused by frequent fluctuations, and a moving average filter is used to smooth the threshold of consecutive multiple frames.

[0032] Further, by predicting the observation path of the user in advance, the required detail level is prepared, and based on the camera motion prediction, the future time LOD demand is reduced, and the calculation delay during switching is reduced.

[0033] Specifically, the following steps are included:

[0034] Step S31, a prediction model of camera motion is established, and the future position is predicted based on the current position, velocity and acceleration information:

[0035] wherein, are the position vector, velocity vector and acceleration vector of the camera in three-dimensional space, respectively, To predict the time window, set to 0.1-0.5 seconds.

[0036] Step S32, based on the predicted camera position to calculate the future all objects in the view frustum LOD requirements:

[0037] ; Wherein, The position of each object in the scene is quickly determined by spatial indexing.

[0038] Step S33, in the background thread asynchronously preload the predicted but not currently activated LOD level data, including geometry grid and texture resources, when actually needed, can be used immediately, significantly reduce the loading delay and the phenomenon of card when LOD switching.

[0039] Further, for each LOD level k to establish the corresponding texture resolution level , keep the matching of geometric complexity and texture accuracy:

[0040] ; Wherein, The basic texture resolution used in the highest detail level (such as 4096x4096), , is the texture scaling factor; control the decay rate of texture resolution with LOD level.

[0041] In the process of LOD switching, the progressive blending of the texture is carried out synchronously, avoiding the visual discontinuity caused by the change of the texture: ; Wherein, The texture data of the k-th level, The normalized texture coordinates.

[0042] According to the anisotropic filtering algorithm to reduce the texture distortion phenomenon when observing at a distance:

[0043] ; Wherein, ( , ) is the sampling step vector calculated along the main gradient direction of the texture, N is the number of anisotropic sampling, which is dynamically adjusted according to the observation angle and distance, to ensure that clear texture effect can be obtained at various viewing angles.

[0044] Based on the same inventive concept, the second aspect, the present application provides a kind of urban three-dimensional model rendering system, for executing the method of first aspect, the system includes: model management module, distance measurement calculation module, LOD decision module, smooth interpolation module and rendering output module.

[0045] The model management module is used for constructing and maintaining a multi-level detail model of each building object in a city scene, and the model management module comprises a model preprocessing unit, an LOD level generation unit and a model index unit, wherein the model preprocessing unit is responsible for geometry optimization and topology simplification of an original three-dimensional model, the LOD level generation unit automatically generates model versions of at least three different detail levels based on a principle of decreasing geometry complexity, and the model index unit establishes a mapping relationship between model identification and LOD levels thereof.

[0046] The distance metric calculation module is used for calculating an effective distance metric from an observation point to a target object in real time.

[0047] The LOD decision module is used for determining a target detail level of each object based on the effective distance metric.

[0048] The smooth interpolation module is used for realizing smooth transition of a time base between adjacent LOD levels.

[0049] The rendering output module is used for converting processed LOD data into a final visual output, and the module comprises a geometry data mixing unit, a shader scheduling unit and a frame buffer management unit, wherein the geometry data mixing unit synthesizes final vertex and index data according to interpolation weights, the shader scheduling unit coordinates allocation of GPU computing resources, and the frame buffer management unit controls output and display of a rendering result.

[0050] Further, the system further comprises a user interaction analysis module, and the user interaction analysis module comprises an interaction behavior recording unit, an attention degree statistical unit and a personalized weight adjustment unit.

[0051] The interaction behavior recording unit tracks click, zoom, stay and other operation behaviors of a user, the attention degree statistical unit analyzes an attention mode of the user to different regions and buildings, and the personalized weight adjustment unit dynamically adjusts an object importance weight according to user preferences to realize a personalized LOD optimization strategy.

[0052] Compared with the prior art, the present application has the following beneficial effects:

[0053] By introducing technical means such as effective distance metric and smooth interpolation algorithm, the present application significantly reduces visual jumps caused by LOD switching in city three-dimensional model rendering, improves stability of rendering performance, and realizes smooth and continuous visual experience; compared with a traditional method, the present application can reduce visual discontinuity caused by LOD switching by more than 80%, and reduce rendering frame rate fluctuation by more than 60%. BRIEF DESCRIPTION OF DRAWINGS

[0054] Figure 1 A city three-dimensional model rendering method flowchart of the present application;

[0055] Figure 2 A schematic diagram of a city three-dimensional model rendering system according to the present application. DETAILED DESCRIPTION

[0056] In order to make the objects, technical solutions and advantages of the present application clearer, the technical solutions of the present application are described below in a clear and complete manner. Obviously, the described embodiments are only some of the embodiments of the present application, rather than all the embodiments. Based on the embodiments of the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts should fall within the scope of the present application.

[0057] Embodiment 1

[0058] As shown in the flow chart of a city three-dimensional model rendering method according to the present application, the method comprises the following steps: Figure 1

[0059] Step S1, a multi-level detail model system is established, and a plurality of three-dimensional models of different detail levels are created for each building object in the city scene, forming a continuous level structure from high precision to low precision.

[0060] It should be noted that the plurality of different detail levels is at least three; the multi-level detail model system created by the present application has the hierarchical geometric simplification feature, the transition between levels is smooth and natural, and the visual consistency is effectively ensured; for a standard office building, five LOD levels can be designed in this embodiment: LOD0 (original high-precision model, about 50,000 polygons) contains complete building facade details, window frames, balcony railings, etc.; LOD1 (about 20,000 polygons) retains the main facade structure but simplifies the window details; LOD2 (about 8,000 polygons) combines similar texture areas and simplifies the protruding structure; LOD3 (about 3,000 polygons) only retains the building outline and main separation line; LOD4 (about 1,000 polygons or less) is represented as a simple geometric body, only retaining the building volume and basic shape. This multi-level model design can provide visually coherent building performance at different observation distances.

[0061] ​Multi-level detail design usually contains 5-7 LOD levels, which can provide smoother transition when the view distance changes. For example, for a landmark building in a city (e.g. city hall), 7 detailed LOD levels can be designed, including: LOD0 (full details, 100,000+ polygons), LOD1 (80,000 polygons), LOD2 (50,000 polygons), LOD3 (25,000 polygons), LOD4 (10,000 polygons), LOD5 (4,000 polygons), and LOD6 (1,500 polygons). The geometric complexity between each level usually follows a decrease ratio of about 1 / 2 to 1 / 3, which has been verified by a large number of experiments to achieve the best balance between visual quality and performance.

[0062] In step S2, the effective distance metric from the viewpoint to the target object is calculated by comprehensively considering the spatial distance, viewing angle factor and object importance, and a continuous LOD switching function is established according to the effective distance metric to map the distance to a continuous detail level value.

[0063] By calculating the effective distance metric, the present application can accurately capture the detail requirements perceived by the human eye when observing a building from different positions and angles; for example, when an observer observes a museum building from the front at a close distance, the building may need to use LOD1 or LOD0 level to display its fine facade details; when the same observer observes the same building at the same distance from the side at a 45-degree angle, due to the perspective effect and viewing angle factor, the system may select a LOD2 level model, which ensures visual quality and improves rendering efficiency. For different types of buildings, the present system presets different basic importance weights, such as landmark buildings (weight value 1.2), commercial centers (weight value 1.0), and ordinary residences (weight value 0.8).

[0064] wherein, is the effective distance of the target object, is the Euclidean distance from the observation point to the object center, is the angle between the line of sight direction and the object main axis, is the importance weight determined based on the object semantics and geometric features. Taking a real city scene as an example, when an observer is located at a ground level position and observes a skyscraper at a distance of 500 meters, if the observation angle is front ( = 0°), then = 1; if the observation angle is 30° ( = 30°), then = 0.5, so that the effective distance calculation is = 500 meters.

[0065] ​​​​​Importance weight for different types of buildings There are also differences: landmark buildings (such as city landmark towers) can be set to 1.5, indicating that higher precision models are needed at the same distance; ordinary commercial buildings can be set to 1.0; and simple supporting facility buildings can be set to 0.8, indicating that lower precision models can be used to ensure that important buildings always maintain sufficient detail in vision.

[0066] ; wherein, is the LOD switching function, and are the highest and lowest detail level indexes, respectively, and are preset distance threshold boundaries.

[0067] The setting of the distance threshold boundary has a decisive influence on the LOD switching effect. Taking a building group in the core area of a city as an example, a typical configuration can be: = 5 (highest detail level), = 0 (lowest detail level), = 100 meters (near distance threshold), = 1000 meters (far distance threshold); when the effective distance between the observer and the building is less than 100 meters, the system will use the highest precision model (LOD5); when the distance is greater than 1000 meters, the lowest precision model (LOD0) will be used; between 100 and 1000 meters, the system will use intermediate precision models, and the precision will decrease linearly with the increase of distance. It has been verified by experiments that this configuration can achieve a good balance between visual quality and rendering performance in modern city scale (about 5-10 square kilometers of core area).

[0068] For different sizes of cities or special areas, these parameters can be adjusted appropriately, for example, in a dense historical block, can be set to 50 meters to provide more detailed near-distance details.

[0069] Step S3, a time-based smooth interpolation algorithm is applied to gradually switch between adjacent LOD levels, eliminating visual jumps when switching.

[0070] In traditional systems, LOD level switching often causes obvious "jump" or "flicker" effects, seriously affecting the sense of immersion; the smooth interpolation algorithm of the present application uses a time-based gradual transition mechanism, effectively eliminating this visual defect.

[0071] Specifically, for a building switching from LOD2 to LOD3, instead of replacing the model immediately, the algorithm gradually blends the vertex data of the two models within a time window of 250-500 milliseconds. This blending process visually presents a smooth "dissolve" effect, making the details of the building appear to change naturally rather than jump suddenly to the user; the smooth transition technique can reduce the perceptibility of LOD switching by about 95%, significantly improving visual continuity and immersion experience.

[0072] ; wherein, is the current actual rendered LOD level, is the level before switching, is the target level, is a smooth interpolation function that ensures first derivative continuity, is a normalized transition time parameter, which controls the transition duration to achieve a visually smooth switching.

[0073] In typical city browsing scenarios, and are usually integer values (such as 3 and 4), but is a continuous floating-point number representing the blending state between the two discrete LOD models. For example, when t = 0.5, may be 3.5, representing the intermediate state between LOD3 and LOD4.

[0074] The setting of the transition duration is that for normal observation speed, a transition duration of 300 milliseconds (i.e., it takes 300 milliseconds from t = 0 to t = 1) usually provides the best smooth experience; for a high-speed moving camera (such as fast flight mode), it can be shortened to 150 milliseconds to maintain responsiveness; for slow observation or close-up shots, it can be extended to 500 milliseconds to obtain a more fine transition effect.

[0075] The effective distance measure is adaptively corrected by the screen projection area to consider the influence of the actual visible size of the object on the screen on the LOD selection: wherein, is the total pixel area of the screen of the current rendering target, is the projection pixel area of the object on the screen plane; this correction factor ensures that smaller projected objects use lower detail levels and larger projected objects use higher detail levels, thereby optimizing the allocation efficiency of rendering resources.

[0076] Building size varies greatly - from small pavilions (a few meters wide) to super-tall skyscrapers (hundreds of meters high), using distance as the only basis for LOD selection can result in insufficient details for small buildings or waste of resources for large buildings. Take a practical case: on a standard resolution (1920x1080, about 2.07 million pixels) display, a large building that occupies 5% of the screen (about 104,000 pixels) and a small building that occupies 0.5% of the screen (about 10,400 pixels) should use different LOD levels even if the actual distance is the same; according to the formula, the correction factor for the large building is , and the correction factor for the small building is . This shows that smaller buildings can use lower-precision models (equivalent to a 14.15-fold increase in distance), while larger buildings need to maintain higher precision (equivalent to a 4.47-fold increase in distance), which significantly improves rendering efficiency while maintaining good visual quality.

[0077] The object importance weight is calculated by weighted combination of multiple dimensions to achieve differentiated LOD strategies for different types of buildings:

[0078] , where is the semantic importance weight, which is preset with different values according to the functional type of the building (such as landmark buildings, commercial buildings, residential buildings), and landmark buildings have the highest weight; is the geometric complexity weight, which is calculated by the number of polygons and geometric feature complexity of the building model, and the higher the complexity, the greater the weight; is the user attention weight, which is calculated based on historical user interaction data (such as clicks, dwell time, zoom operations), and the higher the attention, the higher the weight; the constraint condition is: , to ensure the normalization of the weight, is the constraint condition coefficient, which can be dynamically adjusted according to the application scenario.

[0079] Semantic importance weight can be classified by building function: landmark / historical building = 1.5, government / cultural facility = 1.3, commercial center = 1.1, ordinary office building = 1.0, residential area = 0.8, auxiliary facility = 0.6. Geometric complexity weight is automatically calculated according to model features: Gothic buildings with fine carved facades are about 1.4, modern buildings with complex facades are about 1.2, standard glass curtain wall buildings are about 1.0, and simple geometric shape buildings are about 0.8. User attention weight Then the coefficients are dynamically adjusted based on the interaction data: a shopping mall that users frequently visit can be raised from the default value 1.0 to 1.3; a far suburb building that users have never interacted with can be lowered to 0.7. The typical settings are: (Semantic importance dominates), (Geometric complexity is secondary), (User attention helps adjust).

[0080] The specific calculation of the smooth interpolation function is:

[0081] where and are the tangent vector parameters of the starting point and the ending point respectively, , , are the basis functions of the smooth interpolation function :

[0082] , , .

[0083] By adjusting these parameters, the shape of the transition curve can be controlled to make the LOD switching process exhibit a change rule that is more consistent with the characteristics of human eye perception.

[0084] The parameters and control the tangent direction and size of the curve at the starting point and the ending point, and have a significant impact on the transition rate. In the standard configuration, these two parameters are usually set to: , This set of parameter values makes the transition slow at the beginning (reducing the initial jump feeling), accelerates in the middle (improving responsiveness), and slows down again at the end (smooth ending).

[0085] Experiments show that this "slow-fast-slow" transition curve reduces about 40% of the visual discomfort compared to linear transition. The system can also dynamically adjust these parameters for different observation conditions: for example, for a fast-moving camera, the can be lowered to 0.5 to obtain a faster initial response; for a LOD switch with large detail changes (such as LOD4 to LOD1), the can be increased to 0.7 to extend the transition time at the end and further reduce visual mutations.

[0086] Real-time rendering is implemented based on GPU parallel computing architecture, and the processing flow of LOD is as follows:

[0087] Step S21, the entire city model is divided into a regular grid of cells, each cell independently performs LOD computation and rendering process, wherein The value is dynamically determined according to scene complexity and GPU performance, and the preset value is 50 meters.

[0088] In a typical urban center area (building density is about 150-200 per square kilometer), the grid size is usually set to 50 meters x 50 meters, which can ensure that the number of buildings in each grid is moderate (average 5-8) and can be efficiently cooperated with the view frustum culling algorithm. In the suburbs with low building density, the grid size can be automatically expanded to 100 meters x 100 meters to reduce management overhead; while in the super high-density business center area, it can be reduced to 30 meters x 30 meters to improve the culling efficiency.

[0089] Step S22, for each grid cell, parallel computing LOD decision matrix The decision matrix stores the optimal LOD level of each object in the cell .

[0090] wherein, represents the grid coordinates, is the candidate integer LOD level.

[0091] For a typical 50 meters x 50 meters grid cell containing about 5-8 buildings, the system will complete the LOD calculation of all buildings in a single computing schedule. The decision matrix is usually stored in the GPU memory in two-dimensional texture format, where the (i, j) pair corresponds to the grid coordinates, and the texture value stores the optimal LOD level of the building at that position; this GPU acceleration strategy makes the LOD decision calculation completed in less than 1 millisecond even in a large city scene containing 10,000+ buildings; on a high-end GPU (such as NVIDIA RTX 3080 or higher), the system can increase the grid precision to 10 meters x 10 meters (about 25 times the number of grids), and still keep the LOD decision calculation time per frame below 3 milliseconds.

[0092] Step S23, batch geometry subdivision and vertex data blending are realized in the GPU shader, and the LOD interpolation calculation output of multiple vertices is realized through parallel processing .

[0093] wherein, is the Boolean index mask matrix of the level, is the vertex attribute array corresponding to the LOD level, is the blending weight calculated based on the time parameter , and all weights satisfy the normalization condition .

[0094] The system uses a specially optimized Geometry Shader or Tessellation Shader for efficient processing. For a LOD2 (8,000 polygons) to LOD1 (20,000 polygons) transition of a standard office building, instead of directly switching models, the system dynamically calculates the blending weights based on the time parameter t within a 300ms transition window , such as t = 0.5, , .

[0095] To optimize performance, this embodiment uses batch processing technology to handle up to 256 vertex blending calculations at a time, fully utilizing the advantages of the GPU's SIMD (Single Instruction, Multiple Data) architecture. In processing, the mask matrix ensures that only relevant vertices participate in the calculation, avoiding invalid blending operations. On a typical hardware configuration (such as NVIDIA RTX 2070 or equivalent performance), the system can handle the blending of about 50-100 buildings at the same time, with an additional computational overhead of only about 10-15% of the vertex processing time.

[0096] Continuous monitoring of rendering performance indicators, defining performance ratio : , where is the preset target frame rate, which is 60fps or 30fps, is the actual rendering frame rate at the current time.

[0097] The monitoring uses a sliding window average method, updating the performance evaluation every 100ms (about 6 frames, based on 60fps) to avoid excessive adjustments caused by single-frame fluctuations. The target frame rate can be preset according to different application scenarios and device capabilities: for desktop high-performance applications, it is usually set to 60fps to provide a smooth experience; for mobile devices or web applications, it can be set to 30fps to balance performance and power consumption. The system also provides an adaptive target frame rate function: for example, on a battery-powered laptop, when the battery capacity is detected to be less than 20%, the system can automatically reduce the target frame rate to 30fps to extend the usage time; when connected to an external power source, it returns to 60fps. Based on the performance ratio, dynamically adjust the distance threshold of all LOD levels to achieve adaptive control of rendering load:

[0098] ;

[0099] , where and are the first old and new values of a threshold value, to adjust the intensity parameter to ensure the threshold changes smoothly and avoid sudden LOD level jumps.

[0100] Take a mid-end hardware configuration (such as NVIDIA GTX 1660) as an example: when the user enters a densely built-up area, the frame rate drops from 60fps to 48fps, the performance ratio P(t) = 60 / 48 = 1.25, which is higher than the threshold value of 1.1, the system will apply the first rule: This means that all LOD distance thresholds are increased by 2.5%, resulting in more buildings using lower detail models, thereby reducing rendering load; this small adjustment is almost imperceptible for individual buildings, but in a city scene containing thousands of buildings, the cumulative effect can increase the frame rate by about 10-15%.

[0101] Smooth the adjusted threshold value to prevent visual instability caused by frequent fluctuations, and use a moving average filter to smooth the threshold value of multiple consecutive frames.

[0102] Prepare the required detail levels in advance by predicting the user's observation path, based on camera motion prediction of future time LOD requirements, to reduce the computational delay when switching.

[0103] Specifically includes the following steps:

[0104] Step S31, establish a prediction model of camera motion, predict the future position based on the current position, velocity and acceleration information:

[0105] where, are the position vector, velocity vector and acceleration vector of the camera in three-dimensional space, is the prediction time window, set to 0.1-0.5 seconds.

[0106] Step S32, calculate the LOD requirements of all objects within the future view frustum based on the predicted camera position:

[0107] where, are the positions of the objects in the scene, which are quickly determined by spatial indexing to determine the candidate objects within the view frustum.

[0108] Step S33, asynchronously preload the predicted but currently inactive LOD level data in the background thread, including geometry grids and texture resources, which can be used immediately when actually needed, significantly reducing the loading delay and stuttering phenomenon when switching LOD.

[0109] Establish the corresponding texture resolution level for each LOD level k , maintain the matching of geometric complexity and texture accuracy:

[0110] wherein, is the base texture resolution used for the highest level of detail (e.g. 4096x4096), is the texture scale factor; controls the decay rate of texture resolution with LOD level.

[0111] Synchronize the progressive blending of textures during the LOD switching process to avoid visual discontinuity caused by texture changes: wherein, is the texture data of the th LOD level, is the normalized texture coordinate.

[0112] Reduce the texture aliasing phenomenon when observing from a long distance according to the anisotropic filtering algorithm:

[0113] wherein, , is the sampling step vector calculated along the main gradient direction of the texture, and N is the number of anisotropic sampling, which is dynamically adjusted according to the observation angle and distance to ensure clear texture effects at various viewing angles.

[0114] Taking a certain city planning visualization project as an example, the technical effects of the present application in practical application are shown. The project needs to render a core area of about 5 square kilometers of a city in real time on a general office computer, including about 1,200 buildings of different types.

[0115] The initial data of the project comes from the city BIM system, including detailed three-dimensional building models, totaling about 23 million polygons. The system applies multi-level detail (LOD) processing to each building: LOD5 (highest detail): retains the original detail, about 20,000 polygons per building on average; LOD4: simplifies the window frame and small decorations, about 8,000 polygons per building; LOD3: merges similar surfaces, retains the main outline, about 3,000 polygons per building; LOD2: simplifies to basic blocks, about 1,000 polygons per building; LOD1: extremely simplified representation, about 300 polygons per building; LOD0: box outline, about 50 polygons per building.

[0116] The system sets the base LOD threshold: D1=100 meters (close distance), Dn=1000 meters (long distance). Special buildings are given differentiated processing: city hall (landmark building): semantic importance weight ωs=1.5, geometric complexity weight ωg=1.3; commercial center (user focus area): user attention weight ωu gradually increases from the initial 1.0 to 1.3; standard residence: the base weight is 1.0; suburban industrial buildings: importance weight is reduced to 0.8.

[0117] When the observer browses the city center street (ground view), the system intelligently applies the perspective factor: the high-rise building observed from the front uses a higher LOD; while the building observed from a 45° angle at the same distance automatically reduces the LOD by one level, saving about 30% of rendering resources.

[0118] Test scenario: the observer approaches the city hall from 300 meters away, triggering the switch from LOD3 to LOD4.

[0119] The traditional method of LOD instantaneous switching has a clear jump effect, with a geometric change of about 40 pixels. The method of the present application applies a 300ms smooth transition, sets the interpolation parameters v0=0.8 and v1=0.6, and presents a slow-in and fast-out transition curve, providing a coherent and non-jumpy visual experience.

[0120] Performance adaptive example: using an office computer (i5-11400 processor, RTX 3060 graphics card, 16GB memory), the rendering frame rate of the starting scene (suburban view) is stable at 60fps, and the frame rate drops to 46fps when entering the building-dense area. The system detects the performance ratio P(t)=1.30, temporarily reduces the threshold D1 and Dn by 12%, and automatically switches the distant buildings to a lower LOD. The frame rate returns to 58fps within 2 seconds, and the user has no obvious sense of lag.

[0121] When the user moves along the main road at a stable speed (equivalent to 30km / h): the system predicts the camera position 0.3 seconds in the future, calculates in advance the 6 buildings that will appear in the field of view, and asynchronously loads the high-detail LOD resources of these buildings in the background. When the buildings actually enter the field of view, the high-detail model is ready, reducing the loading delay by 95%.

[0122] Test data shows that the city three-dimensional model rendering method of the present application not only provides excellent visual quality, but also realizes more efficient utilization of hardware resources, making real-time rendering of large-scale city scenes possible on ordinary hardware.

[0123] Embodiment 2

[0124] As shown in Figure 2 , a city three-dimensional model rendering system composition schematic diagram is provided for the present application, which includes a model management module, a distance measurement calculation module, a LOD decision module, a smooth interpolation module, and a rendering output module.

[0125] The city three-dimensional model rendering system adopts a modular design architecture, and each functional module is connected through an efficient data flow pipeline to ensure the real-time and consistency of data transmission. The system processing flow follows the basic link of "model management → distance calculation → LOD decision → smooth interpolation → rendering output", each module can be independently upgraded and optimized, and has good scalability. In terms of hardware implementation, the system supports a heterogeneous computing platform: the CPU is responsible for global management and high-level decision-making, the GPU is responsible for parallel data processing and real-time rendering, and if necessary, special hardware accelerators (such as ray tracing units) can be integrated to enhance specific functions. The system adopts a pipeline parallel architecture, which can achieve a stable rendering rate of more than 60 frames per second under standard configuration, and support to increase to 120 frames / second or more on high-end devices, meeting the high refresh rate display requirements of VR / AR and other applications.

[0126] The model management module is used to construct and maintain a multi-level detail model of each building object in the city scene, and the model management module includes a model preprocessing unit, an LOD level generation unit and a model index unit, wherein the model preprocessing unit is responsible for geometry optimization and topology simplification of the original three-dimensional model, the LOD level generation unit automatically generates at least three model versions of different detail levels based on the principle of decreasing geometric complexity, and the model index unit establishes a mapping relationship between the model identifier and its LOD levels.

[0127] The model management module is the basic data provider of the system, responsible for efficiently managing the multi-level geometry and texture data of thousands of buildings in a large-scale city scene. The model preprocessing unit uses professional mesh optimization algorithms to process the original CAD or BIM exported building model, including mesh repair (such as repairing non-manifold edges, incorrect normal direction, overlapping vertices, etc.), UV coordinate optimization and geometry topology merging. For example, for a standard office building, the preprocessing can optimize the original imported 500,000 polygon model to about 50,000 polygons while keeping the key geometric features unchanged, and the texture mapping efficiency is improved by about 30%.

[0128] The LOD level generation unit is the core of this module, responsible for automatically creating multi-level detailed models for each building. The system uses an improved Progressive Mesh Simplification algorithm, which prioritizes preserving visual features and intelligently selects simplification operations based on the Edge Collapse Cost Function. For models with rich details such as cultural buildings, the system uses a feature preservation strategy to retain elements such as corner lines, contours, and decorative patterns during simplification. For example, for a historical building with complex carving details, the system automatically identifies and marks the carving area as "high protection priority", and even at medium and low levels (such as LOD2 and LOD3), it can retain the key contours of these areas while greatly simplifying ordinary wall and structure areas. The system usually generates 5-7 LOD levels for each building, and the number of polygons between adjacent levels usually follows a reduction ratio of 1:2 to 1:3.

[0129] The model index unit uses a hierarchical hash table structure to efficiently manage all model assets. Each building is indexed by a unique identifier (UUID), and a first-level index table maps the UUID to all LOD model sets for that building. A second-level index table organizes specific geometry and material data by LOD level. The system supports multi-threaded concurrent access, with response times for reading any LOD level controlled within 1 millisecond. For large-scale scenes (such as a complete city model containing 10,000+ buildings), the system implements a block-based streaming loading mechanism, dynamically loading and unloading model data for different regions based on the observation position, ensuring that memory usage is stable within a controllable range (usually 2-4 GB) while maintaining a smooth viewing experience.

[0130] The distance metric calculation module is used to calculate the effective distance metric from the observation point to the target object in real time.

[0131] The importance weighting unit is responsible for calculating and applying object importance weights. This unit evaluates the semantic type, geometric complexity, and user attention of the building to generate normalized importance weights. The system has preset a building type weight table: landmark building = 1.5, commercial center = 1.2, cultural facility = 1.3, office building = 1.0, ordinary residence = 0.8, auxiliary building = 0.6. Geometric complexity is calculated by analyzing the surface variation rate and feature edges of the original model, with complexity ranging from 0.7 to 1.4; user attention is derived from historical interaction data, such as user clicks, zoom-in, or frequency and duration of staying near the building.

[0132] The LOD decision module is used to determine the target level of detail of each object based on the effective distance metric; the module includes three key functional units: a continuous mapping unit, a performance adaptive unit, and a decision optimization unit; to cope with different scales of urban environment, the system implements an environment adaptive strategy: in dense urban areas, the threshold distance is automatically shortened; in open areas, the threshold distance is expanded.

[0133] The performance adaptive unit is responsible for dynamically adjusting the LOD threshold parameters to ensure that the system can maintain the target frame rate on different hardware platforms; the unit uses a PID controller (proportional-integral-derivative controller) model to monitor frame rate fluctuations and calculate the adjustment coefficient applied to the LOD threshold. When the frame rate is lower than the target value (performance is insufficient), the controller generates a negative feedback signal to reduce all LOD thresholds, allowing more buildings to use lower detail models; conversely, when performance is excessive, the threshold is increased to provide better visual effects. The controller parameters are optimized to ensure that the system's response to performance fluctuations is both sensitive and stable - it can complete 90% of the adjustment within 0.5 seconds, while avoiding visual jitter caused by excessive adjustment. The unit also implements a scene complexity prediction mechanism, which adjusts LOD parameters in advance to prevent frame rate from dropping sharply when the camera enters a high complexity area (such as a densely built area).

[0134] The decision optimization unit globally optimizes the preliminary LOD decision results to ensure efficient allocation of system resources. The unit takes into account factors such as visual importance distribution, GPU memory capacity limitations, and the number of objects on the screen to achieve "budgeted LOD optimization." For example, when there are too many buildings on the screen, the system will prioritize ensuring the level of detail of the central area of the view and important buildings, while appropriately reducing the detail of peripheral buildings; when memory is close to the upper limit, the texture resolution of distant buildings will be automatically reduced to release resources. The unit also implements temporal coherence optimization to avoid frequent LOD fluctuations by introducing a change threshold and hysteresis mechanism - only when the calculated LOD value changes by more than ±0.5 and lasts for at least 5 frames will the switch be actually executed.

[0135] The smooth interpolation module is used to achieve smooth transitions between adjacent LOD levels in the time domain.

[0136] The smooth interpolation module is a key component of the system that eliminates the visual jump problem in traditional LOD technology. The module includes three core functional units: a time control unit, an interpolation function unit, and a resource coordination unit.

[0137] The time control unit is responsible for managing the time parameters of LOD transitions, determining the start timing and duration of transitions. When the LOD decision module determines that a building needs to change its LOD level, this unit assesses the visual impact of the change and sets the corresponding transition duration.

[0138] For example, for large-scale LOD changes (such as from LOD5 to LOD2 directly), the system sets a longer transition time (400-500 milliseconds) to reduce visual mutations; for small-scale changes (such as from LOD3 to LOD4), a shorter transition time (200-300 milliseconds) is used to maintain timely response; this unit also implements a line-of-sight-based priority strategy - buildings in the central area of the line of sight get higher priority processing, ensuring that the user's gaze area is prioritized for transition, while controlling the number of parallel transitions, usually limited to 50-100, to avoid GPU resource overload.

[0139] The interpolation function unit implements high-quality smooth transition curves, and the system optimizes control parameters for transitions between different LODs: when transitioning from high detail to low detail, a "slow-in fast-out" curve is used ( ), making details gradually disappear; when transitioning from low to high, a "fast-in slow-out" curve is used ( ), making details naturally appear. This asymmetric design conforms to the perception characteristics of the human eye to detail changes, greatly improving visual comfort. This unit also implements adaptive curve parameters for special observation conditions (such as high-speed moving cameras), using steeper transition curves in rapidly changing scenes to maintain timely response.

[0140] The resource coordination unit is responsible for coordinating geometry, material, and texture resources during transitions to ensure synchronized and consistent transition effects; this unit implements a "resource readiness check" mechanism to confirm that all necessary LOD resources (geometry data, textures, etc.) are ready before starting the transition, avoiding visual flaws caused by resource loading delays. To handle a large number of parallel transitions, the unit uses a resource pool design, pre-allocating and managing GPU memory and computing resources required for transitions to prevent memory fragmentation and resource contention. During the transition process, the system synchronously blends geometry shapes and texture details to avoid the common problem of "geometry changing but texture lagging". For large LOD span transitions (such as from LOD5 to LOD1), the system implements a "multi-step transition" strategy, breaking down large span changes into multiple intermediate transitions, each using independent time control and interpolation functions, further improving visual continuity.

[0141] The rendering output module is responsible for converting the processed LOD data into final visual output. It includes a geometry data blending unit, a shader scheduling unit, and a frame buffer management unit. The geometry data blending unit synthesizes final vertex and index data according to interpolation weights. The shader scheduling unit coordinates the allocation of GPU computing resources. The frame buffer management unit controls the output and display of rendering results.

[0142] The rendering output module is the final executor of the system, responsible for converting the processed LOD data into high-quality visual output. The geometry data blending unit is the core processing engine of this module, which receives the blending weight parameters from the smooth interpolation module and performs efficient vertex data blending calculations on the GPU. This unit uses specially optimized geometry shaders to achieve efficient vertex attribute interpolation, including position, normal, texture coordinates, and tangent data. For buildings in transition, the system uses a multi-pass rendering strategy optimized for cascaded blending: first, precompute at the vertex level, then use vertex index remapping techniques to efficiently perform blending rendering. This unit also implements a lightweight rendering path for mobile devices, which simplifies the blending algorithm and optimizes memory layout, reducing computational overhead by about 40% while maintaining visual effects, making this technology suitable for various hardware platforms.

[0143] The shader scheduling unit is responsible for efficiently managing the allocation and scheduling of GPU computing resources. This unit implements a "layered rendering queue" mechanism, grouping buildings in the city scene according to material type, LOD state (stable or in transition), and rendering priority, minimizing shader switching and state change overhead. For large-scale scenes, the system uses a "deferred shading" rendering pipeline, processing geometry data uniformly in the G-Buffer stage, then efficiently applying complex lighting and shadow algorithms in the lighting stage. For mobile platforms, the system automatically switches to "deferred lighting" or "forward+" rendering paths to optimize memory bandwidth usage. This unit also implements a dynamic LOD shader variant management system, dynamically selecting the most suitable shader precision level (such as high-precision normal maps, simplified ambient reflections, etc.) based on the current scene complexity and available performance.

[0144] The frame buffer management unit controls the processing and output of the final rendering result. This unit implements an advanced post-processing chain, including anti-aliasing (using the SMAA technique), ambient occlusion (using the GTAO algorithm), depth of field, and motion blur, etc., to provide a cinematic-level visual quality for city scenes. The system supports high dynamic range (HDR) rendering procedures, using 16-bit floating-point precision to store and process lighting data, and then converting it to the color range that the display device can present through advanced tone mapping algorithms (ToneMapping). For different display devices, the unit provides adaptive output configuration: for high-resolution displays (such as 4K displays), the system can use dynamic resolution rendering technology to dynamically adjust the actual rendering resolution according to the scene complexity and available performance, and then use high-quality up-sampling algorithms (such as DLSS or FSR) to generate the final output image, achieving the best balance between performance and quality; the unit also supports a programmable rendering special effect plug-in system, allowing developers to add custom post-processing effects to meet the visual needs of specific application scenarios.

[0145] The system also includes a user interaction analysis module, which includes an interaction behavior recording unit, an attention statistics unit, and a personalized weight adjustment unit.

[0146] The user interaction analysis module is an intelligent and personalized enhancement component of the system. This module automatically adjusts the rendering strategy to provide a visual experience that better meets the user's habits and preferences by analyzing user behavior; the interaction behavior recording unit is responsible for capturing and storing various types of interaction data between the user and the three-dimensional city scene. This unit implements a multi-dimensional interaction tracking system, recording a variety of behavior data including explicit interactions (such as clicking, selecting, and zooming in on specific buildings), implicit interactions (viewpoint dwell time, observation angle change patterns), and contextual interactions (such as search queries and information requests). The system uses a lightweight event capture architecture to record mouse movement trajectories and dwell points on desktop environments, track gesture operation patterns on touch devices, and analyze head orientation and gaze points in VR environments. To protect user privacy, all behavior data is anonymized locally before being used to optimize the current user's rendering experience, and is not uploaded to the server by default (optional configuration allows for cloud-based personalization, but requires explicit user authorization).

[0147] The attention statistics unit intelligently analyzes collected interaction data to extract user attention patterns and the distribution of points of interest. This unit employs a hybrid analysis model, combining techniques such as heatmap statistics, viewpoint clustering, and time-series analysis, to identify building types, areas, and features that users frequently focus on. The system constructs a "user attention profile," capturing insights such as: users spend an average of 2.5 times longer on historical buildings than on modern ones; users zoom in multiple times to examine facade details in specific commercial areas; and users tend to use landmarks as reference points when navigating. These statistics are continuously updated using an exponentially weighted moving average (EWMA), giving greater weight to recent activity, ensuring that the attention model adapts to evolving user interests. For multi-user environments, the system supports storing and applying different attention models based on user ID, enabling multiple users to enjoy a personalized visual experience on the same system.

[0148] The personalized weight adjustment unit converts user attention data into a specific LOD weight adjustment strategy, and automatically modifies the importance weights of different buildings based on user attention statistics. For example, when it is detected that the user frequently pays attention to a specific commercial area, the system will The value has been increased from the default of 1.0 to 1.2-1.5, giving these buildings a higher level of detail at the same viewing distance. Weight adjustments follow a smooth gradient to avoid sudden visual changes that can cause discomfort. This unit also implements context-aware adjustment strategies, such as identifying whether the user is in "exploration mode" (frequently changing perspectives) or "observation mode" (examining a specific area for an extended period of time), and adjusting the LOD strategy accordingly—prioritizing smoothness in exploration mode and detail clarity in observation mode. The system supports manual intervention and reset functions, allowing users to explicitly adjust or reset personalized parameters, ensuring that users always maintain control over the rendering experience.

[0149] The specific implementation methods described above further illustrate the objectives, technical solutions and beneficial effects of the present invention in detail. It should be understood that the above description is only a specific implementation method of the present invention and is not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. A method for rendering a city 3D model, characterized in that, The method comprises the following steps: Step S1, a multi-level detail model system is established, a plurality of three-dimensional models of different detail levels are created for each building object in the city scene, and a continuous level structure from high precision to low precision is formed; The plurality of different detail levels are at least three; Step S2, considering the spatial distance, the visual angle factor and the object importance, the effective distance measure from the viewpoint to the target object is calculated, and a continuous LOD switching function is established according to the effective distance measure, and the distance is mapped to a continuous detail level value; wherein, is the effective distance of the target object, is the Euclidean distance from the observation point to the object center, is the angle between the line-of-sight direction and the object principal axis, is the importance weight determined based on the object semantics and geometric features; ; wherein, is a LOD switching function, and are the highest and lowest level of detail indices, respectively, and are preset distance threshold boundaries; Step S3, a time-based smooth interpolation algorithm is applied to perform gradual switching between adjacent LOD levels and eliminate visual jumps during switching; ; where, is the current actual rendered LOD level value, is the level before switching, is the target level, is a smooth interpolation function that guarantees first derivative continuity, is a normalized transition time parameter that controls the visual smoothness of the transition.

2. The method according to claim 1, characterized in that to the effective distance metric Adaptive correction of the screen projection area is performed to take into account the effect of the actual visible size of the object on the screen on the LOD selection: where, is the total screen pixel area of the current render target, is the projected pixel area of the object on the screen plane.

3. The method of claim 2, wherein, weights of the object importance The different types of buildings are differentiated by the LOD strategy through the weighted combination of multi-dimensional factors: wherein, is the semantic importance weight, preset different values according to the functional type of the building, and the landmark building has the highest weight; is the geometric complexity weight, calculated by the number of polygons and geometric feature complexity of the building model, and the higher the complexity, the greater the weight; is the user attention weight, calculated based on historical user interaction data, and the higher the attention, the higher the weight of the building; the constraint condition is: , to ensure the normalization of the weight, is the constraint condition coefficient, which can be dynamically adjusted according to the application scenario.

4. The method of claim 3, wherein, Smooth interpolation function The specific calculation is: where, and are tangent vector parameters of the start and end points, respectively, , , are basis functions of the smoothing interpolation function . ， ， 。 5. The method of claim 4, wherein, Real-time rendering is realized based on GPU parallel computing architecture, and the processing procedure of LOD is as follows: Step S21: Divide the entire city model into Regular grid units, each unit performs LOD calculation and rendering processing independently, where The value of is dynamically determined based on scene complexity and GPU performance, and the default value is 50 meters; Step S22, compute the LOD decision matrix in parallel for each grid cell , the decision matrix stores the optimal LOD level for each object within the cell ; wherein, denotes a grid coordinate, is a candidate integer LOD level; Step S23, batch geometry subdivision and vertex data mixing are implemented in GPU shader, and LOD interpolation calculation output of multiple vertices is realized through parallel processing ; wherein, is a first layer of a Boolean index mask matrix, is a vertex attribute array corresponding to the LOD layer, is a blending weight computed based on a time parameter , all weights satisfying a normalization condition .

6. The method of claim 5, wherein, Continuously monitor rendering performance indicators, define performance ratio : , is a preset target frame rate, 60fps or 30fps, is the actual rendering frame rate at the current moment; The distance threshold values of all LOD levels are dynamically adjusted based on performance ratio to realize adaptive control of rendering load: ； wherein, and are the old and new values of the threshold, respectively, is an adjustment strength parameter to ensure a smooth change of the threshold, avoiding sudden LOD level jumps.

7. The method of claim 6, wherein, The required detail levels are prepared in advance by predicting the observation path of the user, the future time LOD demand is predicted based on camera motion, and the calculation delay during switching is reduced.

8. The method of claim 7, wherein, establishing a corresponding level of texture resolution for each LOD level k maintaining a match between the geometric complexity and the texture accuracy: wherein, is the base texture resolution used for the highest level of detail, is a texture scaling factor; Synchronize the progressive blending of the texture in the LOD switching process to avoid visual discontinuity caused by texture change: ; wherein, is the texture data of the layer, is the normalized texture coordinate.

9. A city 3D model rendering system for performing the method of any one of claims 1-8, characterized by The system comprises a model management module, a distance measure calculation module, an LOD decision module, a smooth interpolation module and a rendering output module; The model management module is used for constructing and maintaining the multi-level detail model of each building object in the city scene, the model management module comprises a model preprocessing unit, an LOD level generation unit and a model index unit, wherein the model preprocessing unit is responsible for geometric optimization and topological simplification of the original three-dimensional model, the LOD level generation unit automatically generates at least three model versions of different detail levels based on the principle of decreasing geometric complexity, and the model index unit establishes the mapping relationship between the model identification and each LOD level thereof; The distance measure calculation module is used for real-time calculation of the effective distance measure from the observation point to the target object; The LOD decision module is used for determining the target detail level of each object based on the effective distance measure; The smooth interpolation module is used for realizing time-based smooth transition between adjacent LOD levels; The rendering output module is used for converting the processed LOD data into final visual output, and the module comprises a geometric data mixing unit, a shader scheduling unit and a frame buffer management unit, wherein the geometric data mixing unit synthesizes the final vertex and index data according to the interpolation weight, the shader scheduling unit coordinates the allocation of GPU computing resources, and the frame buffer management unit controls the output and display of the rendering result.

10. The system of claim 9, wherein, The system further comprises a user interaction analysis module, and the user interaction analysis module comprises an interaction behavior recording unit, an attention degree statistical unit and a personalized weight adjustment unit; The interaction behavior recording unit tracks the operation behaviors of clicking, zooming and staying of the user; The attention degree statistical unit analyzes the attention mode of the user to different regions and buildings, and the personalized weight adjustment unit dynamically adjusts the object importance weight according to the user preference to realize the personalized LOD optimization strategy.

Images