A variable-precision 3D Gaussian rendering method and accelerator based on depth sharing

Abstract

This invention provides a variable-precision 3D Gaussian rendering method and accelerator based on depth sharing. Using pixel blocks as the basic processing unit, it first acquires Gaussian points intersecting with the current block, removes low-opacity points, and divides the block into multiple segments from near to far depth. For each Gaussian point, a mask is generated to mark the intersection position of the pixels it covers. Then, the Gaussian points within each segment are sorted by depth and indexed. For the nearest first segment, the depth sequence of overlapping Gaussian points shared by at least a first number of pixels is found based on the intersection mask, marked as the shared depth, and its index is recorded. Subsequently, a dual-path parallel rendering architecture is adopted. The shared depth rendering unit calculates the coloring result of the shared sequence in one go and broadcasts it. Simultaneously, the block rendering unit, corresponding to each pixel, processes the remaining Gaussian points in each segment (excluding the shared depth) in parallel, merging the results with the broadcast results to obtain the final color of each pixel. Furthermore, the block rendering unit adopts a rendering precision strategy that gradually decreases with increasing depth, significantly reducing computational and storage overhead.

Description

Technical Field

[0001] This invention relates to the field of 3D Gaussian splashing technology, and in particular to a variable precision 3D Gaussian rendering method and accelerator based on depth sharing. Background Technology

[0002] 3D Gaussian Splatting (3DGS), as an emerging real-time radiation field rendering technology, represents a 3D scene using a set of learnable 3D Gaussian ellipsoids. It achieves a good balance between high reconstruction quality and real-time rendering speed, and is widely used in fields such as digital twins, autonomous driving simulation, and virtual reality. However, the rendering process of 3D Gaussian Splatting involves the projection, sorting, and pixel-by-pixel α-hybridization of a large number of Gaussian points, resulting in extremely high computational complexity and storage bandwidth requirements, making it difficult to deploy directly on edge devices where computing power, storage resources, and power consumption are limited.

[0003] To address these challenges, the academic community has proposed several dedicated hardware acceleration solutions. For example, the GSAcc accelerator proposed by the University of Texas at Austin team at DAC 2025 achieves parallelization of the preprocessing and sorting stages through depth inference and Gaussian-centered rasterized data streams, and employs a tile-resident-aware scheduling strategy to reduce off-chip memory access. Another example is the GSCore architecture proposed by the Seoul National University team at ASPLOS 2024, which improves culling efficiency and computational throughput through shape-aware intersection testing, hierarchical sorting, and a sub-tile-based computation skipping mechanism.

[0004] However, the existing solutions described above still have the following technical shortcomings: First, the parallelism of the pixel coloring stage is limited, resulting in high rendering latency. Both GSAcc and GSCore still follow the original 3D Gaussian sputtering α-mixing formula for final pixel color synthesis. This formula has a strict front-to-back depth dependency, meaning that the coloring process for each pixel must process its associated Gaussian points serially. While parallel processing is possible between different pixels, a large number of Gaussian points are repeatedly calculated across multiple pixels, making effective reuse impossible. This leads to computational redundancy and low hardware utilization, limiting further improvements in rendering speed.

[0005] Second, the computational precision is limited, resulting in poor energy efficiency. Existing solutions generally use the original algorithm's FP32 full-precision calculation mode, failing to consider the differences in the contribution of Gaussian points at different depths to the final color. In reality, Gaussian points located close to the line of sight play a dominant role in color, while those at a distance contribute very little due to cumulative transmittance decay. Continuous high-precision calculation not only increases storage bandwidth and memory usage but also leads to high power consumption and latency in the computing unit, making it difficult to meet the dual requirements of low power consumption and real-time performance for edge devices.

[0006] Third, there is still room for improvement in hardware resource utilization. Although GSAcc and GSCore have reduced some invalid computations through methods such as culling, sorting, and skipping sub-tiles, the computation reuse opportunities brought about by the overlap of Gaussian points between pixels have not been fully explored in the core's alpha mixing stage. A large number of repetitive multiply-accumulate operations have not been merged, resulting in low overall energy efficiency of the computing unit.

[0007] Therefore, a new technical solution is urgently needed to improve the parallelism of 3D Gaussian sputtering rendering, reduce computational accuracy redundancy, and improve the efficiency of hardware resource utilization. Summary of the Invention

[0008] In view of this, embodiments of the present invention provide a variable precision 3D Gaussian rendering method and accelerator based on depth sharing, so as to eliminate or improve one or more defects existing in the prior art and solve the problems of low parallelism and redundant calculation precision in the existing 3D Gaussian rendering process.

[0009] One aspect of the present invention provides a variable-precision 3D Gaussian rendering method based on depth sharing, which performs coloring on multiple pixel blocks to be rendered one by one until all are completed. The coloring steps for each pixel block to be rendered include: Retrieve from memory the Gaussian point that intersects with the current pixel block to be rendered, as determined by an intersection test. The Gaussian point records the three-dimensional spatial position, rotation, scaling, opacity, and color information. Remove the Gaussian points with opacity below a first threshold, and group the Gaussian points into multiple segments from near to far according to depth information; add an intersection position mask to each Gaussian point to mark the intersection position with the pixels in the pixel block to be rendered; The Gaussian points in each segment are sorted by depth from near to far in batches to obtain a Gaussian point depth sequence and establish a sequential index. For the first segment closest along the line of sight, find the depth sequence of overlapping Gaussian points that exists between a first number of pixels according to the intersection position mask, and mark it as a shared depth; mark the shared depth index corresponding to all the shared depths in the first segment; the shared depth index mark includes the pixels of the shared depth and the corresponding overlapping Gaussian point depth sequence; Multiple independent shared depth rendering units are used to color the overlapping Gaussian point depth sequence recorded in the shared depth index to obtain the shared depth coloring result and broadcast it; block rendering units that correspond one-to-one with the pixels in the pixel block to be rendered are used to simultaneously color the remaining Gaussian points on each segment that intersect with the current pixel and exclude the shared depth, and combine them with the broadcast shared depth coloring result to obtain the final color information of all pixels on the pixel block to be rendered; The block rendering unit is configured with multi-level rendering precision from high to low according to the Gaussian point depth from near to far.

[0010] In some embodiments, the intersection test employs axis-aligned bounding box intersection test, geometry-aware discretized bounding box intersection test, Gaussian shape-aware intersection test, or Gaussian-mesh intersection test. The pixel block to be rendered adopts a 3×3 or 4×4 specification; The first threshold is set according to multi-level precision requirements, including: (0.02, 0.05] for real-time requirements; (0.01, 0.02] for general requirements; and [0.05, 0.01] for high-precision requirements.

[0011] In some embodiments, the Gaussian points are grouped into multiple segments from near to far according to depth information, including: For the first segment that is closest along the line of sight, dynamic truncation is performed based on the cumulative contribution rate threshold. For real-time scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 90%. For general scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 95%. For high-precision scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 90%.

[0012] In some embodiments, the method further includes: For the first segment that is closest along the line of sight, a dual constraint is set on the number of Gaussian points and the depth threshold. The requirement is that the number of Gaussian points in the first segment is less than or equal to the second threshold, and the depth of each Gaussian point is less than or equal to the preset depth threshold.

[0013] In some embodiments, the method further includes: For a fixed scenario, during the offline phase, it is necessary to statistically analyze the optimal segmentation configuration for each viewpoint and generate a lookup table. This table is used to group and segment the Gaussian points according to the configuration in the lookup table during real-time rendering.

[0014] In some embodiments, finding a sequence of overlapping Gaussian points with depths greater than or equal to a first number of pixels based on the intersection position mask, and marking them as shared depths, includes: The intersection position codes of all Gaussian points in the first segment are aligned and combined to obtain an intersection position matrix; each row of the intersection position matrix is ​​used to record the intersection position code of one Gaussian point, and the rows are arranged according to the depth sequence of the Gaussian points. Each column of the intersection position matrix corresponds to each pixel in the current pixel block to be rendered; the intersection position code uses 0 to mark that the Gaussian point and the pixel do not intersect, and uses 1 to mark that the Gaussian point and the pixel do not intersect. In each column of the intersection position matrix, find candidate shared depths that are continuously marked as 1, query the number of times the candidate shared depth appears in each column, and if it is greater than or equal to a first number, mark it as a shared depth; establish the shared depth index to mark the pixels containing the shared depth and the corresponding coincident Gaussian point depth sequence.

[0015] In some embodiments, the block rendering unit sets a multi-level rendering precision from high to low according to the Gaussian point depth from near to far, including: The distance is divided into a near distance group, a medium distance group, and a far distance group according to the depth of the Gaussian point. The near distance group is rendered with FP32 precision, the medium distance group is rendered with BF16 precision, and the far distance group is rendered with BF8 precision.

[0016] On the other hand, the present invention also provides a variable precision 3D Gaussian rendering accelerator based on depth sharing. The accelerator includes: a data extraction and processing unit, multiple segmentation and sorting units, multiple shared depth rendering units, and multiple block rendering units, wherein each block rendering unit corresponds one-to-one with a pixel in a pixel block to be rendered. The data extraction and processing unit is used to retrieve Gaussian points that intersect with the current pixel block to be rendered, as determined by an intersection test, from the memory. These Gaussian points record three-dimensional spatial position, rotation, scaling, opacity, and color information. The unit then discards Gaussian points with opacity below a first threshold, groups the Gaussian points into multiple segments from near to far according to depth information, and adds an intersection position mask to each Gaussian point to mark its intersection position with pixels in the pixel block to be rendered. The segmented sorting unit is used to sort the Gaussian points in each segment from near to far in batches to obtain a Gaussian point depth sequence and establish a sequential index. The data extraction and processing unit is further configured to, for the first segment closest along the line of sight, find the depth sequence of overlapping Gaussian points that satisfy a first number of pixels existing between the intersection position mask, and mark them as shared depths; mark the shared depth index corresponding to all the shared depths in the first segment; the shared depth index mark includes the pixels of the shared depth and the corresponding overlapping Gaussian point depth sequence; The shared depth rendering unit is used to color the depth sequence of the coincident Gaussian points recorded in the shared depth index, obtain the shared depth coloring result, and broadcast it. The block rendering unit synchronously colors the remaining Gaussian points on each segment that intersect with the current pixel and excludes the shared depth, and combines the coloring results with the broadcast shared depth to obtain the final color information of all pixels on the pixel block to be rendered.

[0017] In some embodiments, the shared depth rendering unit or the block rendering unit has the same structure, including three channels: red, green, and blue, with each channel corresponding to a different deployment: The precision conversion module, located at the input port, is used for hardware-level conversion between FP32, BF16, and INT8. A dual multiplier array, containing two parallel multipliers, which respectively perform the calculation of the effective opacity of the current Gaussian and the calculation of the color contribution of the current Gaussian; A dual adder array, comprising two parallel adders, which respectively perform updates to cumulative transmittance and updates to cumulative color; The cumulative register group contains two dedicated registers, which store the cumulative transmittance and cumulative color of the previous cycle, respectively. The control and multiplexing logic module is used to control the data flow and calculation timing; it is also used to execute segmentation truncation logic to forcibly shut down subsequent calculations when the cumulative transmittance is lower than a set threshold; and it is also used to receive the shared depth staining results and perform the final color merging operation.

[0018] On the other hand, the present invention also provides a computer program product, including a computer program or instructions that, when executed by a processor, implement the steps of the above-described method.

[0019] The variable-precision 3D Gaussian rendering method and accelerator based on depth sharing described in this invention uses pixel blocks as processing units. It acquires Gaussian points intersecting with the current block, removes low-opacity Gaussian points, and groups them into multiple segments according to depth from near to far. For each Gaussian point, an intersection mask marking the position of the pixels it covers is generated. Gaussian points within each segment are sorted by depth from near to far and indexed. For the nearest first segment, the depth sequence of overlapping Gaussian points shared by at least a first number of pixels is found based on the intersection mask, marked as shared depth, and the shared depth index is recorded. Based on this, multiple independent shared-depth rendering units perform a coloring calculation on this shared sequence, and the result is broadcast to all pixels within the block. Simultaneously, block rendering units corresponding to each pixel process the remaining Gaussian points in each segment (excluding shared depth points) in parallel and merge them with the broadcast result to obtain the final color of each pixel. Furthermore, the block rendering units employ a multi-level precision strategy that reduces rendering precision as depth increases, reducing computational and storage overhead while ensuring visual quality.

[0020] Additional advantages, objects, and features of the invention will be set forth in part in the description which follows, and will also become apparent in part to those skilled in the art upon studying the description, or may be learned by practice of the invention. The objects and other advantages of the invention can be realized and obtained by means of the structures specifically pointed out in the specification and drawings.

[0021] Those skilled in the art will understand that the objectives and advantages achievable with the present invention are not limited to those specifically described above, and that the above and other objectives achievable with the present invention will become clearer from the following detailed description. Attached Figure Description

[0022] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, are not intended to limit the scope of the invention. In the drawings: Figure 1 This is a flowchart illustrating the variable precision 3D Gaussian rendering method based on depth sharing according to an embodiment of the present invention.

[0023] Figure 2 This is a schematic diagram of the logic of a variable precision shared depth rendering accelerator for 3D Gaussian splashing according to an embodiment of the present invention.

[0024] Figure 3 This is a hardware architecture diagram of a variable precision shared depth rendering accelerator for 3D Gaussian splashing according to an embodiment of the present invention.

[0025] Figure 4 This is a schematic diagram of the rendering unit logic of a variable precision shared depth rendering accelerator for 3D Gaussian splashing according to an embodiment of the present invention.

[0026] Figure 5 This is a schematic diagram of the shared depth during the 3D Gaussian splash rendering process.

[0027] Figure 6 This is a schematic diagram showing the formats for three precision levels: FP32, BF16, and INT8.

[0028] Figure 7 This is a schematic diagram of the conversion logic for three precisions: FP32, BF16, and INT8. Detailed Implementation

[0029] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the embodiments and accompanying drawings. Here, the illustrative embodiments and descriptions of this invention are used to explain the invention, but are not intended to limit the invention.

[0030] It should also be noted that, in order to avoid obscuring the invention with unnecessary details, only the structures and / or processing steps closely related to the solution according to the invention are shown in the accompanying drawings, while other details that are not closely related to the invention are omitted.

[0031] It should be emphasized that the term "including / comprises" as used herein refers to the presence of a feature, element, step, or component, but does not exclude the presence or addition of one or more other features, elements, steps, or components.

[0032] It should also be noted that, unless otherwise specified, the term "connection" in this article can refer not only to a direct connection, but also to an indirect connection involving an intermediary.

[0033] Currently, 3D Gaussian sputtering (3DGS) rendering technology mainly relies on general computing platforms such as GPUs. Its pixel-by-pixel alpha blending process is difficult to parallelize due to the strict front-to-back depth dependency, resulting in high rendering latency. At the same time, although existing dedicated acceleration solutions (such as GSAcc and GSCore) have optimized culling, sorting, and sub-tile skipping, they still have problems such as the inability to reuse a large number of repetitive Gaussian point calculations between pixels, low energy efficiency due to the use of a single high-precision FP32 mode throughout the process, and insufficient utilization of hardware resources. These issues make it difficult to meet the dual requirements of edge devices for real-time performance and low power consumption.

[0034] In view of this, the present invention provides a variable-precision 3D Gaussian rendering method based on depth sharing, which performs coloring on multiple pixel blocks to be rendered one by one until all are completed, such as... Figure 1 and 3 As shown, the coloring steps for each pixel block to be rendered include steps S101 to S105: Step S101: Obtain from memory the Gaussian point that intersects with the current pixel block to be rendered, as determined by the intersection test. The Gaussian point records the three-dimensional spatial position, rotation, scaling, opacity, and color information.

[0035] Step S102: Remove Gaussian points with opacity below the first threshold, and group the Gaussian points into multiple segments from near to far according to depth information; add an intersection position mask to each Gaussian point to mark the intersection position with the pixels in the pixel block to be rendered.

[0036] Step S103: Sort the Gaussian points in each segment by depth from near to far in batches to obtain the Gaussian point depth sequence and establish a sequential index.

[0037] Step S104: For the first segment closest along the line of sight, find the overlapping Gaussian point depth sequence that exists between more than or equal to a first number of pixels according to the intersection position mask, and mark it as a shared depth; mark the shared depth index corresponding to all shared depths in the first segment; the shared depth index marks the pixels containing the shared depth and the corresponding overlapping Gaussian point depth sequence.

[0038] Step S105: Use multiple independent shared depth rendering units to color the depth sequence of overlapping Gaussian points recorded in the shared depth index, obtain the shared depth coloring result, and broadcast it; use block rendering units that correspond one-to-one with the pixels in the pixel block to be rendered to simultaneously color the remaining Gaussian points on each segment that intersect with the current pixel and exclude the shared depth, and combine them with the broadcast shared depth coloring result to obtain the final color information of all pixels on the pixel block to be rendered.

[0039] Among them, the block rendering unit is set with multi-level rendering precision from high to low according to the Gaussian point depth from near to far.

[0040] In step S101, Gaussian points that intersect with the pixel block are first read from on-chip or off-chip memory. Specifically, intersection tests can be used to determine this. In some embodiments, the intersection test uses axis-aligned bounding box intersection test, geometry-aware discretized bounding box intersection test, Gaussian shape-aware intersection test, or Gaussian-mesh intersection test.

[0041] Specifically, the Axially Aligned Bounding Box (AABB) intersection test projects a 3D Gaussian ellipsoid onto a 2D image plane to obtain an ellipse. It then calculates the circumscribed rectangles (AABBs) of this ellipse in the horizontal and vertical directions, and determines whether these rectangles overlap with the pixel blocks to be rendered. The Geometry-Aware Discretized Bounding Box (QuadBox) intersection test addresses the high false positive rate of AABB by using the geometric shape information of the Gaussian ellipsoid (such as the major axis direction) to construct multiple discretized bounding box segments. These segments, when combined, more tightly fit the edge of the ellipse projection, and then each segment is tested against the pixel block. This method significantly reduces the false positive rate at the cost of minimal computational overhead. The Gaussian Shape-Aware Intersection Test (GSCore method) adaptively selects a testing strategy based on the shape characteristics of the Gaussian ellipsoid. For near-spherical Gaussians with an aspect ratio close to 1, a fast but conservative AABB test is used; for slender Gaussians with an aspect ratio exceeding a preset threshold, a more precise Oriented Bounding Box (OBB) test is used. OBB can be adjusted according to the rotation direction of the ellipse, significantly reducing misjudgments of elongated Gaussian projections. The Gaussian-mesh intersection test (FAMERS method) does not directly test Gaussian points with pixel blocks. Instead, it pre-divides the image plane into a hierarchical mesh, such as a quadtree or multi-resolution mesh. Each Gaussian point is associated with a corresponding level of mesh cell based on its projection radius. During rendering, only the list of Gaussian points in the mesh cell containing the current pixel block is loaded, and implicit intersection filtering is performed through mesh indexing, making it suitable for accelerating large-scale scenes.

[0042] In this invention, the pixel block to be rendered can be 3×3 or 4×4 in size. In some other specific application scenarios, the size of the block can be adjusted adaptively.

[0043] The raw data volume for 3D Gaussian rendering is enormous. Traversing all Gaussian points for each pixel block would result in unacceptable computational complexity. Intersection testing uses geometric judgment to pre-exclude Gaussian points that do not overlap with the current block, allowing each pixel block to process only a small number of candidate Gaussian points, thus significantly reducing the amount of data processed subsequently. This step only reads these filtered Gaussian points, avoiding unnecessary memory accesses. This achieves precise trimming of the rendering data stream, reducing memory bandwidth usage and unnecessary load on subsequent computational units, laying a data foundation for efficient coloring.

[0044] In step S102, for the Gaussian points obtained in step S101, Gaussian points with opacity lower than the first threshold are first removed. These points contribute very little to the final color, and discarding them does not affect the visual quality. The first threshold can be set according to multi-level precision requirements, including: (0.02, 0.05] for real-time requirements; (0.01, 0.02] for general requirements; and [0.05, 0.01] for high-precision requirements.

[0045] Then, the remaining Gaussian points are coarsely sorted from near to far according to their projected depth and grouped into multiple segments, such as foreground, midground, and background segments. The number of segments and depth boundaries are configurable. Simultaneously, an intersection mask is generated for each Gaussian point. This mask is a binary bitmap with a bit width equal to the total number of pixels in the pixel block (e.g., a 4×4 block corresponds to 16 bits). Each bit indicates whether the Gaussian point covers the corresponding pixel: 1 for coverage and 0 for non-coverage.

[0046] In some embodiments, Gaussian points are grouped into multiple segments from near to far according to depth information, including: dynamically truncating the first segment closest along the line of sight based on a cumulative contribution rate threshold; for real-time demand scenarios, such as mobile devices and edge devices, requiring the cumulative contribution rate of Gaussian points in the first segment to be at least 90%; for general demand scenarios, such as autonomous driving simulation and digital twins, requiring the cumulative contribution rate of Gaussian points in the first segment to be at least 95%; for high-precision demand scenarios, such as medical imaging and cultural relic digitization, requiring the cumulative contribution rate of Gaussian points in the first segment to be at least 90%.

[0047] The first segment of candidate Gaussian points is traversed in order of depth from near to far, with the contribution weight of each Gaussian point accumulated in real time. The contribution weight of a single Gaussian point can be roughly estimated as the product of its opacity and the current cumulative transmittance, while the cumulative contribution rate is the ratio of the sum of these products to the total contribution. In 3D Gaussian rendering, the contribution of Gaussian points to the final pixel color decreases exponentially along the viewing direction from near to far. Typically, the first 10-20 near-field Gaussian points contribute over 95% of the color information, while the contribution of the numerous distant Gaussian points is extremely weak. This embodiment utilizes this physical law, not fixing the number of Gaussian points in the first segment, but dynamically determining the segment boundaries based on the cumulative contribution threshold. A high threshold of 99% encompasses more near-field points, ensuring image quality; a low threshold of 90% truncates early, reducing the overhead of subsequent variable-precision calculations and shared depth detection.

[0048] In some embodiments, the method further includes: setting a dual constraint on the number of Gaussian points and a depth threshold for the first segment closest along the line of sight, requiring that the number of Gaussian points in the first segment is less than or equal to a second threshold, and the depth of each Gaussian point is less than or equal to a preset depth threshold.

[0049] Specifically, for the first segment closest along the line of sight, two hard constraints are set: the number of Gaussian points in the first segment must not exceed a preset second threshold, such as K_max = 16, 24 or 32; the depth value of each Gaussian point in the first segment must be less than or equal to a preset depth threshold D_max, such as D_max = 0.3.

[0050] When collecting Gaussian points, the system adds Gaussian points to the first segment sequentially from near to far depth. As long as the number of points already added has not reached K_max and the depth of the current Gaussian point is ≤ D_max, it continues to add points. Once the number reaches K_max or a Gaussian point with a depth > D_max is encountered, the collection stops. The remaining Gaussian points are automatically assigned to the mid-range or long-range segment.

[0051] In densely populated near-field regions, the first 20 Gaussian points may have very shallow depths, but an excessive number can lead to a surge in sorting and shared detection overhead. Conversely, in scenes with clear foreground-background separation, once the depth exceeds a certain threshold, Gaussian points often correspond to physically distant objects, and their contribution to the color of near-field pixels becomes negligible. The upper limit constraint on the number of near-field points prevents a single block from processing too many, ensuring deterministic latency in the hardware pipeline. The depth threshold constraint, on the other hand, physically truncates Gaussian points whose contribution is negligible from distant locations. These dual constraints together ensure that the size of the first segment is both controllable and reasonable.

[0052] In some embodiments, the method further includes: for a fixed scene, to statistically analyze the optimal segmentation configuration for each viewpoint during the offline stage, generating a lookup table, which is used to group and segment the Gaussian points according to the configuration in the lookup table during real-time rendering.

[0053] In a fixed scene, the mapping relationship between camera viewpoint and scene depth is deterministic and predictable. The offline phase can tolerate high computational costs to exhaustively search for optimal configurations, while runtime only requires a single table lookup operation to obtain near-optimal performance parameters. This embodiment separates offline optimization from online execution, ensuring both the efficiency of real-time rendering and fully leveraging the optimization potential brought by scene specificity.

[0054] In step S103, the Gaussian points within each depth segment are sorted sequentially from closest to furthest depth. The sorting key is the depth value of the Gaussian point, and the sorting direction is ascending, with the closest points first and the furthest points last. After sorting, a sequential index is created for each Gaussian point, recording its position in the depth sequence of its respective segment. The sorted Gaussian point sequence and its corresponding sequential index are stored in shared memory for access in subsequent steps.

[0055] In step S104, for the first segment that has completed fine sorting, the intersection position mask of each Gaussian point is used as a reference. Figure 5 Find a sequence of overlapping Gaussian points that meets the following conditions: starting from the first Gaussian point or a middle Gaussian point in the sequence, multiple consecutive Gaussian points are simultaneously covered by at least a first number of pixels, and the coloring of these Gaussian points can share the calculation results.

[0056] In some embodiments, the process of finding a sequence of overlapping Gaussian points with a depth that satisfies a first number of pixels based on the intersection position mask, and marking them as shared depths, includes steps S1041 and S1042: Step S1041: Align and combine the intersection position codes of all Gaussian points in the first segment to obtain an intersection position matrix; each row of the intersection position matrix is ​​used to record the intersection position code of one of the Gaussian points, and each row is arranged according to the depth sequence of the Gaussian points. Each column of the intersection position matrix corresponds to each pixel in the current pixel block to be rendered; the intersection position code uses 0 to mark that the Gaussian point and the pixel do not intersect, and uses 1 to mark that the Gaussian point and the pixel do not intersect.

[0057] Step S1042: In each column of the intersection position matrix, find the candidate shared depth that is continuously marked as 1, query the number of times the candidate shared depth appears in each column, and if it is greater than or equal to the first number, mark it as a shared depth; establish a shared depth index to mark the pixels containing the shared depth and the corresponding overlapping Gaussian point depth sequence.

[0058] In step S105, one or more independent shared depth rendering units are used to process the shared depth sequence obtained in step S104. α Hybrid computation. Each shared depth rendering unit contains a color accumulator, a transmissivity register, and a multiply-accumulate unit, following a recursive formula. , Process each Gaussian point in the shared sequence sequentially. After the calculation is complete, obtain the cumulative color of the shared portion. Cumulative transmittance after the shared portion ends And broadcast these two results to the block rendering units corresponding to all pixels within the block.

[0059] Broadcasts are received using block rendering units that correspond one-to-one with pixels. and As the initial state, only the remaining Gaussian points that intersect with the pixel but are not included in the shared depth sequence are processed. During processing, the block rendering unit sets a multi-level rendering precision from high to low according to the Gaussian point depth, including: dividing the Gaussian point depth into near distance group, mid distance group, and far distance group. The near distance group uses FP32 precision for calculation and rendering, the mid distance group uses BF16 precision for calculation and rendering, and the far distance group uses BF8 precision for calculation and rendering.

[0060] On the other hand, the present invention also provides a variable precision 3D Gaussian rendering accelerator based on depth sharing. The accelerator includes: a data extraction and processing unit, multiple segmentation sorting units, multiple shared depth rendering units, and multiple block rendering units, wherein each block rendering unit corresponds one-to-one with a pixel in the pixel block to be rendered.

[0061] The data extraction and processing unit is used to retrieve Gaussian points that intersect with the current pixel block to be rendered, as determined by the intersection test, from the memory. The Gaussian points record three-dimensional spatial position, rotation, scaling, opacity, and color information. The Gaussian points with opacity below a first threshold are discarded. The Gaussian points are grouped into multiple segments from near to far according to the depth information. An intersection position mask is added to each Gaussian point to mark the intersection position with the pixels in the pixel block to be rendered.

[0062] The segmented sorting unit is used to sort the Gaussian points in each segment from near to far in batches, obtain the Gaussian point depth sequence, and establish a sequential index.

[0063] The data extraction and processing unit is also used to find, based on the intersection position mask, the depth sequence of overlapping Gaussian points that exists between a first number of pixels that is closer to the first segment along the line of sight, and mark it as a shared depth; mark the shared depth index corresponding to all shared depths in the first segment; the shared depth index marks the pixels containing the shared depth and the corresponding overlapping Gaussian point depth sequence.

[0064] The shared depth rendering unit is used to color the depth sequence of coincident Gaussian points recorded in the shared depth index, obtain the shared depth coloring result, and broadcast it.

[0065] The block rendering unit synchronously colors the remaining Gaussian points on each segment that intersect with the current pixel and excludes those with shared depth, and combines them with the broadcast shared depth coloring results to obtain the final color information of all pixels on the pixel block to be rendered.

[0066] In some embodiments, the shared depth rendering unit or the block rendering unit has the same structure, including three channels: red, green, and blue, with each channel corresponding to a different deployment: The precision conversion module, located at the input port, is used for hardware-level conversion between FP32, BF16, and INT8. A dual multiplier array, containing two parallel multipliers, which respectively perform the calculation of the effective opacity of the current Gaussian and the calculation of the color contribution of the current Gaussian; A dual adder array, comprising two parallel adders, which respectively perform updates to cumulative transmittance and updates to cumulative color; The cumulative register group contains two dedicated registers, which store the cumulative transmittance and cumulative color of the previous cycle, respectively. The control and multiplexing logic module is used to control the data flow and calculation timing; it is also used to execute segmentation truncation logic to forcibly shut down subsequent calculations when the cumulative transmittance is lower than a set threshold; and it is also used to receive the shared depth staining results and perform the final color merging operation.

[0067] On the other hand, the present invention also provides a computer program product, including a computer program or instructions that, when executed by a processor, implement the steps of the above-described method.

[0068] The present invention will now be described with reference to a specific embodiment: This embodiment provides a variable-precision shared-depth rendering accelerator suitable for 3D Gaussian splashing. This embodiment effectively utilizes the characteristic that the contribution of shading decreases from near to far along the rendering viewpoint, employs a variable-precision calculation mode to effectively reduce hardware overhead and energy consumption, and proposes a shared-depth calculation mode based on the characteristics of the shading formula. This addresses the bottleneck of the shading process's inability to be parallelized to some extent, successfully improving computational parallelism and further increasing calculation speed to meet real-time requirements.

[0069] like Figure 2 This invention demonstrates the core workflow of the invention and provides, for example... Figure 3 The hardware architecture shown generally includes the following stages in its data processing flow: 1. In this embodiment, coloring is performed in units of "blocks", which generally contain 3×3 or 4×4 pixels. First, Gaussian point data that intersects with the current block is read from the memory through intersection testing.

[0070] 2. The Gaussian points are coarsely sorted according to their depth information, and Gaussian points with low opacity are removed. They are roughly divided into several segments according to near, middle and far, and marked with "chk" in the figure. Each segment saves the corresponding Gaussian point index information. At the same time, each Gaussian point obtains a set of intersection position masks to mark which pixels it intersects with in the block.

[0071] 3. Perform fine sorting on the first i segments, where i ≥ 2, depending on the actual number of sorting units configured. Obtain the index order of accurate depth, where chk 0 retains the order of all shared depth Gaussian points according to the configured number of shared depth pixels, and other segments have no special characteristics.

[0072] 3. Use a separate rendering unit (RU) to color the Gaussian points with shared depth, while broadcasting global data to the block rendering module in depth order for the remaining segments, and monitor the opacity information within the pixels in real time. When the opacity is lower than the threshold, segment truncation is performed and coloring is terminated.

[0073] 4. The calculation of the shared depth and the block rendering module are performed in parallel. Once the RU corresponding to a pixel has been colored, it can be merged with the shared depth result to obtain the final color information of the pixel.

[0074] 5. Once all pixels have been colored, the current block is finished. Load the next block of data and continue coloring until all blocks are completed.

[0075] Specifically, such as Figure 4 As shown, the internal structure of each rendering unit (RU) contains three channels: red, green, and blue. The specific calculation mode is determined by the coloring formula.

[0076] Specifically, this embodiment will be described in two parts: (1) Shared depth parallel rendering Observation staining formula: in, To correspond to the Gaussian point color coefficients, it includes three channels: RGB. This is the opacity coefficient, and the accumulation range is all Gaussian points in the current line of sight, from near to far. Indicates the preceding Cumulative transmittance at Gaussian points.

[0077] It can be observed that the calculation of each Gaussian point is related to the calculation results of all Gaussian points before it. To facilitate pipelined implementation, it can be rewritten in the following form: in, Indicates the first The cumulative transmittance after processing at each Gaussian point.

[0078] Indicates to Perform bitwise inversion. To accumulate transmittance, when this value is too low, subsequent Gaussian points contribute little to the color, and rendering can be terminated early.

[0079] Through the above transformation, the current calculation result is only related to the previous calculation and can be stored in a register. It iterates and updates its value every cycle to achieve pipelined computation, thereby enabling the complete mapping of the entire coloring formula to... Figure 3 The hardware structure is shown.

[0080] The above transformation solves the pipeline problem; however, it requires processing hundreds or even thousands of Gaussian points per pixel, resulting in a very long computation cycle. If the depth sequences of Gaussian points corresponding to two pixels overlap to a certain extent, it is called shared depth. The calculation results for this part are completely consistent and can be calculated using an independent coloring unit. The corresponding pixel coloring unit only needs to calculate the non-overlapping part, thereby improving parallelism by increasing a small amount of hardware overhead.

[0081] like Figure 5 As shown, all three Gaussian points in the image intersect with the six pixels in the upper left corner, meaning that the shared depth of these three pixels is at least 3. Considering the general characteristics of real-world scenes, and combining this with pre-removal of Gaussian points with low contribution, the shared depth approach can greatly improve computational parallelism and shorten rendering latency.

[0082] Suppose that in the coloring of a certain block, the shared depth is k, the coloring formula can be further transformed as follows: Among them, the first sum The process is completed through a separate RU, while the remaining part is completed within the corresponding pixel RU. The final color information is obtained by merging the RUs after the corresponding pixel calculations are completed through one multiplication and one addition.

[0083] This method optimizes the parallelism issue in the 3D Gaussian rendering process to some extent. Due to the characteristics of the rendering process, traditional methods are almost unable to perform parallel processing throughout the entire process. On the one hand, they cannot effectively utilize hardware resources, and on the other hand, they directly cause huge rendering delays. This delay is essentially due to a large number of repetitive calculations performed on different pixels. This method makes reasonable use of the mathematical transformation characteristics of the rendering formula, proposes the concept of shared depth, successfully separates the repetitive calculations in the rendering process, and uses a dedicated rendering module to process them, thereby improving the overall parallelism.

[0084] Considering that the colors of real-world objects generally maintain a certain continuity with spatial changes, meaning that a large number of pixels have the same or similar colors, they share a large number of high-contribution Gaussian points during the reconstruction process, resulting in a large shared depth. This also means a significant improvement in parallelism, effectively reducing rendering latency.

[0085] An example is used to verify the effectiveness of this embodiment, as follows: Suppose a patch with s pixels has a total of N Gaussian points and k shared Gaussian points. Considering the simplest configuration, the Gaussian point sequence is divided into only two segments: one with shared Gaussian points and one with non-shared points. Let the sharing ratio be 1 / k. The rate of decrease in computational load is... acceleration ratio This directly affects chip power consumption and chip computing latency. It is evident that the improvement effect of this solution increases with the increase of the sharing ratio; for example, when s=16, At that time, the computational load decreased by about 30%, and the speedup was about 1.4 times.

[0086] The above is just the simplest configuration. In fact, if multiple segments with shared depth are introduced, the acceleration efficiency will be further improved.

[0087] Furthermore, the above computational derivation only reflects the theoretical savings in the number of Gaussian-pixel blending operations achieved by the shared depth mechanism. In actual GPU operation, 3D Gaussian sputtering rendering is also affected by factors such as inconsistent Gaussian point counts between pixels, alpha blending recursion dependencies, thread branch divergence, irregular memory access, sorting synchronization, and insufficient cache reuse, making it difficult to fully convert peak GPU computing power into effective rendering throughput. Simultaneously, GPU thread, instruction, and register scheduling also incur unavoidable additional overhead.

[0088] In contrast, this approach reduces repetitive mixing operations by sharing depth computation, improves hardware utilization of the α-mixing recursion process through a dedicated RU pipeline, and reduces memory access and computation bit width through a variable precision data path. Therefore, the theoretical advantages of this approach are not only reflected in the reduction of computational load, but also in the improvement of effective computing power utilization, on-chip data reuse rate, and rendering throughput per unit power consumption.

[0089] In the traditional 3D Gaussian sputtering coloring process, the color of a single pixel is: ,in: It can be recursively written as: .

[0090] For each Gaussian point, pixel rendering roughly requires the following steps: , , .

[0091] Therefore, the mixing of a Gaussian point with a pixel can be abstracted as a Gaussian-pixel mixing computation unit, with a computational cost of: .

[0092] If the current block needs to be processed For each Gaussian point, the computational complexity in traditional 3D Gaussian sputtering staining is: .

[0093] Consider a number of pixels, e.g., s=9. The total computational cost of a pixel block (of pixels) is: .

[0094] Consider a more general case, assuming the p-th pixel needs If there are 1 Gaussian point, then the total computational cost in the traditional 3D Gaussian sputtering staining process is: .

[0095] For the scheme adopted in this embodiment, assuming the simplest case in the rendering stage, the Gaussian points are divided into two segments: one segment is the shared depth chk0, and the other segment is the remaining Gaussian points chk1.

[0096] Let the shared depth be k, then: .

[0097] This scheme assigns the shared Gaussian points to an independent RU for unified calculation once, so its computational cost is: kb.

[0098] For the non-shared portion, the computational cost is: Therefore, for this scheme, the total computational load can be expressed as: Next, we will analyze the computational complexity, assuming the average number of Gaussian points per pixel is: .

[0099] The computational cost of traditional 3D Gaussian splash staining is: .

[0100] The computational workload of this scheme is as follows: The rate of decrease in computational load: If we assume the shared depth ratio is... .but: .

[0101] Next, we will analyze the acceleration process. Traditional methods typically process one pixel per unit, with multiple units performing the calculations in parallel. Based on this, the algorithm's computational latency can be calculated: .

[0102] In this scheme, the shared portion is computed through a separate RU, with a latency of: .

[0103] The non-shared portion is still computed in parallel by RU, with a latency of: .

[0104] These two parts are actually computed in parallel, so the actual total latency is: This represents the time required for the RU to combine the shared depth calculation results and the non-shared part calculation results of the broadcast, considering two assumptions based on reality, and the fusion delay of the two calculations. ,and .

[0105] Therefore: .

[0106] Therefore, the acceleration ratio is: (2) Variable precision rendering calculation In the standard 3D Gaussian sputtering algorithm, all types of parameters are stored in FP32 format. While this strictly guarantees the accuracy of the calculation results, it also brings huge storage overhead, additional power consumption and processing latency. For edge computing devices whose main design goals are low power consumption and timeliness, it is obviously difficult to meet the requirements by using a single FP32.

[0107] As mentioned earlier, along the line of sight, the contribution of Gaussian points at different depths to the rendered color gradually decreases as the cumulative transmittance and opacity decrease. Analogously, the color perceived by the human eye is often determined by the color of the object in front of us, while occluded objects have almost no effect on the color we see. Based on this characteristic, this design proposes a variable-precision rendering strategy, dynamically adjusting the calculation precision according to distance. Gaussian points at close range have a significant impact on the final color, requiring high precision to ensure accurate results; therefore, FP32 is still used for calculation. For Gaussian points at medium distance, their contribution decreases, but they may still have some impact on color in some cases; therefore, the slightly lower precision but the same numerical range of the half-precision floating-point number BF16 is chosen. For Gaussian points at great distance, the cumulative transmittance is already low, and their contribution to color is negligible in most cases; therefore, the lower precision INT8 is chosen for representation.

[0108] like Figure 6 The standard formats for the three computational precisions used are shown, where S is the sign bit, E is the exponent of the floating-point number (for FP32 and BF16, the exponent has an offset of 127 to represent smaller numbers), and M is the mantissa of the floating-point precision. Therefore, the actual size of the floating-point number can be represented as: Num here is used to mark the numerical part of INT8 precision, which is stored in two's complement form. It can be seen that each reduction in precision can halve the data bandwidth and storage requirements, while lower precision also means lower power consumption and shorter computation time.

[0109] Furthermore, these precision conversions only require shift logic and fixed addition and subtraction, and some computational units can be shared, so the burden on hardware overhead is not particularly severe. This can be achieved through... Figure 7 The logic implements precision conversion.

[0110] Corresponding to the above method, the present invention also provides an apparatus / system including a computer device, the computer device including a processor and a memory, the memory storing computer instructions, the processor executing the computer instructions stored in the memory, and when the computer instructions are executed by the processor, the apparatus / system performs the steps of the method as described above.

[0111] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the aforementioned edge computing server deployment method. The computer-readable storage medium can be a tangible storage medium, such as random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, floppy disks, hard disks, removable storage disks, CD-ROMs, or any other form of storage medium known in the art.

[0112] In summary, the depth-sharing-based variable-precision 3D Gaussian rendering method and accelerator described in this invention addresses the shortcomings of existing processors in 3D Gaussian rendering speed and the real-time requirements of practical applications. It designs a rendering accelerator that meets the demands for rendering speed and low power consumption in real-world scenarios. Based on the mathematical characteristics of the 3D Gaussian rendering formula, this invention proposes a "shared depth" rendering scheme. By using a dedicated rendering unit to merge redundant calculations generated by Gaussian points at shared depth, it effectively eliminates some redundant calculations, improves hardware parallelism, reduces rendering latency, and meets real-time requirements. Furthermore, this invention proposes a variable-precision rendering process, rationally utilizing the general characteristics of the rendering process. It uses three different precisions—FP32, BF16, and INT8—to render Gaussian points at different depths, further reducing rendering latency and power consumption.

[0113] Those skilled in the art will understand that the exemplary components, systems, and methods described in conjunction with the embodiments disclosed herein can be implemented in hardware, software, or a combination of both. Whether implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this invention. When implemented in hardware, it can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc. When implemented in software, the elements of this invention are programs or code segments used to perform the desired tasks. The programs or code segments can be stored in a machine-readable medium or transmitted over a transmission medium or communication link via data signals carried on a carrier wave.

[0114] It should be clarified that the present invention is not limited to the specific configurations and processes described above and shown in the figures. For the sake of brevity, detailed descriptions of known methods are omitted here. In the above embodiments, several specific steps are described and shown as examples. However, the method process of the present invention is not limited to the specific steps described and shown. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of the present invention.

[0115] In this invention, features described and / or illustrated for one embodiment may be used in the same or similar manner in one or more other embodiments, and / or combined with or in place of features of other embodiments.

[0116] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, various modifications and variations of the embodiments of the present invention are possible. 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.

Claims

1. A variable-precision 3D Gaussian rendering method based on depth sharing, characterized in that, The coloring process is performed on multiple pixel blocks to be rendered one by one until all are completed. The coloring steps for each pixel block to be rendered include: Retrieve from memory the Gaussian point that intersects with the current pixel block to be rendered, as determined by an intersection test. The Gaussian point records the three-dimensional spatial position, rotation, scaling, opacity, and color information. Remove the Gaussian points with opacity below a first threshold, and group the Gaussian points into multiple segments from near to far according to depth information; add an intersection position mask to each Gaussian point to mark the intersection position with the pixels in the pixel block to be rendered; The Gaussian points in each segment are sorted by depth from near to far in batches to obtain a Gaussian point depth sequence and establish a sequential index. For the first segment closest along the line of sight, find the depth sequence of overlapping Gaussian points that exists between a first number of pixels according to the intersection position mask, and mark it as a shared depth; mark the shared depth index corresponding to all the shared depths in the first segment; the shared depth index mark includes the pixels of the shared depth and the corresponding overlapping Gaussian point depth sequence; Multiple independent shared depth rendering units are used to color the overlapping Gaussian point depth sequence recorded in the shared depth index to obtain the shared depth coloring result and broadcast it; block rendering units that correspond one-to-one with the pixels in the pixel block to be rendered are used to simultaneously color the remaining Gaussian points on each segment that intersect with the current pixel and exclude the shared depth, and combine them with the broadcast shared depth coloring result to obtain the final color information of all pixels on the pixel block to be rendered; The block rendering unit is configured with multi-level rendering precision from high to low according to the Gaussian point depth from near to far.

2. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 1, characterized in that, The intersection test employs axis-aligned bounding box intersection test, geometry-aware discretized bounding box intersection test, Gaussian shape-aware intersection test, or Gaussian-mesh intersection test. The pixel block to be rendered adopts a 3×3 or 4×4 specification; The first threshold is set according to multi-level precision requirements, including: (0.02, 0.05] for real-time requirements; (0.01, 0.02] for general requirements; and [0.05, 0.01] for high-precision requirements.

3. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 1, characterized in that, The Gaussian points are grouped into multiple segments from near to far according to depth information, including: For the first segment that is closest along the line of sight, dynamic truncation is performed based on the cumulative contribution rate threshold. For real-time scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 90%. For general scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 95%. For high-precision scenarios, the cumulative contribution rate of the Gaussian points in the first segment is required to be at least 90%.

4. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 3, characterized in that, The method further includes: For the first segment that is closest along the line of sight, a dual constraint is set on the number of Gaussian points and the depth threshold. The requirement is that the number of Gaussian points in the first segment is less than or equal to the second threshold, and the depth of each Gaussian point is less than or equal to the preset depth threshold.

5. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 3, characterized in that, The method further includes: For a fixed scenario, during the offline phase, it is necessary to statistically analyze the optimal segmentation configuration for each viewpoint and generate a lookup table. This table is used to group and segment the Gaussian points according to the configuration in the lookup table during real-time rendering.

6. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 1, characterized in that, Based on the intersection position mask, find the depth sequence of overlapping Gaussian points that satisfy a first number of pixels, and mark them as shared depths, including: The intersection position codes of all Gaussian points in the first segment are aligned and combined to obtain an intersection position matrix; each row of the intersection position matrix is ​​used to record the intersection position code of one Gaussian point, and the rows are arranged according to the depth sequence of the Gaussian points. Each column of the intersection position matrix corresponds to each pixel in the current pixel block to be rendered; the intersection position code uses 0 to mark that the Gaussian point and the pixel do not intersect, and uses 1 to mark that the Gaussian point and the pixel do not intersect. In each column of the intersection position matrix, find candidate shared depths that are continuously marked as 1, query the number of times the candidate shared depth appears in each column, and if it is greater than or equal to a first number, mark it as a shared depth; establish the shared depth index to mark the pixels containing the shared depth and the corresponding coincident Gaussian point depth sequence.

7. The variable-precision 3D Gaussian rendering method based on depth sharing according to claim 1, characterized in that, The block rendering unit is configured with multiple levels of rendering precision, from high to low, according to the Gaussian point depth from near to far, including: The distance is divided into a near distance group, a medium distance group, and a far distance group according to the depth of the Gaussian point. The near distance group is rendered with FP32 precision, the medium distance group is rendered with BF16 precision, and the far distance group is rendered with BF8 precision.

8. A variable-precision 3D Gaussian rendering accelerator based on depth sharing, characterized in that, The accelerator includes: a data extraction and processing unit, multiple segmentation and sorting units, multiple shared depth rendering units, and multiple block rendering units, wherein each block rendering unit corresponds one-to-one with a pixel in a pixel block to be rendered. The data extraction and processing unit is used to retrieve Gaussian points that intersect with the current pixel block to be rendered, as determined by an intersection test, from the memory. These Gaussian points record three-dimensional spatial position, rotation, scaling, opacity, and color information. The unit then discards Gaussian points with opacity below a first threshold, groups the Gaussian points into multiple segments from near to far according to depth information, and adds an intersection position mask to each Gaussian point to mark its intersection position with pixels in the pixel block to be rendered. The segmented sorting unit is used to sort the Gaussian points in each segment from near to far in batches to obtain a Gaussian point depth sequence and establish a sequential index. The data extraction and processing unit is further configured to, for the first segment closest along the line of sight, find the depth sequence of overlapping Gaussian points that satisfy a first number of pixels existing between the intersection position mask, and mark them as shared depths; mark the shared depth index corresponding to all the shared depths in the first segment; the shared depth index mark includes the pixels of the shared depth and the corresponding overlapping Gaussian point depth sequence; The shared depth rendering unit is used to color the coincident Gaussian point depth sequence recorded in the shared depth index, obtain the shared depth coloring result, and broadcast it. The block rendering unit synchronously colors the remaining Gaussian points on each segment that intersect with the current pixel and excludes the shared depth, and combines the coloring results with the broadcast shared depth to obtain the final color information of all pixels on the pixel block to be rendered.

9. The depth-sharing-based variable-precision 3D Gaussian rendering accelerator according to claim 8, characterized in that, The shared depth rendering unit or the block rendering unit has the same structure, containing three channels: red, green, and blue, with each channel deployed accordingly: The precision conversion module, located at the input port, is used for hardware-level conversion between FP32, BF16, and INT8. A dual multiplier array, containing two parallel multipliers, which respectively perform the calculation of the effective opacity of the current Gaussian and the calculation of the color contribution of the current Gaussian; A dual adder array, comprising two parallel adders, which respectively perform updates to cumulative transmittance and updates to cumulative color; The cumulative register group contains two dedicated registers, which store the cumulative transmittance and cumulative color of the previous cycle, respectively. The control and multiplexing logic module is used to control the data flow and calculation timing; it is also used to execute segmentation truncation logic to forcibly shut down subsequent calculations when the cumulative transmittance is lower than a set threshold; and it is also used to receive the shared depth staining results and perform the final color merging operation.

10. A computer program product, comprising a computer program or instructions, characterized in that, When the computer program or instructions are executed by a processor, they implement the steps of the method according to any one of claims 1 to 7.

Images