A method and system for browser-side frame stacking point cloud hierarchical query and rendering

Abstract

This invention provides a method and system for hierarchical querying and rendering of overlay point clouds in browsers, applied in the field of data processing technology. For browser-side overlay point cloud scenarios, it first collects raw data such as point coordinates, colors, and frame sequences. Relying on a parsing engine and frame synchronization adapter, it completes data parsing, deviation detection, and standardization processing, and generates a fused dataset by combining interactive events. Then, it performs data layering according to three layers: global, partitioned, and fine-grained, builds ternary association nodes, and constructs a topological association graph using a spatial indexing algorithm. Subsequently, it extracts core features to generate embedding vectors, which are fed into the query rendering engine for iterative optimization, building a dedicated basic model. Finally, it conducts verification and optimization based on interaction and frame loading monitoring data, balancing query accuracy, rendering frame rate, and compatibility through multi-index algorithms, ultimately achieving efficient hierarchical querying and rendering of overlay point clouds in browsers.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to a method and system for querying and rendering layered point clouds in browser-side frames. Background Technology

[0002] Considering the characteristics of browser operation and the business features of multi-frame overlay of point clouds, large data volume, strong temporal correlation, and frequent interaction, existing implementation solutions all have obvious technical shortcomings, as follows: Frame-stacked point clouds consist of multiple sets of stacked frame units, resulting in a massive number of data points and numerous auxiliary feature dimensions. Traditional whole-load methods store all the data into the browser's memory at once, easily leading to excessive memory usage and page lag. Simple layered solutions do not differentiate loading strategies based on point density and data retrieval efficiency; high-density, fine-grained point areas still use a uniform loading mode, further increasing the computational burden on the front end and failing to balance rendering quality and page smoothness.

[0003] Frame-stacked point clouds exhibit characteristics of frame stacking and point overlap across frames, with strict temporal, coordinate, and attribute relationships between frames. Existing solutions mostly lack dedicated frame synchronization mechanisms, leading to issues such as coordinate offsets, missing points, and inconsistent color parameters between adjacent frames. Furthermore, the lack of a complete system for deviation detection, automatic correction, and anomaly isolation prevents timely identification and handling of data errors, ultimately resulting in misaligned renderings, flickering points, and partial image loss, significantly reducing visualization quality.

[0004] Existing layered solutions rely solely on static spatial ranges to define layers, failing to establish relationships between spatial layers, frame units, point features, and rendering parameters. When users perform interactive operations such as zooming, viewpoint dragging, and local queries in the browser, the query rules and rendering modes for the corresponding layers cannot be dynamically switched based on the user's actions. Zooming in fails to quickly retrieve fine point details, while zooming out still loads massive amounts of detailed data, making it difficult to simultaneously guarantee query accuracy and rendering frame rate.

[0005] Traditional solutions lack supporting control modules such as interactive behavior monitoring, rendering version management, and anomaly fallback verification. Data from multiple rendering tasks and different interaction scenarios is prone to version confusion, and abnormal data can directly flow into the rendering process, causing page errors and screen glitches. At the same time, without establishing a system for effect evaluation, deviation tracing, and dynamic optimization, when rendering effects or query performance problems occur, the cause cannot be automatically located and optimization solutions cannot be generated. It relies on manual troubleshooting and adjustment item by item, resulting in high maintenance costs and low response efficiency.

[0006] Current technologies only use raw point cloud data directly for query rendering, without uniformly extracting, normalizing, and vectorizing core features such as spatial hierarchy, frame number, point density, and visibility status. Massive, heterogeneous point cloud data is difficult to manage in a structured manner, data interoperability between different modules is challenging, and standardized data support cannot be provided for algorithm modeling and intelligent adaptation, resulting in poor technical scalability.

[0007] The general-purpose 3D rendering engine has not been customized to meet the cross-terminal and multi-version compatibility requirements of browsers. In different kernels and different versions of browsers, inconsistencies in rendering effects and failure of query functions often occur. At the same time, the operating strategy is not designed in accordance with the hard constraints such as browser rendering latency and interactive response timeliness. In highly interactive scenarios, problems such as response delay and precipitous drop in frame rate are likely to occur.

[0008] It should be noted that the information disclosed in the background section above is only used to enhance the understanding of the background of this disclosure, and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0009] Other features and advantages of this application will become apparent from the following detailed description, or may be learned in part by practice of the invention.

[0010] According to one aspect of this application, a method for querying and rendering layered point clouds in a browser is provided, comprising: acquiring multi-source data, frame sequence data, and spatial coordinates, color, and precision information of the original layered point cloud in the browser; automatically parsing the layered point cloud data, detecting inter-frame deviations, and performing data standardization preprocessing based on a point cloud parsing engine and a frame synchronization adapter; identifying the spatial hierarchy, frame stacking structure, and visible region type of the point cloud through a hierarchical partitioning model; integrating real-time interaction and viewpoint switching events in the browser into the data update process to generate a fused layered point cloud dataset; layering the fused dataset according to the dimensions of top-level global point cloud, middle-level partitioned point cloud, and bottom-level fine point cloud; constructing a ternary association node including point cloud identifier, frame unit, and rendering parameters for each layer; and aggregating the point cloud hierarchy and visual attribute information through a spatial index matching algorithm to generate a rendering dataset oriented towards... The browser-side layered point cloud topology graph is generated. Based on a hierarchical rule engine and rendering effect prediction model, the topology graph is modeled, extracting core features such as spatial hierarchy, frame number, point density, and visual state to generate point cloud hierarchical feature embedding vectors. These vectors are then imported into a hierarchical query and real-time rendering calculation engine, employing a multi-scale hierarchical rule adaptive matching mechanism for iterative optimization. Simultaneously, an optimization decision chain is generated through interactive behavior monitoring and rendering anomaly visualization, forming a browser-compatible layered point cloud query and rendering foundation model. Based on this foundation model, combined with front-end interactive data and dynamic frame loading monitoring data, performance verification and dynamic optimization are performed. A multi-index comprehensive evaluation algorithm balances point cloud query accuracy, page rendering frame rate, and browser compatibility requirements, generating browser-side layered point cloud hierarchical query and rendering information.

[0011] Another aspect of this application is a browser-side frame-stacked point cloud hierarchy query and rendering system, the system being configured to execute the above-described browser-side frame-stacked point cloud hierarchy query and rendering method by executing the executable instructions.

[0012] According to another aspect of this application, an electronic device includes: a first processor; and a memory for storing executable instructions of the first processor; wherein the first processor is configured to execute the above-described method for querying and rendering layered point clouds in a browser by executing the executable instructions.

[0013] According to another aspect of this application, a computer-readable storage medium is provided, on which a computer program is stored, which, when executed by a second processor, implements the above-described method for querying and rendering layered point clouds in a browser.

[0014] The beneficial effects of this application are as follows: It collects original point cloud data from multiple sources, including coordinates, color, and temporal sequence data; utilizes a parsing engine and frame synchronization adapter to complete inter-frame deviation detection and data standardization; and integrates front-end interactive information to generate a unified fused dataset. The data is then split into three layers: global, regional, and fine-grained, constructing a three-element association node system of point cloud identifier, frame unit, and rendering parameters. A topological association graph is generated using a spatial indexing algorithm. Multi-dimensional features are extracted using a rule engine and rendering prediction model, and embedding vectors are generated. A basic query rendering model is constructed through multi-scale adaptive matching iteration. Interactive and frame loading monitoring data are integrated, and a multi-index evaluation algorithm is used for dynamic optimization, automatically balancing query accuracy, rendering frame rate, and multi-browser compatibility. The entire process forms a closed-loop processing chain: data acquisition, preprocessing, hierarchical mapping, feature encoding, model construction, and dynamic optimization.

[0015] This application aims to eliminate the problems of overlapping frame point offset and screen flicker by adopting a frame synchronization and deviation closed-loop correction mechanism, and stabilize the point cloud query accuracy to over 98%; three-layer hierarchical loading + multi-scale adaptive scheduling significantly reduce browser memory and computing power consumption, and maintain the interactive rendering frame rate at over 25 frames per second.

[0016] Furthermore, by using ternary topology maps and feature embedding to unify heterogeneous point cloud data, the modules have strong interoperability and can be adapted to multiple versions and kernel browsers with a compatibility rate of 97%. The entire process is automated and closed-loop optimization, eliminating the need for manual scene-by-scene debugging, reducing operation and maintenance costs, and accommodating both panoramic browsing and local fine-grained query needs.

[0017] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this disclosure. Attached Figure Description

[0018] Figure 1 This document illustrates a flowchart of a browser-side frame-overlapping point cloud hierarchy query and rendering method provided in an embodiment of this application. Figure 2 This illustration shows a schematic diagram of a browser-side frame-overlay point cloud hierarchy query and rendering system provided in an embodiment of this application. Detailed Implementation

[0019] The preferred embodiments of the present invention will be described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0020] The following is combined with Figure 1This application describes a method for querying and rendering layered point clouds in a browser based on exemplary embodiments of the present application. It should be noted that the following application scenarios are shown only to facilitate understanding of the spirit and principles of the present application, and the embodiments of the present application are not limited in any way. Rather, the embodiments of the present application are applicable to any suitable scenario.

[0021] In one implementation, Figure 1 The diagram illustrates a flowchart of a browser-side frame-overlay point cloud hierarchy query and rendering method according to an embodiment of this application.

[0022] S101 acquires the original stacked point cloud multi-source data, frame sequence data, and spatial coordinates, color, and precision information from the browser.

[0023] In one implementation, retrieving all point data within the entire stacked frame structure serves as the foundation for all subsequent calculations. The system invokes the browser's native data retrieval channel to establish a stable data transmission link between the front-end page and the remote data server. Triggering conditions include three scenarios: page initialization loading, active switching of the 3D scene, and timed background data refresh. During data reception, the original data format is strictly adhered to, without performing format transcoding, point deletion, or feature rewriting operations, thus fully preserving the point set relationships under the multi-frame stacking structure. For example, in a real-world 3D real-scene stacked frame point cloud scene, 20 sets of stacked frames are set, with each frame containing 8600 valid points, totaling 172,000 points in the entire stacked frame structure. After the page completes its initial loading, the front-end automatically requests the entire stacked frame point cloud data package from the server, receiving data batch by batch according to the frame group order. During storage, the system distinguishes between points specific to independent frames and points in overlapping areas across multiple frames, marking and differentiating the 3200 common points overlapping between the 20 sets of frames. All received raw point data is uniformly written into the browser's preset front-end dedicated data buffer. The buffer is divided into independent storage partitions and physically isolated from other types of data, waiting to be called in the next stage.

[0024] The system collects and manages full-volume timing data for frame stacking and timing switching, defining frame unit numbers, arrangement order, and switching intervals to provide a timing reference for subsequent frame synchronization adapters and inter-frame deviation detection. This part is divided into two main execution modules: static frame sequence reading and dynamic frame sequence monitoring. The two modules run in parallel and merge data in real time. The static module directly extracts fixed timing parameters from the built-in description fields of the point cloud data package, while the dynamic module relies on the browser interaction monitoring interface to capture dynamic frame changes caused by user operations. Using the above 20 sets of stacked frame scenarios as an example, the static timing parameters are read from the data package: the frame numbers are set sequentially from 01 to 20, the basic switching interval between adjacent frames is set to 80 milliseconds, and the overlap area of ​​the entire stacked frame image is 35%. At the same time, the system continuously monitors interactive behaviors such as browser view dragging, screen zooming, and scene roaming. When the user drags the view to complete a 15-degree screen rotation, the system captures the frame dynamic loading instruction, temporarily adjusts the frame retrieval order, and prioritizes loading frames 07 to 12 corresponding to the center area of ​​the view. After all static parameters and dynamic behavior data are integrated, a unique identification number and calling priority are assigned to each frame unit. The frame priority in the visible area is set to level one, and the frame priority in the edge area is set to level three. This set of timing data will be directly supplied to the frame synchronization adapter for subsequent frame synchronization operations and inter-frame deviation determination.

[0025] Collecting positional parameters in a 3D coordinate system point by point is the core supporting data for spatial hierarchy division, spatial index matching, and accurate query rendering. The system traverses all points frame by frame according to the collected frame sequence, binding the coordinate parameters of a single point to its corresponding frame unit, ensuring a one-to-one correspondence between point, coordinate, and frame, while distinguishing between the coordinate states of fixed points and dynamically offset points. Based on the aforementioned scenario description, the entire point cloud adopts the browser's standard 3D rendering coordinate system, with the visible center of the page as the origin. The global far-field point coordinate range is set to X(-100,100), Y(-100,100), Z(80,100), the mid-field point coordinate range is set to X(-50,50), Y(-50,50), Z(30,80), and the near-field fine point coordinate range is set to X(-20,20), Y(-20,20), Z(0,30). For 3200 overlapping points in 20 sets of stacked frames, their coordinate offsets in different frames are recorded, with the maximum coordinate offset in a single frame controlled within 0.5 units. All coordinate data are synchronously stored in a buffer along with the corresponding frame unit. When the hierarchical partitioning model identifies spatial levels and the spatial index matching algorithm constructs the index, it directly calls this set of coordinate data to complete the spatial structure determination.

[0026] The system collects color parameters for each data point and corresponding frame to ensure consistency between the rendered image and the original scene's visual effect. Data acquisition is performed synchronously with the frame sequence, distinguishing between static fixed colors and dynamic gradient colors. It fully records the color distribution of a single frame and the rules for color changes across frames, without performing color smoothing or tone unification modifications during the acquisition process. Continuing with this real-world overlay scene as an example, the scene's base color is set to RGB(245,248,250), the colors of building points are set to RGB(120,125,130), and the colors of ground points are set to RGB(180,185,190). For overlay frames 03 to 06, a color gradient effect is set, with the RGB value change within each gradient range controlled to within 5. When a local highlighting action is triggered, the RGB value of the highlighted area is increased by 30. The system records all color parameters and change rules frame by frame. This data is synchronously transferred to the subsequent rendering effect prediction module as the basis for visual feature extraction and rendering effect evaluation.

[0027] The sampling density and precision parameters of the data collection points are used to control the granularity of data processing throughout the entire process, balancing browser computational load and screen rendering effects. The collected content includes global basic precision, regional local precision, and dynamic precision parameters combined with browser operating status, divided into three execution steps: global collection, regional collection, and dynamic perception. For 20 sets of stacked frame scenes, the global basic sampling density of the entire point cloud is set to 12 points per square unit. According to the spatial region division precision standard: the sampling density for distant areas is 6 points per square unit, the sampling density for mid-range areas is 12 points per square unit, and the sampling density for close-range fine areas is 28 points per square unit. The system monitors browser hardware usage in real time. When browser memory usage is below 40%, the original high precision parameters are maintained; when memory usage is between 40% and 70%, the global sampling density is reduced by 20%; when memory usage exceeds 70%, the sampling density for distant and mid-range areas is reduced by 40%. This set of precision parameters will provide granular standards for subsequent data standardization and three-level point cloud partitioning, avoiding browser screen lag and response delays caused by high-precision data.

[0028] The five types of data collected above—point subject data, frame sequence data, spatial coordinates, color, and precision—are correlated and integrated to generate a structured raw dataset, which is then output as a complete data source to the downstream point cloud parsing engine and frame synchronization adapter. The entire aggregation process uses the frame sequence as the core correlation thread, with a single frame unit as the smallest aggregation unit. No additional data operations or feature processing are performed; only data binding and sorting are completed. Using a 20-frame stacked scenario, taking frame unit number 01 as an example, the 410 point subject data, frame time sequence parameters, all coordinate values, color parameters, and sampling precision parameters corresponding to that frame are bound and combined. Then, all frame unit datasets are arranged sequentially according to frame numbers 01 to 20. The integrated full dataset is uniformly stored in a dedicated front-end cache partition in the browser, and multi-dimensional data reading interfaces are provided, supporting content retrieval by frame number, spatial region, and data type. The completed raw dataset has a complete data link and clear correlations, stably supporting subsequent automatic data parsing, inter-frame deviation detection, data standardization, hierarchical recognition, and other business operations.

[0029] S102, based on the point cloud parsing engine and frame synchronization adapter, completes automatic parsing of stacked frame point cloud data, inter-frame deviation detection and data standardization preprocessing. It identifies the point cloud spatial hierarchy, frame stacking structure and visible region type through a hierarchical partitioning model, integrates real-time interaction on the browser end and viewpoint switching events into the data update process, and generates a stacked frame point cloud fusion dataset.

[0030] In one implementation, the raw data of stacked point clouds that have undergone initial acquisition are combined and matched with preset parsing rules and frame synchronization parameters. A point cloud parsing engine algorithm and a multi-frame heterogeneous data parsing mechanism are introduced to achieve accurate extraction and deviation localization of the basic features of the stacked point clouds. The system first retrieves the pre-configured parsing rules and frame synchronization parameters from the platform configuration library. These two types of parameters provide a unified execution standard for the stacked point cloud parsing process. The parsing rules clarify the point cloud file format recognition standard, the spatial range of feature extraction, and the criteria for determining valid points. The rules, combined with the previously established precision standards for distant, mid-range, and near-range partitions, divide the feature extraction granularity. Only contour features are extracted from low-precision distant areas, basic distribution features are extracted from regular mid-range areas, and full point detail features are extracted from high-precision near-range areas. Simultaneously, valid points are defined based on the point sampling density. Points with a sampling density lower than 3 points per square unit are judged as noise points and directly marked as invalid. The frame synchronization parameters define the temporal alignment benchmark and the maximum allowable deviation between adjacent frames for the entire frame sequence. Following the previous standards, the maximum allowable offset of inter-frame coordinates is set to 0.5 units, and the basic switching interval between adjacent frames is fixed at 80 milliseconds. The twenty sets of stacked frame point cloud raw datasets collected in the previous step are fully integrated into the rule system. The data encapsulation format and field definitions are verified according to the parsing rules. At the same time, the order of frames 01 to 20 is calibrated with reference to the frame synchronization parameters. The initial alignment of all data fields, storage format, and temporal arrangement is completed to ensure that all input data meets the pre-running requirements of the algorithm.

[0031] The point cloud parsing engine algorithm employs a layered traversal matching algorithm, consisting of a three-tiered, interconnected structure: a format parsing layer, a point location traversal layer, and an attribute parsing layer. Specifically, the format parsing layer prioritizes identifying the encapsulation format and data encoding method of the current frame's point cloud, achieving compatibility and adaptation according to preset format recognition standards. It distinguishes between general standard formats and customized heterogeneous formats, performing unified decoding and conversion on data of different formats to ensure consistency in subsequent traversal readings. This layer only handles format processing and does not modify the original attributes of the points themselves, such as coordinates, color, and precision. The format parsing layer executes as follows: Step 1: Read the header of the input point cloud data file, identifying the file format (e.g., LAS, PLY, PCD) and encoding method (binary / ASCII); Step 2: Call the corresponding format decoding interface to uniformly convert heterogeneous format data into a standardized structure containing coordinate, color, and intensity fields; Step 3: Verify the integrity of data fields; frame data missing core coordinate fields are marked as invalid and enter the exception handling process; data that passes format verification is transferred to the point location traversal layer.

[0032] The point traversal layer treats each frame as an independent computational unit, traversing points region by region according to spatial partitioning logic. Combining the entire set of scene parameters, the entire set of stacked frames consists of 20 frame units, with each frame containing 8600 valid points. The algorithm first divides the space into three major regions: global background, central region, and close-up detail. Then, it distinguishes between two types of points: points specific to independent frames and overlapping points from multiple frames. Different traversal priorities are assigned to the two types of points, with overlapping points being the primary traversal targets. The point traversal layer executes as follows: Step 1: Traverse points region by region in the order of "far view → mid view → close view" on a single frame basis; Step 2: Prioritize traversing overlapping points across frames, then traverse points specific to a single frame, and label each point with a point type tag; Step 3: Filter noisy points based on a sampling density threshold (3 points / square unit), and mark discrete points below the density threshold as invalid and remove them; Step 4: Count the number and density distribution of points in each region, generate a regional point statistics table, and transfer it to the attribute parsing layer.

[0033] The attribute parsing layer, based on point traversal, simultaneously extracts point morphology, spatial distribution, and inherent basic attributes. Morphology parsing identifies single-point morphology and cluster arrangement, distribution parsing statistically analyzes the density patterns of points within a region, and attribute parsing reads information such as the point's original color and sampling precision. These three layers execute sequentially, automatically jumping to the next frame after each frame is parsed, achieving serial parsing of twenty frames. The algorithm runs entirely within the browser's front-end processing unit, relying on a front-end memory buffer to temporarily store intermediate parsing data, without transmitting raw point data externally, ensuring local data processing. The attribute parsing layer executes as follows: Step 1: Read the three basic attributes—3D coordinates, RGB color, and sampling precision—point by point; Step 2: Identify single-point morphology (isolated points / clustered points) and regional distribution patterns (uniform distribution / dense clustering / sparse dispersion); Step 3: Summarize all point attributes by frame unit, generating a single-frame point cloud attribute dataset, which serves as the algorithm's final output.

[0034] Furthermore, the multi-frame heterogeneous data parsing mechanism incorporates an inter-frame horizontal comparison algorithm. Using the temporally aligned frame sequence as a benchmark, it achieves cross-validation, difference identification, and deviation localization between frames. The algorithm consists of three parts: a temporal benchmark module, a cross-frame comparison module, and an anomaly detection module, with each module operating in conjunction. For the temporal benchmark module: frame 01 is set as the global benchmark frame, and frames 02 to 20 are used sequentially as comparison frames. An 80-millisecond frame interval and a 0.5-unit coordinate offset are used as the core comparison threshold to establish a unified comparison benchmark across the entire frame. For the cross-frame comparison module, a progressive comparison method is adopted, sequentially completing pairwise comparisons of 01 and 02, 02 and 03, ... up to 19 and 20. The comparison dimensions include four core aspects: number of points, three-dimensional coordinates, color parameters, and sampling accuracy, verifying the data content of corresponding positions in adjacent frames item by item.

[0035] For the anomaly detection module, a built-in hierarchical judgment rule is used to perform deviation judgment based on the threshold of the actual scenario. If the number of missing points in a single frame exceeds 2% of the total points, the single point coordinate offset is greater than 0.5 units, the single deviation of RGB color value exceeds 5, or the sampling density deviation is greater than 2 points per square unit, any one of these conditions is judged as a data deviation; content with only minor fluctuations that do not reach the threshold is marked as normal data fluctuation and is not included in the anomaly range.

[0036] The entire set of overlay frames contains twenty sets of continuous frames, with 8600 fixed points per frame. The maximum allowable coordinate offset between frames is 0.5 units, and the frame switching interval is 80 milliseconds. After the system loads the parsing rules and frame synchronization parameters, it loads all the original data in batches according to the frame numbers 01 to 20. The point cloud parsing engine algorithm starts a layered traversal process. The format parsing layer completes the format decoding and adaptation of all frame files. The point traversal layer distinguishes between independent points and 3200 globally overlapping points and traverses them in partitions. The attribute parsing layer simultaneously extracts the shape, distribution, color, and precision attributes of each point, and completely records the basic parsing results of a single frame. The inter-frame horizontal comparison algorithm runs synchronously, using frame 01 as the base frame, and compares the four data dimensions of adjacent frames one by one. When comparing frames 08 and 09, it was detected that 190 points were missing in a local area of ​​frame 09, exceeding the 2% judgment threshold of the total points in a single frame. At the same time, the coordinate offset of some points reached 0.7 units, exceeding the allowable range of 0.5 units.

[0037] The anomaly detection module of the multi-frame heterogeneous data parsing mechanism formally marks this content as data deviation, and synchronously records the frame number, spatial location of the abnormal region, number of missing points, coordinate offset value, and original feature information corresponding to the anomaly. The algorithm integrates all normal parsing results, hierarchical anomaly records, and normal fluctuation annotations, and outputs a complete parsing report, which is synchronously transmitted to the downstream stacked frame data automatic parsing model for subsequent frame synchronization weight calculation and data normalization.

[0038] By connecting the browser's data transmission interface with the point cloud frame sequence repository, an automatic parsing model for stacked frame data is constructed. A frame synchronization adapter is used to adapt the computational model and calculate the synchronization weights of different frame data, establishing a dynamic update and association mechanism for stacked frame point clouds. First, the browser's front-end data transmission interface and the local frame sequence repository are connected to build a two-way data interaction channel. The front-end data transmission interface monitors the data stream generated by page interactions in real time, receiving new point cloud data triggered by operations such as viewpoint switching, screen zooming, and scene transitions. The local frame sequence repository persistently stores the historical frame numbers, temporal arrangement, and parsing results of the entire stacked frame set. All historical data is archived in an orderly manner according to frame numbers from 01 to 20, and can be retrieved at any time, ensuring seamless integration between old and new data.

[0039] The automatic parsing model for stacked frame data is divided into three internal layers that operate in series: a data receiving module, a frame grouping module, and a basic parsing module. The modules unidirectionally transmit calculation results according to the data flow direction. The data receiving module monitors the data flow status of the front-end interface in real time, distinguishing between incremental and full data based on the data volume and generation timing. Data is classified as incremental when only a local point is updated due to user interaction, and as full data when a page reload or scene reset generates a complete new data packet. These two types of data are distinguished, marked, and then passed to the next level module. The frame grouping module has built-in complete frame sequence arrangement rules, using the previously set order of 20 frame groups, and binding the spatial region attributes corresponding to each frame group. Upon receiving new data, it accurately assigns the data to the corresponding frame unit according to the frame number. For overlapping points across frames, its multi-frame association markers are simultaneously retained. The basic parsing module fully reuses the hierarchical traversal matching algorithm and established parsing rules mentioned above. It continues the execution flow of format decoding, point traversal, and attribute extraction. Referring to parameters such as the noise judgment standard of 3 points per square unit of sampling density and the coordinate offset threshold of 0.5 units, it completes the format recognition and basic parsing of the new data and outputs standardized parsing results.

[0040] The frame synchronization adapter adapts to the computational model as the core unit for weight calculation. It connects to the output of the automatic parsing model for stacked frame data, using independent frame units as the smallest computational object, and calculates synchronization weights based on three dimensions: frame loading timing, data integrity, and screen visibility priority. The frame synchronization weights are calculated using a multi-dimensional weighted summation formula, as follows: ,in, is the final synchronization weight for the i-th frame, with a value range of [0,1]. The higher the value, the higher the synchronization priority. Temporally normalized value: Based on the current rendered frame, the smaller the difference in frame sequence number, the better. The closer it is to 1, the better. (N is the total number of frames); Normalized value for data integrity: =Number of valid points / Total number of theoretical points in a single frame; the more missing points, the lower the value. Normalized values ​​for visibility priority: 1 for fully visible frames, 0.5 for partially visible frames, and 0.2 for invisible frames; weighting coefficients are set to [default value]. =0.2、 =0.3、 =0.5, which can be considered the core influencing factor of priority. The mapping between weight and synchronization strategy is as follows: weight ≥ 0.7 is the first priority, and synchronization is performed once per frame rendering cycle; 0.4 ≤ weight < 0.7 is the second priority, and synchronization is performed once every 3 rendering cycles; weight < 0.4 is the third priority, and synchronization is performed once every 10 rendering cycles; during timed full synchronization, it is executed in descending order of weight.

[0041] Based on the overall scene parameters, a weighting standard is defined, assigning first-level weight to foreground frames in the center of the current image, second-level weight to mid-range frames in the middle of the image, and third-level weight to background frames at the edges of the image. The weight level directly corresponds to the synchronization order and frequency of frame data. First-level weight frames have the highest synchronization frequency and are prioritized for data synchronization; third-level weight frames have the lowest synchronization frequency and are updated during idle periods. A two-layer dynamic update mechanism is built based on the weight calculation results. On one hand, a timed update logic is set up to globally verify and synchronize all existing frame data in the database according to a fixed period. On the other hand, an interactive trigger update logic is enabled, immediately initiating local frame synchronization when an operation occurs on the front end. These two operating modes work together to ensure that the entire set of stacked frame data is always in a synchronized state.

[0042] To illustrate with a real-world scenario, the current frame overlay consists of twenty frame units, numbered 01 to 20, with 8600 basic points per frame and an 80-millisecond basic switching interval between frames. When a user rotates the viewpoint 15 degrees in the browser, the front-end data transmission interface immediately and continuously pushes incremental point cloud data. The data receiving module of the frame overlay data automatic parsing model identifies this batch of data as interactively triggered incremental data and forwards it to the frame grouping module. Based on the range of viewpoint changes, the frame grouping module categorizes the incremental data into frame units 07 to 12, which constitute the currently visible core area. The basic parsing module calls existing parsing algorithms and judgment parameters to complete the format recognition, shape, and attribute parsing of the newly added points, while simultaneously screening for basic anomalies such as missing points and coordinate offsets. After data parsing, it is sent to the frame synchronization adapter to adapt the calculation model. The model, based on the visible range of the screen, classifies frames 07 to 12 as foreground frames and assigns them a first-level synchronization weight; adjacent frames 05, 06, 13, and 14 are classified as mid-ground frames and assigned a second-level synchronization weight; the remaining edge frames are classified as background frames and assigned a third-level synchronization weight. The system performs synchronization operations in descending order of weight, with first-level weight frames completing data updates first, followed by second- and third-level weight frames. As the viewpoint continuously changes, the interface continuously pushes new incremental data, and the entire parsing and weight calculation mechanism operates in a loop, enabling the stacked frame point cloud data to be dynamically updated in real time following the front-end interaction, maintaining the consistency of frame sequence timing and data content throughout the process.

[0043] Meanwhile, the timed update mechanism will perform full data synchronization verification on all 20 sets of frame units in the repository according to the preset cycle, check whether the inter-frame coordinate offset, color parameters, and sampling density meet the predetermined threshold standards, supplement edge data that was not updated in time during the interaction, and further strengthen the overall correlation and integrity of the entire set of stacked frame data.

[0044] Using unique point cloud identifiers and frame sequence attribution as core dimensions, this system integrates spatial coordinates, color information, point position accuracy, frame stacking order, visible range core feature data, single-frame scale feature data, and global stacked frame scale feature data to construct a multi-dimensional point cloud standardized association matrix, achieving unified and standardized processing of stacked frame data features. The system traverses all stacked frame points, extracting a globally unique identifier for each point. This identifier is a permanently unchanging identification code throughout the entire data link. After extraction, each point identifier is bound to its corresponding frame sequence number and frame unit. The entire scene uses frame units 01 to 20 as defined earlier, ensuring that a single point belongs only to its corresponding frame. This serves as the core index system for the multi-dimensional point cloud standardized association matrix. Based on the index, the matrix integrates multiple types of core business feature data, including the three-dimensional spatial coordinates of the points, RGB color parameters, point sampling accuracy, frame stacking order number, and the visible range of the screen. At the same time, it distinguishes and incorporates two types of scale features: single-frame scale features are used to describe the point arrangement and attribute status within the current frame, while global stacked frame scale features are used to describe the overall point distribution and comprehensive attributes formed by the stacking of twenty sets of frames.

[0045] During the standardized association process of multi-dimensional point clouds, the entire set of pre-defined data specifications is strictly followed. All data fields are aligned, the units of measurement for various physical quantities are unified, and the normalization conversion of different encapsulation formats is completed. Issues such as inconsistent data formats and parameter units between different frames are addressed centrally, eliminating data standard differences between twenty sets of frames. A strong binding relationship between indexes and features is implemented within the matrix. Any global point cloud identifier can be used to query its frame number, basic attributes, single-frame features, and global features. It can also be used to retrieve all point information within a range by using the frame number. This achieves structured organization and unified management of multi-frame heterogeneous point cloud data, providing a standardized data carrier for subsequent deviation verification and data correction.

[0046] This will be explained using the actual scenario described earlier, which involves twenty sets of stacked frames, 8600 valid points per frame, and 3200 overlapping points between frames. The matrix uses a unique global identifier for each point as the row item and frame sequence numbers from 01 to 20 as the column items. Fill in the corresponding data row by row and column by column. Use the established interval for spatial coordinates. Fill in X(-100,100), Y(-100,100), Z(80,100) for distant viewpoints, X(-50,50), Y(-50,50), Z(30,80) for mid-range viewpoints, and X(-20,20), Y(-20,20), Z(0,3) for close-up viewpoints. Fill in the color parameters uniformly as the scene base color RGB(245,248,250), building point RGB(120,125,130), and ground point RGB(180,185,190). Fill in the sampling precision according to the standard of 6 points per square unit for distant view, 12 points per square unit for mid-range view, and 28 points per square unit for close-up view. At the same time, mark the frame stacking sequence number and the visible range of the current screen corresponding to the point. After each data point, single-frame scale features are added to record the density and attribute distribution of points within the current frame. Simultaneously, global scale features of twenty superimposed frames are added to describe the overall pattern of point arrangement in the scene.

[0047] For 3200 overlapping points across frames, the matrix synchronously associates their attributes across multiple columns, preserving the cross-frame relationships. After matrix normalization, the data format and parameter annotation rules of all frames from 01 to 20 are completely unified. The originally scattered and heterogeneous original data from multiple frames with different formats are integrated into a structured dataset with unified rules. When subsequent functional modules such as inter-frame deviation detection, dynamic correction closed-loop model, and hierarchical partitioning model retrieve data, they can directly and quickly search according to different dimensions such as point identifier, frame number, and spatial region, effectively improving the efficiency of data retrieval and computation.

[0048] The inter-frame deviation detection and dynamic correction closed-loop model handles data anomalies and gaps, and strengthens the correlation characteristics of stacked frame data by combining a timed refresh and interactive trigger dual update mechanism. This is then fused with the output of the automatic parsing model to generate a standardized stacked frame point cloud fusion dataset. The inter-frame deviation detection and dynamic correction closed-loop model consists of three parts: an anomaly identification module, a deviation correction module, and a result review module. These three modules execute sequentially according to a fixed process, forming a closed-loop operating logic. The entire process relies on the previously set standards such as frame synchronization thresholds, point accuracy, and color parameters for computation. The anomaly identification module prioritizes retrieving various deviation records marked in the early stages by the point cloud parsing engine and the multi-frame heterogeneous data parsing mechanism. Simultaneously, it retrieves the constructed multi-dimensional point cloud standardized correlation matrix, using the unified fields, formats, and parameters within the matrix as references to compare the data consistency between frame units 01 to 20 frame by frame. The comparison scope covers four dimensions: number of points, 3D coordinates, RGB color, and sampling accuracy. It focuses on checking for various data gaps such as missing points, coordinate offsets, color mismatches, and accuracy anomalies. The comparison process strictly follows the established judgment criteria: if the number of missing points in a single frame exceeds 2% of the total points, the coordinate offset of a single point exceeds 0.5 units, the single RGB deviation is greater than 5, or the sampling density difference exceeds 2 points per square unit, any one of these criteria is considered as valid data anomaly.

[0049] The deviation correction module receives the anomaly list output by the anomaly identification module and processes it according to the system's preset hierarchical correction rules. For repairable anomalies such as point coordinate offset, minor color deviation, and local point loss, point completion and parameter correction are performed by combining the corresponding data from adjacent normal frames. For problem points with large-area point loss, severe inaccuracies in multiple dimensions, or exceeding the correction threshold, no forced changes are made; instead, separate marking and isolation operations are performed to avoid introducing new data errors after correction. The entire correction process distinguishes between global unified correction and local single-point correction. Global problems are processed in batches, while local anomalies are precisely located and repaired, preserving the original data traces throughout the process. Inter-frame deviation correction adopts a hierarchical correction strategy, using corresponding algorithms for different anomaly types: Coordinate offset correction: The Iterative Closest Point (ICP) rigid registration algorithm is adopted. The overlapping common points of two adjacent frames are used as the matching set. The rotation matrix R and translation vector t between the two frames are solved, and the coordinates of the offset points are transformed and corrected. The registration iteration terminates when the mean square error between two consecutive iterations is less than 1. Or the number of iterations reaches 50.

[0050] Based on point cloud data of corresponding spatial regions in adjacent frames, the KD-tree nearest neighbor interpolation method is used to generate candidate points in the missing region according to the target sampling density. The coordinates and color attributes of the three closest points in adjacent frames are selected and weighted averaged, with the weight inversely proportional to the distance, to complete the missing point filling. A linear grayscale mapping method is used to statistically analyze the RGB mean and variance of common points between two adjacent frames, linearly mapping the color distribution of the abnormal frame to the color range of the reference frame to ensure cross-frame color consistency. After correction, all points must be re-verified through deviation detection. Points that still exceed the threshold after correction are marked as unrepairable anomalies and data isolation is performed.

[0051] The result review module is responsible for conducting a second comprehensive verification of all frame data after deviation correction. The verification dimensions are consistent with those of the anomaly identification module, and the number of points, coordinates, colors, and accuracy are checked again to ensure they meet preset standards. For content that has been repaired, it is confirmed that the anomaly has been completely eliminated; for data that was previously marked and isolated and cannot be repaired, the anomaly marker is continuously retained and the status information is updated synchronously to ensure that the anomaly record is traceable. The three modules execute in a loop, forming a continuous closed loop of deviation detection, correction, and verification.

[0052] This process utilizes a dual update mechanism: scheduled refresh and interactive triggering. The scheduled refresh mechanism operates at a fixed interval, performing full integrity and temporal synchronization checks on the entire set of 20 stacked frame data at preset intervals, proactively identifying hidden deviations in static data. The interactive triggering mechanism monitors browser frontend behavior in real time. When it detects operations such as viewpoint dragging, screen zooming, or scene transitions, it immediately initiates real-time data synchronization and deviation verification, prioritizing the detection of high-priority frame units 07 to 12 corresponding to the currently visible area to ensure real-time data validity during interactions. These two operating modes complement each other, continuously reinforcing the data correlation and temporal consistency among the twenty sets of frame units.

[0053] After completing deviation detection, correction, review, and dual-mechanism synchronous verification, the system integrates multiple types of data results, summarizing and consolidating the original analysis results of the automatic parsing model of the overlay data, the regularized data of the multidimensional point cloud standardized correlation matrix, and the corrected data after closed-loop model processing. Abnormal data that has been marked and isolated is uniformly removed, and all compliant and valid data is summarized. Based on a unified data format, field specifications, and temporal logic, the data is reorganized to ultimately generate a standardized overlay fusion dataset with a unified format, temporal alignment, complete features, and clear abnormal states.

[0054] This is illustrated using a real-world scenario involving 20 sets of stacked frames, 8600 valid points per frame, and 3200 overlapping points across frames. The closed-loop model iterates through all frame units one by one. When comparing frame 08 and frame 09, it was found that frame 09 had 190 missing points, exceeding the 2% threshold for missing points. Additionally, some point coordinates were offset to 0.7 units, exceeding the allowable range of 0.5 units. The deviation correction module retrieved point information from adjacent normal frames to complete the missing points and correct the offset coordinates. For a few points with multiple abnormal parameters, isolation marking was applied. After correction, the result review module re-verified the results, confirming that the number of points and coordinate parameters had returned to the standard range. Simultaneously, at the scheduled timeout, the system performed a global refresh check on all frame units. When the user drags the viewpoint to change the screen, the interaction trigger mechanism immediately activates, synchronously checking the frame data within the visible range. After all data processing is completed, the system integrates the parsing results, matrix normalization content, and corrected data, removes isolated outliers, and forms a complete stacked point cloud fusion dataset. This dataset is then stably transmitted to the downstream layered processing module to support subsequent tasks such as dimensional layering and node construction.

[0055] S103, the fused dataset is layered according to the dimensions of top-level global point cloud, middle-level partitioned point cloud, and bottom-level fine point cloud. Each layer constructs a ternary association node including point cloud identifier, frame unit, and rendering parameters. The point cloud hierarchy and visual attribute information are aggregated through a spatial index matching algorithm to generate a stacked frame point cloud topology association graph for browser-facing applications.

[0056] In one implementation, the system first invokes the platform's preset global-partition-fine-grained layering rules and accompanying layer division instructions. This set of rules and instructions provides a unified execution benchmark for the layering operation. The layering rules clearly define the spatial division range, point selection conditions, and data granularity standards for the three types of point clouds: top-level global, middle-level partitioned, and bottom-level fine-grained. The layer division instructions specify the execution order of the layering operation, the processing requirements for various data fields, and the boundary determination methods between different layers. Based on the above rules and instructions, the system splits the already standardized stacked point cloud fusion dataset into three parts: top-level global point cloud, middle-level partitioned point cloud, and bottom-level fine-grained point cloud, while also distinguishing and defining the point types. The global points cover the entire spatial range of the 3D real-world scene and are mainly used to present the overall outline of the scene and the macroscopic distribution of points. The partitioned points are spatially divided according to geographical blocks and functional areas, corresponding to the point sets of each independent local block within the scene. The fine-grained points focus on the interior of local areas, relying on high sampling density to retain detailed point information.

[0057] This step employs a point cloud identifier unique mapping mechanism. This mechanism uses the globally unique code inherent in each point as a retrieval index, performing association calculations layer by layer to calculate the matching relationship between the current level point and the corresponding frame units 01 to 20. During the calculation process, data consistency verification is performed simultaneously, using the previous verification standards of a maximum coordinate offset of 0.5 units, a single RGB color deviation of no more than 5, and a sampling density difference of no more than 2 points per square unit. This ensures that the coordinates, colors, and precision information of points corresponding to the same global identifier are completely consistent across different spatial levels and frame units. After completing the association matching between levels and frame units, the system matches corresponding rendering parameters based on level attributes. Parameters are assigned according to level positioning: global levels match lightweight rendering configurations, partitioned levels match regular rendering configurations, and fine-grained levels match high-precision rendering configurations, clearly defining the exclusive rendering parameter system for each type of level.

[0058] After completing the hierarchical division, point location association, and rendering parameter matching, the system performs attribute dimension stripping. Following a pre-defined classification logic, the data content is divided into four categories: basic point cloud attributes, spatial attributes, visual attributes, and rendering configuration attributes. Redundant data with duplicate fields or overlapping content is removed during the splitting process. After splitting, all data fields are re-aggregated and categorized according to global, partitioned, and fine-grained spatial hierarchy standards. The overall data structure mapping and transformation are then completed, ensuring that data at each level forms a unified organizational form and storage structure, ultimately generating standardized, layered point cloud structural elements.

[0059] This explanation is based on the previously established large-scale outdoor real-world scene with 20 sets of overlapping frames, 8600 effective points per frame, and 3200 overlapping points across frames. After the system loads the layering rules and instructions, it performs layered processing on the entire fused dataset. The top-level global points include outline-type points of the entire scene, with a sampling density of 6 points per square unit. The middle-level partitioned points are divided according to actual spatial segments such as roads, buildings, and open spaces, with a sampling density of 12 points per square unit. The bottom-level fine points focus on areas such as building facades and road surface details, with a sampling density of 28 points per square unit. The system initiates an identifier mapping mechanism, associating each point with its corresponding frame unit based on the global point code. Simultaneously, it verifies the coordinate range, RGB color values, and sampling density item by item, ensuring the coordinates are strictly controlled within the predetermined range. Colors utilize standard parameters such as RGB(245,248,250), RGB(120,125,130), and RGB(180,185,190), with all data deviations kept within acceptable limits. Low-load rendering parameters are configured for the global level to reduce computational overhead; high-quality rendering parameters are configured for the fine-grained level to ensure detailed display. Subsequently, various attributes, including basic point information, 3D coordinates, color parameters, and rendering configurations, are broken down and redundant fields are cleaned up. Then, the fields are reorganized and the structure adapted according to the level, ultimately outputting three sets of standardized point cloud structure elements with unified format, clear layer boundaries, and well-defined attribute classifications, providing compliant data for subsequent consistency verification and topology map construction.

[0060] Consistency checks are performed on point cloud identifier binding, frame unit affiliation, and rendering parameter association to ensure that the point cloud hierarchical topology is not disrupted. The entire consistency check process has a fixed execution order, performing full-scale checks item by item according to the three dimensions of point cloud identifier binding, frame unit affiliation, and rendering parameter association. The first step checks the binding status of point cloud identifiers to data levels, relying on the globally unique code of the point as the retrieval basis to verify that each code corresponds to only a single spatial level, preventing the same point identifier from being bound to multiple levels simultaneously (global, partition, fine), and preventing mismatches between identifiers and levels. The second step checks the frame unit affiliation relationship of the points after layering, comparing them with the original complete frame sequence from 01 to 20, checking the frame number to which the layered point belongs one by one, ensuring that the layering operation does not change the original frame group arrangement order, point affiliation, and overlapping logic, and maintaining the original temporal structure of the frame sequence. The third step is to verify the matching validity of the rendering parameters. Combining the positioning and point granularity standards of the global, partition, and fine-level layers, we check whether the parameter configuration is suitable for the data volume and sampling density of the corresponding layer, and investigate problems such as incorrect parameter configuration and missing key rendering fields.

[0061] Throughout the entire calibration and testing process, the system incorporates anomaly identification and simple repair submodules to capture various related anomaly information in real time. For low-risk issues such as parameter mismatch and minor label binding deviations, the system automatically corrects them according to preset matching rules. For serious issues that cannot be handled autonomously, such as cross-level label confusion, large-area frame affiliation anomalies, and loss of core rendering parameters, the system uniformly marks the anomalies and sets data interception rules to isolate problematic data and prevent it from flowing into subsequent topology graph construction stages. The entire verification mechanism covers all three layers of point cloud data from top to bottom: the top-level global layer, the middle-level partition layer, and the bottom-level fine layer. It performs a complete inspection of the points, relationships, and configuration parameters of each layer to ensure that the overall hierarchical architecture and node association logic are consistent and unified after the layered processing is completed.

[0062] The following example illustrates the real-world scenario with 20 stacked frames, 8600 valid points per frame, and 320 overlapping points across frames. After the layered processing is complete, the system automatically initiates a full-dimensional consistency verification process. First, it traverses all point identifiers within the three-layer structure, verifying the encoding attribution one by one. No instances of duplicate binding of point identifiers across layers or layer mismatches are found. Second, it checks the frame numbers corresponding to all layered points. The arrangement order of frames 01 to 20 remains unchanged, and the 3200 overlapping points across frames retain their original multi-frame relationships. The layering operation does not disrupt the original stacked frame group logic. Finally, it checks the rendering parameters. The global layer point sampling density is 6 points per square unit, uniformly configured with lightweight rendering parameters; the partition layer point sampling density is 12 points per square unit, configured with regular rendering parameters; and the bottom-level fine layer point sampling density is 28 points per square unit, with corresponding high-resolution rendering parameters. During the inspection, a small number of partition point rendering parameter configuration deviations were found, and the system automatically corrected the parameters; there were also some cases of abnormal point identifier binding, and the system marked and isolated these points. After the entire set of verifications was completed, the hierarchical topology of the three-layer point cloud remained stable, and the hierarchical hierarchy, frame association, and parameter matching relationships all met the preset standards.

[0063] The system integrates the results of dimensional layering, identifier mapping, attribute stripping, and field classification. It then aggregates the hierarchical structure and visual attribute information of the point cloud using a spatial index matching algorithm to generate a stacked frame point cloud topology map containing layered data, a ternary node structure, and hierarchical relationships. The system first summarizes and integrates all valid data output from the previous step, sequentially aggregating three layers of standardized point cloud structural elements, consistency-verified point-to-frame unit relationships, and various attribute data that have been stripped and classified. All summarized data is standardized according to a unified data format and storage specifications, serving as a unified input data source for the spatial index matching algorithm to ensure consistency in data reading and format. The basic parameters used in this step remain unchanged. The entire scene includes frame units 01 to 20, with 8600 valid points per frame and 3200 overlapping points across frames. The criteria for point coordinates, RGB color, sampling density, and frame switching intervals are all maintained as previously set.

[0064] The spatial index matching algorithm is the core computational logic of this stage. The algorithm uses three-dimensional spatial coordinates, global-partition-fine-level hierarchical division boundaries, and the relationship between points and frame units as three major benchmarks to build a global spatial index system. The spatial index adopts a hybrid structure of hierarchical octrees and frame sequence mapping. Independent octree indexes are constructed in three layers: global, partition, and fine-level. The depth of the global octree is set to 4, the hierarchical layer depth to 6, and the fine-level layer depth to 8. Each octree node stores the set of point cloud identifiers within the corresponding spatial range and a list of their respective frame unit numbers. A frame sequence dimension mapping table is extended based on the spatial octree, using the frame number as the key and pointers to all octree nodes under the corresponding frame as the value, to achieve two-dimensional fast retrieval of "spatial location + frame sequence". The index construction process is as follows: first, the octree division of the point cloud at each level is completed according to spatial coordinates; then, each point cloud ternary node is bound to the corresponding octree leaf node; finally, a reverse mapping between the frame number and the octree node is established.

[0065] Vertices are three-element nodes consisting of point cloud identifiers, frame units, and rendering parameters. The node data structure is defined as follows: {pointID:string, / / Globally unique identifier for the point cloud} frameID:number, / / Frame number renderParams:{ / / Rendering parameters for the corresponding layer lodLevel:number, / / Level of detail pointSize: number, / / Point rendering size colorMode: string / / Color rendering mode } Edges are divided into three categories: hierarchical edges (global nodes → partition nodes → fine nodes, with storage space containing proportions), sibling adjacent edges (adjacent spatial nodes at the same level, storing the coordinates of the adjacent boundary), and inter-frame related edges (nodes at the same point in different frames, storing the coordinate offsets); these three types of edges together constitute a complete topological relationship.

[0066] The indexing system prioritizes spatial location and then performs secondary classification based on hierarchical category and frame number, enabling rapid location of any point's spatial region, hierarchical level, and corresponding frame unit. During computation, the algorithm uses a three-layer point cloud hierarchy as the primary aggregation unit, simultaneously incorporating visual attributes such as point RGB color, sampling precision for different zones / far / near views, and visible range. This organically integrates hierarchical, correlated, and attribute data that were originally scattered across different levels, frames, and categories, eliminating data silos.

[0067] During algorithm execution, a three-element association node consisting of a point identifier, a frame unit, and rendering parameters is created synchronously. Each independent node is the smallest data-carrying unit. A single node contains three core pieces of information: a globally unique identifier for the point, the frame number to which the point belongs, and the rendering configuration parameters matched for the current layer. All nodes are arranged in an orderly manner according to the indexing system's layout rules, and data interaction channels are maintained between nodes. After data aggregation and node creation are completed, the algorithm continues to refine the overall point cloud's association logic, clarifying the hierarchical inclusion relationships between the top-level global, middle-level partitioned, and bottom-level fine-grained structures, defining the peer-to-peer connections between different spatial blocks within the same layer, and simultaneously clarifying the point overlay and temporal relationships between different frame units from 01 to 20, thus establishing a complete and interconnected hierarchical association system.

[0068] After all computational processes are completed, the system integrates the hierarchical raw point data, the entire ternary associative node network, and the relationships between multiple levels and frames to finally generate a stacked point cloud topology graph. This topology graph completely records the spatial hierarchy of the entire point cloud, the global point distribution, the frame affiliation of each point, various visual and operational attributes, and all associated logic. The data link is complete and the structural logic is clear, so it can be directly used as input to push to the downstream hierarchical rule engine and rendering effect prediction model to carry out subsequent joint modeling work.

[0069] This example illustrates the process using a 3D outdoor real-world frame-overlay scene. The system first aggregates standardized point cloud structural elements across three layers: global, regional, and fine-grained. This includes verified point binding relationships, decomposed basic attributes, spatial attributes, visual attributes, and rendering configuration attributes, all fed into a spatial index matching algorithm. The algorithm divides spatial index entries based on the X / Y / Z 3D coordinate range, combining regional sampling densities of 6, 12, and 28 per square meter with fixed RGB color parameters to achieve visual attribute fusion. For each group of points within the scene, an independent ternary association node is generated. This node contains the corresponding global identifier, frame numbers 01 to 20, and matching lightweight, regular, and high-quality rendering parameters. The algorithm further refines the hierarchical relationships: the global layer contains all regional layers, and each regional layer contains its corresponding fine-grained layer. Adjacent spatial regional points are interconnected, with frames 01 to 20 forming frame-overlay relationships based on an 80-millisecond switching interval and a 35% overlap. The final generated stacked point cloud topology map fully presents all points, hierarchical structure, frame associations, and attribute configurations, stably connecting to subsequent modeling stages and supporting subsequent operations such as core feature extraction.

[0070] S104 models the topological relationship graph based on the hierarchical rule engine and rendering effect prediction model, extracts the core features of spatial hierarchy, frame number, point density, and visible state, and generates point cloud hierarchical feature embedding vectors.

[0071] In one implementation, the hierarchical rule engine incorporates complete hierarchical judgment rules, feature selection criteria, and feature association logic. Internally, the engine consists of a rule parsing module, a data adaptation module, and a feature guidance module, executed sequentially according to a fixed flow. The rule parsing module reads and parses the three types of hierarchical judgment conditions: global, partitioned, and fine-grained, clarifying the basis for different levels. The data adaptation module interfaces with external topology data, completing data format and field adaptation conversions to ensure the data can be recognized by the internal rules. The feature guidance module defines the feature extraction range and priority based on the selection criteria, guiding subsequent feature collection.

[0072] The rendering effect prediction model is a customized model for browser-side frame-stacked point cloud rendering scenarios. It is divided into a basic perception module, a feature association module, and an output preprocessing module. Before its official deployment, the model underwent multiple rounds of iterative training using frame-stacked point cloud samples with different spatial levels, frame sequence combinations, and point density. The model's input and output are as follows: the input is a 16-dimensional point cloud hierarchical feature embedding vector; the output consists of two predicted values: single-frame rendering latency (unit: ms) and a subjective image quality score (range 0-1). A 3-layer fully connected feedforward neural network is used, with hidden layer dimensions of 32 and 16 respectively, using ReLU activation and linear activation in the output layer; the total number of parameters is approximately 1200, suitable for lightweight browser-side operation. 10,000 sets of frame-stacked point cloud rendering samples with different levels, point densities, and frame numbers were collected, labeled with corresponding actual rendering latency and image quality scores, and divided into training, validation, and test sets in an 8:1:1 ratio. Offline supervised training was employed, with mean squared error (MSE) as the loss function, Adam as the optimizer, a learning rate of 0.001, and 100 training epochs. After the model was deployed to the browser, incremental fine-tuning was performed every 24 hours based on real-time running data to achieve continuous adaptation. The training process covered all frame units from 01 to 20 in this scene, three sampling densities (6 / 12 / 28 samples per square) and sample data from different visible ranges. After training, key operating parameters such as core feature recognition thresholds, feature weight ratios, and vector dimension mapping were fixed, providing a unified standard for subsequent calculations.

[0073] The system uses the stacked point cloud topology graph generated in the previous step as the sole input data source. This data source includes global, partitioned, and fine-grained hierarchical data, a three-element node for point cloud identifiers, frame units, and rendering parameters, and the relationships between all levels and frame units. The topology graph strictly adheres to the data format and field specifications required by the model and engine. Simultaneously, data is pushed to the hierarchical rule engine and the rendering effect prediction model. The two computational units share the same source data, ensuring complete consistency in data scope and content throughout the process, and avoiding computational deviations caused by data differences.

[0074] After data access is complete, the system synchronously starts the hierarchical rule engine and the rendering effect prediction model, loads predefined hierarchical recognition rules and feature selection rules, and calls the weight parameters and recognition thresholds that have been trained by the model. The topology map, which includes a three-layer structure, twenty frame units, and 32,000 cross-frame overlapping points, is fully loaded into the two computing units, and the joint modeling phase officially begins.

[0075] The hierarchical rule engine begins parsing the overall architecture of the topological graph, systematically outlining the hierarchical relationships and spatial boundaries among the top-level global layer, the middle-level partitioned layer, and the bottom-level fine-grained layer. Combining built-in hierarchical determination rules, it performs hierarchical labeling on each ternary node, simultaneously retrieving the frame unit number bound to the node to establish a correspondence between the spatial hierarchy and the frame sequence from 01 to 20. The rendering effect prediction model concurrently performs analysis, combining data such as point sampling density and visible screen range to analyze the impact of different point states on browser rendering load and screen presentation, establishing a correspondence between point attributes and rendering performance.

[0076] The hierarchy determination rules are as follows: the three-dimensional spatial coordinate Z value is the core determination criterion. Z∈[80,100] is determined to be the top-level global point cloud hierarchy, Z∈[30,80) is determined to be the middle-level partitioned point cloud hierarchy, and Z∈[0,30) is determined to be the bottom-level fine point cloud hierarchy.

[0077] The auxiliary point density verification is as follows: global level point density ≤ 8 points / square unit, zone level density 8~20 points / square unit, fine level density > 20 points / square unit. When the coordinate determination and density determination are inconsistent, the coordinate determination shall prevail.

[0078] The feature selection criteria are as follows: features with a correlation coefficient ≥ 0.3 with rendering latency and query accuracy are selected as core features, ultimately retaining four categories: spatial hierarchy, frame number, point density, and visual state. Exclusion criteria include redundant and duplicate features, features with a missing rate > 10%, and non-core attributes that are not significantly related to rendering performance. Priority is ranked as follows: visual state > point density > spatial hierarchy > frame number, with higher priority features participating in rule matching first.

[0079] Establish a mapping relationship of "spatial level → point density range → rendering parameter level", with each level corresponding to a fixed density range and rendering parameter set; establish a dynamic association of "frame number → temporal position → visual state", and dynamically update the visual state features according to the real-time position of the frame sequence; all associations are carried by ternary association nodes and bound to the corresponding nodes in the topology association graph.

[0080] The two computational units maintain real-time data interaction during modeling. The hierarchical division results and frame association data output by the hierarchical rule engine are transmitted to the rendering effect prediction model in real time, while the point distribution and rendering impact data fed back by the rendering effect prediction model are also synchronously transmitted back to the hierarchical rule engine. The two complement each other in computation and work together to complete the global modeling of the entire topology map. During the modeling process, the connection status of ternary nodes and the content of hierarchical labels are continuously monitored. Once abnormal content such as broken node associations or incorrect hierarchical labeling is detected, it is immediately marked, and abnormal areas are restricted from participating in subsequent feature extraction processes.

[0081] After modeling is completed, the two main units further delineate the spatial boundaries of the topology graph, marking the spatial level and corresponding frame number of each ternary node. The rendering effect prediction model simultaneously analyzes the density of points in each region and the visual visibility, determining the extent to which different points consume browser rendering resources. Once the association logic of all nodes, levels, and frame units is confirmed to be correct, the core feature extraction phase officially begins.

[0082] The spatial hierarchy features are based on the hierarchy analysis results of the hierarchy rule engine, distinguishing between three types of hierarchy attributes: global, regional, and fine-grained. Each ternary node's hierarchy category, hierarchical relationships, and spatial boundary range are recorded. Combined with the actual outdoor scene, the global hierarchy covers the entire 3D scene, the regional hierarchy divides the scene into independent sections according to roads, buildings, and open spaces, and the fine-grained hierarchy focuses on detailed areas such as building facades and road surfaces. All hierarchy division standards remain consistent with the layering rules described above.

[0083] The frame sequence number feature relies on the frame unit association relationship within the topology graph to extract the frame number, frame arrangement order, and frame stacking position bound to each node. The entire scene is numbered from 01 to 20, with an 80-millisecond interval between adjacent frame switching and a 35% overlap in the images. The extraction process fully preserves the frame timing and stacking logic.

[0084] The point density feature is calculated by combining the number of points in a unit space with the rendering effect prediction model. According to the established standards, the sampling density is 6 points per square unit in the far-view global area, which is classified as low density; the sampling density of the central area is 12 points per square unit, which is classified as medium density; and the sampling density of the near-view fine area is 28 points per square unit, which is classified as high density.

[0085] The visibility status is determined by combining the browser's current viewpoint, and is divided into three categories: fully visible, partially visible, and invisible. Nodes in the center of the screen are considered fully visible, nodes at the edges of the screen are considered partially visible, and nodes outside the viewpoint are considered invisible.

[0086] All features were extracted node-by-node at a uniform granularity, without altering the topology or the relationships between ternary nodes; only supplementary feature information was recorded. Taking a ternary node on a building facade as an example, this node belongs to the lowest fine-grained level and corresponds to the building's partition; its frame number is 09, located in the middle of the frame sequence; it has 28 points per unit space, classifying it as high-density; and it is currently centered in the browser view, thus deemed fully visible. Feature acquisition for all nodes in the entire scene was completed according to this standard.

[0087] The extracted four types of features include discrete categorical data and continuous numerical data. The system performs unified normalization to smooth out the differences in data dimensions between different features, ensuring that all data meets the requirements for vector fusion. The processing follows the model's preset rules without altering the original feature meaning. After normalization, the four types of features are sequentially concatenated and fused according to the vector dimensions and feature arrangement order specified by the rendering effect prediction model, transforming single-node multi-class features into fixed-dimensional high-dimensional vectors. After all nodes in the entire scene have undergone vector transformation, they are grouped together according to the original hierarchical order and frame arrangement order of the topology graph. The global hierarchical vector group is placed at the front, followed by the partitioned hierarchical and fine-grained hierarchical groups; within the same level, they are arranged sequentially according to frame numbers from 01 to 20, ultimately forming a complete set of point cloud hierarchical feature embedding vectors.

[0088] Discrete features (spatial hierarchy, visibility status) are encoded using one-hot encoding: spatial hierarchy is divided into three classes: global, regional, and fine-grained, encoded as a 3D 0-1 vector; visibility status is divided into three classes: fully visible, partially visible, and invisible, encoded as a 3D 0-1 vector. Continuous features (frame number, point density) are normalized to the [0,1] interval using min-max normalization, where the frame number ranges from [1, N] (N is the total number of frames), and the point density ranges from [0, maximum sampling density]. After initial concatenation, an 8-dimensional original feature vector is obtained, which is then mapped to a 16-dimensional feature embedding vector through a fully connected linear layer. The weights of the linear layer are learned synchronously during the training of the rendering effect prediction model. The final output 16-dimensional embedding vector contains, in order: 4-dimensional hierarchical semantic information, 3-dimensional frame temporal information, 4-dimensional density features, and 5-dimensional visibility status features, which can be directly input into the subsequent rendering engine.

[0089] S105 embeds hierarchical features into vectors and imports them into the hierarchical query and real-time rendering calculation engine. It uses a multi-scale hierarchical rule adaptive matching mechanism for iterative optimization. At the same time, it generates an optimization decision chain through interactive behavior monitoring and rendering anomaly visualization, forming a basic model for frame-by-frame point cloud query and rendering adapted to the browser.

[0090] In one implementation, the hierarchical feature embedding vector serves as the core input carrier for this step, fully carrying four types of high-dimensional features corresponding to all ternary nodes: spatial hierarchy, frame number, point density, and visual state. The vector data completely adopts the content and standards from the previous topology modeling and feature extraction stages, ensuring data consistency. Simultaneously, this step introduces four core constraints: global / partition / fine-grained three-layer scale rules, browser interaction attributes, and point cloud rendering latency requirements. These four categories work together as the judgment criteria for strategy generation. Specifically, the global, partition, and fine-grained three-layer scale rules define exclusive query boundaries, rendering specifications, and data retrieval logic for different levels of point clouds. The top-level global point cloud covers the entire 3D outdoor real-world scene, with a core objective of comprehensive overview querying, and is equipped with a lightweight rendering mode to reduce front-end computational pressure. The middle-level partitioned points divide the query scope according to spatial blocks such as roads, buildings, and open spaces, using conventional rendering standards to balance query efficiency and image quality. The bottom-level fine-grained points focus on local areas such as building facades and road surface details, emphasizing precise point location querying, and are paired with a high-precision rendering mode to fully reproduce detailed images.

[0091] Browser interaction attributes record various operations in real time, such as page view dragging, screen zooming, and scene transitions. Simultaneously, they collect data stream characteristics such as data transmission rate and command response latency under different operations, as well as the front-end's preset interaction response time requirements. Point cloud rendering latency requirements have clearly quantified performance constraints. Based on the entire browser runtime environment, the maximum rendering time per frame is set at 25 milliseconds. Under continuous view switching and screen zooming interaction scenarios, the average rendering latency must not exceed 30 milliseconds. All rendering-related logic must adhere to this latency threshold.

[0092] The system embeds hierarchical features into vectors and performs full-dimensional association matching with three types of constraints. According to spatial hierarchy division standards, different feature groups within the vectors are mapped to global, partitioned, and fine-scale rules. Simultaneously, it binds corresponding operational logic to each hierarchy based on the current interaction type and rendering latency threshold. For high-dimensional point cloud features at different levels, differentiated query modes and rendering schemes are designed to adapt the entire operational logic to the browser's hardware performance, data processing capabilities, and interactive usage requirements. Ultimately, it outputs a complete and implementable hierarchical query and real-time rendering execution strategy.

[0093] Multi-scale hierarchical rule adaptive matching employs a "feedback-driven incremental iteration" mechanism. The specific logic is as follows: the joint optimization objective is to minimize rendering latency and maximize query accuracy. The objective function is: ,in, For single-frame rendering latency, The preset latency threshold (default 25ms) is used. To improve query accuracy, The balancing factor is set to 0.6 by default. The iteration is triggered when 50 front-end interaction operations (view dragging, zooming, querying) are completed, or when the rendering latency exceeds the threshold for 3 consecutive frames, an iteration optimization is triggered.

[0094] The rule parameters are updated using gradient descent to adjust three types of rule parameters: loading granularity, rendering resolution, and query accuracy at each level of the point cloud. Each iteration calculates the gradient of the objective function based on interactive monitoring data and updates the parameters along the negative gradient direction, with a step size of 0.05. The iteration convergence condition is that the fluctuation range of the objective function value is less than 1% for three consecutive iterations, or the number of iterations reaches 20, at which point the iteration terminates and the current rule parameters are locked.

[0095] This explanation focuses on a real-world architectural scene with 20 stacked frames and 8600 points per frame. After the system loads the point cloud feature embedding vectors for the corresponding scene, it breaks down the execution logic according to a three-layer scale rule. For global-level points, the sampling density is 6 points per square unit. The vector features primarily consist of global distribution information. The system is configured with a large-scale batch query mode and a lightweight rendering strategy to reduce the number of rendered points and computational overhead. For zone-level points, the sampling density is 12 points per square unit. The vectors contain independent features for each zone. The system uses a region-oriented query method with standard image quality rendering parameters to ensure a smooth browsing experience. For low-level fine-grained points, the sampling density reaches 28 points per square unit. The vectors record rich detailed features. The system uses a single-point, small-range precise query mode and a high-quality rendering scheme to fully present scene details.

[0096] During screen interaction, when a user zooms in, the browser's interaction properties detect this behavior, and the system automatically switches to the execution strategy corresponding to the finer level, prioritizing the loading of detailed points and enabling high-precision rendering. When the user zooms out to view the overall scene, the system switches to a global level query and rendering strategy. Throughout the entire process, the system continuously verifies rendering time, strictly controlling the rendering time of a single frame to not exceed 25 milliseconds, and keeping the average latency within 30 milliseconds under continuous interaction. Once the threshold is approached, the system automatically fine-tunes the rendering parameters to ensure smooth operation. After multi-dimensional matching, rule adaptation, and performance constraint verification, a layered query and real-time rendering execution strategy adapted to this scenario is officially generated, providing a complete basis for subsequent rule granularity and data loading level settings.

[0097] The system processes query rendering execution strategies based on hierarchical rule matching priority and hierarchical data retrieval efficiency, setting rule execution granularity and data loading levels. The system prioritizes generated hierarchical query and real-time rendering execution rules based on business usage frequency and functional importance. Considering the overall browser-side frame-stacked point cloud runtime scenario, rules are divided into high-priority and low-priority categories. Functional rules for real-time user interaction and precise point retrieval are classified as high-frequency core rules, while non-real-time rules such as backend data statistics and log aggregation are classified as low-frequency auxiliary rules. Simultaneously, data retrieval efficiency is evaluated based on the actual situation of the global, partitioned, and fine-grained point cloud layers. Evaluation dimensions include the total number of points per layer, data read time per session, and network and front-end memory transfer overhead. Continuing with the basic parameters of this scenario, the entire frame-stacked system contains frame units 01 to 20, with 5160 points per frame at the global level, 8600 points per frame at the partitioned level, and 12400 points per frame at the bottom-level fine-grained level. The global level has the smallest data volume, with a single read time controlled within 8 milliseconds, resulting in the best retrieval efficiency; the partition level has a medium data volume, with a single read time of about 14 milliseconds, resulting in a normal retrieval efficiency; the fine level has a large number of points and rich auxiliary attribute fields, with a single read time of up to 26 milliseconds, resulting in relatively low data retrieval efficiency.

[0098] After prioritizing and evaluating retrieval efficiency, the system uniformly categorizes all query and rendering execution rules into three granularities: coarse-grained, regular-grained, and fine-grained. Fine-grained mode fully loads all point attributes, frame association information, and rendering parameters, performing calculations and verifications point-by-point and frame-by-frame to ensure the accuracy of query results and rendered images. Regular-grained mode retains core calculation fields and simplifies unnecessary auxiliary information, balancing accuracy and efficiency. Coarse-grained mode loads only basic contour data, simplifying the calculation process and minimizing front-end computational load. The system matches the corresponding execution granularity according to rule priority. High-priority core business rules uniformly use fine-grained execution mode, low-priority auxiliary rules use coarse-grained execution mode, and partition-related regular business rules are matched with regular granularity.

[0099] Meanwhile, based on the differences in retrieval efficiency at each level, multiple data loading levels are defined, each corresponding to a different data loading strategy. The global level, with the highest retrieval efficiency, is set to a Level 1 full-speed loading level, loading all data at once after a data request is initiated. The partition level, with moderate retrieval efficiency, is set to a Level 2 regular loading level, loading data in batches according to fixed data blocks. The fine-grained level, with relatively low retrieval efficiency, is set to a Level 3 segmented loading level, splitting data into multiple groups of fragments and loading them sequentially at time intervals to avoid page lag and response delays caused by massive amounts of data flooding the browser simultaneously. All execution granularity and data loading levels are bound to the corresponding query rendering execution strategy, forming a standardized and implementable fine-grained operational specification.

[0100] This document uses 20 sets of overlay outdoor real-world scenes as examples for illustration. In this scenario, the real-time rendering rules linked to viewpoint switching and the precise spatial point query rules are directly user-visualized and are the most frequently used and functionally important, thus designated as high-priority rules, and uniformly executed in a fine-grained mode. During the calculation process, all fields such as point coordinates, RGB color, sampling density, frame number, and rendering configuration are fully invoked, and verification calculations are performed frame by frame and point by point to ensure smooth screen transitions and accurate point queries. Auxiliary rules such as background point total statistics and historical frame data aggregation are used less frequently and are designated as low-priority rules, using a coarse-grained execution mode. Only the basic data of point outlines and quantities are read, and auxiliary fields such as color, precision, and frame association are removed to simplify the calculation logic and reduce browser CPU and memory usage.

[0101] In terms of data loading configuration, the global layer has 5160 points per frame, with a single read time of 8 milliseconds. It is set to a first-level full-speed loading level, directly loading the entire batch of data after triggering the loading command, meeting the needs of fast panoramic browsing. The middle-layer partition layer has 8600 points per frame, set to a second-level normal loading level, loading data continuously in blocks of 2000 points each. The bottom-layer fine-grained layer has 12400 points per frame, the largest data volume, and is set to a third-level segmented loading level, splitting the data into four groups of data chunks, each group loaded sequentially at 15-millisecond intervals. This loading method ensures the detailed display effect of the fine-grained layer points while avoiding page lag caused by loading a large amount of data at once.

[0102] The system processes multi-scale matching rules, data loading levels, globally unique point cloud identifiers, and hierarchical feature vectors, and incorporates full-process interactive behavior monitoring records, rendering status version control, and abnormal data fallback verification parameters. Multi-scale matching rules and data loading levels are standardized operational specifications already established in the initial process. The globally unique point cloud identifier serves as the unique identification code for points and frame units within the entire system, running throughout the entire data link. The hierarchical feature vector is the core data carrier supporting query and rendering operations. Building upon the existing operational framework, the system sequentially integrates three types of supporting control parameters: full-process interactive behavior monitoring records, rendering status version control, and abnormal data fallback verification parameters. Each of these parameters performs its specific function, improving the overall operational system from three dimensions: behavior tracing, version management, and risk prevention.

[0103] The end-to-end interactive behavior monitoring and recording module captures all browser-side operations in real time, comprehensively retaining full log content including user operation type, operation trigger time, data retrieval actions, and screen rendering actions, enabling full traceability of front-end behavior based on log data. The monitoring scope covers common interactive actions such as viewpoint dragging, screen zooming, scene switching, and point location queries, while also recording data loading progress and feature vector calls under corresponding operations. The rendering status version control module assigns a unique version number to each rendering task and each set of stacked frame datasets, classifying versions according to task start time and front-end interaction scenarios, distinguishing between regular static rendering versions and dynamic interactive rendering versions, preventing confusion and errors in rendering data from different time periods and scenarios. The abnormal data fallback verification parameters have pre-defined abnormal judgment thresholds and data interception rules, conducting pre-verification for various issues such as missing feature vectors, incorrect point location identification matching, abnormal rendering commands, and incorrect point location attributes. Abnormal data is identified and intercepted before it flows into the processing stage, avoiding browser rendering failures and query failures at the source.

[0104] All newly added control parameters are bound one-to-one with existing multi-scale matching rules, data loading levels, globally unique point cloud identifiers, and hierarchical feature vectors. The entire binding relationship covers all frame units from 01 to 20, as well as all points at the global, partition, and fine-grained levels. Any execution rule, any set of point data, and any feature vector will be matched with a corresponding monitoring log entry, version number, and verification rule. The modules are interconnected and operate collaboratively to form a complete closed-loop control system.

[0105] This project utilizes an outdoor real-world scene with 20 overlapping frames and 8600 valid points per frame for detailed explanation. The system assigns a unique interaction monitoring log entry to each globally unique point cloud identifier, categorizing entries such as operation time, operation type, and data call path. When a user performs operations such as point location query, 15-degree view rotation, or screen zoom in / out in the browser, the system simultaneously records the operation's time, the corresponding frame number, and the currently retrieved hierarchical feature vector group. For example, when a user views visible core frames 07 to 12, the log will fully record the interaction behavior and data flow path for that period. Subsequent actions can be reviewed by retrieving the corresponding logs based on the point identifier.

[0106] In terms of rendering version management, the system assigns independent version numbers according to the running scenario. When the page is idle and statically browsing the entire set of stacked frames, a unified static rendering version is assigned; for dynamic interactive scenarios where the user continuously drags the viewpoint and zooms the screen, an independent interactive rendering version is assigned. Each time the entire set of 20 frame units starts a rendering task, a unique version identifier is generated, and different versions are isolated from each other to avoid cross-interference between historical rendering data and real-time rendering data.

[0107] The fallback verification process for abnormal data follows the established criteria outlined earlier, configuring thresholds to include missing feature vector fields, mismatched point identifiers with frame units, single RGB color deviations exceeding 5, point coordinate offsets exceeding 0.5 units, and sampling density differences exceeding 2 points per square unit. When the system detects missing fields in the hierarchical feature vector of a frame, or an incorrect global identifier for a single point bound to another frame unit, the fallback verification parameters immediately trigger an interception mechanism, blocking the transmission of this abnormal data to downstream query and rendering modules, and simultaneously marking the abnormal content. For valid data, normal processing proceeds according to established multi-scale matching rules and data loading levels. This comprehensive management system effectively mitigates issues such as screen tearing, point loss, and incorrect query results caused by abnormal data, ensuring the stable operation of the browser-side frame-stacked point cloud service.

[0108] This system integrates query rendering execution strategies, data loading levels, globally unique point cloud identifiers, hierarchical feature vectors, interaction monitoring records, and state control and anomaly verification parameters to form a browser-compatible frame-stacked point cloud query rendering basic model. The model is divided into six functional modules based on the order of front-end data flow: feature storage, rule scheduling, data loading, interaction monitoring, version control, and anomaly verification. These modules are bidirectionally connected via the browser's internal data channel, allowing for real-time data exchange. The modules function in a coordinated and integrated manner. The entire model retains the configuration parameters from previous outdoor real-world frame-stacked scenarios, including 20 frame units (01 to 20), distinguishing between global, regional, and fine spatial levels. It adheres to established standards for the number of points, sampling density, coordinate ranges, color parameters, and deviation thresholds. The module operation logic fully matches the browser's operating architecture, hardware resources, and performance limitations.

[0109] The feature storage module serves as the data hub of the model, centrally managing all globally unique point cloud identifiers and hierarchical feature vectors. Internally, the module partitions and stores feature vectors according to frame number and spatial level, separating global, partitioned, and fine-grained feature vectors into different regions. A binding index is also established between identifiers and feature vectors. All feature data, including the unique code, corresponding spatial level, frame number, point density, and visibility status of all points within the entire scene, are managed uniformly here. When other modules retrieve data, they can quickly search using point identifiers, frame numbers, and levels, ensuring efficient and accurate data retrieval.

[0110] The rule scheduling module is dedicated to invoking hierarchical query and real-time rendering execution strategies, multi-scale matching rules, and rule execution granularity. This module pre-stores high-priority real-time interaction rules, low-priority background statistical rules, and three execution standards: fine-grained, regular-grained, and coarse-grained. Based on scene configuration, for high-priority tasks such as viewpoint switching and precise point location queries, the module automatically matches the fine-grained execution mode, fully verifying all fields of data, including point coordinates, RGB color, and sampling density. For low-priority auxiliary tasks such as total point location statistics, the module matches the coarse-grained execution mode, retrieving only basic contour data, thus rationally allocating computing resources.

[0111] The data loading module strictly adheres to the pre-defined data loading levels for data scheduling. The global level is set to a first-level full-speed loading level, the partition level to a second-level normal loading level, and the fine-grained level to a third-level segmented loading level. The module incorporates data sharding and time interval control logic. A single global frame of 5160 data points can be loaded all at once; a single partition frame of 8600 data points is divided into data blocks of 2000 points each and loaded continuously; and a single fine-grained frame of 12400 data points is split into four groups, each group loaded sequentially at 15-millisecond intervals. This fundamentally prevents excessive browser memory usage and page lag caused by a sudden influx of massive amounts of data.

[0112] The interaction monitoring module, version control module, and anomaly verification module are fully embedded in the overall business process, running synchronously with the entire process of data retrieval, loading, calculation, and rendering. The interaction monitoring module captures all front-end operations in real time, such as viewpoint dragging, screen zooming, and point location querying, recording the operation time, operation type, corresponding frame number, and data call path. The version control module assigns an independent version number to each rendering task, distinguishing between static browsing versions and dynamic interactive versions, and isolating data from different versions to prevent data confusion. The anomaly verification module continuously screens against established judgment standards. When it detects problems such as point coordinate offset exceeding 0.5 units, RGB color single deviation greater than 5, sampling density difference exceeding 2 points per square unit, missing feature vector fields, or incorrect point identifier binding, it immediately triggers an interception action to prevent abnormal data from entering the calculation stage.

[0113] The entire model, from its architecture design to its operational logic, is adapted to the resource limitations of mainstream browsers, such as memory, computing power, and bandwidth. The six modules work collaboratively, and after accessing any set of point cloud hierarchical feature vectors, it can autonomously complete the entire process of rule matching, hierarchical loading, point location query, and image rendering. Simultaneously, it performs status monitoring, version management, and anomaly interception, making it the core carrier for subsequent effect verification, dynamic parameter optimization, and formal image rendering.

[0114] To illustrate this using a real-world scenario, when a user initiates a point cloud query in a browser, the model begins its complete execution process. First, the feature storage module retrieves the global point identifiers and corresponding hierarchical feature vectors for the corresponding frame unit and spatial level based on the query conditions, and synchronously outputs the data to other modules. Then, the rule scheduling module identifies this query as a high-priority core business, activates fine-grained execution standards, and invokes the corresponding layered query and rendering execution strategies. The data loading module matches the loading level of the current level; if it's a global level, it loads data at full speed; if it's a fine-grained level, it loads data gradually according to the fragment intervals. Throughout the data loading and computation process, the interaction monitoring module automatically records this query operation, the corresponding visual frame numbers 07 to 12, and the data flow path; the version control module locks the specific version for the current rendering task; and the anomaly verification module verifies the point coordinates, color, density, and identifier binding relationships one by one, immediately intercepting and marking any anomalies that exceed the limits.

[0115] After all modules work together to complete query calculations and image rendering, the entire process executes smoothly. Page response speed and image quality meet preset latency standards, with single-frame rendering time controlled within 25 milliseconds and continuous interaction average latency not exceeding 30 milliseconds. The model operates stably and can be directly integrated into subsequent multi-indicator evaluation and dynamic optimization stages, supporting the continuous operation of the entire stacked point cloud hierarchical query and rendering business.

[0116] S106, based on the query rendering basic model, combines front-end interaction data and dynamic frame loading monitoring data to verify the effect and dynamically optimize it. Through a multi-index comprehensive evaluation algorithm, it balances the point cloud query accuracy, page rendering frame rate, and browser compatibility requirements, and generates browser-side stacked frame point cloud hierarchical query and rendering information.

[0117] In one implementation, multi-dimensional operational parameters of the stacked frame point cloud are processed based on the query rendering basic model. A multi-index comprehensive evaluation algorithm and a browser-side multi-source data fusion mechanism are introduced to realize point cloud feature parsing and operational parameter conversion. The query rendering basic model serves as the sole basic data source in this step. It comprehensively includes the spatial hierarchical features of the entire stacked frame point cloud, hierarchical query rules, rendering configuration parameters for each level, and front-end interaction adaptation parameters. All data follows the previous outdoor real-scene standard, covering all frame units from 01 to 20, and the three spatial levels of global / partition / fine. The configurations such as the number of points, sampling density, coordinate range, color parameters, latency threshold, and deviation judgment criteria are all kept consistent.

[0118] The single indicator ranges are divided as follows: the normal range is when the indicator value is ≥ 95% of the target value; for example, query accuracy ≥ 93.1%, rendering frame rate ≥ 28.5fps, and compatibility ≥ 92.15% are within the normal range. The critical range is when the indicator value is between 80% and 95% of the target value; the abnormal range is when the indicator value is < 80% of the target value.

[0119] The overall score ranges are divided as follows: the normal range is a score ≥ 0.9; the critical range is 0.7 ≤ Score < 0.9; and the abnormal range is a score < 0.7. The interval triggering logic is as follows: when in the normal range, the current operating strategy is maintained; when in the critical range, mild optimization is triggered to fine-tune the parameters; and when in the abnormal range, deep optimization is triggered, and the optimization decision chain is started to perform full parameter iterative optimization.

[0120] This stage simultaneously utilizes two core computing units: a multi-index comprehensive evaluation algorithm and a browser-side multi-source data fusion mechanism. The multi-index comprehensive evaluation algorithm pre-defines three core evaluation dimensions: query accuracy, page rendering frame rate, and browser compatibility. It also defines the statistical criteria, judgment logic, and basic operational rules for each dimension, clearly defining the standards for normal, critical, and abnormal intervals. The browser-side multi-source data fusion mechanism handles data integration and standardization. It aggregates information from various sources, including front-end interaction logs, dynamic frame loading monitoring data, inherent characteristics of data points, and real-time rendering status. It unifies the field formats, units of measurement, and data precision of various data types, eliminating format differences between multi-source data and ensuring complete consistency in the data read by subsequent algorithms.

[0121] After the system officially starts operation, it first extracts multi-dimensional operating parameters in batches from the basic rendering model. These parameters include query response time for different level points, single-load rate of points, real-time rendering load, and operating adaptation status under different browsers. The extraction process is carried out according to global, partition, and fine-level classifications, distinguishing the operating data of different frame units from 01 to 20. Subsequently, a multi-index comprehensive evaluation algorithm is invoked, using the fused multi-source data as input to perform secondary deep analysis on the original features such as point cloud spatial hierarchy, point density, and screen visibility. The entire operation follows established business mapping rules, achieving bidirectional conversion between the inherent features of the point cloud and device operating performance parameters: on the one hand, point and hierarchy features are transformed into quantifiable operating indicators; on the other hand, real-time operating indicators are back-linked to the corresponding point cloud feature dimensions, completing data interoperability and conversion. The converted features and parameters are integrated into a unified dataset, serving as the standard input for the rendering effect accuracy evaluation model.

[0122] To elaborate on the outdoor real-world scene with the twenty sets of overlay frames mentioned earlier, the entire scene has 8,600 basic points per frame, 5,160 points per frame at the global level with a sampling density of 6 points per square unit, 8,600 points per frame at the partition level with a sampling density of 12 points per square unit, and 12,400 points per frame at the fine level with a sampling density of 28 points per square unit. The maximum rendering time for a single frame is preset to 25 milliseconds, and the average latency for continuous interaction does not exceed 30 milliseconds.

[0123] The system first reads the corresponding parameters from the basic query rendering model: the average query response time for the global level is 7 milliseconds, with fast point loading speed and low rendering load; the average query response time for the partition level is 14 milliseconds, with a medium rendering load; and the average query response time for the fine-grained level is 26 milliseconds, with a relatively low point loading speed and a relatively high rendering load. Simultaneously, it extracts adaptation and runtime data from multiple browsers to record the screen performance under different environments.

[0124] Next, the browser-side multi-source data fusion mechanism aggregates recent interaction logs such as viewpoint rotation and screen zoom, as well as the loading time and completion status of frame units 01 to 20. This data, combined with original features such as point density and visible range, unifies the format of all data. A multi-index comprehensive evaluation algorithm analyzes the integrated data and transforms it according to business mapping rules: high-density point features (28 per square unit at the fine-grained level) are converted into high-rendering-load, long-query-time operating parameters; low-density, large-area point features (6 per square unit at the global level) are converted into low-rendering-load, fast-query operating parameters; points located in the center of the screen and fully visible are matched with high-frequency rendering and high-query-frequency operating indicators; points visible at the edge of the screen but not visible outside the viewpoint are matched with low-frequency operating indicators. Simultaneously, operational anomalies such as low rendering frame rate and query timeouts are located to the feature dimensions of the corresponding high-density fine-grained points and the core visible area.

[0125] By aligning with browser front-end interaction specifications and the requirements for layered rendering of point clouds, a rendering effect accuracy evaluation model is constructed. The weights of various performance indicators are calculated through an adaptive index weight calculation model, and a dynamic verification and optimization mechanism for point cloud query rendering is established.

[0126] The multi-indicator comprehensive evaluation adopts a weighted summation model, combined with scenario-adaptive weight dynamic adjustment, as follows: Comprehensive score calculation formula: ,in, = 1, , , These are the normalized scores for query accuracy, rendering frame rate, and browser compatibility, respectively, with values ​​ranging from [0,1].

[0127] The indicator normalization rules are as follows, and the query accuracy is as follows: The target accuracy is 98% by default; any value exceeding 1 is counted as 1. Rendering frame rate: The target frame rate is 30fps by default. Browser compatibility: It covers four mainstream browsers: Chrome, Edge, Firefox, and Safari.

[0128] The adaptive weight allocation rules are as follows, for high-frequency interaction scenarios (continuous view dragging, frequent zooming): =0.2, =0.6, =0.2, prioritizing rendering frame rate. Precise scene query (local point retrieval, zoom in for viewing): =0.6, =0.2, =0.2, prioritizing query accuracy. Cross-terminal compatibility scenarios: =0.2, =0.2, =0.6, prioritizing compatibility with multiple browsers.

[0129] The rendering effect accuracy evaluation consists of two parts: a rendering effect accuracy evaluation model and an adaptive index weight calculation model. These two models work together, combining the browser's operating environment, front-end interaction status, and the layered point cloud features of the stacked frames to determine the effect and dynamically adjust the weights. The rendering effect accuracy evaluation model is internally divided into three sequentially running layers: an index receiving module, an effect judgment module, and a preliminary scoring module. Data is passed between modules in a fixed flow, with the output of one module directly serving as the input of the next.

[0130] The indicator receiving module is specifically responsible for receiving bidirectionally converted operating parameters and point cloud feature data. The data range covers all frame units from 01 to 20, as well as query response time, point loading rate, rendering load, point density, and visibility status at three spatial levels: global, partition, and fine. The module performs format standardization and field sorting on the received data, removing invalid and redundant information, and retaining only the corresponding data for three core evaluation categories: query accuracy, rendering frame rate, and browser compatibility. The effect judgment module checks each indicator against preset rules to see if it meets the standards, distinguishing between normal, critical, and abnormal states. The preliminary scoring module combines the judgment results to complete a comprehensive score, and finally outputs a comprehensive judgment result on the rendering effect and point query accuracy in the current scene.

[0131] Before its official deployment in business applications, the model underwent iterative training. Training samples covered various front-end interaction scenarios, including multiple mainstream browsers, viewpoint dragging / screen zooming / scene switching, and stacked point cloud data with three density levels: 6 points per square meter globally, 12 points per square meter in different zones, and 28 points per square meter for fine-grained analysis. After training, a complete set of operational standards was established, clearly defining the acceptable thresholds and performance grading standards for each indicator. Specific thresholds were set for this scenario: a single-frame rendering frame rate of 30 frames per second was set, and a frame rate of 25 frames per second was set for continuous interaction scenarios; the accuracy of point location lookup was set to 98%; and the browser multi-version compatibility rate was set to 97%. Three performance levels were also established: all indicators meeting the standards were considered excellent; a single indicator slightly below the threshold was considered acceptable; and multiple indicators or a single indicator significantly below the threshold were considered unacceptable.

[0132] The adaptive metric weight calculation model is a complementary computational unit that communicates with the rendering effect accuracy evaluation model in real time. The model dynamically adjusts the weight distribution of three metrics—query accuracy, rendering frame rate, and browser compatibility—based on the current browser model, front-end interaction intensity, and user behavior, while maintaining a fixed total weight. The model incorporates multiple weight allocation schemes to adapt to different usage scenarios, serving as the core control unit for dynamic evaluation.

[0133] After system startup, the system first deploys and initializes the rendering effect accuracy evaluation model based on browser general interaction specifications and the layered rendering adaptation requirements of global / partial / fine point clouds, differentiating the evaluation focus of different levels. The global level focuses on large-scale browsing and loading speed, the partition level considers both query effect and screen performance, and the fine level focuses on ensuring the accuracy of point location queries and the quality of detailed rendering. After initialization, the converted running parameters and point cloud feature data from the previous step are completely sent to the indicator receiving module, and the adaptive indicator weight calculation model is started simultaneously to calculate the real-time weights of the three types of indicators in combination with the real-time running environment.

[0134] In highly interactive scenarios, where users continuously drag the viewpoint and frequently zoom in and out, the system increases the weight corresponding to the rendering frame rate. When multiple browsers access the page simultaneously and use it across devices, the system increases the weight of browser compatibility. When users focus on detailed areas such as building facades and roads and perform precise location queries, the system increases the weight of query accuracy. Based on the combined calculation results of the two models, a normalized dynamic verification mechanism is established to verify the overall effect of layered queries and image rendering in real time throughout the process. At the same time, a dynamic optimization trigger logic is set: once any indicator falls below the preset qualified threshold, the mechanism immediately triggers the optimization process, providing a basis for subsequent deviation correction and parameter adjustment.

[0135] Using an outdoor overlay scene as an example, the entire scene consists of 20 frame units, with a fine-level point density of 28 points per square meter. The acceptable frame rate for single-frame rendering is 30 frames per second. When users continuously drag the viewpoint and browse the screen using mainstream browsers, this is considered a high-interaction scenario. The adaptive metric weight calculation model automatically adjusts the weight allocation, increasing the rendering frame rate weight to 50%, setting the query accuracy weight to 25%, and setting the browser compatibility weight to 25%.

[0136] The rendering effect accuracy evaluation model's indicator receiving module continuously collects real-time frame rate, query results, and browser adaptation data. The effect judgment module compares each data point against the acceptable thresholds of 30 frames per second, 98% query accuracy, and 97% adaptation rate. During operation, it was detected that the real-time frame rate in the fine-grained region was only 22 frames per second, lower than the acceptable threshold of 25 frames per second for interactive scenes. The effect judgment module marked this state as abnormal. The dynamic verification mechanism then identified the performance problem and automatically triggered a dynamic optimization process. Subsequent steps will conduct deviation investigation, parameter correction, and strategy optimization based on this judgment result.

[0137] Using rendering effect matching as the core dimension, a multi-dimensional rendering control correlation matrix is ​​constructed by integrating single-frame, partition, and global scale feature data, front-end interaction data, dynamic frame loading monitoring data, and initial rendering result query data. Rendering effect matching serves as the core index of the entire matrix, specifically used to compare the degree of fit between the actual query and rendering performance of the browser-side stacked frame point cloud and the preset expected standards. The matching level is divided based on the comprehensive performance of various operational indicators. Combining the 20 sets of stacked frames, the global / partition / fine three-layer point architecture used throughout the entire business, and the established frame rate, query accuracy, and compatibility thresholds, rendering effect matching is divided into three levels: excellent, qualified, and needing optimization. The level division is based on the judgment rules of the previous multi-indicator evaluation system for complete matching.

[0138] Single-frame scale data, partition scale data, and global scale data are divided according to spatial and frame ranges. Single-frame scale data records the distribution of all points within any independent frame unit from 01 to 20, the real-time rendered image, and the color and accuracy status of the points. Partition scale data is divided into preset spatial blocks such as roads, buildings, and open spaces, and statistically analyzes the overall operation of all frames combined within a single block. Global scale data covers all 20 stacked frames and the entire 3D outdoor scene, reflecting the comprehensive query and rendering performance of the entire point cloud. Front-end interactive data fully records all browser operations such as viewpoint dragging, screen zooming, scene jumping, and point click queries, along with auxiliary information such as operation trigger time and operation duration. Dynamic frame loading monitoring data collects the loading progress, single-frame loading time, loading interruption, loading timeout, and other abnormal states of each frame unit in real time. The initial query rendering result data is the raw query feedback and raw rendered image data directly output by the query rendering base model, without secondary modification or processing.

[0139] The system constructs a multi-dimensional rendering control and correlation matrix according to a row-column structure, uniformly using the rendering effect matching level as the matrix row dimension, with each row corresponding to a matching level. The column dimensions are set as six categories: global scale features, partition scale features, single-frame scale features, front-end interaction data, dynamic frame loading monitoring data, and query rendering initial results. All column items cover all dimensions of monitoring content. The data filling process strictly follows a one-to-one correspondence rule. Each row record is filled with scale data, interaction behavior, frame loading status, and original running results within the corresponding range, based on the current rendering effect level. The matrix has a complete data linkage mechanism. Any change in data in any column—such as a longer frame loading time, abnormal query results in a certain area, or continuous zooming by the user—will synchronously link to the corresponding rendering effect level in that row, and simultaneously correlate with the corresponding spatial layer, specific frame number, and point cluster, ensuring all data nodes are interconnected and providing complete data support for subsequent deviation identification, problem localization, and data correction.

[0140] The following is a detailed explanation of the outdoor frame-by-frame real-world scene. The entire scene comprises frame units 01 to 20, with a global point sampling density of 6 per square unit, a partition point density of 12 per square unit, and a fine point density of 28 per square unit. The standard rendering time for a single frame does not exceed 25 milliseconds, and the average latency for continuous interaction does not exceed 30 milliseconds. The matrix is ​​divided into different rows based on three rendering effect matching levels: excellent, acceptable, and needing optimization. In the excellent row, scale data is entered indicating that the overall global point cloud loading is normal, all partition query results are accurate, and the single frames 01 to 20 are complete. Simultaneously, regular browsing-type interactive behaviors are recorded, with frame loading times consistently between 8 and 18 milliseconds and no loading anomalies. Normal query rendering results are also entered concurrently.

[0141] Within the acceptable level, minor deviations were recorded for some edge partition points and slight fluctuations in individual non-core single frames. The corresponding interactions were mostly short-term screen zooming, with frame loading times ranging from 19 to 24 milliseconds. No loading failures occurred, and the initial results were generally normal with only minor deviations. Within the unoptimized level, errors were clearly recorded in the query results for the building partitions containing fine-grained points. Frame units 09 and 10 took 27 milliseconds to load, exceeding the standard limit. This was also linked to user interactions involving prolonged viewpoint dragging and repeated zooming in on detailed areas, indicating significant anomalies in the initial query rendering results for this row.

[0142] Staff can directly rely on this matrix to trace the source of problems. When issues such as screen lag or query failures are discovered, they can first locate the row containing the matching level to be optimized. This allows them to quickly pinpoint the anomaly in the building partition and frame units 09 and 10, while simultaneously confirming that the problem is caused by high-frequency viewing angle dragging and screen zooming interactions, thus accurately defining the scope and cause of the anomaly. All data formats, judgment criteria, and parameter thresholds in the matrix are consistent with the analysis, rendering, and evaluation stages described above. The entire process adheres to established rules such as a coordinate offset of 0.5 units, an RGB color deviation of 5, a sampling density difference of 2 points, a query accuracy of 98%, and a rendering frame rate of 25 frames per second, ensuring the consistency and uniformity of the entire data system.

[0143] The rendering data deviation correction model addresses anomalies in the query and rendering processes. Combined with front-end interactive feedback and frame loading status monitoring and calibration mechanisms, it enhances overall performance. This is integrated with the rendering accuracy evaluation model results, and an optimization decision chain is generated based on anomaly visualization, forming a complete browser-side layered point cloud query and final rendering information. The rendering data deviation correction model consists of three parts: a deviation identification module, an automatic correction module, and an anomaly marking module. These three modules operate cyclically according to a fixed process, forming a closed-loop working mode. Data flows between modules in real time, with the output of one module directly serving as the input for the next. The entire process relies on a unified set of business judgment standards, using established parameters such as a query accuracy of 98%, a single-frame rendering frame rate of 30 frames / second, an interactive scene frame rate of 25 frames / second, a frame loading duration threshold, a maximum point coordinate offset of 0.5 units, a single RGB color deviation of 5, and a sampling density difference of 2 points per square unit.

[0144] The deviation identification module specifically reads all data within the multi-dimensional rendering control association matrix. This matrix includes global, partitioned, and fine-scale data, front-end interaction records, frame loading status, and the original rendering results. The module retrieves the pass / fail criteria output by the rendering effect accuracy evaluation model, compares the data item by item, and comprehensively identifies various problems that occur during business operations. These include deviation types such as incorrect point query results, rendering stutters, single or multi-frame loading timeouts, compatibility issues across different browsers, mismatched point attributes, and frame timing errors. The identification process simultaneously records the corresponding frame number, spatial partition, point range, and deviation severity, defining the target area for subsequent correction work.

[0145] The automatic correction module is equipped with a set of preset correction rules to perform automated correction operations for common problems identified by the deviation identification module. Common correction actions include rematching the spatial index structure, adjusting the loading priority of different levels and frame units, dynamically switching rendering resolution, resetting the point query index, correcting the frame timing order, and fine-tuning point color and density parameters. All correction operations do not modify the original point data, but only adjust the running logic and configuration parameters. After the correction is completed, the operation content and execution results are recorded synchronously. For faults that exceed the scope of the automatic correction rules, have a wide impact, or have multiple indicators showing serious anomalies simultaneously, the module does not perform forced repair actions and directly transfers the case to the anomaly marking module.

[0146] The anomaly marking module specifically marks severe deviations that cannot be automatically repaired. The marking information includes the anomaly type, the frame number, the corresponding spatial partition, the number of affected points, and the current operating status. All marked anomaly data is isolated to prevent problematic data from participating in subsequent calculations. At the same time, the marking information is synchronized to the visualization display port for easy viewing by operations and maintenance personnel.

[0147] The front-end interaction feedback mechanism and the frame loading monitoring and calibration mechanism work in tandem with the rendering data deviation correction model throughout the entire process. The front-end interaction feedback mechanism continuously collects user experience and page operation feedback data, and combines this with the interaction behavior type to help determine the causes of deviations, distinguishing between different sources of problems such as human error, system configuration, and network environment. The frame loading monitoring and calibration mechanism monitors the loading progress, timing sequence, and loading time of all frame units from 01 to 20 in real time, proactively correcting problems such as frame timing errors, loading delays, and incorrect frame stacking order, reducing the probability of deviations from the frame data source.

[0148] After completing deviation correction and state calibration, the system fuses the corrected query and rendering operation data with the comprehensive judgment result output by the rendering effect accuracy evaluation model. The integrated dataset retains the original features, correction records, and effect ratings. Simultaneously, all fixed issues and pending anomalies are visualized, prioritized according to anomaly type, impact level, and coverage frame range, generating a hierarchical optimization decision chain. The decision chain clearly defines the optimization direction, parameter adjustment range, and execution order for each issue, directly guiding subsequent parameter iterations, rule optimizations, and strategy updates. Once all data, correction records, effect conclusions, and optimization schemes are integrated, a complete, directly usable, layered point cloud query and rendering final information is generated, ready for immediate use in a browser.

[0149] This project uses an outdoor real-world scene with 20 stacked frames and 8600 points per frame, illustrated by a three-layer architecture: global, zone, and fine-grained. After data comparison, the multi-dimensional rendering control correlation matrix identified errors in the building zone point query results. It also detected that frames 09 and 10 had loading times of 27 milliseconds, exceeding the 25-millisecond threshold for single frames; both are considered normal deviations. The deviation identification module accurately located the anomaly in the middle-layer zone and specified frame unit. The automatic correction module then activated the corresponding rules, re-matched the spatial index of that area, and increased the loading priority of frames 09 and 10, thus automatically correcting both issues.

[0150] During the process, some older browsers were detected to be displaying abnormalities. This issue exceeded the scope of the automatic correction rules. The anomaly marking module labeled this type of adaptation anomaly, recording the affected browser type, the corresponding frame range, and marking the anomaly location and affected area on the visualization interface. The front-end interaction feedback mechanism simultaneously collected data showing that users mainly performed zooming in and localized queries during this period. The frame loading monitoring and calibration mechanism continuously verified the timing and loading status of other frames to ensure that all data except for the problematic frames were running normally.

[0151] The system integrates corrected operational data and rendering effect evaluation conclusions, and combines all anomaly information to generate an optimization decision chain. Decisions include optimizing partition query indexes, further compressing loading time for key frames, and specifically adjusting adaptation parameters for older browsers. Finally, it integrates normal operation data, fixed business content, pending anomalies, and a complete set of optimization solutions to form a complete browser-side overlay frame point cloud hierarchy query and rendering information, supporting the official page display and long-term iterative optimization.

[0152] In one implementation, such as Figure 2 As shown, this application also provides a browser-side frame-stacked point cloud hierarchy query and rendering system, including: The stacked frame point cloud source data acquisition module 201 is used to acquire original stacked frame point cloud multi-source data, frame sequence data, and information such as spatial coordinates, color, and precision from the browser. The stacked frame point cloud fusion dataset generation module 202 is used to complete the automatic parsing of stacked frame point clouds, inter-frame deviation detection and data standardization preprocessing based on the point cloud parsing engine and frame synchronization adapter. It identifies spatial hierarchy, frame stacking structure and visible area type by relying on the hierarchical partitioning model, and generates stacked frame point cloud fusion dataset by combining real-time browser interaction and viewpoint switching event to update data. The stacked frame point cloud topology association graph construction module 203 is used to divide the fused dataset into three types of point clouds: top-level global, middle-level partition, and bottom-level fine. For each type, a three-element association node of point cloud identifier-frame unit-rendering parameter is constructed. The hierarchical structure and visual attributes are aggregated by the spatial index matching algorithm to generate a browser-side stacked frame point cloud topology association graph. The hierarchical feature embedding vector generation module 204 is used to model the topological relationship graph based on the hierarchical rule engine and the rendering effect prediction model, extract core features such as spatial hierarchy, frame number, point density, and visibility state, and generate point cloud hierarchical feature embedding vectors. The query rendering basic model building module 205 is used to import the hierarchical feature embedding vector into the hierarchical query and real-time rendering calculation engine, and iteratively optimizes the multi-scale hierarchical rule adaptive matching mechanism. Combined with interactive behavior monitoring and rendering anomaly visualization to generate an optimization decision chain, a browser-side stacked frame point cloud query rendering basic model is formed. The stacked frame point cloud query and rendering information generation module 206 is used to verify and dynamically optimize based on the query and rendering basic model, combined with front-end interactive data and dynamic frame loading monitoring data. It balances query accuracy, rendering frame rate and browser compatibility through a multi-index comprehensive evaluation algorithm to generate browser-side stacked frame point cloud hierarchical query and rendering information.

[0153] The computer-readable storage medium provided in the above embodiments of this application and the browser-side frame-overlay point cloud hierarchy query and rendering method provided in the embodiments of this application are based on the same inventive concept and have the same beneficial effects as the methods adopted, run or implemented by the applications stored therein.

[0154] The various embodiments in this application are described in a related manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments for evaluating the browser-side frame-overlay point cloud hierarchy query and rendering method, electronic device, electronic device, and readable storage medium are basically similar to the embodiments for the browser-side frame-overlay point cloud hierarchy query and rendering method described above, so the description is relatively simple. Relevant parts can be referred to in the description of the embodiments for the browser-side frame-overlay point cloud hierarchy query and rendering method described above.

Claims

1. A method for querying and rendering layered point clouds in a browser, characterized in that, include: Acquire raw, multi-source point cloud data, frame sequence data, spatial coordinates, color, and precision information from the browser. Based on the point cloud parsing engine and frame synchronization adapter, the system completes automatic parsing of stacked frame point cloud data, inter-frame deviation detection and data standardization preprocessing. The system identifies the point cloud spatial hierarchy, frame stacking structure and visible region type through the hierarchical partitioning model. Real-time interaction and viewpoint switching events on the browser are integrated into the data update process to generate a stacked frame point cloud fusion dataset. The fused dataset is layered into top-level global point cloud, middle-level partitioned point cloud, and bottom-level fine point cloud. Each layer constructs a ternary association node including point cloud identifier, frame unit, and rendering parameters. The point cloud hierarchy and visual attribute information are aggregated through a spatial index matching algorithm to generate a stacked frame point cloud topology association graph for browser-facing applications. The topological relationship graph is modeled based on the hierarchical rule engine and the rendering effect prediction model. The core features of spatial hierarchy, frame number, point density and visible state are extracted to generate point cloud hierarchical feature embedding vectors. The hierarchical feature embedding vectors are imported into the hierarchical query and real-time rendering calculation engine. A multi-scale hierarchical rule adaptive matching mechanism is used for iterative optimization. At the same time, an optimization decision chain is generated through interactive behavior monitoring and rendering anomaly visualization to form a basic model for frame-by-frame point cloud query and rendering adapted to the browser. Based on the query rendering basic model, combined with front-end interaction data and dynamic frame loading monitoring data, the effect is verified and dynamically optimized. Through a multi-index comprehensive evaluation algorithm, the point cloud query accuracy, page rendering frame rate and browser compatibility requirements are balanced to generate browser-side stacked frame point cloud hierarchical query and rendering information.

2. The method as described in claim 1, characterized in that, Based on a point cloud parsing engine and frame synchronization adapter, automatic parsing, inter-frame deviation detection, and data standardization preprocessing of stacked point cloud data are completed. A hierarchical partitioning model identifies point cloud spatial levels, frame stacking structures, and visible region types. Real-time browser interaction and viewpoint switching events are integrated into the data update process to generate a fused stacked point cloud dataset, including: The raw data of the stacked point cloud that has been initially collected is combined and matched with the preset parsing rules and frame synchronization parameters. The point cloud parsing engine algorithm and the multi-frame heterogeneous data parsing mechanism are introduced to achieve accurate extraction of basic features and deviation localization of the stacked point cloud. Connect to the browser-side data transmission interface and the point cloud frame sequence repository, build an automatic parsing model for stacked frame data, use a frame synchronization adapter to adapt the calculation model to calculate the synchronization weight of different frame data, and establish a dynamic update association mechanism for stacked frame point clouds. Using the unique identifier of point cloud and the frame sequence attribution as the core dimensions, a multi-dimensional point cloud standardized correlation matrix is ​​constructed by integrating spatial coordinates, color information, point position accuracy, frame stacking order, core feature data of visible range, single frame scale feature data and global stacked frame scale feature data, so as to achieve unified and regular processing of stacked frame data features. By using a closed-loop model that detects and dynamically corrects inter-frame deviations to handle abnormal data gaps, and combining a timed refresh + interactive triggering dual update mechanism to enhance the correlation characteristics of stacked frame data, a standardized stacked frame point cloud fusion dataset is generated by integrating the output results of the automatic parsing model.

3. The method as described in claim 1, characterized in that, The fused dataset is layered into top-level global point cloud, mid-level partitioned point cloud, and bottom-level fine point cloud. Each layer constructs a ternary association node including point cloud identifier, frame unit, and rendering parameters. A spatial index matching algorithm aggregates the point cloud hierarchy and visual attribute information to generate a browser-facing, frame-by-frame point cloud topology association graph, including: Based on global-partition-fine-level hierarchical rules and hierarchical division instructions, the standardized stacked point cloud fusion dataset is subjected to dimensional hierarchical processing. A three-level data separation structure is constructed to distinguish overall point position, partition point position, and fine point position information. The relationship between the level and frame unit is calculated and the data consistency is confirmed through the unique mapping mechanism of point cloud identifier. The relationship between the level type and the corresponding rendering parameter is identified. The attribute dimension is stripped. Field classification and structural mapping are performed on the dataset according to the spatial level to generate the hierarchical standardized point cloud structural elements. Consistency checks are performed on point cloud identifier binding, frame unit affiliation, and rendering parameter association to ensure that the point cloud hierarchical topology is not disrupted. By integrating the results of dimensional layering, identifier mapping, attribute stripping, and field classification, and aggregating the hierarchical structure and visual attribute information of point clouds through a spatial index matching algorithm, a topological association diagram of stacked point clouds containing hierarchical data, ternary node structure, and hierarchical relationships is generated.

4. The method as described in claim 1, characterized in that, The hierarchical feature embedding vectors are imported into the hierarchical query and real-time rendering computation engine. A multi-scale hierarchical rule adaptive matching mechanism is used for iterative optimization. Simultaneously, an optimization decision chain is generated through interactive behavior monitoring and rendering anomaly visualization, forming a basic model for frame-by-frame point cloud query and rendering adapted to browser platforms, including: Based on hierarchical feature embedding vectors, global / partition / fine three-level scale rules, browser interaction attributes, and point cloud rendering latency requirements, high-dimensional hierarchical feature data is processed to generate an adapted hierarchical query and real-time rendering execution strategy. The query rendering execution strategy is processed based on the hierarchical rule matching priority and hierarchical data retrieval efficiency, and the rule execution granularity and data loading level are set. Processing of multi-scale matching rules, data loading levels, globally unique point cloud identifiers, and hierarchical feature vectors, and adding full-process interactive behavior monitoring records, rendering status version control, and abnormal data fallback verification parameters; By integrating query rendering execution strategies, data loading levels, globally unique point cloud identifiers, hierarchical feature vectors, interaction monitoring records, state control and anomaly verification parameters, a basic model for frame-by-frame point cloud query rendering adapted to browsers is formed.

5. The method as described in claim 4, characterized in that, Based on the query rendering basic model, combined with front-end interaction data and dynamic frame loading monitoring data, the effect is verified and dynamically optimized. A multi-index comprehensive evaluation algorithm is used to balance point cloud query accuracy, page rendering frame rate, and browser compatibility requirements, generating browser-side layered point cloud query and rendering information, including: Based on the query rendering basic model, the multi-dimensional operation parameters of the stacked frame point cloud are processed. A multi-index comprehensive evaluation algorithm and a browser-side multi-source data fusion mechanism are introduced to realize point cloud feature parsing and operation parameter conversion. To align with browser front-end interaction specifications and layered rendering requirements for point cloud stacking, a rendering effect accuracy evaluation model is constructed. The weights of various performance indicators are calculated through an adaptive index weight calculation model, and a dynamic verification and optimization mechanism for point cloud query rendering is established. With rendering effect matching degree as the core dimension, a multi-dimensional rendering control correlation matrix is ​​constructed by integrating single-frame-partition-global scale feature data, front-end interaction data, dynamic frame loading monitoring data and query rendering initial result data. By using a rendering data deviation correction model to handle abnormal deviations during the query and rendering process, and combining front-end interactive feedback with a frame loading status monitoring and calibration mechanism to enhance the overall operating effect, the model is integrated with the rendering effect accuracy evaluation model results. Based on anomaly visualization, an optimization decision chain is generated to form a complete browser-side stacked frame point cloud hierarchical query and final rendering information.

6. A browser-based system for querying and rendering layered point clouds, characterized in that, The system is configured to execute the browser-side frame-overlay point cloud hierarchy query and rendering method according to any one of claims 1 to 5 by executing executable instructions.

7. An electronic device, characterized in that, include: First processor; and memory for storing executable instructions of the first processor; The first processor is configured to execute the browser-side frame-overlay point cloud hierarchy query and rendering method according to any one of claims 1 to 5 by executing the executable instructions.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the second processor, it implements the browser-side frame-overlapping point cloud hierarchy query and rendering method according to any one of claims 1 to 5.

Images