Octree-driven gaussian splatting ray acceleration apparatus and method

Abstract

This invention discloses an octree-driven Gaussian splash ray acceleration device and method, primarily relating to the field of computer graphics technology. It includes: a filtering module for performing validity filtering to obtain a set of valid Gaussian splash units; an octree spatial index structure construction module for performing recursive spatial subdivision to construct an octree spatial index structure; a unified index structure generation module; a candidate Gaussian splash unit set determination module for determining the candidate Gaussian splash unit set through hierarchical spatial pruning; and a Gaussian splash unit output module for performing precise ray-sphere intersection calculations and outputting the most recently hit Gaussian splash unit. The beneficial effects of this invention are: it solves the technical problem in the prior art where the lack of a unified Gaussian splash ray acceleration structure in the Web environment leads to high latency and lack of interactive synchronization, achieving the technical effects of improving spatial query efficiency and high-precision hit feedback.

Description

Technical Field

[0001] This invention relates to the field of computer graphics technology, specifically to an octree-driven Gaussian splash ray acceleration device and method. Background Technology

[0002] Gaussian Splat rendering, as a high-quality point cloud reconstruction representation, has been gradually applied to browsers. Unlike traditional discrete point clouds, Gaussian splat includes attributes such as three-axis scale, rotation, and opacity. Each splat has a continuous ellipsoidal volume coverage in space, making traditional point cloud algorithms no longer applicable in the picking decision and indexing construction logic.

[0003] In the process of implementing the technical solutions in the embodiments of the present invention, it has been found that at least the following technical problems exist: CPU linear traversal, directly performing intersection on all splats, is simple to implement, but with millions of data points, the CPU needs to decode, transform, and perform precise intersection on each splat, which cannot guarantee real-time interactive frame rates. GPU rendering picking (IDPass / offscreen picking) obtains splatIDs through a special rendering buffer, centralizing computation on the GPU. However, in browsers, the results need to be read back asynchronously, resulting in latency, unstable accuracy, and difficulty in synchronizing rendering frames. Furthermore, multiple rendering workflows need to be maintained, leading to high engineering complexity. Moreover, GPURay marching / Volumetric Rendering based on BVH primarily serves rendering effects such as lighting and shadows, and the index structure cannot provide CPU-reusable synchronous high-precision picking capabilities. Summary of the Invention

[0004] This invention provides an octree-driven Gaussian splash ray acceleration device and method to address the technical problem that the lack of a unified Gaussian splash ray acceleration structure in the Web environment leads to high latency and lack of interactive synchronization.

[0005] In view of the above problems, the present invention provides an octree-driven Gaussian splash ray acceleration device and method.

[0006] A first aspect of the present invention provides an octree-driven Gaussian splash ray acceleration device, the device comprising: The system comprises the following modules: a filtering module, which traverses the Gaussian splash unit set via the browser's main thread, performs validity filtering, and obtains a valid Gaussian splash unit set; an octree spatial index structure construction module, which transfers the valid Gaussian splash unit set to a Web.Worker independent of the browser's main thread based on an ownership transfer mechanism, and uses Web.Worker to perform recursive spatial subdivision to construct an octree spatial index structure; a unified index structure generation module, which linearizes the octree spatial index structure to generate a unified index structure; a candidate Gaussian splash unit set determination module, which receives ray picking requests, performs hierarchical spatial traversal of the rays based on the unified index structure, and determines the candidate Gaussian splash unit set through level-by-level spatial pruning; and a Gaussian splash unit output module, which performs precise ray-sphere intersection calculations on the candidate Gaussian splash unit set and synchronously outputs the most recently hit Gaussian splash unit on the central processing unit side.

[0007] In one possible embodiment, Web.Worker is used to perform recursive spatial subdivision and construct an octree spatial index structure, including: traversing the set of valid Gaussian splash units, calculating the overall bounding range of the scene, and constructing the spatial boundary of the octree root node, wherein the spatial boundary is the minimum and maximum points of the scene bounding box; during the recursive spatial subdivision process, a two-condition stopping strategy is used to determine the number of Gaussian splash units contained in the current node and the node level depth. When the stopping condition is met, the current node is designated as a leaf node, and the Gaussian splash unit index list of the current node is retained; when the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet spatial partitioning rule, and the Gaussian splash units are assigned to the corresponding child nodes based on their center positions; when the recursive subdivision reaches the stopping condition, deduplication processing is performed on the Gaussian splash unit index list contained in the leaf node.

[0008] In one possible embodiment, the stopping function in the two-condition stopping strategy is: ;in, For stopping functions, The number of Gaussian splash units contained in the current node. To preset the node capacity threshold, The current node depth, This is the preset maximum depth limit for nodes.

[0009] In one possible embodiment, when the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet spatial partitioning rule, and the child nodes are assigned to the corresponding child nodes based on the center position of the Gaussian splash unit. This includes: determining the center point and half-size vector of the spatial range of the current node; determining the bounding box representation function of the k-th child node based on the center point and the half-size vector, where k is a positive integer greater than or equal to 0 and less than or equal to 7; traversing the indices of the Gaussian splash units within the current node, performing coordinate positioning in the lookup table indexToCenter, and determining whether the unit falls within the bounding box of the eight child nodes. If so, the index is added to the index list of the corresponding child node. The bounding box representation function of the k-th child node is: ;in, Let be the bounding box of the k-th child node. This represents the element-wise Hadamard product. , For symbol vectors, It is a half-size vector. Center point.

[0010] In one possible embodiment, the octree spatial index structure is linearized to generate a unified index structure, including: after the main thread receives the octree spatial index structure returned by the Web Worker, performing coordinate transformation; using a breadth-first traversal strategy, starting from the root node, the octree spatial index structure is accessed node by node according to a predetermined level traversal order, and each node is assigned a consecutive integer ID, where the integer ID is ; Once the first child node is added to the queue, a traversal operation is performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in the global array to form a continuous index range. The bounding box of each node, the base address information of the child node, the index range of the leaf node, and the hierarchical identification information of the leaf node are encoded in a fixed layout to obtain a unified index structure. The unified index structure can be accessed in a consistent manner by the central processing unit and the graphics processing unit.

[0011] In one possible embodiment, after the first child node is added to the queue, a traversal operation is performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in a global array, forming a continuous index range. This includes: after the first child node is added to the queue, obtaining the base address of the child node of the first child node, and performing a breadth-first traversal until the set of nodes to be traversed is empty, thus meeting the traversal termination condition. The base address of the child node is: , The base address of the child node. The integer ID of the first child node. This represents the starting position of the first child node in the global linear sequence; for nodes determined to be leaf nodes, their Gaussian splash cell indices are sequentially appended to the global array to obtain the corresponding index range. ,in: ; ;in, Let the starting position of the Gaussian splash cell index of node i in the global array L be given. This represents the number of Gaussian splash cell indices contained in node i, i.e., |node_i.data.indexes|. Let L be the end position of the index of node i in L.

[0012] In one possible embodiment, a ray picking request is received, and a hierarchical spatial traversal is performed on the ray based on the unified index structure. The candidate Gaussian splash unit set is determined through hierarchical spatial pruning, including: performing a ray spatial transformation, traversing from the root node of the octree spatial index structure, performing a first-stage ray-AABB intersection test on each leaf node, determining whether the ray intersects with the bounding box of the leaf node, if not, pruning directly, skipping the leaf node and all its child nodes; if so, continuing to perform hierarchical traversal on the child nodes of the leaf node, and adding the associated Gaussian splash unit index list to the candidate Gaussian splash unit set.

[0013] In one possible embodiment, a ray space transformation is performed, starting from the root node of the octree spatial index structure, and a first-stage ray-AABB intersection test is performed on each leaf node to determine whether the ray intersects with the bounding box of the leaf node, including: obtaining the ray origin transformation formula: Formula for obtaining ray direction transformation: ; ; ;in, The world coordinates of the ray origin are derived from the back projection calculation of the camera position or mouse screen coordinates. This is the world coordinate unit vector of the ray direction, derived from the camera's line of sight or the normalized vector from the screen point to the camera. Let be the local coordinates of the ray's origin. These are auxiliary points used to ensure that the direction vector is correctly transformed under non-uniform scaling. Let be the local coordinate unit vector along the ray direction. The world transformation matrix is ​​defined; based on the ray origin transformation formula and ray direction transformation formula, a ray space transformation is performed, using the Slab method to treat AABB as the intersection of three pairs of parallel planes; for coordinate axis α... ,when When greater than or equal to 0, the ray interacts with the first... The parameters of the intersection points of the planes are: in, ray direction Components on the α-axis; As the origin of the ray Components on the α-axis The minimum distance of the bounding box of a node on the α-axis. The maximum distance of the node bounding box on the α axis; based on the intersection parameter calculation formula, calculate the parameters of the ray entering the node bounding box and the parameters of the ray leaving the node bounding box; determine whether the parameters of the ray entering the node bounding box and the parameters of the ray leaving the node bounding box satisfy the necessary and sufficient condition, if so, then the ray intersects with the node bounding box of the leaf node.

[0014] In one possible embodiment, a precise ray-sphere intersection calculation is performed on the candidate Gaussian splash unit set, and the most recently hit Gaussian splash unit is output synchronously on the central processing unit side. This includes: determining the radius of the bounding sphere by taking the center point of any candidate Gaussian splash unit in the candidate Gaussian splash unit set as the sphere center and combining the average of at least two scales in the principal direction scale parameters; determining a set of discrimination auxiliary variables by combining the local coordinates of the ray origin and the local coordinate unit vector of the ray direction, as well as the radius of the bounding sphere; determining the intersection distance when the set of discrimination auxiliary variables satisfies the necessary intersection condition; determining the hit point set based on the intersection distance, performing a world space transformation, and selecting the Gaussian splash unit corresponding to the hit point with the minimum distance for output.

[0015] A second aspect of the present invention provides an octree-driven Gaussian splash ray acceleration method, the method comprising: The browser's main thread iterates through the Gaussian splash unit set, performs validity filtering, and obtains a valid Gaussian splash unit set. Based on the ownership transfer mechanism, the valid Gaussian splash unit set is transferred to a Web.Worker independent of the browser's main thread. The Web.Worker is used to perform recursive spatial subdivision to construct an octree spatial index structure. The octree spatial index structure is linearized to generate a unified index structure. A ray picking request is received, and based on the unified index structure, a hierarchical spatial traversal is performed on the ray. A candidate Gaussian splash unit set is determined through level-by-level spatial pruning. A precise ray-sphere intersection calculation is performed on the candidate Gaussian splash unit set, and the most recently hit Gaussian splash unit is output synchronously on the central processing unit side.

[0016] One or more technical solutions provided in this invention have at least the following technical effects or advantages: The device provided by this invention includes a filtering module for traversing the Gaussian splash unit set via the browser's main thread, performing validity filtering, and obtaining a valid Gaussian splash unit set; an octree spatial index structure construction module for transferring the valid Gaussian splash unit set to a Web.Worker independent of the browser's main thread based on an ownership transfer mechanism, and using Web.Worker to perform recursive spatial subdivision to construct an octree spatial index structure; a unified index structure generation module for linearizing the octree spatial index structure to generate a unified index structure; a candidate Gaussian splash unit set determination module for receiving ray picking requests, performing hierarchical spatial traversal on the rays based on the unified index structure, and determining the candidate Gaussian splash unit set through level-by-level spatial pruning; and a Gaussian splash unit output module for performing precise ray-sphere intersection calculations on the candidate Gaussian splash unit set and synchronously outputting the most recently hit Gaussian splash unit on the central processing unit side. The following technical effects are achieved: 1. The asynchronous worker build process, combined with the frame-by-frame execution strategy, has a delay of 1-50ms per stage. The build process does not block rendering and maintains 60FPS.

[0017] 2. Improved query efficiency: 10-50 times faster in scenarios with millions of queries, and query latency reduced from 100-200ms to 2-10ms, meeting real-time interaction requirements.

[0018] 3. Linearized storage avoids object pointer overhead, with each node occupying only 48 bytes. The index of a million splats occupies about 4-5MB, which is only 14% of the original data.

[0019] 4. The ownership transfer mechanism avoids data copying, with a 16MB data transfer time of <1ms. Peak memory usage is reduced from 2n to n, showing significant effectiveness in memory-constrained environments such as mobile devices.

[0020] 5. The CPU performs the calculations and directly returns the precise world coordinates, normals, and splat indexes without requiring asynchronous GPU readback. The latency is <10ms, and the hit precision is floating-point precision. ). Attached Figure Description

[0021] Appendix Figure 1 This is a schematic diagram of the structure of the Gaussian splash ray acceleration device based on octree driving provided in an embodiment of the present invention.

[0022] Appendix Figure 2 This is a measured statistical diagram of a typical scenario of sub-node partitioning in an octree-driven Gaussian splash ray accelerator provided in an embodiment of the present invention.

[0023] Appendix Figure 3This is a comparison chart of real-time pickup performance in the octree-driven Gaussian splash ray accelerator provided in the embodiments of the present invention.

[0024] Appendix Figure 4 This is a performance diagram of an octree-driven Gaussian splash ray accelerator without octree picking enabled, provided in an embodiment of the present invention.

[0025] Appendix Figure 5 This is a performance diagram of enabling octree picking in a Gaussian splash ray accelerator based on octree driving, provided in an embodiment of the present invention.

[0026] Appendix Figure 6 This is a flowchart of the Gaussian splash ray acceleration method based on octree-driven method provided in an embodiment of the present invention.

[0027] The labels shown in the attached diagram: 11. Filtering module, 12. Octree spatial index structure construction module, 13. Unified index structure generation module, 14. Candidate Gaussian splash unit set determination module, 15. Gaussian splash unit output module. Detailed Implementation

[0028] The present invention will be further illustrated below with reference to specific embodiments. It should be understood that these embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. Furthermore, it should be understood that after reading the teachings of this invention, those skilled in the art can make various alterations or modifications to the invention, and these equivalent forms also fall within the scope defined by the appended claims. It should be noted that the terms "comprising" and "having" are intended to cover non-exclusive inclusion; for example, a process, method, apparatus, product, or server that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or modules not explicitly listed or inherent to these processes, methods, products, or devices.

[0029] Example 1, as shown in the appendix Figure 1 As shown, this invention proposes an octree-driven Gaussian splash ray acceleration device. Its core technology lies in establishing a hierarchical spatial index that matches the geometric properties of Gaussian splash units, which have a continuous ellipsoidal covering volume. This index simultaneously meets the requirements of real-time rendering and synchronous picking in a Web environment, thereby achieving a unified acceleration structure shared by both CPU and GPU. Specifically, the device includes: Filtering module 11 is used to traverse the Gaussian splash cell set through the browser's main thread, perform validity filtering, and obtain a valid Gaussian splash cell set; In one possible embodiment, during the process of traversing the Gaussian splash cell set in the browser's main thread, the data in the Gaussian splash cell set is filtered. Preferably, the filtering process can be implemented by a custom function, such as filtering based on the opacity. Specifically, when the opacity is greater than or equal to a threshold preset by those skilled in the art, the corresponding Gaussian splash cell is added to the valid Gaussian splash cell set as valid data.

[0030] For example, the filtering function is defined as: ; in, For the validity result of the i-th Gaussian splash unit, when it is When, the corresponding Gaussian splash unit is used as valid data, when it is If so, the corresponding Gaussian splash unit will be discarded. For the first Opacity of a Gaussian splash unit The typical value is 0.1. The center coordinates of the filtered Gaussian splash cells are in the following format: The data is stored sequentially into a Float32Array. Each Gaussian splash unit occupies 16 bytes, which is equivalent to 4 single-precision floating-point numbers.

[0031] Correspondingly, the total data volume is: ;in This represents the number of Gaussian splash units retained after filtering.

[0032] Octree spatial index structure construction module 12 is used to transfer the effective Gaussian splash unit set to Web.Worker, which is independent of the browser main thread, based on the ownership transfer mechanism, and use Web.Worker to perform recursive space subdivision to construct octree spatial index structure; Furthermore, Web.Worker is used to perform recursive space subdivision and construct an octree spatial index structure, including: Traverse the set of effective Gaussian splash units, calculate the overall bounding range of the scene, and construct the spatial boundary of the octree root node, where the spatial boundary is the minimum and maximum points of the scene bounding box; During the recursive space subdivision process, a two-condition stopping strategy is used to determine the number of Gaussian splashing units and the node level depth in the current node. When the stopping condition is met, the current node is designated as a leaf node, and the Gaussian splashing unit index list of the current node is retained. When the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet space partitioning rule, and the Gaussian splash unit is assigned to the corresponding child node according to the center position of the Gaussian splash unit. When the recursive subdivision reaches the stopping condition, deduplication is performed on the list of Gaussian splash cell indices contained in the leaf nodes.

[0033] Preferably, Web.Worker traverses the set of valid Gaussian splash cells and calculates the scene bounding box, where the minimum and maximum points are defined as follows: ; ;in , This represents the number of effective Gaussian splash units in the filtered set of effective Gaussian splash units. The minimum component on the x-axis in the effective Gaussian splash element set. The minimum component on the y-axis in the effective Gaussian splash element set. The minimum component on the z-axis in the effective Gaussian splash element set. The maximum component on the x-axis in the effective Gaussian splash element set. The maximum component on the y-axis in the effective Gaussian splash element set. This represents the maximum z-axis component within the effective Gaussian splash unit set. The scene bounding box size vector is: .

[0034] Furthermore, the stopping function in the dual-condition stopping strategy is:

[0035] in, For stopping functions, The number of Gaussian splash units contained in the current node. To preset the node capacity threshold, The current node depth, This is the preset maximum depth limit for nodes.

[0036] Furthermore, when the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet space partitioning rule, and the child nodes are assigned to the corresponding child nodes based on the center position of the Gaussian splashing unit, including: Determine the center point and half-size vector of the spatial extent of the current node; Based on the center point and the half-size vector, determine the bounding box representation function of the k-th child node, where k is a positive integer greater than or equal to 0 and less than or equal to 7; Traverse the indexes of the Gaussian splashing units within the current node, perform coordinate positioning in the lookup table indexToCenter, and determine whether it falls within the bounding box of the eight child nodes. If so, add the index to the index list of the corresponding child node. The bounding box representation function of the k-th child node is: ; in, Let be the bounding box of the k-th child node. This represents the element-wise Hadamard product. , For symbol vectors, It is a half-size vector. Center point.

[0037] Preferred, The typical value is 2000. The current node depth, The typical value is 8.

[0038] In one embodiment, if the stopping condition is met, the node is marked as a leaf node and its list of Gaussian splash cell indices is retained. Before retention, a deduplication operation needs to be performed on the indices; the deduplicated set of indices is defined as follows:

[0039] in The current index set of the node. The global index set has already been added. The deduplicated indexes are sorted in ascending order; the time complexity of the sorting operation is: .

[0040] Preferably, the spatial extent of the current node is subdivided according to the octet rule to determine the center point and half-size vector, where the center point is calculated as follows: The half-size vector is defined as: .

[0041] In the bounding box representation function The symbol vectors are shown in Table 1, with specific values ​​as follows: The symbol vectors of the eight child nodes are combined as follows (arranged clockwise from top / bottom layer): Table 1. Values ​​of Symbolic Vectors

[0042] Preferably, the lookup table `indexToCenter` is constructed by traversing the coordinate array `sceneCenters` (format: [x, y, z, globalIndex, ...]), extracting the global index of each splat as the key, and its offset (i×4) in the array as the value, establishing a mapping relationship `indexToCenter[globalIndex] = arrayOffset`. This lookup table achieves fast coordinate positioning with minimal time complexity and solves the problem of discontinuous global index and storage location after filtering. During the allocation phase, for each splat index within a node, i.e., the Gaussian splash cell index, its coordinates are located using the lookup table `indexToCenter`. Then determine whether it falls within the bounding box of its child nodes.

[0043] First, the bounding box of each child node is determined using the bounding box representation function, and then the coordinates are determined. If the index falls within the bounding box of the eight child nodes, then add the index to the index list of the corresponding child node.

[0044] Each splat iterates through 8 child nodes. If a node meets the inclusion condition, its index is added to the index list of that child node. Due to boundary cases—that is, when the center point of the splat is exactly on the boundary of a child node—a single splat may be assigned to multiple child nodes, resulting in index redundancy. The redundancy coefficient is defined as: ; in, This represents the set of splat indices for the k-th child node. This indicates the number of splats contained in the child node; This represents the original total number of splats in the current parent node; This represents the total number of splats that are repeatedly assigned.

[0045] According to such Figure 2 The chart shown illustrates the measured statistics for a typical scenario of child node partitioning. The measured data (Intel i7-12700K, single-threaded WebWorker), 570,000 splats (depth 8): approximately 520ms. During the build process, asynchronous execution via WebWorker was used, while the main thread maintained a smooth 60FPS rendering. This confirms that... The redundancy typically ranges from 1.2% to 4.8%. This redundancy is automatically eliminated through subsequent deduplication mechanisms, stopping when the recursive subdivision reaches the stopping condition (node ​​depth > 1). or number of splats < When performing this step, the lookup table `addedIndexes` is used to remove duplicates from the index list, ensuring that each splat appears only once in the final leaf node. Theoretically... It may exceed 5%, such as splat being densely distributed at the boundaries of multiple child nodes, but the deduplication mechanism ensures the uniqueness of the final index, does not affect the correctness of the query, and only increases the memory overhead of a constant factor.

[0046] After all child nodes are created, the index list of the current node is cleared. The process is recursively repeated for each child node until the stopping condition is met.

[0047] Complexity analysis of the construction process: Let the maximum depth of the octree be... The total number of splats in the scene is The theoretical upper limit of the total number of nodes is: ; This upper bound is used to pre-allocate memory buffers and estimate GPU texture size; the actual number of nodes is usually much smaller than this value (due to premature stopping of subdivision).

[0048] Determine the total time complexity of this process, where the total time complexity is... Let the number of nodes in the d-th layer be... The total number of splats for all nodes in this layer is Total time spent per floor: Due to redundancy, .

[0049] Total time ,because (Balanced tree hypothesis), to obtain

[0050] The unified index structure generation module 13 is used to linearize the octree spatial index structure and generate a unified index structure. Furthermore, the octree spatial index structure is linearized to generate a unified index structure, including: After the main thread receives the octree spatial index structure returned by the Web Worker, it performs coordinate transformation. A breadth-first traversal strategy is adopted, starting from the root node and traversing the octree spatial index structure according to a predetermined level traversal order. Each node is assigned a consecutive integer ID, where is ; ; Once the first child node is added to the queue, the traversal operation is performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in the global array, forming a continuous index range. The bounding box of each node, the base address information of the child node, the index range of the leaf node, and the hierarchical identification information of the leaf node are encoded in a fixed layout to obtain a unified index structure, wherein the unified index structure can be accessed by the central processing unit and the graphics processing unit in a consistent manner.

[0051] Furthermore, after the first child node is added to the queue, a traversal operation is performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in a global array, forming a continuous index range, including: After the first child node is added to the queue, obtain the base address of the child node of the first child node, and perform a breadth-first traversal until the set of nodes to be traversed is empty, satisfying the traversal termination condition. The base address of the child node is: , The base address of the child node. The integer ID of the first child node. This represents the starting position of the first child node in the global linear sequence; For nodes identified as leaf nodes, their Gaussian splash cell indices are sequentially appended to the global array to obtain the corresponding index range. ,in: ; ; in, Let the starting position of the Gaussian splash cell index of node i in the global array L be given. This represents the number of Gaussian splash cell indices contained in node i, i.e., |node_i.data.indexes|. Let L be the end position of the index of node i in L.

[0052] In an embodiment of the present invention, a breadth-first traversal strategy is used to assign consecutive IDs to octree nodes, and the integer IDs are: ; The implicit expression of parent-child relationships is achieved through a child node base address mechanism (childBase), avoiding explicit storage of pointers. The formula for calculating the child node base address is:

[0053] The range of child node IDs is This ensures continuity. The data for each node is encoded as 12 floating-point numbers (3×4 matrix) in a fixed layout, naturally matching the RGBA32F texture format. The splat indexes of leaf nodes are stored separately in independent textures, via tuples. This invention enables a compact representation of variable-length data. Compared to the traditional tree structure, which requires the CPU to maintain object pointers and the GPU to maintain array indices, this invention reduces engineering complexity by approximately 30% through unified linearized encoding. Each node is 48 bytes, compared to the traditional object's ~100 bytes, which includes overhead such as pointers and metadata. Furthermore, linearized storage improves cache hit rate, enhances CPU-side traversal performance by approximately 15-20%, and is more user-friendly for contiguous memory access patterns.

[0054] Specifically, the breadth-first traversal queue operation is defined as follows: initial state Execute in each iteration: The traversal termination condition is .

[0055] The append operation is defined as: ; in, This represents an array concatenation operation. Ultimately... It equals the total number of leaf node indices (after considering deduplication).

[0056] All node information is encoded as a floating-point array. Each node occupies 12 floating-point numbers (3 rows x 4 columns, conforming to RGBA texture format). Node The encoding layout is as follows:

[0057] The meanings of each field are as follows: and For bounding box coordinates, The base address of the child node. The number of child nodes (0-8). This is the starting position of the leaf index. Number of leaf indices The node depth (root node) ), Label the leaf nodes:

[0058] The encoding process iterates through all nodes, and for each node... implement: ; array Uploaded as a DataTexture, texture size is The format is RGBA32F. Access node. The During the row, the texture coordinates are calculated as follows: .

[0059] texelFetch is used for precise lookup, avoiding interpolation errors. The integer coordinate transformation formula is: ; Leaf index array It is also encoded as a DataTexture. Since the RGBA format contains 4 floating-point numbers per pixel, the array length needs to be padded to a multiple of 4. ; Fill value set to As an invalidation flag: ; The size of the leaf index texture is When accessing a leaf index, the linear index... Convert to texture coordinates: ; The final generated meta-information vector records the texture parameters: ; in, The number of rows per node. This represents the maximum depth of the tree. This vector is used in both CPU-side traversal and GPU shader access.

[0060] Memory usage analysis shows 48 bytes per node (12 floating-point numbers) and 4 bytes per leaf index. (The following is a partial list of memory usage parameters.) 1 node There are leaf indexes, and the total memory usage is: ; For a million splats, the typical value is , Total memory is approximately: ; Compared to the original Gaussian point data (approximately 32 bytes per splat, totaling 32MB), the indexing overhead is only 14%, which is acceptable.

[0061] The candidate Gaussian splash unit set determination module 14 is used to receive ray picking requests, perform hierarchical spatial traversal on the ray based on the unified index structure, and determine the candidate Gaussian splash unit set through hierarchical spatial pruning. Furthermore, upon receiving a ray picking request, based on the unified index structure, a hierarchical spatial traversal is performed on the ray, and a candidate Gaussian splash unit set is determined through level-by-level spatial pruning, including: Perform ray space transformation, starting from the root node of the octree space index structure, and perform the first stage ray-AABB intersection test on each leaf node to determine whether the ray intersects with the bounding box of the leaf node. If not, prune directly and skip the leaf node and all its child nodes. If so, continue performing a hierarchical traversal of the child nodes of the leaf node, and add the associated Gaussian splash cell index list to the candidate Gaussian splash cell set.

[0062] First, the ray is transformed from world space to the local space of the Gaussian point. Let the world transformation matrix of the Gaussian point be... Then the inverse matrix Used for coordinate transformation. Matrix example: Suppose a Gaussian point undergoes a composite transformation of rotation around the Y-axis by 45°, scaling (2, 1.5, 2), and translation (10, 5, 0), then the world transformation matrix is... The first row is [1.414,0,-1.414,10], the second row is [0,1.5,0,5], the third row is [1.414,0,1.414,0], and the fourth row is [0,0,0,1]. The corresponding inverse matrix... The first line is [0.354,0,0.354,-4.950], the second line is [0,0.667,0,-3.333], the third line is [-0.354,0,0.354,0], and the fourth line is [0,0,0,1].

[0063] Furthermore, a ray space transformation is performed, starting from the root node of the octree spatial index structure. For each leaf node, a first-stage ray-AABB intersection test is performed to determine whether the ray intersects with the bounding box of the leaf node, including: Formula for obtaining the ray origin transformation: ; Formula for obtaining ray direction transformation: ; ; ; in, The world coordinates of the ray origin are derived from the back projection calculation of the camera position or mouse screen coordinates. This is the world coordinate unit vector of the ray direction, derived from the camera's line of sight or the normalized vector from the screen point to the camera. Let be the local coordinates of the ray's origin. These are auxiliary points used to ensure that the direction vector is correctly transformed under non-uniform scaling. Let be the local coordinate unit vector along the ray direction. The world transformation matrix; Based on the ray origin transformation formula and ray direction transformation formula, ray space transformation is performed, and the Slab method is used to treat AABB as the intersection of three pairs of parallel planes. For coordinate axis α ,when When greater than or equal to 0, the ray interacts with the first... The parameters of the intersection points of the planes are:

[0064] in, ray direction Components on the α-axis; As the origin of the ray Components on the α-axis The minimum distance of the bounding box of a node on the α-axis. The maximum distance of the bounding box of the node on the α axis; Based on the intersection parameter calculation formula, calculate the parameters of the ray entering the node's bounding box and the parameters of the ray leaving the node's bounding box; Determine whether the parameters of the ray entering the bounding box of the node and the parameters of the ray leaving the bounding box of the node satisfy the necessary and sufficient condition. If so, the ray intersects with the bounding box of the leaf node.

[0065] By using axis-aligned AABB as a unified spatial partitioning basis, and with AABB naturally aligned to WebGL's texture addressing coordinates, it can be directly bound to a unified DataTexture encoding structure, allowing CPU pickup and GPU rendering to share the same level of indexing.

[0066] In other words, if the parameter of the ray entering the node's bounding box is greater than the parameter of the ray leaving the node's bounding box, it means that the ray has not passed through the node's bounding box. If the parameter of the ray entering the node's bounding box is less than or equal to the parameter of the ray leaving the node's bounding box, it means that the ray has passed through the node's bounding box.

[0067] If the ray origin is already inside the bounding box, then the following conditions are met: ; in If tolerance is allowed, the intersection is returned directly, and the intersection point is set to the starting point itself.

[0068] like (The ray is parallel to the axis) It is necessary to check whether the starting point is within the valid range of the axis. If the starting point is not within the range, return "not intersecting".

[0069] The computational complexity of the intersection test is This requires approximately 15-20 floating-point operations (6 divisions, 6 comparisons, and several additions and subtractions). For disjoint nodes, their entire subtrees are pruned, skipping thousands to tens of thousands of splat tests. Pruning efficiency is defined as:

[0070] In actual testing That is, 99% of splats are skipped by passing the AABB test.

[0071] The Gaussian splash unit output module 15 is used to perform accurate ray-sphere intersection calculation on the candidate Gaussian splash unit set and synchronously output the most recently hit Gaussian splash unit on the central processing unit side.

[0072] Furthermore, an accurate ray-sphere intersection calculation is performed on the candidate Gaussian splash unit set, and the most recently hit Gaussian splash unit is simultaneously output on the central processing unit side, including: The radius of the enclosing sphere is determined by taking the center point of any candidate Gaussian splash unit in the candidate Gaussian splash unit set as the center of the sphere and combining the average value of at least two scales in the principal direction scale parameters. By combining the local coordinates of the ray's origin and the local coordinate unit vector of the ray's direction, as well as the radius of the enclosing sphere, the set of auxiliary variables for discrimination is determined; When the set of discrimination auxiliary variables satisfies the necessary condition for intersection, the distance between the intersection points is determined; The set of hit points is determined based on the intersection distance, and a world space transformation is performed. The Gaussian splash unit corresponding to the hit point with the minimum distance is selected for output.

[0073] Specifically, the ray-sphere intersection problem reduces to solving equations:

[0074] in, Local coordinates of the ray origin. The local coordinate unit vector of the ray direction. The ray parameter represents the distance traveled along the direction from the starting point, and the coordinates of the intersection point are... , Local coordinates (3D vector) of the center of the splat.

[0075] After expansion, we get information about The quadratic equation: ,because unit vector ( ), simplified to: ; in, Let vector V be in the ray direction The projection (scalar) on the surface. It is the square of the distance from the ray's origin to the center of the sphere (a scalar). Let splat be the radius of the sphere.

[0076] Define auxiliary variables: , , .

[0077] Where V is the vector pointing from the origin of the ray to the center of the sphere.

[0078] The discriminant is: ; The necessary condition for them to intersect is: ,Right now: ; in, The square of the distance from the ray's origin to the center of the sphere. Let be the projection (with sign) of the vector from the starting point to the center of the sphere along the ray direction, which is equivalent to the distance from the nearest point of the ray to the center of the sphere not exceeding the radius.

[0079] If they intersect, the parameters of the two intersection points are: ; ; Take the first orthogonal point (excluding intersections after the ray origin): ; The world coordinates and normal of the intersection point are as follows: ; ; The normal direction points outward from the sphere (from the center of the sphere towards the intersection point). The distance to the intersection point is defined as a parameter. itself: ; All hit points are collected into an array. Then, it is converted back to world space and sorted by distance. The world space conversion formula is: ; ; The actual distance needs to be recalculated (local space cannot be used directly). ): ; After sorting, select the hit point with the shortest distance: .

[0080] Furthermore, we perform performance analysis and speedup ratio calculation for Gaussian splash ray acceleration based on octree-driven methods. Performance comparisons are shown below. Figure 3-5 As shown, suppose the scene includes There are splats, and the octree depth is . On average, each leaf node contains One splat. The time complexity of linear traversal is: ; in, The time required to perform a single intersection test on a sphere (approximately 20 floating-point operations).

[0081] After octree acceleration, the average ray traversal There are nodes, of which the number of branch nodes is . The number of leaf nodes is The total time is: ; in, The test time is AABB (approximately 15 floating-point operations).

[0082] Simplified to: .

[0083] Due to the pruning properties of octagonal trees, Proportional to tree depth: The number of leaf nodes also satisfies .

[0084] therefore: .

[0085] The acceleration ratio is defined as: ; Ignore the overhead of the AABB test ( ), simplified to: .

[0086] Actual test data verification, when , , At that time, linear traversal takes approximately An octree traversal takes approximately The measured acceleration ratio is: .

[0087] The theoretical speedup ratio is: .

[0088] The actual value is slightly lower than the theoretical value, mainly due to the following reasons: the additional overhead of octree traversal (node ​​access, recursive calls, condition judgments, etc.), which accounts for about 10-15% of the total time; the increased cache miss rate, as the memory access pattern of tree traversal is not as continuous as that of linear traversal; and the redundancy testing of boundary splats, with about 1-5% of splats being tested repeatedly.

[0089] The overall cost factor is defined as: .

[0090] The corrected speedup model is as follows: The model matches the measured data well.

[0091] Example 2, based on the same inventive concept as the octree-driven Gaussian splash ray accelerator in the foregoing examples, as shown in the appendix. Figure 6 As shown, this invention provides a Gaussian splash ray acceleration method based on octree-driven methods. The method and apparatus embodiments of this invention are based on the same inventive concept. The method includes: The browser's main thread iterates through the Gaussian splash unit set, performs validity filtering, and obtains a valid Gaussian splash unit set. Based on the ownership transfer mechanism, the valid Gaussian splash unit set is transferred to a Web.Worker independent of the browser's main thread. The Web.Worker is used to perform recursive spatial subdivision to construct an octree spatial index structure. The octree spatial index structure is linearized to generate a unified index structure. A ray picking request is received, and based on the unified index structure, a hierarchical spatial traversal is performed on the ray. A candidate Gaussian splash unit set is determined through level-by-level spatial pruning. A precise ray-sphere intersection calculation is performed on the candidate Gaussian splash unit set, and the most recently hit Gaussian splash unit is output synchronously on the central processing unit side.

[0092] It should be noted that the order of the above embodiments of the present invention is merely for descriptive purposes and does not represent the superiority or inferiority of the embodiments. Furthermore, the above description focuses on specific embodiments of this specification. Additionally, the processes depicted in the accompanying drawings do not necessarily require a specific or sequential order to achieve the desired results. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0093] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0094] This specification and accompanying drawings are merely illustrative examples of the invention and are intended to cover any and all modifications, variations, combinations, or equivalents within the scope of the invention. Clearly, those skilled in the art can make various alterations and modifications to the invention without departing from its scope. Therefore, if such modifications and modifications fall within the scope of the invention and its equivalents, the invention is intended to include these modifications and modifications.

Claims

1. An octree-driven Gaussian splash ray acceleration device, characterized in that, The device includes: The filtering module is used to traverse the Gaussian splash cell set through the browser's main thread, perform validity filtering, and obtain the valid Gaussian splash cell set. An octree spatial index structure construction module is used to transfer the effective Gaussian splash unit set to Web.Worker, which is independent of the browser's main thread, based on the ownership transfer mechanism, and to use Web.Worker to perform recursive space subdivision to construct an octree spatial index structure. The unified index structure generation module is used to linearize the octree spatial index structure and generate a unified index structure. The candidate Gaussian splash unit set determination module is used to receive ray picking requests, perform hierarchical spatial traversal on the ray based on the unified index structure, and determine the candidate Gaussian splash unit set through hierarchical spatial pruning. The Gaussian splash unit output module is used to perform accurate ray-sphere intersection calculations on the candidate Gaussian splash unit set and synchronously output the most recently hit Gaussian splash unit on the central processing unit side.

2. The octree-driven Gaussian splash ray acceleration apparatus of claim 1, wherein, Using Web.Worker to perform recursive space subdivision, an octree spatial index structure is constructed, including: Traverse the set of effective Gaussian splash units, calculate the overall bounding range of the scene, and construct the spatial boundary of the octree root node, where the spatial boundary is the minimum and maximum points of the scene bounding box; During the recursive space subdivision process, a two-condition stopping strategy is used to determine the number of Gaussian splashing units and the node level depth in the current node. When the stopping condition is met, the current node is designated as a leaf node, and the Gaussian splashing unit index list of the current node is retained. When the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet space partitioning rule, and the Gaussian splash unit is assigned to the corresponding child node according to the center position of the Gaussian splash unit. When the recursive subdivision reaches the stopping condition, deduplication is performed on the list of Gaussian splash cell indices contained in the leaf nodes.

3. The octree-driven Gaussian splash ray acceleration device as described in claim 2, characterized in that, The stopping function in the dual-condition stopping strategy is: in, For stopping functions, The number of Gaussian splash units contained in the current node. To preset the node capacity threshold, The current node depth, This is the preset maximum depth limit for nodes.

4. The octree-driven Gaussian splash ray acceleration apparatus of claim 2, wherein, When the stopping condition is not met, the spatial range of the current node is divided into eight child nodes according to the octet space partitioning rule, and the child nodes are assigned to the corresponding child nodes based on the center position of the Gaussian splashing unit, including: Determine the center point and half-size vector of the spatial extent of the current node; Based on the center point and the half-size vector, determine the bounding box representation function of the k-th child node, where k is a positive integer greater than or equal to 0 and less than or equal to 7; Traverse the indexes of the Gaussian splashing units within the current node, perform coordinate positioning in the lookup table indexToCenter, and determine whether it falls within the bounding box of the eight child nodes. If so, add the index to the index list of the corresponding child node. The bounding box representation function of the k-th child node is: ； in, Let be the bounding box of the k-th child node. This represents the element-wise Hadamard product. , For symbol vectors, It is a half-size vector. Center point.

5. The octree-driven Gaussian splash-based ray launching apparatus of claim 1, wherein, The octree spatial index structure is linearized to generate a unified index structure, including: After the main thread receives the octree spatial index structure returned by the Web Worker, it performs coordinate transformation. The breadth-first traversal strategy is adopted, and nodes of the octree spatial index structure are accessed according to a predetermined hierarchical traversal order from a root node, and each node is allocated a continuous integer ID, wherein the integer ID is; ; Once the first child node is added to the queue, the traversal operation is performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in the global array, forming a continuous index range. The bounding box of each node, the base address information of the child node, the index range of the leaf node, and the hierarchical identification information of the leaf node are encoded in a fixed layout to obtain a unified index structure, wherein the unified index structure can be accessed by the central processing unit and the graphics processing unit in a consistent manner.

6. The octree-driven Gaussian splash-based ray acceleration apparatus of claim 5, wherein, After the first child node is added to the queue, traversal operations are performed until the traversal termination condition is met. The Gaussian splash cell indices contained in the leaf nodes are stored sequentially in a global array, forming a continuous index range, including: After the first child node is added to the queue, obtain the base address of the child node of the first child node, and perform a breadth-first traversal until the set of nodes to be traversed is empty, satisfying the traversal termination condition. The base address of the child node is: , The base address of the child node. The integer ID of the first child node. This represents the starting position of the first child node in the global linear sequence; For nodes identified as leaf nodes, their Gaussian splash cell indices are sequentially appended to the global array to obtain the corresponding index range. ,in: ； ； in, Let the starting position of the Gaussian splash cell index of node i in the global array L be given. This represents the number of Gaussian splash cell indices contained in node i, i.e., |node_i.data.indexes|. Let L be the end position of the index of node i in L.

7. The octree-driven Gaussian splash-based ray launching apparatus of claim 1, wherein, Upon receiving a ray picking request, based on the unified index structure, a hierarchical spatial traversal is performed on the ray, and a candidate Gaussian splash unit set is determined through level-by-level spatial pruning, including: Perform ray space transformation, starting from the root node of the octree space index structure, and perform the first stage ray-AABB intersection test on each leaf node to determine whether the ray intersects with the bounding box of the leaf node. If not, prune directly and skip the leaf node and all its child nodes. If so, continue performing a hierarchical traversal of the child nodes of the leaf node, and add the associated Gaussian splash cell index list to the candidate Gaussian splash cell set.

8. The octree-driven Gaussian splash ray casting apparatus of claim 7, wherein, Perform a ray space transformation, starting from the root node of the octree spatial index structure, and perform a first-stage ray-AABB intersection test on each leaf node to determine whether the ray intersects with the bounding box of the leaf node, including: Obtaining the ray origin transformation formula: ; Formula for obtaining ray direction transformation: ； ； ； in, The world coordinates of the ray origin are derived from the back projection calculation of the camera position or mouse screen coordinates. This is the world coordinate unit vector of the ray direction, derived from the camera's line of sight or the normalized vector from the screen point to the camera. Let be the local coordinates of the ray's origin. These are auxiliary points used to ensure that the direction vector is correctly transformed under non-uniform scaling. Let be the local coordinate unit vector along the ray direction. The world transformation matrix; Based on the ray origin transformation formula and ray direction transformation formula, ray space transformation is performed, and the Slab method is used to treat AABB as the intersection of three pairs of parallel planes. For coordinate axis α ,when When greater than or equal to 0, the ray interacts with the first... The parameters of the intersection points of the planes are: in, ray direction Components on the α-axis; As the origin of the ray Components on the α-axis The minimum distance of the bounding box of a node on the α-axis. The maximum distance of the bounding box of the node on the α axis; Based on the intersection parameter calculation formula, calculate the parameters of the ray entering the node's bounding box and the parameters of the ray leaving the node's bounding box; Determine whether the parameters of the ray entering the bounding box of the node and the parameters of the ray leaving the bounding box of the node satisfy the necessary and sufficient condition. If so, the ray intersects with the bounding box of the leaf node.

9. The octree-driven Gaussian splash-based ray launching apparatus of claim 1, wherein, Perform precise ray-sphere intersection calculations on the candidate Gaussian splash unit set, and synchronously output the most recently hit Gaussian splash unit on the central processing unit side, including: The radius of the enclosing sphere is determined by taking the center point of any candidate Gaussian splash unit in the candidate Gaussian splash unit set as the center of the sphere and combining the average value of at least two scales in the principal direction scale parameters. By combining the local coordinates of the ray's origin and the local coordinate unit vector of the ray's direction, as well as the radius of the enclosing sphere, the set of auxiliary variables for discrimination is determined; When the set of discrimination auxiliary variables satisfies the necessary condition for intersection, the distance between the intersection points is determined; The set of hit points is determined based on the intersection distance, and a world space transformation is performed. The Gaussian splash unit corresponding to the hit point with the minimum distance is selected for output.

10. A method of Gaussian ray acceleration based on octree-driven, characterized in that, The method is implemented by the octree-driven Gaussian sputtering ray accelerator as described in any one of claims 1-9, and the method includes: The browser's main thread iterates through the Gaussian splash cell set, performs validity filtering, and obtains the valid Gaussian splash cell set. Based on the ownership transfer mechanism, the effective Gaussian splash unit set is transferred to Web.Worker, which is independent of the browser's main thread. Web.Worker is then used to perform recursive space subdivision and construct an octree space index structure. Linearize the octree spatial index structure to generate a unified index structure; Upon receiving a ray picking request, a hierarchical spatial traversal is performed on the ray based on the unified index structure, and a set of candidate Gaussian splash units is determined through progressive spatial pruning. Perform precise ray-sphere intersection calculations on the candidate Gaussian splash unit set, and synchronously output the most recently hit Gaussian splash unit on the central processing unit side.

Images