# SafeguardGS: 3D Gaussian Primitive Pruning
While Avoiding Catastrophic Scene Destruction

Yongjae Lee
Johns Hopkins University
Baltimore, MD 21218
<EMAIL_ADDRESS>
&Zhaoliang Zhang
Johns Hopkins University
Baltimore, MD 21218
<EMAIL_ADDRESS>
&Deliang Fan
Johns Hopkins University
Baltimore, MD 21218
<EMAIL_ADDRESS>

###### Abstract

3D Gaussian Splatting (3DGS) has made a significant stride in novel view
synthesis, demonstrating top-notch rendering quality while achieving real-time
rendering speed. However, the excessively large number of Gaussian primitives
resulting from 3DGS’ suboptimal densification process poses a major challenge,
slowing down frame-per-second (FPS) and demanding considerable memory cost,
making it unfavorable for low-end devices. To cope with this issue, many
follow-up studies have suggested various pruning techniques, often in
combination with different score functions, to optimize rendering performance.
Nonetheless, a comprehensive discussion regarding their effectiveness and
implications across all techniques is missing. In this paper, we first
categorize 3DGS pruning techniques into two types: Cross-view pruning and
pixel-wise pruning, which differ in their approaches to rank primitives. Our
subsequent experiments reveal that while cross-view pruning leads to
disastrous quality drops under extreme Gaussian primitives decimation, the
pixel-wise pruning technique not only sustains relatively high rendering
quality with minuscule performance degradation but also provides a reasonable
minimum boundary for pruning. Building on this observation, we further propose
multiple variations of score functions and empirically discover that the
color-weighted score function outperforms others for discriminating
insignificant primitives for rendering. We believe our research provides
valuable insights for optimizing 3DGS pruning strategies for future works.

##  1 Introduction

The emergence of Neural Radiance Fields (NeRFs) (Mildenhall et al., 2020;
Barron et al., 2021, 2022) has presented an opportunity for quality
enhancement with advanced detail in various fields, such as computer vision
(Xie et al., 2021; Mirzaei et al., 2023; Li et al., 2023a; Wang et al., 2023),
robotics (Yen-Chen et al., 2021; Rosinol et al., 2023; Zhu et al., 2023), and
extended reality (Deng et al., 2022; Shen et al., 2023). The key concept that
enables NeRF to achieve photorealistic rendering is encoding 3D scenes with
their view-dependent effects into a series of multi-layer perceptrons (MLPs)
and synthesizing novel views using alpha-blending with an appropriate color
sampling strategy. However, the deep MLP structure and the high-cost volume
rendering technique result in substantial computational overhead, hindering
prevalent adoption in real-time applications. This has prompted subsequent
research to focus on developing specialized data structures (Yu et al., 2021a;
Chen et al., 2022a; Fridovich-Keil et al., 2022; Müller et al., 2022),
sophisticated sampling strategies (Neff et al., 2021; Kurz et al., 2022; Li et
al., 2023b), and incorporating deferred rendering techniques (Hedman et al.,
2021; Chen et al., 2023) in an effort to improve rendering efficiency.

The recent approach of 3D Gaussian Splatting (3DGS) (Kerbl et al., 2023) has
demonstrated remarkable success in high-quality 3D scene encoding, achieving
high-fidelity scene rendering at the real-time level. Unlike previous NeRF
methods (Mildenhall et al., 2020; Yu et al., 2021a; Müller et al., 2022),
which implicitly represent 3D scenes using MLPs with dedicated data
structures, 3DGS explicitly models scenes with parameterized 3D Gaussian
primitives. To generate view-dependent images, the primitives are projected
onto the image plane and rasterized by accumulating resampled colors using
alpha-blending for each pixel ray, a process called Splatting (Zwicker et al.,
2001a, b). In terms of implementation details, 3DGS further optimizes the
rasterization by grouping and processing the primitives together in 16x16
tiles.

Despite the diligent efforts of 3DGS to maximize rendering efficiency, it
still falls short due to the challenge of primitive booming. During the
densification stage, where primitives are cloned and split to rectify
erroneously reconstructed regions, they often proliferate excessively,
resulting in tons of primitives. This explosive growth in the number of
primitives puts heavy pressure on computer working memory, leading to severe
rendering latency. Meanwhile, as highlighted by Fan et al. (2023), the
majority of these primitives have negligible importance and can be eliminated
without adversely affecting the quality of the rendered output. Recognizing
this, several recent studies (Fan et al., 2023; Lee et al., 2024; Fang and
Wang, 2024; Niemeyer et al., 2024; Liu et al., 2024) have proposed various
Gaussian primitive pruning techniques to detect and remove insignificant
primitives. However, these techniques have not been comprehensively explored.
There is a risk of significant quality degradation with improper selection of
pruning settings, as shown in Fig. 1.

Figure 1: The cross-view pruning technique can result in seriously degraded
scene reconstruction when used with inappropriate pruning settings. It is
crucial to empirically determine the maximum pruning ratio to avoid
detrimental scene destruction. We reproduce images using the pruning technique
from RadSplat (Niemeyer et al., 2024). The text beneath each image indicates
the score threshold, PSNR, and the number of primitives.

In this paper, we propose SafeguardGS, which inherently imposes a limit on the
pruning ratio to prevent hazardous scene destruction and demonstrates superior
pruning performance under extreme conditions compared to existing techniques.
Initially, through a thorough examination of existing Gaussian primitive
pruning techniques, we observe an interesting pattern: some techniques perform
robustly even under aggressive pruning settings, while others do not. We
figure out that the primary distinction is that the former methods rank and
prune based on the global importance of primitives (by accumulating or
maximizing each primitive’s score across views), while the latter methods
identify and prune unimportant primitives for each ray individually. Building
on this observation, we classify 3DGS pruning techniques into two categories.
The first category (the former methods), cross-view pruning, maintains quality
well at low pruning ratios but experiences a drastic drop at relatively high
ratios. The second category (the latter methods), pixel-wise pruning,
consistently produces decent results even at the maximum pruning ratio.
Subsequently, we propose multiple importance score functions that measure each
primitive’s significance in different degrees and benchmark their performance.
Our experiments demonstrate that $Score_{v13}$ is the most efficient technique
among the proposed score functions and existing techniques.

We summarize our contributions as:

  * •

We classify Gaussian primitive pruning techniques into two categories: cross-
view pruning and pixel-wise pruning. To the best of our knowledge, this work
is the first attempt to categorize these pruning techniques.

  * •

Based on empirical study, we propose an optimal pruning technique with a
color-weighted score function, which prevents catastrophic destruction of
rendering quality.

  * •

We present copious experimental results on Gaussian primitive pruning using
multiple variations of score functions.

##  2 Related Work

###  2.1 Neural Radiance Fields

In recent decades, numerous methods for reconstructing and representing 3D
scenes have attracted significant interest in both computer vision and
graphics fields. Traditionally, structure-from-motion (SfM) (Snavely et al.,
2006) and multi-view stereo (MVS) (Goesele et al., 2007) have been utilized to
estimate camera parameters from a collection of images and build dense 3D
point representations of object shapes in these images. Subsequently, the
streamlined software architecture of SfM and MVS, known as COLMAP (Schönberger
et al., 2016; Schönberger and Frahm, 2016), has become the de facto practice
for generating virtual 3D scenes.

Meanwhile, the groundbreaking approach of NeRF (Mildenhall et al., 2020),
which represents colors and shapes by multi-layer perceptrons (MLPs) encoded
features and reconstructs novel view images by synthesizing the features with
the volume rendering technique, has advanced rendering quality towards
photorealism. The success of NeRF has led to its application in various
fields, including image processing (Czerkawski et al., 2024), simultaneous
localization and mapping (Zhu et al., 2023; Rosinol et al., 2023), generative
modeling (Niemeyer and Geiger, 2021; Gu et al., 2021; Schwarz et al., 2020),
and human modeling (Gao et al., 2022; Chen et al., 2022b).

Unsurprisingly, among the many challenges in NeRF, such as reconstructing
unbounded 3D scenes (Zhang et al., 2020), data sparsity (Yu et al., 2021b;
Wang et al., 2021), inconsistent data (Martin-Brualla et al., 2021), noisy
data (Ma et al., 2022), and temporal data (Li et al., 2021; Gao et al., 2021),
enhancing the efficiency of both rendering and memory has become a significant
concern. A notable contribution to efficient NeRF methods is by Sun et al.
(2022), who identified the bottleneck in MLPs and proposed a hybrid
representation combining voxel grids of features with shallow MLPs.
Furthermore, Fridovich-Keil et al. (2022) achieved faster rendering speeds
through completely MLP-less grids by employing spherical harmonics (SH).
Alternatively, other grid-based methods have proposed using more efficient
data structures to avoid the high memory strain from dense grids, such as
tensor decomposition (Chen et al., 2022a), hash tables (Müller et al., 2022),
octrees (Yu et al., 2021a), and feature quantization (Shin and Park, 2024).
Although their endeavors have demonstrated rapid scene convergence and
improved image quality compared to traditional MLP-based NeRF methods, grid-
based methods are not yet deemed perfect due to limitations in bounded image
quality imposed by the selection of data structure for grids and hindered
forward-pass speed caused by the inherent multiple sampling approach in the
volume rendering technique.

###  2.2 Compact 3D scene representation with Gaussian primitives

3D Gaussian Splatting (3DGS) (Kerbl et al., 2023) has achieved unprecedented
results, establishing a new standard for balancing rendering quality and
speed. This remarkable accomplishment is attributed to its MLP-less 3D
representation, which employs 3D Gaussians characterized by mean, variance,
color, and opacity, enabling real-time high-quality rendering. Additionally,
the explicit 3D scene representation facilitates the use of the typical
graphics rendering method, rasterization, allowing full parallelism of the
GPU.

Despite its state-of-the-art improvement, the densification algorithm of 3DGS
(Kerbl et al., 2023), which populates new Gaussians in unreconstructed
regions, often leads to millions of Gaussians occupying vast memory space in
the machine, posing a major new challenge. Initially, the authors addressed
this issue by regularly pruning unimportant Gaussians evaluated by their
opacity as lower than a predefined threshold. However, (Fan et al., 2023) has
proven that this strategy does not effectively decrease the number of
Gaussians. They showed that an additional 60% pruning, detected by their
proposed Gaussian importance evaluation metric, is possible without
sacrificing quality. Similarly, concurrent works have proposed distinct
importance metrics to identify unimportant Gaussians (Niemeyer et al., 2024;
Fang and Wang, 2024; Lee et al., 2024; Liu et al., 2024); however, their
implications, particularly the characteristics that should be considered in
designing the metric, remain undisclosed.

##  3 Gaussian primitive pruning technique

###  3.1 Background

#### 3D Gaussian Splatting.

3D Gaussian Splatting (3DGS) Kerbl et al. (2023) represents a 3D scene using a
set of $N$ 3D Gaussians as geometric primitives. Each Gaussian primitive
$\\{\mathbf{G}_{i}\mid i=1,2,3,\ldots,N\\}$ is parameterized by a center
position (mean) vector $\mathbf{x}_{i}\in\mathbb{R}^{3}$, a scale vector
$\mathbf{s}_{i}\in\mathbb{R}^{3}$, a rotation vector
$\mathbf{r}_{i}\in\mathbb{R}^{4}$, an opacity value
$\mathbf{o}_{i}\in\mathbb{R}^{1}$, and $k$ Spherical Harmonics (SH)
coefficients $\mathbf{f}_{i}\in\mathbb{R}^{k}$. In practice, the opacity value
is activated by a sigmoid function to bound the range to
$\bm{\sigma}_{i}=\sigma(\mathbf{o}_{i})\in[0,1]$. Moreover, the SH degree is
set to three, resulting in a total of 59 parameters.

In the initialization of the Gaussian primitives, 3DGS uses an SfM-generated
sparse point cloud (Snavely et al., 2006) if available, or alternatively, it
randomly initializes a fixed number of Gaussians with positions and SH
coefficients drawn from a uniform distribution. During the first half of 3DGS
training, the densification process is employed to augment the number of
primitives, addressing improperly represented geometries (i.e., under-
reconstruction and over-reconstruction) and inadequately emerged floaters.
After the densification stage, the number of primitives ramains constant, and
only the remaining primitives are further optimized.

To rasterize the primitives into a pixel using the Splatting technique
(Zwicker et al., 2001a, b), 3DGS first selects the primitives projected by the
ray and sorts them by their distance from the camera. Then, the 2D Gaussian
$\mathcal{G}_{i}$, projected onto the image plane, is computed by considering
both the Gaussian definition
$G(\mathbf{x})=\textsf{exp}(-\frac{1}{2}\mathbf{x}^{T}\mathbf{\Sigma}^{-1}\mathbf{x})$
and the covariance matrix $\mathbf{\Sigma^{\prime}}$ in camera coordinates,
which is
$\mathbf{\Sigma^{\prime}}=\mathbf{JW\Sigma}\mathbf{W}^{T}\mathbf{J}^{T}$.
Here, $\mathbf{W}$ is the view transform matrix, and $\mathbf{J}$ is the
Jacobian of the affine-approximated projective transform matrix. Furthermore,
the 3D covariance matrix $\mathbf{\Sigma}$ in world coordinates is defined by
$\mathbf{\Sigma}=\mathbf{RS}\mathbf{S}^{T}\mathbf{R}^{T}$, where the rotation
matrix $\mathbf{R}$ and the scale matrix $\mathbf{S}$ are derived from their
vector forms. The final color $\mathbf{C}$ of the pixel is determined by
progressively accumulating the colors of the projected 2D Gaussians, from the
nearest to the farthest from the camera, through alpha blending. Formally,

$\mathbf{C}=\sum_{i\in N}c_{i}\alpha_{i}T_{i}\text{,\hskip 14.22636pt where
}\alpha_{i}=\bm{\sigma}_{i}\mathcal{G}_{i}\text{ and
}T_{i}=\prod_{j=1}^{i-1}(1-\alpha_{i}).$ (1)

The view-dependent appearance $c_{i}$ of Gaussian primitive $\mathbf{G}_{i}$
is computed from its SH coefficients $\mathbf{f}_{i}$.

#### Gaussian primitive pruning.

The required model size to represent a 3D scene with Gaussian primitives
increases proportionally with the number of primitives. To control the number
of primitives, 3DGS introduces the densification process. However, its naive
approach of duplicating and removing primitives seems suboptimal and tends to
proliferate millions of primitives, as discussed by the authors. For example,
a scene represented by one million primitives with full-precision parameter
values results in a memory pressure of approximately 225MB. Moreover, since
the differentiable rasterizer orders the primitives and accesses them from the
nearest to the farthest on a pixel-by-pixel basis, an excessive number of
primitives critically hampers rendering speed as well as burdens rendering
memory.

Many recent works focus on this problem by proposing methods to prune
primitives based on specific criteria. The common approach involves defining a
metric to quantify each primitive’s importance and generating a mask to
identify primitives that meet a specific pruning setting (such as pruning
ratio, score threshold, or ranking threshold) based on the evaluated
importance. For instance, LightGaussian (Fan et al., 2023) defines a global
significance score depending on a primitive’s opacity $\mathbf{o}_{i}$ and
adaptively normalized volume
$\gamma_{i}=(\min(\max(\frac{\prod\mathbf{s}_{i}}{\prod\mathbf{s}_{max90}},0),1)^{0.1}$
by the 90% largest primitive in the scene, across all training views, and
prunes primitives whose importance falls below a pre-selected pruning ratio.
Similarly, Mini-Splatting (Fang and Wang, 2024) defines an importance score
that primarily measures a primitive’s contribution (i.e., $\alpha_{i}T_{i}$ in
Eq. 1) to the rendered pixel colors. The number of primitives is controlled by
a predefined pruning ratio, but unlike LightGaussian, Mini-Splatting uses
importance scores as the sampling probability for each primitive, and they are
stochastically sampled to better maintain overall geometry with the pruning
ratio. However, accumulating the importance of each primitive to every pixel
may become overly sensitive to certain types of scene coverage, exaggerating
importance when a primitive has a high hit count. To address this, (Niemeyer
et al., 2024) proposes using the max operator instead of summation and
identifies primitives for pruning when their maximum contribution across rays
falls below a predefined score threshold. Similarly, (Liu et al., 2024)
employs the same idea of primitive’s contribution but with a different pruning
setting, independently determining the top-K dominant primitives with
significant contributions for each pixel and pruning those ranked lower than
the predefined K-th rank. The score functions used in these studies are
summarized as follows:

  * •

$Score_{LG}(\mathbf{G}_{i})=\sum_{r=1}^{MWH}\mathbbm{1}(\mathbf{G}_{i},r)\cdot\mathbf{\sigma}_{i}\cdot\gamma_{i}$,
(Fan et al., 2023)

  * •

$Score_{MS}(\mathbf{G}_{i})=\sum_{r=1}^{MWH}\mathbbm{1}(\mathbf{G}_{i},r)\cdot\alpha_{i}\cdot
T_{i}$, (Fang and Wang, 2024)

  * •

$Score_{RS}(\mathbf{G}_{i})=\max_{r=1}^{MWH}\mathbbm{1}(\mathbf{G}_{i},r)\cdot\alpha_{i}\cdot
T_{i}$, (Niemeyer et al., 2024)

  * •

$Score_{EG}(\mathbf{G}_{i},r)=\alpha_{i}\cdot T_{i}$, (Liu et al., 2024)

Here, $\mathbbm{1}(\mathbf{G}_{i},r)$ represents an indicator function,
indicating whether the Gaussian primitive $\mathbf{G}_{i}$ intersects with the
ray $r$ or not. $Score(\mathbf{G}_{i})$ evaluates the contribution of the
primitive across all rays, while $Score(\mathbf{G}_{i},r)$ assesses its
contribution with respect to the ray $r$.

###  3.2 Categorization of Gaussian primitive pruning techniques

The aforementioned pruning techniques utilize distinct pruning scores and
settings. Essentially, they can be categorized into two groups depending on
whether the score evaluation considers all rays collectively or each ray
independently.

Figure 2: Given a set of Gaussian primitives $\mathbf{G}_{i}$, cross-view
pruning (middle) evaluates the importance of each primitive by considering
their contributions to each ray through accumulation or max operations. In
contrast, pixel-wise pruning (right) evaluates the contributions to each ray
independently, resulting in a safer pruning approach. In this example of using
aggressive pruning settings, pixel-wise pruning technique keeps 75% of
primitives, while cross-view pruning only saves $\mathbf{G}_{4}$.

#### Cross-view pruning.

One technique for identifying Gaussian primitives to be pruned involves
evaluating the Gaussian primitives $\mathbf{G}_{i}$ at a global level (Fan et
al., 2023; Fang and Wang, 2024; Niemeyer et al., 2024). The term ’cross-view
pruning’ is coined from the concept that each primitive is collectively
evaluated considering its contribution to every pixel. As illustrated in the
middle figure in Fig. 2, the score of each Gaussian primitive $\mathbf{G}_{i}$
is evaluated, considering all rays intersecting the primitive. Once the score
of each primitive is computed, those with values falling below the pruning
ratio or below a score threshold are pruned.

#### Pixel-wise pruning.

Another technique for determining which Gaussian primitives should be pruned
involves generating a mask on a pixel-wise basis (Liu et al., 2024). The term
’pixel-wise pruning’ is coined from the concept that each primitive is
evaluated with respect to each ray and is masked if it never reaches the
ranking threshold in any ray. As illustrated in the right figure in Fig. 2,
each primitive $\mathbf{G}_{i}$ has multiple scores evaluated with respect to
rays intersecting with $\mathbf{G}_{i}$, and they are ranked along each ray.
For example, when the $n$-th ranking threshold is applied, the primitive
$\mathbf{G}_{1}$ has only one intersection with Ray A, thus having one score,
which is the lowest among the primitives ($\mathbf{G}_{1}$, $\mathbf{G}_{2}$,
and $\mathbf{G}_{4}$) intersecting with Ray A, eligible to be pruned. On the
other hand, the primitive $\mathbf{G}_{4}$ has three scores with respect to
Ray A, Ray B, and Ray C. Although it is ranked as the second-highest for Ray A
and Ray C, it is preserved because its score with respect to Ray B is the
highest among the primitives intersecting with Ray B. Theoretically, this
technique ensures that each ray intersects with at most $n$ primitives.

#### Cross-view vs. pixel-wise.

Figure 3: PSNR evaluations were conducted on the Bicycle scene from MipNeRF360
(Barron et al., 2022) using various pruning settings. With fewer than 1
million primitives, the pixel-wise pruning technique (dark blue line) safely
reconstructs the scene. In contrast, cross-view pruning techniques (orange
lines) indiscriminately prune the primitives, reducing them to fewer than 0.45
million.

To explore the implications of cross-view pruning and pixel-wise pruning, we
trained 3DGS using both pruning techniques, each with varying pruning
settings. For the cross-view pruning technique, we varied the pruning ratio of
LightGaussian (Prune_LG) (Fan et al., 2023) from 0.05 to 0.95 with a step size
of 0.05, the score threshold of RadSplat (Prune_RS) (Niemeyer et al., 2024)
with 0.01 and from 0.05 to 0.95 with a step size of 0.05, and the pruning
ratio of Mini-Splatting (Prune_MS) (Fang and Wang, 2024) from 0.05 to 0.95
with a step size of 0.05. For the pixel-wise pruning technique, we tested the
ranking threshold of EfficientGS (Prune_EG) (Liu et al., 2024) with values of
1, 5, 10, and 30. In Fig. 3, we observed that the PSNR value of both
techniques began to drop at around 1.5 million Gaussian primitives. However,
interestingly, their slopes differed. While the cross-view pruning technique
indiscriminately pruned until nothing remained, the pixel-wise pruning
technique avoided over-decimation of the primitives, maintaining at least
around 0.45 million Gaussian primitives. This is because, practically, the
minimum ranking threshold for the pixel-wise technique is 1, ensuring at least
one Gaussian primitive is saved from pruning for each pixel of the training
images. In the case of cross-view pruning, such a safe boundary is not
provided and needs to be empirically determined.

###  3.3 Importance score for pruning

Both cross-view pruning and pixel-wise pruning techniques require defining a
function to score the importance of a Gaussian primitive, as discussed in
Section 3.1. Furthermore, we have demonstrated in the previous section that
even with aggressive pruning settings, pixel-wise pruning can reasonably
preserve scene quality (Prune_EG with a ranking threshold of 1 in Fig. 3
achieves a PSNR of 24.63 with 452k primitives). However, this is still of
lower quality compared to vanilla 3DGS (PSNR of 25.11). Fig. 4 (a) and (b)
compare the rendered image of fully trained vanilla 3DGS and the rendered
image immediately after pruning by Prune_EG with a ranking threshold of 1.
This juxtaposition suggests that the score function of EfficientGS is
insufficiently sensitive to the color difference between the primitive and the
pixel during pruning, resulting in the loss of high-frequency areas when the
Gaussian primitives are pruned too aggressively. Based on this observation, we
revisit the importance function and propose variations that take the color
disparity between the Gaussian primitive and the pixel into account, as
follows:

  * •

Variant 1: $Score_{v1}(\mathbf{G}_{i},r)=\mathbf{\sigma}_{i}$,

  * •

Variant 2: $Score_{v2}(\mathbf{G}_{i},r)=\alpha_{i}$

  * •

Variant 3: $Score_{v3}(\mathbf{G}_{i},r)=\Delta T_{i}$

  * •

Variant 4: $Score_{v4}(\mathbf{G}_{i},r)=exp(-||X_{P}-X_{i}||_{2})$

  * •

Variant 5:
$Score_{v5}(\mathbf{G}_{i},r)=exp(-||X_{P}-X_{i}||_{2})\cdot\alpha_{i}$

  * •

Variant 6:
$Score_{v6}(\mathbf{G}_{i},r)=exp(-||X_{P}-X_{i}||_{2})\cdot\alpha_{i}\cdot
T_{i}$

  * •

Variant 7:
$Score_{v7}(\mathbf{G}_{i},r)=exp(-||X_{P}-X_{i}||_{2})\cdot\alpha_{i}\cdot\Delta
T_{i}$

  * •

Variant 8:
$Score_{v8}(\mathbf{G}_{i},r)=cosine\\_similarity(\mathbf{C}_{GT},c_{i})$

  * •

Variant 9:
$Score_{v9}(\mathbf{G}_{i},r)=1-mean(||\mathbf{C}_{GT}-c_{i}||_{1})$

  * •

Variant 10:
$Score_{v10}(\mathbf{G}_{i},r)=exp(-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))$

  * •

Variant 11:
$Score_{v11}(\mathbf{G}_{i},r)=exp(-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot\alpha_{i}$

  * •

Variant 12:
$Score_{v12}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot\alpha_{i}$

  * •

Variant 13:
$Score_{v13}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot\alpha_{i}\cdot
T_{i}$

  * •

Variant 14:
$Score_{v14}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot\Delta
T$

  * •

Variant 15:
$Score_{v15}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot
exp(-||X_{P}-X_{i}||_{2})$

  * •

Variant 16:
$Score_{v16}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot
exp(-||X_{P}-X_{i}||_{2})\cdot\alpha_{i}$

  * •

Variant 17:
$Score_{v17}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot
exp(-||X_{P}-X_{i}||_{2})\cdot\alpha_{i}\cdot T_{i}$

  * •

Variant 18:
$Score_{v18}(\mathbf{G}_{i},r)=(1-mean(||\mathbf{C}_{GT}-c_{i}||_{1}))\cdot
exp(-||X_{P}-X_{i}||_{2})\cdot\Delta T$

Through experimentation, we have discovered that the 13th variant better
preserves high-frequency areas compared to the score function of EfficientGS
(Prune_EG), as depicted in Fig. 4 (c) and (d).

Figure 4: The importance score function of EfficientGS
($Score_{EG}(\mathbf{G}_{i},r)=\alpha_{i}\cdot T_{i}$) lacks consideration of
the colors of Gaussian primitives, resulting in the loss of high-frequency
information during pruning, as indicated by the white holes on the wheel axle
marked by red arrows in (a) and (b). Our carefully designed new score
function, $Score_{v13}(\mathbf{G}_{i},r)$, which is sensitive to the color
disparity between the primitive color and the ground truth pixel value, helps
preserve the details, as shown in (c) and (d).

wheel axle

##  4 Experimental results

###  4.1 Experimental setup

#### Implementation details.

Thanks to the open-source code of vanilla 3DGS (Kerbl et al., 2023), we
readily build our experimental platform. We implement the Gaussian primitive
pruning techniques upon 3DGS’ Python code. Furthermore, we extended the CUDA
differentiable 3DSG rasterizer to include the score function variants. We make
our code publicly available to contribute to future studies: [web link].

We train each technique for 30k iterations, using four NVIDIA RTX A5000 GPUs.
During training, we apply the pruning techniques once at 20k for fair
comparison. For other settings (e.g., learning rates, scheduling of spherical
harmonics degree increment, and densification process), we follow the vanilla
3DGS configuration and keep consistency across all pruning techniques and
datasets.

#### Datasets and Metrics.

For the comprehensive comparison of pruning techniques and the effectiveness
of importance score functions, we train each pruning technique on various
datasets including Synthetic NeRF (Mildenhall et al., 2020), MipNeRF360
(Barron et al., 2022), Tanks&Temples (Knapitsch et al., 2017), and Deep
Blending (Hedman et al., 2018), and we evaluate the rendering quality by using
PSNR, SSIM, and LPIPS. Moreover, for the evaluation in terms of efficiency, we
also report training duration in minutes, FPS, and the number of Gaussian
primitives in millions.

We follow the common approaches to use the datasets. In the case of the
Synthetic NeRF dataset, comprising nine small, bounded virtual scenes, we
allocate one hundred 800x800 images for training and two hundred 800x800
images for testing. For the unbounded, real-world scenes found in the
MipNeRF360 dataset (consisting of four indoor scenes and five outdoor scenes),
Tanks&Temples dataset (including two outdoor scenes), and Deep Blending
dataset (containing two indoor scenes), we use every 8th image for testing and
the rest for training at their original resolutions.

#### Pruning techniques of baselines.

As our motivation to comprehend the implications of various pruning
techniques, we import the only the pruning implementations from the prior
works. The pruning technique notations are $Prune_{LG}$, $Prune_{MS}$,
$Prune_{RS}$, and $Prune_{EG}$, respectively originated from LightGaussian
(Fan et al., 2023), Mini-Splatting (Fang and Wang, 2024), and RadSplat
(Niemeyer et al., 2024). Note that, as of this paper’s submission, only
LightGaussian has opened their code, so we carefully reproduce the pruning
techniques of Mini-Splatting and RadSplat based on their arXiv papers.

###  4.2 Cross-view vs. pixel-wise pruning

Our experiment shows that the pixel-wise pruning with one of our proposed
importance function exhibits the best performance compared to the baseline
pruning techniques outlined in Table 1.

Table 1: Averaged results of cross-view pruning and pixel-wise pruning techniques on the MipNeRF360 dataset at similar numbers of Gaussian primitives. Bold text indicates the best performances. Prune technique | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | Training$\downarrow$ (mins.) | FPS$\uparrow$ | # prim.(M)
---|---|---|---|---|---|---
$Prune_{LG}$ | 25.923 | 0.7539 | 0.3118 | 31.44 | 715.9 | 0.292
$Prune_{MS}$ | 26.272 | 0.7780 | 0.2817 | 31.30 | 680.8 | 0.313
$Prune_{RS}$ | 26.770 | 0.7912 | 0.2707 | 30.04 | 702.0 | 0.330
SafeguardGS | 27.091 | 0.7892 | 0.2673 | 30.92 | 681.9 | 0.353

###  4.3 Importance score functions

Our experiment shows that the important score function incorporating pixel
color distance with color-weight shows the best pruning efficiency in Table 2.

Table 2: Results on the Bicycle scene from MipNeRF360. All settings are
trained with a ranking threshold of 1.

Score Function PSNR$\uparrow$ SSIM$\uparrow$ LPIPS$\downarrow$
Training$\downarrow$ (mins.) FPS$\uparrow$ # prim.(k) $Score_{v1}$ 23.326
0.6218 0.4035 36.89 702.0 0.159 $Score_{v2}$ 24.187 0.6812 0.3402 37.82 603.6
0.402 $Score_{v3}$ 24.614 0.7103 0.3096 38.44 573.4 0.452 $Score_{v4}$ 24.727
0.7137 0.3003 39.52 546.5 0.705 $Score_{v5}$ 24.629 0.7106 0.3052 38.73 607.4
0.563 $Score_{v6}$ 24.730 0.7165 0.2988 38.40 620.1 0.553 $Score_{v7}$ 24.701
0.7166 0.2991 37.87 626.3 0.553 $Score_{v8}$ 24.458 0.6915 0.3292 38.67 638.0
0.474 $Score_{v9}$ 24.520 0.6952 0.3269 38.92 591.6 0.471 $Score_{v10}$ 24.275
0.6867 0.3351 37.16 695.7 0.406 $Score_{v11}$ 24.268 0.6863 0.3354 37.71 630.4
0.405 $Score_{v12}$ 24.240 0.6859 0.3349 37.70 661.6 0.407 $Score_{v13}$
24.632 0.7110 0.3088 37.51 670.5 0.454 $Score_{v14}$ 24.621 0.7105 0.3093
37.68 626.2 0.454 $Score_{v15}$ 24.700 0.7134 0.3010 38.40 563.0 0.693
$Score_{v16}$ 24.632 0.7117 0.3041 38.60 613.8 0.565 $Score_{v17}$ 24.744
0.7171 0.2987 38.28 571.0 0.553 $Score_{v18}$ 24.693 0.7166 0.2988 37.73 620.1
0.552

##  5 Conclusion

In this paper, we categorize Gaussian primitive pruning techniques and
demonstrate that pixel-wise pruning, coupled with a color-weighted score
function ($Score_{v13}$), efficiently works for decimating the primitives with
minimal performance degradation. From the experiment comparing the techniques,
we observe that while the cross-view pruning is prone to destructing the scene
unless a careful selection of pruning threshold is made, the pixel-wise
pruning can set a reasonable boundary for the threshold, preventing the
unconscionable pruning of Gaussian primitives. Moreover, we notice that the
importance functions suggested by prior works rarely consider the impact of
primitives’ colors. We come up with a variety of possible importance functions
and test them to find the optimal one. We confirm that the pixel-wise pruning
technique with the optimal importance function demonstrates state-of-the-art
efficiency among pruning methods, saving training duration, and enhancing FPS
under the same number of Gaussian primitives. Moreover, the efficiency in
terms of training as well as FPS is improved with minuscule but negligible
quality loss compared to vanilla 3DGS.

#### Limitation

We mainly focus on pruning efficiency in this paper. While our study shows
achievement of the state-of-the-art pruning efficiency with a safeguard
against disastrous scene destruction, the rendering quality is slightly lower
than with vanilla 3DGS. Moreover, pruning the primitives after the
densification stage scarcely helps to reduce peak memory usage. We observe
that incorporating the proposed pruning technique during the densification
stage results in significantly faster training speeds with imperceptible
performance drops on the Synthetic NeRF dataset. However, this isn’t the case
for unbounded real-world scenes. Furthermore, like vanilla 3DGS, our method
doesn’t handle scenes containing various appearances across the training
images. Our method greatly depends on the size of the training data (the total
number of pixels of all training images).

## Acknowledgments and Disclosure of Funding

This research is based upon work supported by the Office of the Director of
National Intelligence (ODNI), Intelligence Advanced Research Projects Activity
(IARPA), via IARPA R&D Contract No. 140D0423C0076. The views and conclusions
contained herein are those of the authors and should not be interpreted as
necessarily representing the official policies or endorsements, either
expressed or implied, of the ODNI, IARPA, or the U.S. Government. The U.S.
Government is authorized to reproduce and distribute reprints for Governmental
purposes notwithstanding any copyright annotation thereon.

## References

  * Mildenhall et al. [2020] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng.  Nerf: Representing scenes as neural radiance fields for view synthesis.  In _ECCV_ , 2020.
  * Barron et al. [2021] Jonathan T Barron, Ben Mildenhall, Matthew Tancik, Peter Hedman, Ricardo Martin-Brualla, and Pratul P Srinivasan.  Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 5855–5864, 2021.
  * Barron et al. [2022] Jonathan T Barron, Ben Mildenhall, Dor Verbin, Pratul P Srinivasan, and Peter Hedman.  Mip-nerf 360: Unbounded anti-aliased neural radiance fields.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 5470–5479, 2022.
  * Xie et al. [2021] Christopher Xie, Keunhong Park, Ricardo Martin-Brualla, and Matthew Brown.  Fig-nerf: Figure-ground neural radiance fields for 3d object category modelling.  In _2021 International Conference on 3D Vision (3DV)_ , pages 962–971. IEEE, 2021.
  * Mirzaei et al. [2023] Ashkan Mirzaei, Tristan Aumentado-Armstrong, Konstantinos G Derpanis, Jonathan Kelly, Marcus A Brubaker, Igor Gilitschenski, and Alex Levinshtein.  Spin-nerf: Multiview segmentation and perceptual inpainting with neural radiance fields.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 20669–20679, 2023.
  * Li et al. [2023a] Zhaoshuo Li, Thomas Müller, Alex Evans, Russell H Taylor, Mathias Unberath, Ming-Yu Liu, and Chen-Hsuan Lin.  Neuralangelo: High-fidelity neural surface reconstruction.  In _IEEE Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2023a.
  * Wang et al. [2023] Yiming Wang, Qin Han, Marc Habermann, Kostas Daniilidis, Christian Theobalt, and Lingjie Liu.  Neus2: Fast learning of neural implicit surfaces for multi-view reconstruction.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 3295–3306, 2023.
  * Yen-Chen et al. [2021] Lin Yen-Chen, Pete Florence, Jonathan T Barron, Alberto Rodriguez, Phillip Isola, and Tsung-Yi Lin.  inerf: Inverting neural radiance fields for pose estimation.  In _2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)_ , pages 1323–1330. IEEE, 2021.
  * Rosinol et al. [2023] Antoni Rosinol, John J Leonard, and Luca Carlone.  Nerf-slam: Real-time dense monocular slam with neural radiance fields.  In _2023 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)_ , pages 3437–3444. IEEE, 2023.
  * Zhu et al. [2023] Zihan Zhu, Songyou Peng, Viktor Larsson, Zhaopeng Cui, Martin R Oswald, Andreas Geiger, and Marc Pollefeys.  Nicer-slam: Neural implicit scene encoding for rgb slam.  _arXiv preprint arXiv:2302.03594_ , 2023.
  * Deng et al. [2022] Nianchen Deng, Zhenyi He, Jiannan Ye, Budmonde Duinkharjav, Praneeth Chakravarthula, Xubo Yang, and Qi Sun.  Fov-nerf: Foveated neural radiance fields for virtual reality.  _IEEE Transactions on Visualization and Computer Graphics_ , 28(11):3854–3864, 2022.
  * Shen et al. [2023] Chuanyue Shen, Letian Zhang, Zhangsihao Yang, Masood Mortazavi, Xiyun Song, Liang Peng, and Heather Yu.  Envisioning a next generation extended reality conferencing system with efficient photorealistic human rendering.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 4622–4631, 2023.
  * Yu et al. [2021a] Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa.  Plenoctrees for real-time rendering of neural radiance fields.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 5752–5761, 2021a.
  * Chen et al. [2022a] Anpei Chen, Zexiang Xu, Andreas Geiger, Jingyi Yu, and Hao Su.  Tensorf: Tensorial radiance fields.  In _European Conference on Computer Vision_ , pages 333–350. Springer, 2022a.
  * Fridovich-Keil et al. [2022] Sara Fridovich-Keil, Alex Yu, Matthew Tancik, Qinhong Chen, Benjamin Recht, and Angjoo Kanazawa.  Plenoxels: Radiance fields without neural networks.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 5501–5510, 2022.
  * Müller et al. [2022] Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller.  Instant neural graphics primitives with a multiresolution hash encoding.  _ACM transactions on graphics (TOG)_ , 41(4):1–15, 2022.
  * Neff et al. [2021] Thomas Neff, Pascal Stadlbauer, Mathias Parger, Andreas Kurz, Joerg H Mueller, Chakravarty R Alla Chaitanya, Anton Kaplanyan, and Markus Steinberger.  Donerf: Towards real-time rendering of compact neural radiance fields using depth oracle networks.  In _Computer Graphics Forum_ , volume 40, pages 45–59. Wiley Online Library, 2021.
  * Kurz et al. [2022] Andreas Kurz, Thomas Neff, Zhaoyang Lv, Michael Zollhöfer, and Markus Steinberger.  Adanerf: Adaptive sampling for real-time rendering of neural radiance fields.  In Shai Avidan, Gabriel Brostow, Moustapha Cissé, Giovanni Maria Farinella, and Tal Hassner, editors, _Computer Vision – ECCV 2022_ , pages 254–270, Cham, 2022. Springer Nature Switzerland.  ISBN 978-3-031-19790-1.
  * Li et al. [2023b] Ruilong Li, Hang Gao, Matthew Tancik, and Angjoo Kanazawa.  Nerfacc: Efficient sampling accelerates nerfs.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 18537–18546, 2023b.
  * Hedman et al. [2021] Peter Hedman, Pratul P Srinivasan, Ben Mildenhall, Jonathan T Barron, and Paul Debevec.  Baking neural radiance fields for real-time view synthesis.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 5875–5884, 2021.
  * Chen et al. [2023] Zhiqin Chen, Thomas Funkhouser, Peter Hedman, and Andrea Tagliasacchi.  Mobilenerf: Exploiting the polygon rasterization pipeline for efficient neural field rendering on mobile architectures.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 16569–16578, 2023.
  * Kerbl et al. [2023] Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis.  3d gaussian splatting for real-time radiance field rendering.  _ACM Transactions on Graphics_ , 42(4):1–14, 2023.
  * Zwicker et al. [2001a] Matthias Zwicker, Hanspeter Pfister, Jeroen Van Baar, and Markus Gross.  Ewa volume splatting.  In _Proceedings Visualization, 2001. VIS’01._ , pages 29–538. IEEE, 2001a.
  * Zwicker et al. [2001b] Matthias Zwicker, Hanspeter Pfister, Jeroen van Baar, and Markus Gross.  Surface splatting.  In _Proceedings of the 28th Annual Conference on Computer Graphics and Interactive Techniques_ , SIGGRAPH ’01, page 371–378, New York, NY, USA, 2001b. Association for Computing Machinery.  ISBN 158113374X.  doi: 10.1145/383259.383300.  URL https://doi.org/10.1145/383259.383300.
  * Fan et al. [2023] Zhiwen Fan, Kevin Wang, Kairun Wen, Zehao Zhu, Dejia Xu, and Zhangyang Wang.  Lightgaussian: Unbounded 3d gaussian compression with 15x reduction and 200+ fps.  _arXiv preprint arXiv:2311.17245_ , 2023.
  * Lee et al. [2024] Joo Chan Lee, Daniel Rho, Xiangyu Sun, Jong Hwan Ko, and Eunbyung Park.  Compact 3D Gaussian Representation for Radiance Field, 2024.
  * Fang and Wang [2024] Guangchi Fang and Bing Wang.  Mini-Splatting: Representing Scenes with a Constrained Number of Gaussians, 2024.
  * Niemeyer et al. [2024] Michael Niemeyer, Fabian Manhardt, Marie-Julie Rakotosaona, Michael Oechsle, Daniel Duckworth, Rama Gosula, Keisuke Tateno, John Bates, Dominik Kaeser, and Federico Tombari.  RadSplat: Radiance Field-Informed Gaussian Splatting for Robust Real-Time Rendering with 900+ FPS, 2024.
  * Liu et al. [2024] Wenkai Liu, Tao Guan, Bin Zhu, Lili Ju, Zikai Song, Dan Li, Yuesong Wang, and Wei Yang.  Efficientgs: Streamlining gaussian splatting for large-scale high-resolution scene representation.  _arXiv preprint arXiv:2404.12777_ , 2024.
  * Snavely et al. [2006] Noah Snavely, Steven M Seitz, and Richard Szeliski.  Photo tourism: exploring photo collections in 3d.  In _ACM siggraph 2006 papers_ , pages 835–846. 2006.
  * Goesele et al. [2007] Michael Goesele, Noah Snavely, Brian Curless, Hugues Hoppe, and Steven M Seitz.  Multi-view stereo for community photo collections.  In _2007 IEEE 11th International Conference on Computer Vision_ , pages 1–8. IEEE, 2007.
  * Schönberger et al. [2016] Johannes Lutz Schönberger, Enliang Zheng, Marc Pollefeys, and Jan-Michael Frahm.  Pixelwise View Selection for Unstructured Multi-View Stereo.  In _European Conference on Computer Vision (ECCV)_ , 2016.
  * Schönberger and Frahm [2016] Johannes Lutz Schönberger and Jan-Michael Frahm.  Structure-from-Motion Revisited.  In _Conference on Computer Vision and Pattern Recognition (CVPR)_ , 2016.
  * Czerkawski et al. [2024] Mikolaj Czerkawski, Javier Cardona, Robert Atkinson, Craig Michie, Ivan Andonovic, Carmine Clemente, and Christos Tachtatzis.  Neural knitworks: Patched neural implicit representation networks.  _Pattern Recognition_ , page 110378, 2024.
  * Niemeyer and Geiger [2021] Michael Niemeyer and Andreas Geiger.  Giraffe: Representing scenes as compositional generative neural feature fields.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 11453–11464, 2021.
  * Gu et al. [2021] Jiatao Gu, Lingjie Liu, Peng Wang, and Christian Theobalt.  Stylenerf: A style-based 3d-aware generator for high-resolution image synthesis.  _arXiv preprint arXiv:2110.08985_ , 2021.
  * Schwarz et al. [2020] Katja Schwarz, Yiyi Liao, Michael Niemeyer, and Andreas Geiger.  Graf: Generative radiance fields for 3d-aware image synthesis.  _Advances in Neural Information Processing Systems_ , 33:20154–20166, 2020.
  * Gao et al. [2022] Xiangjun Gao, Jiaolong Yang, Jongyoo Kim, Sida Peng, Zicheng Liu, and Xin Tong.  Mps-nerf: Generalizable 3d human rendering from multiview images.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 2022.
  * Chen et al. [2022b] Mingfei Chen, Jianfeng Zhang, Xiangyu Xu, Lijuan Liu, Yujun Cai, Jiashi Feng, and Shuicheng Yan.  Geometry-guided progressive nerf for generalizable and efficient neural human rendering.  In _European Conference on Computer Vision_ , pages 222–239. Springer, 2022b.
  * Zhang et al. [2020] Kai Zhang, Gernot Riegler, Noah Snavely, and Vladlen Koltun.  Nerf++: Analyzing and improving neural radiance fields.  _arXiv preprint arXiv:2010.07492_ , 2020.
  * Yu et al. [2021b] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa.  pixelnerf: Neural radiance fields from one or few images.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 4578–4587, 2021b.
  * Wang et al. [2021] Qianqian Wang, Zhicheng Wang, Kyle Genova, Pratul P Srinivasan, Howard Zhou, Jonathan T Barron, Ricardo Martin-Brualla, Noah Snavely, and Thomas Funkhouser.  Ibrnet: Learning multi-view image-based rendering.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 4690–4699, 2021.
  * Martin-Brualla et al. [2021] Ricardo Martin-Brualla, Noha Radwan, Mehdi SM Sajjadi, Jonathan T Barron, Alexey Dosovitskiy, and Daniel Duckworth.  Nerf in the wild: Neural radiance fields for unconstrained photo collections.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 7210–7219, 2021.
  * Ma et al. [2022] Li Ma, Xiaoyu Li, Jing Liao, Qi Zhang, Xuan Wang, Jue Wang, and Pedro V Sander.  Deblur-nerf: Neural radiance fields from blurry images.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 12861–12870, 2022.
  * Li et al. [2021] Zhengqi Li, Simon Niklaus, Noah Snavely, and Oliver Wang.  Neural scene flow fields for space-time view synthesis of dynamic scenes.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 6498–6508, 2021.
  * Gao et al. [2021] Chen Gao, Ayush Saraf, Johannes Kopf, and Jia-Bin Huang.  Dynamic view synthesis from dynamic monocular video.  In _Proceedings of the IEEE/CVF International Conference on Computer Vision_ , pages 5712–5721, 2021.
  * Sun et al. [2022] Cheng Sun, Min Sun, and Hwann-Tzong Chen.  Direct voxel grid optimization: Super-fast convergence for radiance fields reconstruction.  In _Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition_ , pages 5459–5469, 2022.
  * Shin and Park [2024] Seungjoo Shin and Jaesik Park.  Binary radiance fields.  _Advances in Neural Information Processing Systems_ , 36, 2024.
  * Knapitsch et al. [2017] Arno Knapitsch, Jaesik Park, Qian-Yi Zhou, and Vladlen Koltun.  Tanks and temples: Benchmarking large-scale scene reconstruction.  _ACM Transactions on Graphics (ToG)_ , 36(4):1–13, 2017.
  * Hedman et al. [2018] Peter Hedman, Julien Philip, True Price, Jan-Michael Frahm, George Drettakis, and Gabriel Brostow.  Deep blending for free-viewpoint image-based rendering.  _ACM Transactions on Graphics (ToG)_ , 37(6):1–15, 2018.