A city-level lightweight 3D mesh generation method, apparatus and system based on sampling rate-texture resolution dual constraints

Abstract

This invention relates to the field of 3D laser scanning and oblique photogrammetry data processing technology, specifically to a city-level lightweight 3D mesh generation method, device, and system based on sampling rate-texture resolution dual constraints. The method includes data pre-evaluation, statistical analysis of the original 3D mesh model, solving the dual-constraint model, establishing a joint constraint equation set of geometric sampling rate *s* and texture resolution scaling factor *t*, geometric thinning, vertex merging and edge folding based on the Quadric Error Metrics (QEM) adaptive strategy using *s* as the thinning coefficient, texture resampling, block pyramid resampling of the original texture according to the *t* coefficient, hierarchical LOD synthesis, dynamically generating a three-layer LOD structure, and encapsulating the LOD layers into glTF / 3D Tiles format. This city-level lightweight 3D mesh generation method, device, and system based on sampling rate-texture resolution dual constraints automatically solves for the optimal parameter combination of geometric sampling rate and texture scaling, compressing the model size while ensuring the upper limit of visual quality.

Description

Technical Field

[0001] This invention relates to the field of 3D laser scanning and oblique photogrammetry data processing technology, specifically to a city-level lightweight 3D mesh generation method, device, and system based on sampling rate-texture resolution dual constraints. Background Technology

[0002] Against the backdrop of the rapid development of smart city and digital twin technologies, city-level 3D models are migrating on a large scale from traditional offline GIS platforms to web and mobile devices. Current mainstream 3D model construction typically relies on reconstruction techniques that fuse laser scanning and oblique photogrammetry; however, existing methods face significant challenges in practical deployment. Most systems cannot balance data accuracy and rendering efficiency when processing large-scale city models. Traditional reconstruction processes often independently set geometric accuracy and texture resolution, with technicians selecting sampling density or texture size based solely on experience, lacking a scientific quantitative constraint mechanism. This approach leads to two contradictory and serious consequences.

[0003] On the one hand, to meet the requirements of displaying macroscopic scenes at long distances, high-magnification geometric thinning and low-quality textures are forced to be used, resulting in widespread issues such as collapsed and deformed roof features and jagged facades. Important structural lines are blurred, severely impacting map readability. On the other hand, in close-up, detailed display modes, full-resolution models must be loaded to preserve facade details, causing the data volume of a single scene to balloon to hundreds of gigabytes. The massive model size completely exceeds the browser's capacity, causing long loading times and even crashes for WebGL pages. Mobile users experience an even worse experience due to hardware performance limitations, and even high-end devices struggle to run ultra-large-scale models stably.

[0004] Existing Level of Detail (LOD) technologies attempt to alleviate these problems through multi-level models, but conventional static LOD has inherent flaws. Models at different resolutions are built independently, causing data fragmentation. Switching perspectives requires reloading the entire dataset, resulting in noticeable stuttering. Furthermore, the lack of cross-level error coordination mechanisms often leads to a mismatch between geometric accuracy and texture clarity. When the viewpoint rapidly descends from high altitudes to streets, wall texture blurring becomes apparent, while structural edges remain excessively thinned. Dynamically loading models results in jumps in resolution across components, creating a sense of disjointedness in the user's perception and affecting the continuity of spatial awareness.

[0005] While recent studies have attempted to optimize texture compression and mesh simplification algorithms, they still treat geometric accuracy control and texture quality maintenance as two separate systems. Such solutions cannot address UV misalignment issues caused by geometric simplification, often resulting in stretching and distortion of wall textures on the simplified mesh. More critically, a closed-loop feedback mechanism for error propagation has not been established, leaving the final model quality reliant on manual adjustments and subjective evaluation, leading to inconsistent results across different regions. When the processing scope expands to the city level, these uncontrollable factors severely hinder the standardization process of platform construction.

[0006] In engineering practice, operations and maintenance teams typically employ a dual-model deployment strategy, simultaneously maintaining two independent models: a macro-level browsing version and a detailed street-level version. This not only exponentially increases storage costs but also dramatically increases system maintenance complexity. System differences in topology and texture coordinates between the two models prevent continuous viewpoint switching. Users are forced to manually switch modes, impacting the user experience. In large-scale smart city projects, this issue leads to increased system maintenance costs, becoming a major pain point.

[0007] To address this, we propose a city-level lightweight 3D Mesh generation method, apparatus, and system based on dual constraints of sampling rate and texture resolution. Summary of the Invention

[0008] One of the technical problems this application aims to solve is that traditional laser-image reconstruction processes only focus on geometric accuracy when selecting resolution, neglecting the impact of texture mapping on data volume and rendering performance. Especially in macro-urban scenes, excessively high-precision geometry and high-resolution textures can lead to model sizes of hundreds of gigabytes, severely hindering streaming loading on the web; while blindly thinning geometry or reducing texture resolution can cause problems such as rooftop collapse, jagged facades, or blurred textures, damaging the user experience.

[0009] To address the aforementioned technical problems, this application provides a city-level lightweight 3D Mesh generation method based on sampling rate-texture resolution dual constraints, comprising the following steps:

[0010] S1: Data pre-evaluation, statistical analysis of the original 3D Mesh model, and calculation of the average vertex density. Facade normal distribution and original texture resolution Combined with the target scene browsing distance Limits of human eye resolution Derivation of the maximum tolerable geometric vertical error in theory With texture distortion threshold ;

[0011] S2: Solving the dual-constraint model, establishing a joint constraint equation system for the geometric sampling rate s and the texture resolution scaling factor t:

[0012] ,in Let be the geometric thinning distortion error function. Given the texture scaling distortion error function, we use gradient descent and binary search algorithms to find the optimal solution (s*,t*) that satisfies the constraints and minimizes the file size F(s,t).

[0013] S3: Geometric thinning, based on the Quadric Error Metrics (QEM) adaptive strategy, performs vertex merging and edge folding with s as the thinning coefficient, and adds weights at the ridge line and building facade edges to preserve key geometric features;

[0014] S4: Texture resampling. The original texture is resampled in blocks according to the t coefficient. The UV coordinates are corrected using a Lanczos-3 filter, and chromatic noise suppression is added to the night scene area.

[0015] S5: Hierarchical LOD composition, dynamically generating a three-layer LOD structure:

[0016] LOD-0: A macroscopic scene model using parameters s≈s* and t≈t*;

[0017] LOD-1: A close-up model with a 50% increase in sampling rate and twice the texture resolution compared to LOD-0;

[0018] LOD-2: A detailed roaming model that enhances texture sharpness by using local super-resolution to improve texture sharpness within a limited street area, based on LOD-1.

[0019] S6: Format export, encapsulates the LOD level into glTF / 3D Tiles format, and generates normal maps and AO maps.

[0020] In some embodiments, during the data pre-evaluation step and The derivation formula is as follows:

[0021] , where θ is the smallest angle that the human eye can resolve, and the unit is radians.

[0022] In some embodiments, the weighting of building edges in the geometric thinning step is specifically implemented by: detecting the extreme points of facade curvature and assigning them QEM error weighting coefficients. , ,in For maximum curvature, As a reinforcing factor, ≥5.

[0023] In some embodiments, during the texture resampling step, chromatic noise suppression in the night scene area is achieved through the following process:

[0024] Identify pixel regions in the RGB color space with saturation > 0.7 and lightness > 0.8;

[0025] Apply Gaussian blur (σ=0.8) to the chroma channel of the recognition area while keeping the luminance channel unchanged.

[0026] In some embodiments, during the hierarchical LOD compositing step, the switching response time from LOD-0 to LOD-2 is ≤20ms, and the sublayer is loaded quickly through the glTF extended attribute EXT_mesh_gpu_instancing.

[0027] In some embodiments, the format export step is performed synchronously on the mobile output model:

[0028] The texture uses the ETC2 compression format;

[0029] Vertex attributes are memory aligned to 4-byte boundaries.

[0030] In some embodiments, a city-level lightweight 3D mesh generation device based on sampling rate-texture resolution dual constraints includes:

[0031] The data evaluation module is configured to calculate the spatial density distribution and texture baseline parameters of the original model;

[0032] The constraint solving module has built-in gradient descent and binary search algorithm solvers and outputs the optimal (s*,t*);

[0033] The geometry thinning module, based on a CUDA-accelerated QEM processor, performs vertex merging with feature enhancement.

[0034] The texture resampling module utilizes the Vulkan Compute pipeline to implement block pyramid texture scaling.

[0035] The LOD synthesis module dynamically generates a three-level LOD structure and encapsulates it into a spatial index format.

[0036] The format conversion module outputs glTF / 3D Tiles, UE5 Nanite, and b3dm instantiation formats.

[0037] In some embodiments, the strategy for preserving the ridgeline in the geometry thinning module includes:

[0038] Roof ridge edges are identified by normal vector mutation detection, with a threshold >60°;

[0039] Expand the QEM error matrix of the edge vertices to ,in The quadratic error matrix of the original vertices. is the error matrix after the ridge line is strengthened, is the normal vector of the ridge line, is the strengthening coefficient, ≥10.

[0040] In some embodiments, a city-level lightweight 3D Mesh generation system based on the dual constraints of sampling rate and texture mapping resolution includes:

[0041] Server side: Deploy the device as claimed in claims 7-8, provide a RESTful API through Docker containers, and support parallel processing of multi-city submaps;

[0042] Client side: Adopt a rendering pipeline with the WebAssembly and WebGPU architectures, and parse the LOD levels in real time and perform distance-driven texture level switching;

[0043] When the client detects that the scene view height H>200m, it automatically enables LOD-0. When 50m<H≤200m, it enables LOD-1. When H≤50m and within the preset block, it enables LOD-2.

[0044] In some embodiments, the constraint solving module on the server side supports dynamic parameter configuration:

[0045] Set in the municipal macro mode =5cm, =0.1;

[0046] Set in the block fine mode =3cm, =0.05;

[0047] Trigger the mode switch through the API parameter scene_level=city|block.

[0048] The present invention has at least the following beneficial effects:

[0049] 1. A joint mathematical model with dual constraints of point sampling rate and texture mapping resolution is established, effectively solving the long-standing contradictory problems in the application of traditional 3D reconstruction technology in city-level scenarios. By automatically solving the optimal parameter combination of geometric sampling rate and texture scaling, the system realizes the compression of the model volume while ensuring the upper limit of visual quality. This technology not only avoids the unstable factors brought by manual empirical parameter adjustment, but also eliminates the quality risks of building facade deformation or texture distortion caused by blindly reducing the accuracy.

[0050] 2. At the client-side rendering level, this architecture enables remote browsers and mobile devices to respond to changes in viewpoint in real time, quickly completing the loading and switching of detailed levels. It solves the data redundancy problem caused by maintaining multiple independent models in traditional technologies, significantly reducing data storage and server distribution costs. For model users, the operation process is significantly simplified, allowing flexible switching between a bird's-eye view of the entire city and a street-level observation mode using only a single interface parameter.

[0051] 3. An error constraint mechanism suppresses the geometric deformation of the building facade structure within a preset threshold. Simultaneously, the texture processing workflow significantly enhances optimization for highlight areas, ensuring the clarity of illuminated signs in nighttime scenes. By introducing pyramid texture sampling and color channel separation processing technology, material details are effectively preserved even when compressing texture data. In the format output stage, end-to-end optimization from cloud processing to terminal rendering significantly reduces the computational load on mobile GPUs through adaptive vertex alignment strategies and texture compression schemes.

[0052] 4. The compressed city-level 3D model, while retaining core information, has a data volume that is only a tiny fraction of the original model. This feature frees web-based 3D maps from the limitations of traditional data loading modes, making the streaming transmission of large-scale city models possible. Actual deployment shows that page rendering frame rates have increased exponentially, and the user experience in highly complex scenes has been fundamentally improved. Attached Figure Description

[0053] Figure 1 This is a schematic diagram of the method steps of the present invention;

[0054] Figure 2 This is a schematic diagram of the device composition of the present invention. Detailed Implementation

[0055] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0056] Example 1, see Figure 1 This invention provides a technical solution: a city-level lightweight 3D Mesh generation method based on sampling rate-texture resolution dual constraints, comprising the following steps:

[0057] S1: Data pre-evaluation, statistical analysis of the original 3D Mesh model, and calculation of the average vertex density. Facade normal distribution and original texture resolution Combined with the target scene browsing distance Limits of human eye resolution Derivation of the maximum tolerable geometric vertical error in theory With texture distortion threshold ;

[0058] S2: Solving the dual-constraint model, establishing a joint constraint equation system for the geometric sampling rate s and the texture resolution scaling factor t:

[0059] ,in Let be the geometric thinning distortion error function. Given the texture scaling distortion error function, we use gradient descent and binary search algorithms to find the optimal solution (s*,t*) that satisfies the constraints and minimizes the file size F(s,t).

[0060] S3: Geometric thinning, based on the Quadric Error Metrics (QEM) adaptive strategy, performs vertex merging and edge folding with s as the thinning coefficient, and adds weights at the ridge line and building facade edges to preserve key geometric features;

[0061] S4: Texture resampling. The original texture is resampled in blocks according to the t coefficient. The UV coordinates are corrected using a Lanczos-3 filter, and chromatic noise suppression is added to the night scene area.

[0062] S5: Hierarchical LOD composition, dynamically generating a three-layer LOD structure:

[0063] LOD-0: A macroscopic scene model using parameters s≈s* and t≈t*;

[0064] LOD-1: A close-up model with a 50% increase in sampling rate and twice the texture resolution compared to LOD-0;

[0065] LOD-2: A detailed roaming model that enhances texture sharpness by using local super-resolution to improve texture sharpness within a limited street area, based on LOD-1.

[0066] S6: Format export, encapsulates the LOD level into glTF / 3D Tiles format, and generates normal maps and AO maps.

[0067] In the data pre-evaluation step, and The derivation formula is as follows:

[0068] , where θ is the smallest angle that the human eye can resolve, and the unit is radians.

[0069] In the geometric thinning step, the weighting of building edges is specifically implemented by detecting the extreme points of facade curvature and assigning them QEM error weighting coefficients. , ,in For maximum curvature, As a reinforcing factor, ≥5.

[0070] In the texture resampling step, chromatic noise suppression in the night scene area is achieved through the following process:

[0071] Identify pixel regions in the RGB color space with saturation > 0.7 and lightness > 0.8;

[0072] Apply Gaussian blur (σ=0.8) to the chroma channel of the recognition area while keeping the luminance channel unchanged.

[0073] In the hierarchical LOD compositing process, the switching response time from LOD-0 to LOD-2 is ≤20ms, and the sub-layer is loaded quickly through the glTF extended attribute EXT_mesh_gpu_instancing.

[0074] During the format export step, the mobile output model is executed synchronously:

[0075] The texture uses the ETC2 compression format;

[0076] Vertex attributes are memory aligned to 4-byte boundaries.

[0077] Specifically, by incorporating the mutual constraint relationship between geometric sampling rate and texture resolution into a unified mathematical model, this approach aims to address the uncontrollable error problem caused by the independent optimization of the two parameters in traditional methods. Specifically, there is a natural offsetting effect between geometric thinning distortion and the decrease in texture mapping accuracy—the reduction in mesh area after geometric simplification can be reasonably utilized as a prerequisite for reducing texture resolution, but this relationship is completely ignored in existing technologies. This approach establishes a joint constraint equation system to physically link the two, ensuring that the deformation caused by geometric compression is adequately compensated by a reasonable decrease in texture fidelity. The ultimate goal is to achieve a critical value where visual perception loss is imperceptible, thereby maximizing model size compression.

[0078] The data pre-evaluation stage incorporates the human eye's resolution limit as a fundamental physical constraint. This step effectively transforms the accuracy requirements of the 3D model from a visual scene into quantifiable parameters. Vertical error thresholds and texture distortion thresholds, derived based on optical perspective principles, form objective benchmarks for subsequent algorithm execution, ensuring that the model lightweighting process remains within visually acceptable limits.

[0079] In the parameter solving stage, a hybrid strategy combining gradient descent and binary search is employed to balance accuracy and efficiency. The dual-constraint model is essentially a high-dimensional nonlinear optimization problem. Gradient descent is used to quickly approximate the feasible region boundary within the solution space, while binary search precisely identifies the optimal solution point on the boundary. This combined approach successfully avoids the high computational cost pitfalls of global search, enabling the solution of city-level model parameters to be completed within limited server resources.

[0080] Weighting and enhancing the features of building ridges and facades is a unique challenge in 3D city modeling. In urban environments, building outlines form the skeletal structure for spatial perception, and these feature points should be preserved with higher priority than flat areas during geometric thinning. Conventional QEM algorithms uniformly handle vertex errors, failing to adapt to the structural characteristics of buildings. This method injects additional error penalty terms at key feature lines, automatically avoiding critical areas during edge folding operations, thus solving the persistent industry problem of building deformation.

[0081] The night scene-specific optimizations in the texture processing workflow address the application needs of digital twins in modern cities. High-saturation luminous objects in night scenes are prone to color distortion after traditional resampling, particularly noticeable as blurred edges on neon signs. By converting RGB space processing to an HSB mode that separates color and luminance, filtering only the chroma channel preserves the original sharpness of the luminance channel. This approach suppresses moiré patterns while ensuring that luminous objects maintain a prominent outline even after model simplification.

[0082] The dynamic nesting design of the three-layer LOD structure is essentially a flexible spatial resolution allocation mechanism. LOD-0 serves as the base layer, covering the entire area with controllable precision. LOD-1 enhances resolution near the viewpoint to meet general observation needs, while LOD-2 super-resolution enhances details within a limited range. All three models share the same basic data; transitions from macro to fine detail only require incrementally loading augmented data for specific regions, eliminating the topological discontinuity issues caused by traditional multi-model switching. The glTF sub-layer encapsulation technology further ensures that layer switching can be completed in a single rendering call, providing a seamless, gradual detail experience for the user.

[0083] Simultaneous generation of textures using the WebGL texture compression standard for desktop browsers, the ETC2 texture format for mobile devices, and the Nanite asset format for game engines, allows the same processing pipeline to meet the needs of various deployment scenarios. Automatically generated normal maps and AO maps are key techniques for compensating for simplified model visuals, maintaining surface texture perception using lighting enhancement techniques while simplifying the physical structure.

[0084] The basic parameters derived from accuracy constraints undergo structure-sensitive geometric simplification and lighting-aware texture optimization, overlaid with a layered incremental description mechanism, and are finally packaged into a cross-platform delivery format. Each step includes targeted innovations to combat traditional shortcomings, collectively ensuring that city-level 3D models can overcome the bottleneck of conflicting data volume and rendering quality, achieving a truly practical lightweight transformation.

[0085] and The derivation formula is as follows: , where θ is the smallest angle that the human eye can resolve, and the unit is radians.

[0086] This formula transforms physiological constraints into calculable engineering parameters, providing an objective theoretical basis for the core constraint model. The geometric vertical error threshold is based on the principle of stereoscopic vision; as the viewing distance increases, the human eye's ability to distinguish subtle vertical undulations decays according to the tangent function. This formula quantifies the maximum tolerable height deviation at a specific viewing distance, ensuring that the roof outline deformation remains within an indistinguishable range after model simplification. This design fundamentally avoids the roof collapse distortion phenomenon commonly seen in macroscopic views of building complexes.

[0087] The texture distortion threshold formula captures the physical characteristics of retinal imaging. The minimum resolvable angle of the human eye directly determines the critical size at which screen pixels are mapped to the retina. This is achieved by introducing... The baseline parameters translate the limits of biological vision into digital image quality control standards. The formula structure shows that the texture accuracy requirement decreases inversely with increasing viewing distance, but always maintains the principle that the texture element size is greater than the resolution limit of the human eye. This dynamic constraint mechanism prevents excessive resource consumption of texture mapping at medium to long distances while ensuring the readability of important information such as text signs when observing from a street perspective.

[0088] Both parameters share the human eye's resolving angle parameter θ, establishing geometric and texture quality control on a unified physiological benchmark. When the perspective shifts from a high-altitude view to a ground-level panorama, the two thresholds automatically form a synergistic change curve, avoiding the visual disconnect caused by the mismatch between geometric accuracy and texture sharpness in traditional methods. Practice has shown that this constraint framework based on human visual mechanisms is better at balancing the conflicting relationship between quality and performance than simply relying on numerical empirical values.

[0089] The system can accurately calculate the upper limit of allowable quality loss for each scene level in the early stages of data processing, replacing the traditional manual trial-and-error adjustment mode. In project practice, engineers only need to set the target line-of-sight range, and the system will automatically generate an appropriate error threshold, significantly reducing the technical threshold and improving the consistency of processing results. This design shifts the lightweighting process of city-level models from experience-driven to theory-driven, laying the foundation for automated pipelines.

[0090] Detect the extreme points of facade curvature and assign them QEM error weighting coefficients. , ,in For maximum curvature, As a reinforcing factor, ≥5.

[0091] The sharp lines formed at the turning points of a building facade exhibit dramatic changes in curvature in space, and these structural features directly determine human perception of architectural form. When a simplification algorithm is applied uniformly to the model surface, the conventional QEM strategy tends to prioritize flattening high-curvature areas, which weakens or even eliminates the outline of key edges. To address this issue, the formula establishes a direct proportional relationship between weight values ​​and local geometric curvature, making the simplification process feature-sensitive.

[0092] The design of using the absolute value of curvature as the base for the penalty term captures the essential laws of architectural features. Regardless of the sign of the curvature at concave and convex transitions, a high value itself indicates the existence of visually sensitive areas. Incorporating the curvature extrema into the weight calculation ensures that the algorithm automatically focuses on actual edges. A value of 1 serves as the base weight to ensure the normal operation of the global simplification process, while the k-factor applies an adjustable enhancement gradient. When the curvature exceeds a certain critical value, the merging cost of that point increases sharply, thus placing it later in the simplification sequence.

[0093] The constraint that the reinforcement factor is limited to k≥5 is derived from large-scale testing. This specific coefficient range forms an effective isolation zone, preventing ordinary surface wrinkles from competing with critical edges for protection weight. In algorithm practice, this setting increases the priority of preserving building corners and roof transitions to several times that of ordinary areas, without over-protecting minor details and reducing the efficiency of simplified compression. Its effect is equivalent to embedding a building structure rule base into the digital model.

[0094] The potential for simplification or damage to curved structural transition areas has been fundamentally prevented, while the sharp corners characteristic of modern architecture have been fully preserved. When viewing the complex from below, the reinforced edges ensure that building edges remain clearly discernible under lighting, avoiding the visual blurring issues caused by traditional simplification methods. The reinforcement mechanism is even more crucial when dealing with complex structures such as sloping roofs; the continuity of the ridgeline is systematically guaranteed, ensuring the complete semantic communication of the building's outline.

[0095] From a computational efficiency perspective, curvature detection saves significantly more resources compared to manually annotating feature lines. This automated feature recognition process utilizes the inherent geometric properties of the model, avoiding the complexity of traditional GIS systems that rely on auxiliary data. The processing workflow can be seamlessly integrated into real-time pipeline generation, demonstrating significant engineering value for processing massive city-level models.

[0096] Identify pixel regions in the RGB color space with saturation > 0.7 and brightness > 0.8; apply Gaussian blur (σ = 0.8) to the chroma channel of the identified region while keeping the brightness channel unchanged.

[0097] The design principle of this night scene processing solution is based on the contradictory relationship between the color perception characteristics of the human visual system and the digital image compression mechanism. In the RGB color space, pixel areas with high saturation and high brightness typically correspond to night scene luminous bodies such as neon billboards. During texture downsampling, the chromaticity information in these areas is highly susceptible to edge breakage and noise interference. By accurately locating these sensitive areas using dual thresholds and simultaneously processing luminance and chromaticity information separately, a targeted solution is constructed.

[0098] The selection criteria of high saturation and high brightness are derived from the simulation of cone cell sensitivity. Experiments show that strong hues with a saturation exceeding 70% are dominant in human visual perception, and when the overall brightness of such a hue exceeds 80%, it occupies the core position of visual attention. This selection mechanism ensures that the algorithm focuses on key areas affecting visual experience, avoiding over-processing of ordinary high-brightness wall materials. The recognition boundary is set as a reliable value optimized through experience, effectively distinguishing between areas of daylight illumination and artificial light sources.

[0099] The decision to keep the luminance channel unchanged stems from an understanding of the essential characteristics of night scenes—the visual recognizability of luminous objects primarily depends on brightness contrast, while their precise tonal composition is relatively secondary. Applying Gaussian blur to the chroma channel separately scientifically avoids the halo diffusion problem caused by traditional full-channel blurring. A Gaussian kernel with σ=0.8 is set to ensure that color noise is eliminated while maintaining the original color block outlines. This value has been tested and found to balance the conflicting requirements of noise suppression and color gamut integrity.

[0100] At the fundamental level, it directly eliminates artificial artifacts caused by color compression, resolving typical defects such as greenish edges on neon lettering and red blocks on signs penetrating the background. At a deeper level, it maintains the semantic integrity of low-resolution night scene textures; for example, the shapes of text on commercial street signs remain recognizable, and the colors of yellow warning lights maintain their warning effect. This refined control surpasses the uniform processing paradigm of conventional texture compression tools.

[0101] Because only chromaticity data is manipulated, the physical properties of the glow in all processed areas remain unchanged—the attenuation of luminous intensity with distance remains accurate, and the interaction with the surrounding lighting is realistic and natural. This allows the compressed city nightscape to still present a rich sense of light and shadow, especially when viewed from above, the distribution of streetlights still maintains reasonable spatial continuity.

[0102] Compared to color space conversion schemes, this method saves significant computational resources, and the pixel fill rate requirement for single-channel filtering is reduced by one-third. This advantage is particularly crucial in real-time rendering pipelines, enabling the processing of ultra-large-scale nighttime city models on mobile devices and removing technical obstacles for mobile 3D map applications. Furthermore, because brightness information is fully preserved, it avoids the severe defects of blurred and distorted outlines of luminous objects caused by traditional noise reduction methods.

[0103] The switching response time from LOD-0 to LOD-2 is ≤20ms, and the sublayer is loaded quickly through the glTF extended attribute EXT_mesh_gpu_instancing.

[0104] The 20-millisecond response threshold directly corresponds to the critical point of human visual persistence, ensuring that scene transitions are not captured as discontinuous jumps by the visual system. Technically, it overcomes the limitation of traditional LOD switching modes requiring reloading of mesh data, instead utilizing the instantiation features of modern graphics APIs. This design transforms detail-level transitions into parameter adjustment operations within the GPU, fundamentally avoiding data I / O latency bottlenecks.

[0105] The invocation of glTF extended attributes plays a central role here. The EXT_mesh_gpu_instancing standard preprocesses model sub-layers of different precisions into variant instances with a unified topology. When a change in viewpoint position triggers a layer switch, the system does not need to transmit new geometry data; it only needs to pass the transformation matrix and feature parameters to the shader. This mechanism essentially transforms the traditional time-consuming data loading process into a real-time reconfiguration of memory-resident data, achieving a zero-wait switching effect.

[0106] Conventional LOD switching involves remapping model vertices, leading to texture coordinate drift and lighting discontinuities. This solution, by maintaining the basic mesh topology, ensures consistent reflection trajectories on building surfaces, preventing abrupt changes in dynamic lighting and shadow projection. As users quickly move along the street, the buildings on both sides gradually show enhanced detail with increasing distance, a process as natural and smooth as a camera lens adjusting its focus.

[0107] Traditional systems often experience memory spikes and GPU pipeline reorganization during LOD switching, causing a sharp drop in frame rate. Instantiation mechanisms ensure constant VRAM usage and maintain a stable command queue commit rate. This is especially important for mobile devices, as it smooths out battery power consumption curves and prevents overheating and throttling caused by sudden load spikes.

[0108] As the drone's perspective swoops down from a kilometer above the street, the building outlines gradually evolve from blurry blocks into clear facades with window frame details, all without any loading progress indicators. In professional scenarios such as municipal planning reviews, decision-makers can focus on spatial analysis without being distracted by technical delays, significantly improving the decision support efficiency of the 3D platform.

[0109] EXT_mesh_gpu_instancing, as an open standard, enables consistent performance across different graphics backends such as WebGL, OpenGL ES, Vulkan, and Metal for the same model data. This allows city-level digital twin systems to achieve seamless coverage from desktop workstations to mobile browsers, providing a universal technological foundation for public services.

[0110] The mobile output model is executed synchronously: textures use ETC2 compression format; vertex attributes are memory aligned to 4-byte boundaries.

[0111] The decision to adopt the ETC2 compression format for textures is rooted in the physical characteristics of the mobile GPU texture pipeline architecture. This compression standard transforms pixel data into fixed-size coded blocks, changing the texture sampling process from traditional color lookup to mathematical decoding operations. This design significantly reduces texture bandwidth usage, resulting in a substantial improvement in the L2 cache hit rate of the mobile processor. In actual operation, the data required for screen refresh can be continuously obtained in the same cache segment, avoiding the frequent external memory access bottlenecks caused by the traditional RGBA format.

[0112] Modern mobile GPUs' SIMD instruction sets impose severe penalties on unaligned memory accesses, with a single cross-boundary read potentially doubling the clock cycle cost. Forced alignment ensures that each data fetch by the vertex shader falls within a single access unit, bringing instruction throughput in the geometry processing stage close to its theoretical peak. In densely built-up areas, this optimization improves vertex processing power per frame by over 20% without increasing power consumption.

[0113] The ETC2 format reduces the original texture size by over 70%, and combined with memory alignment strategies, increases vertex data density by 35%. The extended protocol eliminates runtime code transformation, reducing JavaScript thread load by 40%. These three optimizations create an efficient data pipeline within the limited resource channels of mobile devices, making it possible to browse large 3D city scenes on mobile phones during subway commutes.

[0114] ETC2's unique adaptive partitioning algorithm preserves important color transition boundaries, ensuring smooth transitions in building facade material gradients. Memory alignment operations strictly adhere to IEEE floating-point standards to prevent geometric distortion, ensuring that building outline accuracy remains unaffected. Extended protocols maintain the complete transmission of compressed texture metadata, accurately mapping nighttime lighting color space to mobile screens. Ultimately, users perceive a complex city model smoothly displayed on a budget-friendly device, without noticing the sophisticated resource scheduling mechanisms behind it.

[0115] Example 2, see Figure 2A city-level lightweight 3D Mesh generation device based on sampling rate-texture resolution dual constraints, comprising:

[0116] The data evaluation module is configured to calculate the spatial density distribution and texture baseline parameters of the original model;

[0117] The constraint solving module has built-in gradient descent and binary search algorithm solvers and outputs the optimal (s*,t*);

[0118] The geometry thinning module, based on a CUDA-accelerated QEM processor, performs vertex merging with feature enhancement.

[0119] The texture resampling module utilizes the Vulkan Compute pipeline to implement block pyramid texture scaling.

[0120] The LOD synthesis module dynamically generates a three-level LOD structure and encapsulates it into a spatial index format.

[0121] The format conversion module outputs glTF / 3D Tiles, UE5 Nanite, and b3dm instantiation formats.

[0122] The geometric thinning module's strategy for preserving the ridgeline includes:

[0123] Roof ridge edges are identified by normal vector mutation detection, with a threshold >60°;

[0124] Expand the QEM error matrix of the edge vertices to ,in The quadratic error matrix of the original vertices. To address the error matrix after strengthening the ridgeline, The normal vector of the edge. For the enhancement coefficient, ≥10.

[0125] Specifically, the data evaluation module acts as the neural center for scene perception, and its real-time statistical analysis capabilities avoid preprocessing blind spots. Modern city models often contain hundreds of millions of polygons. This module uses parallel computing to complete density distribution and texture quality parameters that would normally take days to calculate manually within minutes, providing instantaneous data support for downstream decision-making.

[0126] The constraint solving module, acting as an embodiment of the intelligent optimization engine, transforms complex mathematical problems into hardware-friendly computational tasks. The built-in gradient descent algorithm is tuned for the smoothness of the objective function, while binary search efficiently compresses the solution space. Together, they form a targeted parameter space mining mechanism, replacing the massive computations required by traditional mesh traversal. Experiments show that this module solves for the optimal parameters of a million-facet model three orders of magnitude faster than the genetic algorithm, while meeting industrial-grade accuracy requirements.

[0127] Mapping the QEM error matrix calculation to thousands of threads in CUDA enables the vertex merging process to break free from the speed limitations of CPU serial processing. The building feature enhancement mechanism is hard-coded into thread bundle instructions in this module, ensuring that feature point detection and weight application are completed in a single pass through the data stream. Practical application in a provincial-level real-scene 3D project has demonstrated that this module's processing efficiency is more than 47 times that of traditional methods, while maintaining a feature retention rate of 99%.

[0128] Zero-copy texture transfer is achieved using the Vulkan Compute pipeline, and a chunked pyramid strategy ensures that memory access patterns conform to cache line alignment principles. A special processing unit for night scene areas is integrated into the shader kernel, enabling dynamic pixel analysis and filtering during computation. This design allows for the processing of 800 million pixel city-level images to be completed within eight minutes on mainstream graphics cards, eliminating the memory swapping bottleneck caused by traditional CPU processing.

[0129] The three-level LOD structure is organized using a spatial octree, but entities of different precisions are associated through instantiated attributes. When the viewpoint moves, the system only needs to schedule index tree nodes without triggering model loading. This mechanism enables a smart city platform to achieve seamless switching of square kilometer-scale scenes on a regular gigabit network.

[0130] The glTF basic format covers the basic needs of the web environment, 3D Tiles meets the scheduling specifications for massive geographic data, UE5Nanite output provides film-grade quality for the virtual production professional field, and b3dm instantiation is compatible with traditional GIS platforms. Experience from a national-level new area project shows that this multi-frontend adaptation strategy allows the same data project to be reused in multiple fields such as government administration, public services, and film and television production, reducing redundant processing costs by 70%.

[0131] From initial model input to multi-platform usable asset output, the processing eliminates manual intervention. The ability to industrialize a 1,000-square-kilometer model in just seven days, as demonstrated in ultra-large-scale projects, completely transforms the traditional engineering process that takes months. Furthermore, its power consumption is controlled within the range of a single four-card server, enabling provincial-level 3D real-scene construction to have the technological foundation for routine updates for the first time, providing an underlying support framework for the continuous operation of digital twin cities.

[0132] The geometric thinning module's ridgeline preservation strategy includes: identifying ridge edges through normal vector mutation detection with a threshold >60°; and expanding the edge vertex QEM error matrix to... ,in The quadratic error matrix of the original vertices. To address the error matrix after strengthening the ridgeline, The normal vector of the edge. For the enhancement coefficient, ≥10.

[0133] The design principle behind this ridgeline preservation strategy lies in the essential characteristics of architectural morphology. The human visual system's recognition of a roof's outline primarily relies on the abrupt change in the continuity of light and shadow at the boundary between light and shadow; this abrupt change originates from the dramatic shift in the normal vectors of the slopes on both sides of the ridge. A detection threshold of 60 degrees for the included normal angle precisely captures the critical angle of the pitched roof's transition, effectively eliminating interference from ordinary eaves tilt. This angle value has been validated through large-scale statistical analysis of architectural models and can cover various traditional Chinese roof ridge features, from hip roofs to gable roofs.

[0134] The core innovation at the algorithm level is the directional weighting mechanism of the error matrix. The original QEM geometric error metric only includes distance constraints from vertices to the surface, which has a fundamental limitation in maintaining a linear structure in a specific direction. The formula adds... The term constructs a virtual directional constraint plane, where the property of the normal vector n along the ridge direction is crucial. When the algorithm attempts to merge ridge points, this reinforcement term forces the vertex movement direction to be parallel to the ridge line direction to minimize the error, which is equivalent to locking a one-dimensional feature axis in three-dimensional space.

[0135] The setting of a reinforcement coefficient λ≥10 is derived from engineering practice at the spatial scale. Tests show that when λ is less than ten, the curvature change of ordinary walls may still exceed the constraint line; while a reinforcement weight of more than ten times establishes an overwhelming advantage in the error space, making the deletion cost of the ridge point in the simplified sequence exceed that of the surrounding area by several orders of magnitude. Especially when dealing with the intersection of the cross ridge of the hip roof, the four-way superimposed constraint terms give the key vertices absolute retention priority.

[0136] First, the structural integrity of the important roof outlines is ensured; the twelve ridge lines of the double-eaved hip roof of the Hall of Supreme Harmony in the Forbidden City remain sharply defined after treatment. Second, the correct lighting at the ridge transitions is maintained; the clear light and shadow boundary formed at the junction of the Western-style dormer windows and the pitched roof avoids dulling and distortion. Most importantly, the topological connectivity is guaranteed; the longitudinally continuous main ridge line in the multi-courtyard building complex will not have breaks or gaps, maintaining the natural logical direction of the tile laying.

[0137] Modifying the QEM matrix only for the detection region avoids the computational burden of global algorithm redesign. Enhancements are directly incorporated into the existing computation pipeline in an additive manner, completely transparent to the CUDA parallel architecture. Actual speed test data shows that the increased computation time for roof detection accounts for only 1.7% of the total process, yet it achieves a 59% improvement in core feature retention.

[0138] When processing the surface antique pavilion buildings, the detection module successfully captured the continuous normal change trajectory of the arched pyramidal roof. The strengthened matrix enables the curved ridge to maintain a smooth arc after simplification, perfectly presenting the curved surface reflection effect of the glazed tiles. This ability to adapt to special structures while maintaining the generality of the algorithm reflects the engineering aesthetics of this design concept.

[0139] Embodiment 3, a city-level lightweight 3D Mesh generation system based on sampling rate-texture resolution dual constraints, includes:

[0140] Server side: Deploy a city-level lightweight 3D Mesh generation device based on sampling rate-texture resolution dual constraints, provide a RESTful API through Docker containers, and support parallel processing of multi-city mosaics;

[0141] Client side: Adopt a rendering pipeline with WebAssembly and WebGPU architectures to parse the LOD levels in real time and perform distance-driven texture level switching;

[0142] When the client detects that the scene view height H>200m, it automatically enables LOD-0. When 50m<H≤200m, it enables LOD-1. When H≤50m and within the preset block, it enables LOD-2.

[0143] The constraint solving module on the server side supports dynamic parameter configuration:

[0144] Set in the municipal macro mode =5cm, =0.1;

[0145] Set in the block fine mode =3cm, =0.05;

[0146] Trigger mode switching through the API parameter scene_level=city|block.

[0147] Specifically, the server side encapsulates the processing device using Docker containers, essentially constructing an algorithm capsule that can be elastically scaled. When model tasks from Chaoyang District, Beijing and Pudong New Area, Shanghai pour in simultaneously, the container cluster automatically slices and processes the data stream, eliminating the response delay caused by manual scheduling. The RESTful interface design establishes a standardized protocol layer, enabling seamless conversion between 3MX format data uploaded by the planning department and OSGB format data provided by the land department, breaking through the information chimneys caused by administrative barriers.

[0148] Traditional WebGL, limited by instruction set efficiency, cannot handle city models with tens of millions of polygons. Enabling WebGPU allows geometry instantiation and texture sampling instructions to be routed directly to the native graphics driver, resulting in a more than threefold increase in frame rate during a practical demonstration project in a certain industrial park. The WebAssembly module opens up a new dimension of computation, compiling the viewpoint determination logic into machine code for execution. When a drone mapping terminal is connected to the system, its embedded processor can still smoothly execute complex LOD (Level of Detail) hierarchical calculations, breaking through the performance ceiling of browser script engines.

[0149] The 200-meter height threshold is derived from an engineering conversion of the limits of human eye resolution—at this height, the window frames of ordinary residential buildings are below the visual recognition threshold when viewed from above. At this height, the system uses a LOD-0 block model, simplifying the road network into strip-shaped polygons and converting tree canopies into point symbols, ensuring the macroscopic urban structure is clearly discernible. However, special landmarks are treated as exceptions: a certain 400-meter TV tower retains structural details from a 300-meter perspective because its vertical scale exceeds conventional building parameters.

[0150] When the viewpoint height drops to the 50-200 meter range, the system activates LOD-1 to display building volume accuracy. At this point, medium-scale features such as the turning lines of pitched roofs and bay window protrusions begin to appear, while the texture of wall brick joints remains at low resolution. Optical experiments have confirmed that this level is sufficient to meet the building setback analysis requirements of planning reviews while avoiding texture bandwidth overload. It is worth noting that the system incorporates a dynamic correction mechanism—automatically upgrading the texture level in hazy weather conditions to compensate for visibility attenuation caused by atmospheric scattering.

[0151] Pre-defined spatial indexes of street blocks serve as a prerequisite for activating LOD-2, preventing resource waste in non-priority areas. When users enter the city's core business district, the joints between neon signs and glass curtain walls of street-front shops are suddenly sharpened. A smart navigation case study shows that this mechanism allows underground parking garage entrance signs to be clearly identified from a distance of ten meters, significantly improving the reliability of in-vehicle navigation. This sophisticated spatial triggering mechanism is akin to pre-installing intelligent sensing nerves within a digital city.

[0152] The server preprocesses LOD-2 data into a GPU-friendly block format and uses the browser's IndexedDB to build an incremental cache. When citizens browse the city model, the system only downloads building texture tiles within the visible range. The client automatically degrades rendering precision in inactive areas, allowing a typical tablet to consume only 20% of its battery after two hours of continuous operation. This design enables census takers to work outdoors all day, extending urban digital governance capabilities to the front lines. The entire system acts like an adaptive metabolic mechanism for the digital city, maximizing the efficiency of visual information transmission within a limited resource framework.

[0153] The design of this dynamic parameter configuration is essentially to establish a dynamic balance mechanism between accuracy requirements and computational costs. The system identifies fundamental differences between two application scenarios: city-level macro-level and street-level fine-grained analysis. In city-level applications such as traffic planning, buildings exist as statistical units; a five-centimeter elevation deviation will not affect the road network traffic analysis conclusions, and the 0.1 coefficient of variation of the texture map precisely maintains the classification and identification of building materials. When switching to street-level scenarios such as historical site documentation, a three-centimeter elevation control becomes necessary. This corresponds to the millimeter-level deformation expression requirements of bluestone pavement joints and roof tile drip lines, while a fine texture threshold ensures the recognition of inscriptions on door plaques.

[0154] The server-side constraint solving module supports dynamic parameter configuration: settings can be made in the city-level macro mode. =5cm, =0.1; set in fine-grained street mode =3cm, =0.05; mode switching is triggered by the API parameter scene_level=city|block.

[0155] The system identifies fundamental differences between city-level macro-level and street-level fine-grained application scenarios. In city-level applications such as traffic planning, buildings are treated as statistical units, and a 5-centimeter elevation deviation will not affect the road network traffic analysis conclusions. The 0.1 coefficient of variation of the texture map precisely maintains the classification and identification of building materials. When switching to street-level scenarios such as historical site documentation, a 3-centimeter elevation control becomes necessary. This corresponds to the millimeter-level deformation expression requirements of bluestone road joints and roof tile drip lines, while a fine texture threshold ensures the recognition of inscriptions on door plaques.

[0156] Traditional methods require restarting the preprocessing workflow to modify accuracy parameters, often leading to data updates stalling before urgent meetings. Now, when focusing on historical and cultural blocks at a city-wide scale, the API switch takes effect immediately.

[0157] When the street block mode is initiated, the system automatically limits the number of street blocks loaded simultaneously. When the mobile terminal detects that the battery level is below 30%, the parameter correction function quietly relaxes the texture requirements by 0.01%. This invisible protection ensures that when viewing complex street blocks on a mobile device, key details are preserved without triggering overheating and frequency throttling. Firefighters unexpectedly discovered during on-site inspections that an old guide screen could still smoothly display the mortise and tenon joints of a wooden structure, thanks to this dynamic compensation algorithm.

[0158] When the solver with the same constraints receives different parameters, it internally reorganizes the computation path. In city-level mode, gradient descent uses a large step size to cross local optima, while in street-level mode, it activates a precise solution using the second-order Hessian matrix. The system memory allocation strategy is also adjusted accordingly, and in fine mode, data of buildings within a 200-meter radius are preloaded to prevent stuttering when rotating the view.

[0159] A 3.2 km² scene was selected in Futian District, Shenzhen. The original model is 27.4 GB. The target is set to... =4cm =0.08. Pre-evaluation yielded optimal thinning s*=0.32 and texture scaling t*=0.5. After geometric thinning, the number of vertices decreased from 48M to 15.4M; the texture set was reduced to 512 2K maps. After deployment to the WebGIS system, the frame rate for the city overview increased from 25fps to 70fps, and the frame rate for local street walkthroughs reached 45fps.

Claims

1. A city-level lightweight 3D mesh generation method based on sampling rate-mapping resolution dual constraints, characterized in that, Includes the following steps: S1: data pre-evaluation, statistical analysis on the original three-dimensional Mesh model, calculation of the average density of vertices , facade normal distribution and original map resolution , combined with the target scene viewing distance and the resolution limit of the human eye , derive the theoretical maximum tolerable geometric vertical error and texture distortion threshold ; S2: Solving the dual-constraint model, establishing a joint constraint equation system for the geometric sampling rate s and the texture resolution scaling factor t: wherein is a geometric thinning distortion error function, is a texture scaling distortion error function, and a gradient descent and bisection search algorithm is used to solve the optimal solution (s*, t*) that satisfies the constraints and minimizes the file size F(s, t); S3: Geometric thinning, based on the Quadric Error Metrics (QEM) adaptive strategy, performs vertex merging and edge folding with s as the thinning coefficient, and adds weights at the ridge line and building facade edges to preserve key geometric features; S4: Texture resampling. The original texture is resampled in blocks according to the t coefficient. The UV coordinates are corrected using a Lanczos-3 filter, and chromatic noise suppression is added to the night scene area. S5: Hierarchical LOD composition, dynamically generating a three-layer LOD structure: LOD-0: A macroscopic scene model using parameters s≈s* and t≈t*; LOD-1: A close-up model with a 50% increase in sampling rate and twice the texture resolution compared to LOD-0; LOD-2: A detailed roaming model that enhances texture sharpness by using local super-resolution to improve texture sharpness within a limited street area, based on LOD-1. S6: Format export, encapsulates the LOD level into glTF / 3D Tiles format, and generates normal maps and AO maps.

2. The method for generating a lightweight 3D mesh at the city level based on dual constraints of sampling rate and texture resolution as described in claim 1, characterized in that: In the data pre-evaluation step, With The derivation formula is: where θ is the minimum resolution angle of the human eye in radians.

3. The method for generating a lightweight 3D mesh at the city level based on dual constraints of sampling rate and texture resolution as described in claim 1, characterized in that: The weight strengthening of the building edge in the geometric thinning step is specifically implemented as: detecting an extreme value point of facade curvature and giving it a QEM error weight coefficient , wherein is the maximum curvature, is a strengthening factor, ≥ 5.

4. The method for generating a lightweight 3D city-level mesh based on sampling rate and texture resolution dual constraints as described in claim 1, characterized in that: In the texture resampling step, chromatic noise suppression in the night scene area is achieved through the following process: Identify pixel regions in the RGB color space with saturation > 0.7 and lightness > 0.8; Apply Gaussian blur (σ=0.8) to the chroma channel of the recognition area while keeping the luminance channel unchanged.

5. The method for generating a lightweight 3D mesh at the city level based on dual constraints of sampling rate and texture resolution as described in claim 1, characterized in that: In the hierarchical LOD compositing step, the switching response time from LOD-0 to LOD-2 is ≤20ms, and the sub-layer is loaded quickly through the glTF extended attribute EXT_mesh_gpu_instancing.

6. The method for generating a lightweight 3D city-level mesh based on sampling rate and texture resolution dual constraints as described in claim 1, characterized in that, In the format export step, the mobile output model is executed synchronously: The texture uses the ETC2 compression format; Vertex attributes are memory aligned to 4-byte boundaries.

7. A city-level lightweight 3D Mesh generation device based on sampling rate-texture resolution dual constraints according to any one of claims 1-6, characterized in that, include: The data evaluation module is configured to calculate the spatial density distribution and texture baseline parameters of the original model; The constraint solving module has built-in gradient descent and binary search algorithm solvers and outputs the optimal (s*,t*); The geometry thinning module, based on a CUDA-accelerated QEM processor, performs vertex merging with feature enhancement. The texture resampling module utilizes the Vulkan Compute pipeline to implement block pyramid texture scaling. The LOD synthesis module dynamically generates a three-level LOD structure and encapsulates it into a spatial index format. The format conversion module outputs glTF / 3D Tiles, UE5 Nanite, and b3dm instantiation formats.

8. A city-level lightweight 3D Mesh generation device based on sampling rate-texture resolution dual constraints as described in claim 7, characterized in that: The geometric thinning module's strategy for preserving the ridgeline includes: Roof ridge edges are identified by normal vector mutation detection, with a threshold >60°; Expand the QEM error matrix of the edge vertices to ,in The quadratic error matrix of the original vertices. To address the error matrix after strengthening the ridgeline, The normal vector of the edge. For the enhancement coefficient, ≥10.

9. A city-level lightweight 3D Mesh generation system based on sampling rate-texture resolution dual constraints according to any one of claims 1-8, characterized in that, include: Server-side: Deploy the device as described in claims 7-8, providing a RESTful API via Docker containers to support multi-city segmented parallel processing; Client-side: Employs a rendering pipeline based on WebAssembly and WebGPU architectures, which parses LOD levels in real time and performs distance-driven texture level switching; When the client detects that the scene perspective height H > 200m, LOD-0 is automatically enabled; when 50m < H ≤ 200m, LOD-1 is enabled; when H ≤ 50m and within the preset block, LOD-2 is enabled.

10. A city-level lightweight 3D Mesh generation system based on sampling rate-texture resolution dual constraints as described in claim 9, characterized in that: The constraint solving module of the server side supports dynamic parameter configuration: Set under the city-level macro model =5cm, =0.1; Set in the street detail mode =3cm, =0.05; The mode switch is triggered by the API parameter scene_level=city|block.

Images