Gaussian data tree index construction method and device supporting incremental updating and rendering method

Abstract

The invention provides a Gaussian data tree index construction method and device supporting incremental updating and a rendering method.The Gaussian data tree index construction method comprises the steps that firstly, normalization processing and integer format conversion are conducted on original Gaussian data, spatial index key values are generated based on coordinates of an integer format, and the spatial index key values serve as coded values corresponding to the original Gaussian data; segmenting the original Gaussian data into a plurality of data blocks according to the coded values; then constructing a local octree; then, generating a global octree; a storage offset is distributed to each node of the global octree, and a byte range corresponding to each node is determined based on the storage offset; each data block stores the original Gaussian data according to the corresponding storage offset and the sequence of the coded values. The subsequent query efficiency can be improved by storing the data blocks according to the coded value sequence, meanwhile, the memory mapping technology is adopted to process the oversized node data so as to reduce IO overhead, and the storage layout and the output mode effectively improve the data writing efficiency and the subsequent reading performance.

Description

Technical Field

[0001] This disclosure relates to the fields of computer graphics and big data processing and visualization, and in particular to a method and apparatus for constructing a Gaussian data tree index that supports incremental updates, as well as a rendering method. Background Technology

[0002] Currently, Gaussian data storage and rendering suffer from the following technical shortcomings:

[0003] 1. Efficiency problem in generating multi-resolution Gaussian models

[0004] Existing Level of Detail (LOD) rendering techniques based on Gaussian models require multiple iterative training iterations on the entire dataset to achieve viewpoint continuity during distance transitions. This process leads to:

[0005] 1) Computational redundancy: Each level of LOD needs to be trained independently, with a time complexity of O(kN²) (where k is the Gaussian component and N is the amount of data); 2) Storage expansion: The coexistence of multi-level LOD data increases storage requirements by 200%-300%; 3) Structural defects: The generated tree index has an over-partitioning phenomenon, producing invalid nodes with a depth of more than 20 levels in sparse data areas.

[0006] 2. Adaptability defects of spatial index structures

[0007] When traditional octrees are used to organize large-scale discrete data, rendering Gaussian distributions exposes the following problems: 1) Density-sensitive imbalance: In Gaussian distribution regions where σ>3σ (accounting for approximately 15%-20% of the data-dense areas), differences in node split depth lead to tree height variance exceeding 5 levels; 2) Low memory efficiency: Building a complete octree with 100 million data points requires 12GB-15GB of memory (node ​​metadata accounts for 30%); 3) Update lag: A single incremental update triggers a global reconstruction, with latency increasing linearly with the amount of data (measured ΔN=10). 5 (When Δt≥8s)

[0008] 3. Work bottlenecks caused by data heterogeneity

[0009] Cross-vendor data sources present the following compatibility challenges: 1) Naming convention conflicts: mainstream data is usually stored in a single folder containing training results of various resolutions. The hierarchical sorting can only be distinguished by file size, and the specific resolution changes are uncertain; 2) Preprocessing overhead: data normalization operations account for 20%-30% of the overall process time (including coordinate transformation, unit unification, illegal value filtering, etc.).

[0010] In terms of full-scale rendering, high-density data scenarios are prone to system crashes; in terms of multi-resolution rendering, there are multiple bottlenecks: 1) repeated calculations lead to resource waste; 2) memory usage remains high; 3) the rendering efficiency of traditional octree structures drops sharply when data is not uniformly distributed; 4) lack of dynamic incremental updates; 5) the training process of multi-resolution Gaussian models has problems of slow convergence speed and excessive time consumption. Summary of the Invention

[0011] This disclosure provides at least one method and apparatus for constructing a Gaussian data tree index that supports incremental updates, as well as a rendering method, to solve at least one of the above-mentioned technical problems.

[0012] According to one aspect of this disclosure, a method for constructing a Gaussian data tree index that supports incremental updates is provided, comprising:

[0013] The original Gaussian data is normalized; the coordinates of the normalized original Gaussian data are converted into integer format, and a spatial index key value is generated based on the coordinates in integer format. The spatial index key value is used as the encoding value of the corresponding original Gaussian data.

[0014] The original Gaussian data is divided into multiple data blocks according to the encoded values;

[0015] A local octree is constructed using each data block; during the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or when the maximum depth is reached; higher-density regions of the original Gaussian data automatically generate deeper-level nodes; non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node; leaf nodes store the parameters of the original Gaussian data remaining after the parent node is full within the spatial range corresponding to its parent node.

[0016] The local octrees corresponding to each data block are merged to obtain the global octree;

[0017] A storage offset is allocated to each node of the global octree using a preorder traversal method. The byte range corresponding to each node is determined based on the storage offset, and the byte range corresponding to each node is recorded. The original Gaussian data is stored in each data block according to the order of the corresponding storage offset and the encoded value.

[0018] In one possible implementation, the method for constructing a Gaussian data tree index that supports incremental updates also includes:

[0019] Retrieve new Gaussian data;

[0020] The newly added Gaussian data is normalized; the coordinates of the newly added Gaussian data after normalization are converted into integer format, and a spatial index key value is generated based on the coordinates in integer format. The spatial index key value is used as the encoding value of the corresponding newly added Gaussian data.

[0021] Based on the encoded value of the newly added Gaussian data, determine the target node of the newly added Gaussian data in the global octree;

[0022] Based on the amount of data stored in the target node, determine whether the parameters after the target node stores the newly added Gaussian data exceed the preset threshold.

[0023] If the preset threshold is not exceeded, the parameters of the newly added Gaussian data will be stored in the target node.

[0024] In one possible implementation, the method for constructing a Gaussian data tree index that supports incremental updates also includes:

[0025] If the parameters of the newly added Gaussian data stored in the target node exceed the preset threshold, the target node will be split, and the nodes generated from the split and the target node will be used to store the data originally stored in the target node and the parameters of the newly added Gaussian data.

[0026] In one possible implementation, the method for constructing a Gaussian data tree index that supports incremental updates also includes:

[0027] If the amount of data after merging sibling nodes at the same level is less than the preset threshold, then the sibling nodes at the same level will be merged.

[0028] If the data volume of all sibling nodes at the same level is less than the preset threshold, and the sum of the data volume of sibling nodes at the same level is greater than the preset threshold, then a portion of the data of one sibling node is stored in another sibling node so that the data volume of the other sibling node is equal to the preset threshold.

[0029] In one possible implementation, the normalization process for the original Gaussian data includes:

[0030] During the normalization process, the input data is the center point coordinates of the original Gaussian data; the maximum and minimum values ​​of each dimension are calculated; and the scaling factor is dynamically calculated.

[0031] Based on the maximum and minimum values ​​of each dimension and the scaling factor, the coordinates of the original Gaussian data are mapped to the unit cube space.

[0032] In one possible implementation, dividing the original Gaussian data into multiple data blocks according to the encoded values ​​includes:

[0033] Read the raw Gaussian data in segments, reading a fixed length of raw Gaussian data stream each time;

[0034] Based on the encoded values, the parameters and encoded values ​​of each original Gaussian data are stored in different encoded files, and the encoded files are named with the segment number + the three highest encoded values.

[0035] Merge encoded files of the same region using file commands to obtain a region file;

[0036] The region files are encoded and sorted to obtain n region files that are divided into eight regions, where n is less than or equal to 8, and each region file corresponds to one data block.

[0037] In one possible implementation, merging the local octrees corresponding to each data block to obtain a global octree includes:

[0038] Create the root node of the global octree;

[0039] The root node of each local octree is used as a child node of the root node of the global octree.

[0040] In one possible implementation, the method for constructing a Gaussian data tree index that supports incremental updates also includes:

[0041] During the output phase, multi-threaded asynchronous writing of node data is used, with the number of threads dynamically configured based on hardware resources. Memory mapping technology is also employed to handle extremely large node data in order to reduce I / O overhead.

[0042] In one possible implementation, the parameters include mean, covariance, color, and transparency.

[0043] According to another aspect of this disclosure, a rendering method is provided, comprising:

[0044] Construct a tree index for Gaussian data using any of the above-described methods that support incremental updates;

[0045] Data is searched based on the constructed tree index, and the searched data is used for image rendering.

[0046] According to another aspect of this disclosure, a Gaussian data tree index construction apparatus supporting incremental updates is provided, comprising:

[0047] The preprocessing module is used to normalize the original Gaussian data; convert the coordinates of the normalized original Gaussian data into integer format, generate spatial index key values ​​based on the integer format coordinates, and use the spatial index key values ​​as the encoding values ​​of the corresponding original Gaussian data.

[0048] The block segmentation module is used to divide the original Gaussian data into multiple data blocks according to the encoded values;

[0049] A local tree structure building module is used to construct a local octree using each data block. During the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or when the maximum depth is reached. Higher-density regions of the original Gaussian data automatically generate nodes at deeper levels. Non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node. Leaf nodes store the parameters of the remaining original Gaussian data within the spatial range corresponding to their parent node after the parent node is full.

[0050] The merge module is used to merge the local octrees corresponding to each data block to obtain the global octree;

[0051] The storage optimization module is used to allocate a storage offset to each node of the global octree using a preorder traversal method, determine the byte range corresponding to each node based on the storage offset, and record the byte range corresponding to each node; each data block stores the original Gaussian data in the order of the corresponding storage offset and the encoded value.

[0052] This disclosure discloses a method, apparatus, and rendering method for constructing a Gaussian data tree index that supports incremental updates. First, the original Gaussian data is normalized. Then, the coordinates of the normalized original Gaussian data are converted into integer format, and spatial index keys are generated based on these integer coordinates. These spatial index keys are used as the encoding values ​​for the corresponding original Gaussian data. Next, the original Gaussian data is divided into multiple data blocks according to the encoding values. Then, a local octree is constructed using each data block. During the construction of the local octree, splitting stops when the node data volume falls below a preset threshold or reaches the maximum depth. High-density regions of the original Gaussian data are automatically... A deeper level of nodes is generated. Non-leaf nodes store parameters of the original Gaussian data sampled at a preset threshold within the spatial range corresponding to the non-leaf node. Leaf nodes store parameters of the original Gaussian data remaining after the parent node is full within the spatial range corresponding to its parent node. Then, the local octrees corresponding to each data block are merged to obtain a global octree. A preorder traversal is then used to allocate a storage offset to each node in the global octree. Based on the storage offset, the byte range corresponding to each node is determined and recorded. Each data block stores the original Gaussian data in the order of its corresponding storage offset and encoded value. Storing data blocks in the order of encoded values ​​improves subsequent query efficiency. In the output stage, multi-threaded asynchronous writing of node data is used, with the number of threads dynamically configured according to hardware resources. Memory mapping technology is also used to handle very large node data to reduce IO overhead. This storage layout and output method effectively improves data writing efficiency and subsequent read performance. In this disclosure, memory usage is reduced by more than 80% through block processing, and TB-level data can be processed; the method of full block processing of non-leaf nodes in this disclosure improves the data utilization of Gaussian data buffer by 30%, the rendering frame rate by 50%, and the LOD switching is smoother.

[0053] Furthermore, in this disclosure, newly added Gaussian data is processed as follows: the newly added Gaussian data is normalized; the coordinates of the normalized newly added Gaussian data are converted into integer format, and a spatial index key value is generated based on the integer format coordinates, and the spatial index key value is used as the encoding value of the corresponding newly added Gaussian data; based on the encoding value of the newly added Gaussian data, the target node of the newly added Gaussian data in the global octree is determined; based on the amount of data stored in the target node, it is determined whether the parameters of the newly added Gaussian data stored in the target node exceed the preset threshold; if the parameters of the newly added Gaussian data stored in the target node exceed the preset threshold, the target node is split, and the nodes generated by the split and the target node are used to store the data originally stored in the target node and the parameters of the newly added Gaussian data. Incremental construction reduces the amount of repeated calculations by 70%, improves the training iteration efficiency by 3 times, improves the real-time update capability, supports incremental updates of 500,000 points per second, and is cross-platform compatible.

[0054] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0055] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0056] Figure 1 This is one of the flowcharts for the Gaussian data tree index construction method supporting incremental updates in this disclosure embodiment;

[0057] Figure 2 This is the second flowchart of the method for constructing a Gaussian data tree index that supports incremental updates in this disclosure embodiment;

[0058] Figure 3A , Figure 3B This is a schematic diagram of the local octree before merging in an embodiment of this disclosure;

[0059] Figure 3C This is a schematic diagram of a global octree in an embodiment of this disclosure;

[0060] Figure 4 This is a schematic diagram of sibling node merging in an embodiment of this disclosure;

[0061] Figure 5 This is a flowchart of the TB-level data octree construction process in this embodiment of the disclosure;

[0062] Figure 6 This is a flowchart of the rendering method in an embodiment of this disclosure;

[0063] Figure 7 This is a schematic diagram of the structure of the Gaussian data tree index construction device that supports incremental updates in this embodiment of the present disclosure. Detailed Implementation

[0064] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0065] The three core problems existing in the technology are: 1) Low efficiency in generating LODs using Gaussian models: Traditional methods involve multiple iterations on the full dataset to train Gaussian models at different resolutions. This leads to a quadratic increase in computational complexity, and independent training of multiple LOD levels causes storage redundancy; 2) Insufficient adaptability of spatial index structures: Existing octrees exhibit structural imbalance when data density distribution is uneven, and differences in node splitting depth lead to decreased query efficiency and excessive memory consumption; 3) Poor compatibility with heterogeneous data: Cross-source data lacks a unified standard, and the preprocessing stage consumes a large amount of computational resources, affecting the overall system throughput.

[0066] This disclosure addresses the aforementioned technical problems by proposing a method and apparatus for constructing a Gaussian data tree index that supports incremental updates, as well as a rendering method. This disclosure reduces memory usage by over 80% through block processing, enabling the handling of TB-level data. The full-block processing of non-leaf nodes in this disclosure improves the utilization rate of the Gaussian data buffer by 30%, increases the rendering frame rate by 50%, and provides smoother LOD switching. Furthermore, the incremental construction method reduces repetitive computation by 70%, improves training iteration efficiency by 3 times, enhances real-time update capabilities, supports incremental updates of 500,000 points per second, and is cross-platform compatible.

[0067] The technical solution of this disclosure will be described below through specific embodiments.

[0068] like Figure 1 The diagram shows a flowchart of the Gaussian data tree index construction method supporting incremental updates in this embodiment. The execution subject of this embodiment is a computing device or component with data processing capabilities. Specifically, the method of this embodiment may include the following steps:

[0069] S110. Normalize the original Gaussian data; convert the coordinates of the normalized original Gaussian data into integer format, generate a spatial index key value based on the integer format coordinates, and use the spatial index key value as the encoding value of the corresponding original Gaussian data.

[0070] During the normalization process, the input data is the center point coordinates of the original Gaussian data. The maximum and minimum values ​​of each dimension are calculated, and the scaling factor is dynamically calculated. Then, based on the maximum and minimum values ​​of each dimension and the scaling factor, the coordinates of the original Gaussian data are mapped to the unit cube space.

[0071] Morton encoding is performed on the normalized coordinates to generate spatial index key values.

[0072] S120. Divide the original Gaussian data into multiple data blocks according to the encoded values.

[0073] The specific steps of segmentation may include: reading the original Gaussian data in segments, reading a fixed length of original Gaussian data stream each time; storing the parameters and encoding values ​​of each original Gaussian data into different encoding files according to the encoding values, with the encoding file named as segment number + the high three bits of the encoding value; merging the encoding files of the same region using file commands to obtain region files; sorting the region files by encoding to obtain n region files divided into eight corresponding regions, where n is less than or equal to 8, and each region file corresponds to one data block.

[0074] S130. Construct a local octree using each data block; wherein, during the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or reaches the maximum depth; higher-density regions of the original Gaussian data automatically generate deeper-level nodes, and non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node; leaf nodes store the parameters of the remaining original Gaussian data within the spatial range corresponding to their parent node after the parent node is full.

[0075] The input data stream is divided into data blocks according to the Morton coding range; each data block independently constructs a local octree, and the depth of the leaf nodes is dynamically adjusted according to the density of points within the block.

[0076] Based on the sorting results of Morton coding, the space is dynamically and recursively partitioned, and the depth of the leaf nodes is adaptively determined by the local point density. Each node (including non-leaf nodes and leaf nodes) stores parameters of Gaussian data with a full block (i.e., the amount of data stored is a preset threshold) as much as possible. When the amount of data in a node reaches the preset threshold, it continues to split; otherwise, it terminates as a leaf node.

[0077] The data storage of the nodes satisfies the following conditions: non-leaf nodes store randomly sampled data within their spatial range, and the data volume reaches a preset threshold; leaf nodes store the parameters of the remaining Gaussian data after the parameters of the original Gaussian data corresponding to the parent node are fully distributed. This ensures that the parent node is always a full node. The data block size is controlled by a preset capacity threshold and is independent of the spatial partitioning depth. Specifically, the data stored in non-leaf nodes is not duplicated with the data stored in their child nodes, there is no duplicate data among all nodes, and the sum of the data in all nodes is the sum of the parameters of the original Gaussian data.

[0078] The construction of an octree satisfies the following: the depth of the leaf nodes is not uniformly distributed, and higher-density areas automatically generate deeper-level leaf nodes; each node (including non-leaf nodes) stores a data block containing complete Gaussian distribution parameters (mean, covariance, transparency).

[0079] S140. Merge the local octrees corresponding to each data block to obtain the global octree.

[0080] Specifically, the merging is as follows: create the root node of the global octree; and use the root nodes of each local octree as child nodes of the root node of the global octree.

[0081] The root node of the local octree is used as the child node of the global octree; the original dynamic depth structure of each sub-octree is preserved, and only the index level is merged.

[0082] S150. A storage offset is allocated to each node of the global octree using a preorder traversal method. The byte range corresponding to each node is determined based on the storage offset, and the byte range corresponding to each node is recorded. Each data block stores the original Gaussian data in the order of the corresponding storage offset and the encoded value.

[0083] The data is stored in the manner described above. During the output phase, multi-threaded asynchronous writing of node data is used. The number of threads is dynamically configured according to hardware resources. At the same time, memory mapping technology is used to process very large node data to reduce IO overhead.

[0084] The above embodiments can achieve the following beneficial effects: 1) Intelligent spatial partitioning: Morton coding and adaptive octree hierarchical partitioning technology are used to achieve efficient spatial organization of data; 2) Streaming processing architecture: Through the three-stage pipeline of "blocking-merging-incremental update", it supports real-time processing of TB-level data; 3) Dynamic rendering optimization: The LOD level is automatically adjusted based on data density to achieve a dynamic balance between rendering frame rate and quality.

[0085] In some embodiments, newly added Gaussian data is processed as follows:

[0086] Acquire newly added Gaussian data; normalize the newly added Gaussian data; convert the coordinates of the normalized newly added Gaussian data into integer format, and generate a spatial index key value based on the integer format coordinates, using the spatial index key value as the encoding value of the corresponding newly added Gaussian data; determine the target node of the newly added Gaussian data in the global octree based on the encoding value of the newly added Gaussian data; determine whether the amount of data stored in the target node exceeds the preset threshold after storing the parameters of the newly added Gaussian data in the target node based on the amount of data stored in the target node; if it does not exceed the preset threshold, store the parameters of the newly added Gaussian data in the target node; if the amount of data stored in the target node exceeds the preset threshold after storing the parameters of the newly added Gaussian data in the target node, split the target node, and use the split-generated node and the target node to store the data originally stored in the target node and the parameters of the newly added Gaussian data.

[0087] Furthermore, to improve storage space utilization, if the combined data volume of sibling nodes at the same level is less than the preset threshold, the sibling nodes at the same level can be merged. If the data volume of all sibling nodes at the same level is less than the preset threshold, but the sum of their data volumes is greater than the preset threshold, a portion of the data from one sibling node can be stored in another sibling node, so that the data volume of the other sibling node equals the preset threshold. This allows for the addition of a full-block node, while the non-full-block nodes can be used to store new incremental data.

[0088] In the above incremental update process, Morton codes are calculated for new data and target nodes are located; node splitting / merging is dynamically adjusted; if the number exceeds the threshold, nodes are split; if sibling nodes meet the capacity condition after merging, they are merged at the same level.

[0089] In some embodiments, such as Figure 5 The diagram shown illustrates the construction of a TB-level octree, which can specifically include:

[0090] 1) Dynamic encoding and spatial partitioning: The coordinates of Gaussian data are converted into Morton codes using the encode_3uint2() function to achieve spatial linearization encoding.

[0091] 2) Adaptive hierarchical partitioning: The optimal octree hierarchy is automatically calculated based on the density of Gaussian data points. The higher the density of a region, the larger the hierarchy, and the lower the density of a region, the smaller the hierarchy.

[0092] like Figure 5As shown, when the number of points is less than or equal to limit (limit=61440), node['idx']=idx; the current node index list is equal to idx; otherwise, node['idx'] = idx, randomly selects the limit number of points from idx, if the remaining number of points is less than or equal to 8 times limit, then node[children][i] = i*limit:min((i+1)*limit,len(idx)) directly and sequentially distributes them to each child node, if the remaining number of points is greater than 8 times, then recursively proceed to the next level.

[0093] 3) Random sampling to maintain balance: When splitting nodes, np.random.choice is used for random sampling to ensure that the amount of data in each child node is balanced.

[0094] Recursive tree construction: Recursive construction is implemented using the `build_octree_core` function, stopping splitting when the number of node data points falls below a threshold (preset threshold limit=61440). Based on this constraint, splitting is stopped as early as possible for low-density nodes, avoiding tree structure imbalance in any subtree. This successfully solves the density-sensitive imbalance problem. The algorithm also ensures a minimum total number of child nodes, resulting in a minimal tree organization and improved memory utilization.

[0095] The algorithm described above effectively minimizes the sum of the levels of all nodes in the tree. For example, the root node has a level of 0, its children have a level of 1, its grandchild nodes have a level of 2, and so on. This algorithm guarantees that the sum of the levels of all nodes is minimized. Furthermore, this algorithm constructs the octree based on the original, highest-level Gaussian data, rather than using Gaussian data of different resolutions. Therefore, the total amount of data used by this algorithm is half that of traditional methods, significantly improving memory utilization and data generation efficiency during Gaussian rendering. In contrast, the commonly used multi-resolution replacement mode reloads and updates the entire octree data with each camera view change, resulting in a noticeable decrease in performance and efficiency compared to the incremental updates of this algorithm.

[0096] In some embodiments, this disclosure employs a flow-based block architecture based on a "block-tree merging-node writing" three-step framework, as detailed below:

[0097] 1. Block processing stage:

[0098] Divide the original data into multiple data blocks (chunk_list);

[0099] Construct a local octree independently for each data block (build_octree_core);

[0100] 2. Merging tree structure stage:

[0101] The tree structure of each data block is integrated using the max_points_build_octree function;

[0102] Establish global index relationships and maintain node boundary information (get_bounds_by_indices_stream).

[0103] 3. Node-based write phase:

[0104] Calculate storage space requirements per node (byte_length = header_length + len(node['idx']) * 16 * 2);

[0105] Where byte_length: length in bytes; header_length: header file length, which is a fixed value; len(node['idx']): the total number of Gaussian data in the current node.

[0106] A streaming write strategy is adopted to generate node URIs (uri = f"{start}-{start+byte_length -1}"); where uri: resource address; start: start position of node file; start+byte_length-1: end position of node file.

[0107] After the build is complete, the temporary data blocks are automatically cleaned up (os.remove(chunk_file)).

[0108] like Figure 2 As shown below, the method for constructing a Gaussian data tree index that supports incremental updates, as disclosed in this disclosure, will be described in detail through a specific embodiment. The method includes the following steps:

[0109] S1. Data Preprocessing and Encoding Optimization: This process first normalizes the data, then performs Morton encoding on the normalized results. During data normalization, the input data consists of the center point coordinates of Gaussian data. The maximum and minimum values ​​of each dimension are calculated; then, a scaling factor is dynamically calculated to ensure sufficient accuracy is retained when the coordinates are mapped to the unit cube space. A unique-dimensional scaling strategy is employed to avoid anisotropic deformation. The normalized coordinates are converted to integer format, and spatial index keys are generated using bit interleaving technology to ensure that spatially adjacent points have continuous encoded values. The encoding result serves as the sole basis for subsequent spatial partitioning.

[0110] S2, the octree recursive construction algorithm, is based on the sorting results of Morton coding. This algorithm dynamically and recursively partitions the space, with the depth of leaf nodes adaptively determined by the local point density. First, the space is divided into eight parts according to the Morton coding prefix, with each node corresponding to one-eighth of the cube space. Each data block uses a depth-first strategy to build the tree structure, stopping splitting when the node's data volume falls below a preset threshold or reaches the maximum depth. High-density regions automatically generate deeper-level nodes, while non-leaf nodes store random samples of all child node data within their spatial range, maintaining a preset threshold to ensure the parent node is always a full node. Leaf nodes store the complete parameters of the original Gaussian data points, including mean, covariance, color, and transparency. In this step, the entire dataset is sorted.

[0111] S3, Parallel Block Processing: This step divides the input Gaussian data stream into multiple blocks according to the Morton coding range, and each block independently constructs a local octree. First, the data is divided into contiguous blocks based on the Morton coding value range to avoid the memory pressure caused by global sorting. Each block is processed in parallel, using the same recursive algorithm as the global construction to build the local octree. During the local tree construction process, the depth of leaf nodes within a block is adaptively adjusted according to the actual point density, preserving local features. This block processing method effectively supports streaming processing of large-scale data while maintaining spatial continuity between data blocks.

[0112] The Morton encoding automatically divides the points into eight regions, similar to a 2x2 Rubik's Cube. The Morton high-three codes for each region are 0-7. Points in each region can be quickly filtered based on these high-three codes. To recursively find the sub-eight regions of a given block, the Morton encoding is shifted three bits to the right, and then filtered based on the shifted high-three codes.

[0113] The above-mentioned Gaussian data stream is divided into multiple data blocks according to the Morton coding range. Specifically, for very large files, full reading would result in excessive memory consumption, so segmented file reading is used. A fixed-length stream is read each time, and after reading, the stream is encoded. Based on the high three bits of the encoding, the encoding and index of each point are appended to different encoded files. The file names are based on the segment number plus the high three bits of the Morton coding. After the stream-based block reading is complete, files in the same region are merged using file commands, and the encoded files in that region are then sorted. Finally, n point information set files corresponding to eight regions are obtained, where n < 8 (some regions may not have a point set). The points stored in the blocks contain the index and encoding information of the sorted points, so re-encoding and sorting are unnecessary. The advantage of block partitioning is that it can solve the problem of octree splitting of massive data and reduces the peak value of a single sorting operation.

[0114] S4, Global Octree Merging: After the local octrees are constructed, the root nodes of each local octree are merged to form the global octree. The merging process employs a level-alignment strategy, treating the root nodes of each local octree as child nodes of the global octree, merging only the index levels while preserving the original dynamic depth structure of the subtrees. Morton coding range verification ensures the spatial continuity of adjacent data blocks, maintaining the consistency of the global spatial partitioning during the merging process. This merging method preserves the fine-grained structural features of the local trees while constructing a complete global spatial index.

[0115] For example, Figure 2 The process of octree block processing for TB-level point cloud data (e.g., 200 million points) is described: First, a maximum number of points in a single block is set (e.g., 20 million points). All points are octree encoded and allocated to 8 temporary files (f0-f7) ​​through streaming processing (100MB of data each time). If the number of points in a file exceeds the maximum (e.g., 200 million points divided into 8 blocks will inevitably result in an over-limit file), the same operation is recursively performed on the over-limit file - re-encode and block it and generate the next level of temporary files until the number of points in all sub-blocks is less than 20 million points before an octree can be constructed, ultimately forming a hierarchical block multi-level tree structure.

[0116] like Figure 3A , 3B The image shows the local octree before merging. Figure 3C This is the merged global octree. The root node of the merged global octree is a newly created node R0. This node does not contain any specific Gaussian points; it is simply a container. The aforementioned level alignment means that for extremely large amounts of data, after partitioning according to the above rules, each tree R1 with its root node as its parent is a complete tree structure, and the level structure of each R1 always satisfies 1. <L<=10。

[0117] S5, Storage Optimization and Parallel Output: This step optimizes the storage and performs parallel output on the constructed global octree. A preorder traversal is used to allocate a storage offset for each node, and its byte range in the binary file is recorded. Data blocks are stored in Morton-coded order to improve subsequent query efficiency. During the output phase, multi-threaded asynchronous writing of node data is used, with the number of threads dynamically configured based on hardware resources. Memory mapping technology is employed to handle very large node data to reduce I / O overhead. This storage layout and output method effectively improves data writing efficiency and subsequent read performance.

[0118] The data block refers to the final write result, storing the Gaussian center point, covariance, color, and transparency. The original data information is located based on the source data index corresponding to the encoding sort. In this embodiment, all data within each node is ordered, allowing for quick acquisition of the boundbox range of each node. The aforementioned multi-threaded processes write to different file segments, recording their byte range within the binary file.

[0119] In practice, a threshold is set, such as maxPoint = 30 million. When the value exceeds maxPoint, memory mapping is used. When the data is small, it is processed directly in memory.

[0120] S6, an incremental update mechanism, supports dynamic adjustments to the existing octree structure to incorporate new data. New data is located at the target node by calculating Morton's code. The node is automatically split when the data volume of the target node exceeds a threshold but has not reached the maximum depth. Nodes are automatically merged when the data volume of sibling nodes at the same level is below the threshold after merging. During node splitting, the sampling data distribution characteristics of the parent node are inherited; after merging, the statistical characteristics of the parent node are recalculated. The entire process dynamically monitors node memory usage, triggering forced splits when necessary to ensure the tree structure remains in an optimal state to support efficient queries.

[0121] S1-S5 have already completed the construction of the entire tree. S6 is the optimization of the algorithm. The octree constructed in the first five steps is not a full tree structure. The points of each node may be randomly distributed. After the solution S6, the full node rate can be guaranteed to reach 80%, and the rendering memory utilization is improved by 2 times.

[0122] The aforementioned inheritance of the parent node's sampling data distribution characteristics during node splitting means that the spatial range of the subset after splitting is always contained within the parent node. Recalculating the parent node's statistical characteristics after merging refers to recalculating the entire node's range and total number of points.

[0123] like Figure 4 As shown, R0 has three sibling nodes: R2, R3, and R4. None of these sibling nodes have reached the requirement of a full leaf node, and the total number of the three nodes exceeds the preset threshold of 61440. Therefore, all points from R2 and R3 are taken, and 61440 - 60000 - 100 = 1340 points are sequentially taken from R4 to reconstruct R2. R3 then becomes 3660 points. This reduces the original three non-full leaf nodes to one. The algorithm merges full leaf nodes during the splitting process, and after the entire tree is constructed, the tree structure can be further optimized to maximize the proportion of full leaf nodes.

[0124] Based on the same inventive concept, this disclosure provides a rendering method, such as Figure 6 As shown, it may include the following steps:

[0125] S610. Construct a tree index for Gaussian data using the method described in any of the above embodiments.

[0126] S620: Perform data search based on the constructed tree index, and use the searched data for image rendering.

[0127] The same content will not be repeated here.

[0128] Based on the same inventive concept, this disclosure provides a Gaussian data tree index construction apparatus that supports incremental updates. The steps performed by the components of this apparatus are the same as or similar to the methods described above, therefore, similar details will not be repeated. Figure 7 As shown, the Gaussian data tree index construction device supporting incremental updates in this embodiment includes:

[0129] The preprocessing module 710 is used to normalize the original Gaussian data; convert the coordinates of the normalized original Gaussian data into integer format, generate spatial index key values ​​based on the integer format coordinates, and use the spatial index key values ​​as the encoding values ​​of the corresponding original Gaussian data.

[0130] The block segmentation module 720 is used to divide the original Gaussian data into multiple data blocks according to the encoded values.

[0131] The local tree structure building module 730 is used to construct a local octree using each data block. During the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or when the maximum depth is reached. Higher-level nodes are automatically generated from the high-density regions of the original Gaussian data. Non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node. Leaf nodes store the parameters of the remaining original Gaussian data within the spatial range corresponding to their parent node after the parent node is full.

[0132] The merging module 740 is used to merge the local octrees corresponding to each data block to obtain a global octree.

[0133] The storage optimization module 750 is used to allocate a storage offset to each node of the global octree using a preorder traversal method, determine the byte range corresponding to each node based on the storage offset, and record the byte range corresponding to each node; each data block stores the original Gaussian data in the order of the corresponding storage offset and the encoded value.

[0134] This embodiment is the same as or similar to the embodiment of the Gaussian data tree index construction method that supports incremental updates, so the same or similar content will not be repeated here.

[0135] The various embodiments of the techniques described above can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include: implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0136] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0137] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0138] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0139] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0140] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0141] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0142] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A method for constructing a Gaussian data tree index that supports incremental updates, characterized in that, include: Normalize the original Gaussian data; The coordinates of the normalized original Gaussian data are converted into integer format, and spatial index key values ​​are generated based on the coordinates in integer format. The spatial index key values ​​are used as the encoding values ​​of the corresponding original Gaussian data. The original Gaussian data is divided into multiple data blocks according to the encoded values; A local octree is constructed using each data block; during the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or when the maximum depth is reached; higher-density regions of the original Gaussian data automatically generate deeper-level nodes; non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node; leaf nodes store the parameters of the remaining original Gaussian data within the spatial range corresponding to their parent node after the parent node is full. The local octrees corresponding to each data block are merged to obtain the global octree; A storage offset is allocated to each node of the global octree using a preorder traversal method. The byte range corresponding to each node is determined based on the storage offset, and the byte range corresponding to each node is recorded. The original Gaussian data is stored in each data block according to the order of the corresponding storage offset and the encoded value.

2. The method according to claim 1, characterized in that, Also includes: Retrieve new Gaussian data; Normalize the newly added Gaussian data; The coordinates of the newly added Gaussian data after normalization are converted into integer format, and a spatial index key value is generated based on the coordinates in integer format. The spatial index key value is used as the encoding value of the corresponding newly added Gaussian data. Based on the encoded value of the newly added Gaussian data, determine the target node of the newly added Gaussian data in the global octree; Based on the amount of data stored in the target node, determine whether the parameters after the target node stores the newly added Gaussian data exceed the preset threshold. If the preset threshold is not exceeded, the parameters of the newly added Gaussian data will be stored in the target node.

3. The method according to claim 2, characterized in that, Also includes: If the parameters of the newly added Gaussian data stored in the target node exceed the preset threshold, the target node will be split, and the nodes generated from the split and the target node will be used to store the data originally stored in the target node and the parameters of the newly added Gaussian data.

4. The method according to any one of claims 1 to 3, characterized in that, Also includes: If the amount of data after merging sibling nodes at the same level is less than the preset threshold, then the sibling nodes at the same level will be merged. If the data volume of all sibling nodes at the same level is less than the preset threshold, and the sum of the data volume of sibling nodes at the same level is greater than the preset threshold, then a portion of the data of one sibling node is stored in another sibling node so that the data volume of the other sibling node is equal to the preset threshold.

5. The method according to claim 1, characterized in that, The normalization process for the original Gaussian data includes: During the normalization process, the input data is the center point coordinates of the original Gaussian data; the maximum and minimum values ​​of each dimension are calculated; and the scaling factor is dynamically calculated. Based on the maximum and minimum values ​​of each dimension and the scaling factor, the coordinates of the original Gaussian data are mapped to the unit cube space.

6. The method according to claim 1, characterized in that, The step of dividing the original Gaussian data into multiple data blocks according to the encoded values ​​includes: Read the raw Gaussian data in segments, reading a fixed length of raw Gaussian data stream each time; Based on the encoded values, the parameters and encoded values ​​of each original Gaussian data are stored in different encoded files, and the encoded files are named with the segment number + the three highest encoded values. Merge encoded files of the same region using file commands to obtain a region file; The region files are encoded and sorted to obtain n region files that are divided into eight regions, where n is less than or equal to 8, and each region file corresponds to one data block.

7. The method according to claim 1, characterized in that, The step of merging the local octrees corresponding to each data block to obtain a global octree includes: Create the root node of the global octree; The root node of each local octree is used as a child node of the root node of the global octree.

8. The method according to claim 1, characterized in that, Also includes: During the output phase, multi-threaded asynchronous writing of node data is used, with the number of threads dynamically configured based on hardware resources. Memory mapping technology is also employed to handle extremely large node data in order to reduce I / O overhead.

9. A rendering method, characterized in that, include: Construct a tree index for Gaussian data using the method described in any one of claims 1 to 8; Data is searched based on the constructed tree index, and the searched data is used for image rendering.

10. A Gaussian data tree index construction device supporting incremental updates, characterized in that, include: The preprocessing module is used to normalize the raw Gaussian data; The coordinates of the normalized original Gaussian data are converted into integer format, and spatial index key values ​​are generated based on the coordinates in integer format. The spatial index key values ​​are used as the encoding values ​​of the corresponding original Gaussian data. The block segmentation module is used to divide the original Gaussian data into multiple data blocks according to the encoded values; A local tree structure building module is used to construct a local octree using each data block. During the construction of the local octree, splitting stops when the amount of node data is below a preset threshold or when the maximum depth is reached. Higher-density regions of the original Gaussian data automatically generate nodes at deeper levels. Non-leaf nodes store the parameters of the preset threshold of randomly sampled original Gaussian data within the spatial range corresponding to the non-leaf node. Leaf nodes store the parameters of the remaining original Gaussian data within the spatial range corresponding to their parent node after the parent node is full. The merge module is used to merge the local octrees corresponding to each data block to obtain a global octree; The storage optimization module is used to allocate a storage offset to each node of the global octree using a preorder traversal method, determine the byte range corresponding to each node based on the storage offset, and record the byte range corresponding to each node; each data block stores the original Gaussian data in the order of the corresponding storage offset and the encoded value.

Images