# Visibility-Based Geometry Pruning of Neural Plenoptic Scene Representations

Davi R Freitas, Ioan Tabus, Christine Guillemot

► To cite this version:

Davi R Freitas, Ioan Tabus, Christine Guillemot. Visibility-Based Geometry Pruning of Neural Plenoptic Scene Representations. IEEE Transactions on Multimedia, In press, pp.1-17. 10.1109/tmm.2025.3618548. hal-05101627

HAL Id: hal-05101627

https://hal.science/hal-05101627v1

Submitted on 6 Jun 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# Visibility-Based Geometry Pruning of Neural Plenoptic Scene Representations

Davi R. Freitas Ⓒ, Student Member, IEEE, Ioan Tabus Ⓒ, Senior Member, IEEE, Christine Guillemot Ⓒ, Fellow, IEEE

**Abstract**—The need for more realistic 3D scene representations has fomented the development of models for a wide range of applications. In this context, solutions that attempt to model the light's behavior through the plenoptic function have provided considerable advancements using neural-based approaches, often presenting a trade-off between rendering time and model sizes. In this work, we propose a pruning framework to reduce the sizes of these models by computing the visibility over the training data, applicable to different 3D scene representations. In particular, we implement first a solution suitable for the 3D Gaussian Splatting, and then we exemplify the solution for the Neural Radiance Fields (NeRF)-style of rendering using PlenOctrees. We show that our pruning solution produces smaller models in terms of the number of elements – be they voxels, points, or Gaussians – with minimal losses in terms of rendering novel views. We further assess our solution by combining it with state-of-the-art (SOTA) compression solutions for both rendering schemes. Results over the NeRF-Synthetic dataset show comparable metrics to the SOTA for PlenOctrees, achieving marginal gains for lower bitrates. For 3DGS, the combination of our pruning method and compression solutions achieves a compression ratio of up to 37.5 times over the uncompressed 3DGS models, with only a 0.5 dB decrease in rendering quality. When compared against other SOTA compression methods, our solution produces models 1.4 times smaller, with less than a 0.1 dB loss over novel views for synthetic data, and models 1.9 times smaller with less than 0.2 dB loss when synthesizing novel views on real-world, outdoor content.

**Index Terms**—NeRF, PlenOctrees, 3D Gaussian Splatting, Pruning, Compression

## I. INTRODUCTION

THE modeling of three-dimensional (3D) scenes has been a focal point of study across multiple disciplines. In computer vision, for example, representing a 3D scene structure from 2D images allows the generation of novel photorealistic views that can be used for a wide range of applications related to object recognition and scene understanding, such as virtual and augmented reality, 3D reconstruction, and medical imaging. On the other hand, in domains like robotics, a robust 3D representation is paramount to facilitate spatial perception, navigation, and interaction for tasks like autonomous exploration and industrial automation. Traditional methods for representation of such scenes include point clouds (PC) [1], meshes [2], voxel grids [3], and even sets of depth maps [4].

On the other hand, 3D scene rendering has seen considerable advancements using neural-based representations that

parametrize the scene as a description of the light rays in space, the so-called plenoptic function. Neural Radiance Fields (NeRF) [5] was among the first exponents, which led to extensions to enhance the method by improving its image quality [6], [7], adapting it to different image formats [8], [9], making it more generalizable for sparse inputs [10], accelerating its training and/or inference speed [11]–[14], among others.

Nevertheless, NeRF's design for volumetric rendering resulted in the advent of solutions that accelerate the rendering via a trade-off between the model's size and speed. 3D Gaussian Splatting (3DGS) [15] emerged as an alternative by representing 3D scenes by using Gaussian kernels, generating a rendering process that is both fast and with state-of-the-art (SOTA) quality without a particular need for a neural network (NN). However, the tendency of 3DGS optimization to produce an elevated number of Gaussians to represent 3D scenes results in large model sizes. This has proved to be a challenge for the widespread adoption of such models, since applications like handheld devices and head-mounted displays work with constrained resources that are not compliant with the elevated storage and memory footprints. This fomented the development of solutions that compress them [16]–[19].

In this work, we propose a framework to reduce the size of 3D scene representations for scenes with an “inwards-facing” disposition, by exploiting their underlying geometry regardless of their format. This is achieved by using the training views to compute the visibility of the elements in the scene – be they points, voxels, or Gaussians, depending on the representation type – and pruning the ones that are deemed less visible and thus, less impactful for the rendering quality of the model. We implement our method with two solutions that use a different underlying framework to render 3D scenes. In this work, we primarily focus on 3DGS, where we remove Gaussians to generate more compact models, thus reducing the memory consumption of such scenes as well as allowing them to be rendered faster. Moreover, we also apply our pruning method in a NeRF-style approach, where we use the PlenOctrees framework to prune voxels from large octrees.

In short, our solution has the following contributions:

1. A geometry pruning approach that can be applied to both PlenOctree and Gaussian splatting with minimal modifications,

a. When used in conjunction with PlenOctrees, our pruning solution provides an accurate geometry, closer to the ground-truth than the pruned point clouds obtained by other existing approaches,

<footnote>This project has received funding from the European Union's Horizon 2020 research and innovation programme under the Marie Skłodowska-Curie grant agreement No 956770.</footnote>
b) For the 3DGS, we embed our method inside the optimization/densification process to reduce the required number of Gaussians to represent the scene,

2) We finally combine our pruning method with existing compression algorithms for both our solutions implemented with PlenOctrees and Gaussian Splatting, to achieve even smaller bitrates than in the SOTA.

## II. RELATED WORK

### A. Plenoptic Representations

The ability to model scenes and objects with changing colors as the viewer changes their viewing angle, i.e. non-Lambertian, is highly desired in immersive applications. As such, the plenoptic function [20] is a mathematical model that represents a “sea of light” by describing each light ray in the world as a wave through a set of parameters, generally given by

$$P(x, y, z, \theta, \phi, \lambda, t). \qquad (1)$$

This provides a means of representation of the intensity of each light ray in the world according to the spatial coordinates $(x, y, z)$, the viewing angle $(\theta, \phi)$, the light wavelength $\lambda$ and time $t$. Such function can be incorporated differently in the modeling of 3D scenes according to the type of scene representation; 360° videos only have 3 degrees of freedom, using the angular coordinates $\theta, \phi$ [21]. Light field images define the light transport in a 3-D scene with a 5D feature space, with spatial and angular coordinates [22]. Plenoptic point clouds [23], [24] represent such a model with a collection of vectors, with an explicit geometry given by a finite set of points in $\mathbb{R}^3$ and a finite number of RGB colors as attributes corresponding to the camera viewpoints during capture, naturally sampling the viewing direction of the 3D space.

In this context, the Neural Radiance Fields (NeRF) [5] concept is first introduced as a scene-specific, learned continuous light field. Through the use of multi-layer perceptrons (MLP), NeRF implements a continuous function $F$ that maps the 3D coordinates $\mathbf{x} = (x, y, z)$ from a direction $\mathbf{n}$ with azimuth and elevation $\mathbf{n} = (\theta, \phi)$ into a color $\mathbf{c}$ and density $\sigma$

$$ (\mathbf{c}, \sigma) = F_{\Theta}(\mathbf{x}, \mathbf{n}). \qquad (2) $$

Therefore, NeRF naturally represents the plenoptic function in Eq. 1, with the coordinates and viewing direction being represented through $\mathbf{x}$ and $\mathbf{n}$ in Eq. 2 to obtain the view-dependent color $\mathbf{c}$, which models the dependency on the wavelength $\lambda$ of the plenoptic light intensity function in Eq. 1.

Representations where the scene is implicitly defined as a continuous function of spatial coordinates through learned or inferred parameters are known as implicit scene representations. When these quantities are defined continuously in spatial coordinates and are parametrized by an NN, they are defined as a neural field [25]. The continuity and differentiability of such approaches make them suitable for novel view synthesis, i.e., for generating new viewpoints of the scene.

### B. Novel View Synthesis

NeRF is able to represent 3-D scenes by reconstructing them via a NN (see Eq. 2) from a set of training images with known camera positions. The view-dependent color $\mathbf{c}$ and the density $\sigma$ that are output from the NN are parameters used in a classical volume rendering approach [26], where a predicted pixel color (or radiance) $\hat{C}(\mathbf{r})$ of the original pixel $C(\mathbf{r})$ is obtained by accumulating the transmittance $T$ over a ray $\mathbf{r}(t) = \mathbf{o} + t\mathbf{n}$. Here $\mathbf{o}$ is the camera center in the world space coordinates and $\mathbf{n}$ is determined by the pixel position. Thus, the predicted radiance of $\hat{C}(\mathbf{r})$ can be viewed as

$$ \hat{C}(\mathbf{r}) = \int_{t_n}^{t_f} T(t)\sigma(\mathbf{r}(t))\mathbf{c}(\mathbf{r}(t), \mathbf{n})dt, \qquad (3) $$

$$ T(t) = \exp(-\int_{t_n}^{t} \sigma(\mathbf{r}(s))ds). \qquad (4) $$

Effectively, this integral is numerically computed as

$$ \hat{C}(\mathbf{r}) = \sum_{i=1}^{N} T_i(1 - \exp(-\sigma_i \delta_i))\mathbf{c}_i, \qquad (5) $$

by partitioning $t$ between the near and far planes – with bounds $t_n$ and $t_f$, respectively – into evenly-spaced $N$ bins, and each sample is drawn uniformly at random from within these partitions. The transmissivity $T_i = \exp(-\sum_{j=1}^{i-1} \sigma_j \delta_j)$ represents the accumulation of the density values sampled along a ray $\mathbf{r}$ separated by distances given by a step-size $\delta_i = t_{i+1} - t_i$.

The use of the density $\sigma$ in the rendering equation in Eq. 5 effectively creates a density field to represent the scene's geometry, in such a way that allows the scene to be reconstructed for different views in a robust way, even if the true underlying geometry is unknown. Such modeling of the 3-D geometry is also known as soft modeling and was first introduced in Soft3D [27]. For the case of NeRF, this soft modeling of the scene's geometry allows for quality enhancement when rendering novel views (Eq. 5) without specific knowledge of the scene's underlying geometry.

Differentiable splatting, such as 3-D Gaussian Splatting [15] (3DGS), is an alternative approach to these NeRF-like methods by modeling a scene optimizing a set of 3-D Gaussians. The image formation model for a predicted pixel color $\hat{C}$ is

$$ \hat{C} = \sum_{i \in \mathcal{N}} \alpha_i \mathbf{c}_i \prod_{j=1}^{i-1} (1 - \alpha_j), \qquad (6) $$

where $\mathcal{N}$ is a set of ordered 3D points that overlap the same pixel after projection, $\alpha_i$ is the opacity, and $\mathbf{c}_i$ is the color associated to each i-th Gaussian projected to the same pixel. Defining the accumulation of densities in a ray from Eq. 5 in NeRF as the opacity $\alpha_i = (1 - \exp(-\sigma_i \delta_i))$, it is straightforward that the image formation model from 3DGS (Eq. 6) is the same as NeRF's (Eq. 5). Nevertheless, as a point-based $\alpha$-blending approach, 3DGS' rendering differs from NeRF's volumetric one, as the non-continuous nature of the former's modeling requires the estimation of $\alpha$ values by evaluating 2D Gaussians, and those can only be obtained via rasterization of the 3D Gaussians as opposed to NeRF's ray marching.
### C. Speed-up NeRF Variants and Model Compression

Ray-marching through the scene in NeRF's rendering makes its training and inference intrinsically slow since every sample in the ray has to query the MLP to obtain the volume rendering parameters for the predicted pixel color (Eq. 5).

As a result, different proposals have sought to speed up the training efficiency and/or the rendering time of the NN's evaluation. Pre-baking NeRF's outputs into a sparse voxel grid [28], [29], or representing the parameters into octrees [12] are ways to accelerate the model's rendering. Alternatively, optimizing over a sparse voxel grid from scratch [13] or using auxiliary multi-scale hash grids to reduce the complexity of the NN's task [11] can also speed up the training.

However, these grid-based, NeRF-like solutions improve the rendering speed at the cost of storage space. Hence, solutions have been proposed to address such weaknesses. The authors in [30] reduce the grid sizes by learning a hybrid tensor rank decomposition, while Rho et al. [31] transform the spatial information into the frequency domain. Re:NeRF [32] applies voxel pruning via removing and re-including parameters for any NeRF-like method that minimizes a differentiable loss function. In addition to pruning voxels, the work in [33] aims to also compress the scene according to an octree quantization and intra-frame prediction of the volume rendering parameters as point cloud attributes by looking at a point's neighborhood.

### D. Gaussian Splatting Compression

3D Gaussian Splatting achieved breakthroughs in the task of synthesizing novel views by achieving real-time rendering performance while presenting smaller storage footprints comparatively to other view-dependent representations, such as voxel-based [24], [34], [35] and the grid-based, NeRF-like approaches [36]. Nevertheless, such Gaussian-based optimization tends to over-parametrize the scene with kernels to generate high-fidelity renders, increasing the storage and memory requirements. Moreover, previous work [33] shows that representing view-dependent colors as a set of spherical harmonics (SH) coefficients takes up most of the said storage costs. Hence, Niedemayr et al. [16] proposed to compress both the SHs coefficients and the Gaussian parameters via a clustering algorithm based on the sensitivity of the reconstruction quality to the changes of such attributes. This clustering is combined with quantization-aware training to compress codebooks of the SHs and Gaussian parameters with dictionary-based entropy coding. In addition to the attribute compression, Lee et al. [17] also proposed to reduce the number of Gaussians during optimization. This is done with a learnable mask that removes small-sized Gaussians and those with low opacity. This is combined with a geometry codebook representation of the Gaussians and a grid-based neural field to represent the view-dependent colors by feeding the view direction and feature vectors into a small MLP. Other solutions to reduce the sizes of 3DGS models include vector quantization [18], self-organizing grids [19], [37], and distillation of SH coefficients to a lower degree [19].

These works address the size reduction of models that follow either a NeRF-like or a splatting pipeline. Our solution

aims to prune the scene models by looking at the scene's disposition to the acquired viewpoints, thus being able to be used for both NeRF-based and splatting-based methods with minimal adaptations.

## III. PROPOSED FRAMEWORK

Leveraging the scene's underlying geometry is a way to orient the pruning while minimizing distortion losses by exploring redundancies while maintaining the object's "water-tightness", regardless of the geometry's representation.

We focus in this work on inward-facing scenes, that is, the cameras in the training set are arranged to be centered around an object. As a result, scenes of this type tend to be less sparse when compared to natural, large-scale ones. This type of camera arrangement leads to points being visible by multiple cameras at once. Therefore, one can leverage such a setup to prune points from the scene based on their visibility with regard to the training viewpoints. Removing the ones that are less visible to a given set of cameras can minimize losses on the 2-D rendered views while working directly on the 3-D space without the need for ground-truth geometry.

Consider an object in space as seen in Fig. 1 represented by $N$ unbounded points of the format $\mathbf{p}_i = (x_i, y_i, z_i)$, for $i = 1, ..., N$, forming the list of points $\mathbf{P}_w = \{\mathbf{p}_i\}_{i=1}^N$ in the World Coordinate Space. In order to generate $K$ rendered views for the scene, the points in $\mathbf{P}_w$ are projected to a set of camera poses $\mathbf{D} = \{\mathbf{d}_j\}_{j=1}^K$. Each point $\mathbf{p}$ is forward projected to each $j$ Camera Coordinate System (CCS) through $\tilde{\mathbf{p}}_c = \mathbf{d}_j\tilde{\mathbf{p}}$, where $\tilde{\mathbf{p}}_c$ and $\tilde{\mathbf{p}}$ are $\mathbf{p}$ in homogeneous coordinates in the Camera and World Coordinate Systems, respectively. In addition to that, each pose $\mathbf{d}_j = \begin{bmatrix} \mathbf{R} & \mathbf{t} \\ 0 & 1 \end{bmatrix}$ corresponds to the $4 \times 4$ extrinsic matrix containing each camera's translation $\mathbf{t}$ and rotation $\mathbf{R}$. The homogeneous image coordinates $\tilde{\mathbf{x}}_c$ are then obtained by projecting the homogeneous 3D coordinates $\tilde{\mathbf{x}}_c = \mathbf{K}\tilde{\mathbf{p}}_c$, where the camera intrinsic matrix $\mathbf{K}$ is assumed to be known for each viewpoint. The 2D pixel coordinates $\mathbf{x}_c$ are finally obtained by normalizing the $\tilde{\mathbf{x}}_c$ by the depth. We denote $\tilde{\mathbf{x}}_c = (u, v) = \pi(\mathbf{p})$ the projection of a point $\mathbf{p}$ into the pixel $(u, v)$ of a view, as described above.

The forward projection also allows the estimation of the points' visibility to each camera, detecting potential occlusions. This is done by analyzing the set of points that end up being projected to the same pixel coordinates $\mathbf{x}_c$ (see Fig. 1).

Note that the projected pixel positions are dependent on the camera position in the World Coordinate System and its optical characteristics. Hence, the distance from the point to the camera and the image's resolution are two of the factors that determine the perceived point size in a given image. Moreover, the perceived point size is also affected by the rendering method of its underlying representation.

Let Let $M_{uv} = \{\mathbf{p}_i | \pi(\mathbf{p}_i) = (u, v)\}_{i=1}^N$ be the set of 3D points that are projected by the projection $\pi$ to the same pixel of coordinates $(u, v)$. One can then order the points in the set $M_{uv}$ based on the z-values of its elements in the Camera Coordinate System, and consider the $\tau$ closest points to be visible, with the rest of the set being marked as occluded for that
<figure><img src="image_2.png" /><figcaption>Fig. 1: Proposed pruning scheme where, for each camera with an extrinsic matrix $D$, the 3D scene is forward-projected to detect which points lie in the frustum of the same pixel. Based on the *Thickness* parameter, the $τ$ elements with the smallest z-values are considered visible from that viewpoint. These are marked as units in a $N \times K$ binary visibility map, and points are removed if they are not visible for at least $v$ training views. This is controlled by the *MVE* parameter.</figcaption></figure>

specific viewpoint. That is, $M_{uv}^* = \arg\min_{|S|=\tau} \sum_{\mathbf{p}_i \in S} z_i$, where $S$ corresponds to any subset of size $\tau$ of $M_{uv}$. One can adjust $\tau$ as a parameter in order to control how many of the points in $M_{uv}$ are marked as visible for a given pixel: a lower value will mark more points as “occluded” at each view, essentially modifying the “thickness” of the object. Hence, we refer to $\tau$ in this work as *thickness*.

When applying such occlusion detection to all the training views, a binary $N \times K$ visibility mask $O$ can be computed, where 1 means that the $n$-th point is visible for the $k$-th viewpoint, and 0 otherwise. The visibility mask computation procedure is further detailed in Algorithm 1.

Additionally, the pruning of the points can be controlled by analyzing how many cameras each point is visible on, since the overall rendering quality is less sensitive to points occluded by most viewpoints. We perform this by evaluating against a threshold $v$ over the column-wise sum of the elements from $O$, such that $S_n = \sum_{k=1}^K O_{nk} > v, n = 1, ..., K$. We can combine the threshold $v$ in addition to the *thickness* parameter to adjust the degree of pruning of the scene's geometry. We also refer to $v$ as *minimum number of views per element* (MVE), as an MVE value of $v$ means that every point or element in the space that is pruned is only visible for $v$ or fewer views.

Assuming an “inwards-facing” camera disposition, with the cameras posed around a central object, occlusions of points from specific viewpoints are determined by the self-occlusions of the object’s own geometry. The visibility of these points can be adjusted based on the user’s desired depth of traversal through the scene, controlled via the *thickness* parameter. The *MVE* can be viewed as a mechanism to mitigate the formation of floating artifacts during training by discouraging the model from generating elements outside the object’s watertight surfaces, effectively pruning these spurious elements.

Notice that we refer to the smallest unit here as an element, since our algorithm has the flexibility to be used with any method that produces spatial structures. Hence, we show our visibility-based algorithm’s application with a NeRF-based and a splatting-based rendering approach.

## A. NeRF-based Approach

The framework for our solution based on NeRF's rendering is based on PlenOctrees [12], an approach that provides faster rendering by pre-tabulating the NN that predicts the parameters required for NeRF's volume rendering. We review the pipeline of the PlenOctrees method in order to then explain how our pruning method interacts with the original solution.

The method consists of constructing an octree structure where each voxel contains the rendering parameters optimized via rendering loss [12]. To achieve real-time performance, the ray-marching procedure has to be done directly on the PlenOctree, which means that the color information in the voxel has to be view-independent beforehand. Hence, the NeRF network from which PlenOctree extracts its parameters is a modified version that outputs spherical harmonics (SH) coefficients for the color and the density of the soft geometry. This greatly increases the storage and memory requirements to execute such an approach, as SHs of order 3 mean that each voxel stores 16 coefficients per color channel.

In order to reduce the impact of this tradeoff of speed for size, the original PlenOctrees paper [12] proposes some techniques to reduce the complexity of the structures. The work in [33] further explores the search for a more compact representation by reducing the number of occupied voxels during optimization, performed by thresholding the octree based on the $\sigma$ values. The pruned PlenOctree was then fine-tuned and compressed as a voxelized point cloud whose attributes were the SH coefficients and the density.
<figure><img src="image_3.png" /><figcaption>Fig. 2: Proposed pruning strategy in the Plenoctrees pipeline. (a) The pruning method is introduced after the initial optimization step in the octree and is followed by a fine-tuning stage before being conveyed for compression. (b) Plenoctrees' voxel-based representation produces fixed splats as cubes, which can cause rendering issues when pruned. A voxel size that is too small (left) can generate holes, while a size too large (right) can make the scene appear “blocky”.</figcaption></figure>

We can introduce our visibility-based pruning method in this pipeline by replacing the pruning strategy based on the threshold on $\sigma$ from the optimization step with our algorithm, as seen in Fig. 2-(a). Here, NeRF’s density field is discretized into the PlenOctree’s voxels, which have a fixed size in the 3D space for a given resolution. This fixed size means that increased geometric detail may require a higher voxel resolution, and pruning these voxels could potentially increase the occurrences of holes due to their fixed splats for more aggressive values of thickness and MVE. Since these splats are non-adaptive due to their intrinsic representation, one can minimize such a phenomenon by downsampling the octree, thus increasing the perceived voxel size. Therefore, an additional parameter for our method when working with PlenOctrees is the grid’s resolution; a lower resolution may be able to fill apparent holes in the object, although an increased voxel size may reduce the quality of the renders due to the lack of detail in finer geometry, making the object appear “blocky”, as in Fig. 2-(b).

Algorithm 2 details the pruning implementation within the PlenOctrees pipeline. A PlenOctree child node $p_{oct}$ is first converted into a voxel $p_{pc}$ in a voxelized PC $M$ by $p_{pc} = p_{oct} \times 2^R - 0.5$, where $R$ is the depth of the voxel grid. The local coordinates are converted into world positions and then sent for the visibility mask computation. After the voxels are pruned, the PC $M$ is converted back to a PlenOctree $\hat{G}$, from where it can be re-optimized with a fine-tuning step done in the same manner as the first optimization block from Fig. 2-(a). That is, the octree is optimized with stochastic gradient descent

on the original training images using the same rendering loss as NeRF, $\mathcal{L}_{RGB} = \sum_{\mathbf{r} \in \mathcal{R}} \|C(\mathbf{r}) - \hat{C}(\mathbf{r})\|_2^2$.

## B. Splatting-based Approach

The 3DGS pipeline, on the other hand, provides an adaptive splat by representing the 3-D scene via a set of Gaussian kernels. This is achieved by the fact that each one of these Gaussians can be approximately represented by a corresponding ellipsoid by describing its covariance matrix $\Sigma$ with a scaling matrix $S$ and rotation matrix $R$. This anisotropic modeling of the covariance allows the Gaussians to be optimized into different shapes, as opposed to the fixed splats one sees in voxel-based solutions such as PlenOctrees (Sec. III-A).

To project the Gaussian positions, we use the location of their centroids as points of reference for the visibility algorithm. Note that the centroids are the positions where the density of the kernels is at its highest, that is, where they appear more “opaque” (see Fig 3).

Our method can be implemented by embedding our pruning into 3DGS’ optimization pipeline, as seen in Fig. 4. More specifically, the visibility computation and consequent removal of Gaussians can be performed jointly with the Adaptive Density Control block, by removing the occluded kernels every time the $\alpha$ value of the Gaussians is reset to zero.

Algorithm 3 details the steps in this procedure within 3DGS’ optimization and densification pipeline, with the steps concerning our visibility pruning algorithm being highlighted in blue. After a certain number of iterations, the visibility mask
<figure><img src="image_4.png" /><figcaption>Fig. 3: Visibility computation using 3DGS' Gaussian kernels. Notice that the Gaussians' centroids are considered as reference positions, where they are perceived as the most “opaque”.</figcaption></figure>

**Algorithm 1** Computation of the Visibility Mask.

**function** COMPUTEVISIBILITYMASK(P, V, τ)
    **Input:** Set of points P, viewpoints V and thickness τ
    **Output:** A $N \times K$ visibility matrix O
    O ← InitializeWith0s()

**for all** j ← 1 to K do
    c ← V[j]          ▷ Current viewpoint
d ← GetExtrinsicMatrix(c)
K ← GetIntrinsicMatrix(c)
M ← ∅             ▷ List of points projected to same pixel

**for all** i ← 1 to N do
    p ← P[i]          ▷ Current point
    $\mathbf{x}_c = (u, v) \leftarrow \text{ForwardProjection}(p, d, K) \triangleright$
    3D to 2D
    $M_{u,v}$ . add($p$)

**end for**
$M^* \leftarrow \emptyset$

**for all** $M_{u,v}$ in $M$ do
    ▷ Set $M_{u,v} = \{(x_i, y_i, z_i) \mid i = 1, \dots, M\}$
    Sort($M_{u,v}$) by the key $z_i$

**for** each i = 1 to τ do
    ▷ Thickness
    $M^*$.add($M_{u,v}[i]$) ▷ Pick first τ points

**end for**
**end for**

**for all** i ← 1 to N do
    **if** $P[i]$ in $M^*$ **then**
        $O[i, j] \leftarrow 1$

**end if**
**end for**

**end for**
**return** O

**end function**

O is computed and the points are pruned according to their values in O in relation to the threshold defined by the MVE parameter.

Consequently, pruning the occluded Gaussians results in not only the color information, but the $\alpha$ to be more concentrated into the remaining kernels, making the “distilled” model closer to a “hard” geometry representation than a soft one. This mechanism gradually controls the number of kernels during training and allows the remaining Gaussians to be optimized in terms of both their shape (geometrical parameters) and their color attributes (SH parameters).

Moreover, to prioritize the pruning of the smaller Gaussians, we also introduce a regularization term for 3DGS' loss

$$ \mathcal{L} = (1 - \lambda)\mathcal{L}_1 + \lambda\mathcal{L}_{D-SSIM} + \beta\frac{1}{N}\sum_{i=1}^{N}\frac{1}{\|\mathbf{S}_i\|}. \quad (7) $$

Here, the loss terms $\mathcal{L}_1$ and $\mathcal{L}_{D-SSIM}$ are the L1 rendering loss and the D-SSIM term used in the original 3DGS [15] paper, and we introduce the regularization term on the scaling matrices $\mathbf{S}$ of the Gaussians to encourage the removal of smaller kernels. The scaling regularization term in Eq. 7 is only applied for the duration of the densification process in the optimization of the 3DGS. This is done to steer the existing Gaussians into larger sizes, hence limiting the number of newly generated kernels that converge into small ellipsoids (which are less important for the rendering quality).

**Algorithm 2** Visibility Pruning within PlenOctrees.

$G \leftarrow$ Set of PlenOctree child nodes
$V \leftarrow$ Set of training views
$M \leftarrow$ PointCloudWorldCoordinates($G$)
$O \leftarrow$ ComputeVisibilityMask($M, V$) ▷ Visibility Mask

**for all** rows n in O do
    $sum \leftarrow \sum_{k=1}^{K} O_{nk}$ ▷ Number of visible viewpoints
    for Voxel in n

**if** $sum \le \nu$ **then**
    RemoveVoxel($M$)

**end if**
**end for**

$\hat{G} \leftarrow$ PlenOctreesFromPointCloud($M$)

## IV. COMPRESSION

Our visibility-based geometry pruning method can generate more compact representations in terms of numbers of elements, be they points, voxels, or even Gaussians. These models can be combined with existing compression algorithms to achieve lower bit-rates than the ones from the state-of-the-art.

### A. PlenOctrees

In [33], the density $\sigma$ and the SHs $\mathbf{k}$ from the PlenOctrees models are compressed from the perspective of a plenoptic point cloud. That is, consider the coordinate indices of the
<figure><img src="image_5.png" /><figcaption>Fig. 4: Proposed pruning strategy in the 3DGS pipeline.</figcaption></figure>

**Algorithm 3** Visibility Pruning within 3DGS.
___
**Input** SfM Points
**Output** Positions
**Input** Set of Training Views
**Input** InitAttributes()
**Input** Opacities
**Iteration Count** i ← 0
**while** not converged **do**
  **SampleTrainingView**(*V*)
  **Camera** *v* and
  **Rasterize**(*M*, *S*, *C*, *A*, *v*)
  **Loss** *I*, *Î*
  **Backprop** & Step
  **IsRefinementIteration**(*i*) **then**
    **for all** Gaussians (*μ*, *Σ*, *c*, *α*) in (*M*, *S*, *C*, *A*) **do**
      **if** *α* < *ε* or **IsTooLarge**(*μ*, *Σ*) **then**
        **Pruning**
        **RemoveGaussian**()
      **end if**
      **if** ∇<sub>*p*</sub>*L* > *τ*<sub>*p*</sub> **then**
        **Densification**
        **if** ‖*S*‖ > *τ*<sub>*S*</sub> **then**
          **Over-reconstruction**
          **SplitGaussian**(*μ*, *Σ*, *c*, *α*)
        **else**
          **Under-reconstruction**
          **CloneGaussian**(*μ*, *Σ*, *c*, *α*)
        **end if**
      **end if**
      **end for**
      **end if**
      **IsVisibilityPruneIteration**(*i*) **then**
        **ComputeVisibilityMask**(*M*, *V*)
        **Visibility**
      **Mask**
      **for all** rows *n* in *O* **do**
        **sum** ← ∑<sub>*k*<sub>1</sub>=1</sub><sup>*K*</sup> *O*<sub>*nk*</sub>
        **Number of visible**
        **for all** Gaussian in *r*
          **if** *sum* ≤ *ν* **then**
            **MVE**
            **RemoveGaussian**()
          **end if**
        **end for**
        **end if**
        **i** ← *i* + 1
      **end while**
___

n-th child in the PlenOctree grid with depth *M*, denoted as $\mathbf{x}_{\text{oct}}(n) = [X_n, Y_n, Z_n]$. This set of nodes can be interpreted as a voxelized point cloud (PC) at depth *M*, containing *N* voxels. The coordinates representing the geometry of this voxelized PC, denoted by $\mathbf{x}_{\text{pc}}$, are given by $\mathbf{x}_{\text{pc}} = \mathbf{x}_{\text{oct}} \times 2^M - 0.5$. Each point is associated with density and spherical harmonics attributes $\mathbf{s}(n) = (\sigma_n, \mathbf{k}_{n0}^0, \mathbf{k}_{n1}^{-1}, \mathbf{k}_{n1}^0, \mathbf{k}_{n1}^1, \dots, \mathbf{k}_{nl}^\ell)$, where $\mathbf{k}_{nl}^m \in \mathbb{R}^3$. That is, *P* represents a voxelized PC where, rather than having a single color attribute, contains multiple ones corresponding to the parameters required for the volume rendering in PlenOctree.

The geometry $\mathbf{x}_{\text{pc}}$ is encoded losslessly in [33], with the attributes encoded lossily using a modified version of the Geometry-Based Video Point Cloud Coding (G-PCC) from the Moving Picture Experts Group (MPEG) [38], [39]. The orthogonal basis formed by the decomposition into SHs provides a decorrelation between the multiple attributes of $\mathbf{P}$ for each of the color channels that is analogous to the usage of Karhunen-Loève Transform (KLT) coefficients applied in [40].

In this work, we compress the geometry and multiple attributes from the Plenoctrees derived PC $\mathbf{P}$ using the more recent Geometry-Based Solid Content Test Model (GeS-TM) [41] to compress the models. As a branch split from G-PCC, in this codec the attributes are lossy compressed via the region adaptive hierarchical transform (RAHT), while the geometry is either losslessly encoded via octree representation, or encoded with losses using the triangle soup (Trisoup) coding. Both are then entropy encoded to create the respective bitstreams.

Once the attributes are decoded and unscaled, the PC $\mathbf{P}$ can be reconstructed into $\hat{\mathbf{P}}$. From the geometry $\mathbf{x}_{\text{pc}}$ of $\hat{\mathbf{P}}$ that was encoded losslessly, one can reconstruct a PlenOctree with the same structure as the original one, but with lossy reconstructed attributes $\sigma$ and SHs. These are encoded with attribute quantization parameters (QP) of six different values, from the lowest to the highest quantization: (22, 28, 34, 40, 46, 51). This allows the selection of a certain level of model quality according to the bitrate constraints of the user.
## B. 3D Gaussian Splatting

For 3DGS, we combine our pruning solution with two SOTA compression methods, which are summarized in the rest of this subsection. The compression solution by Niedemayr et al. [16] targets strictly the color attributes and the Gaussian parameters (scale and rotation). This is achieved by first applying sensitivity-aware vector clustering to group the kernels' colors and shape parameters into codebooks. This parameter sensitivity measure $S$ is calculated by evaluating the change in the image quality to changes of a parameter $p$, such that

$$S(p) = \frac{1}{\sum_{i=1}^{K} P_i} \sum_{i=1}^{K} \left| \frac{\partial E_i}{\partial p} \right| \quad (8)$$

$E$ is the sum of the RGB components for all pixels. $P_i$ is the number of pixels in image $i$. $S$ is used to guide the clustering into codebooks $C$, computed via k-Means using a similarity measure between the vectors and the centroids of $C$.

The parameters are then fine-tuned on the training set, with the optimization for position, opacity, and scaling for the Gaussians, as well as the color and codebook entries. This is done via quantization-aware training with Min-Max Quantization. In the forward pass, the quantization is simulated considering a certain number of bits in addition to the moving average of each parameter's minimum and maximum values. The backward pass then ignores the simulated quantization and calculates the gradient for the parameter without quantization.

Finally, the set of Gaussians and the codebooks for the SHs and Gaussian shape parameters are compressed with DEFLATE [42]. By ordering the Gaussians according to their positions in Z-order in Morton order, one can leverage the spatial coherence of the attributes with a dictionary-based entropy coding algorithm (LZ77 [43]).

The second one, proposed by Lee et al. [17], introduces a mechanism to reduce the number of Gaussians, in addition to their compression. In combination with our visibility-pruning strategy, this can lead to representations with even fewer kernels and, consequently, more compact.

The Gaussian reduction strategy is based on a learnable mask during the optimization that removes Gaussians that minimally impact performance. This is done by targeting the removal of small-sized kernels at every densification step, due to their minimal impact on rendering quality performance. Therefore, binary masks $M$ are applied to the opacities and scale attributes of the kernels. The masked scale $\hat{s}$ and opacity $\hat{o}$ are employed with the straight-through estimator,

$$M_n = \text{sg}(1[\sigma(m_n) > \epsilon] - \sigma(m_n)) + \sigma(m_n), \quad (9)$$

$$\hat{s}_n = M_n s_n, \quad \hat{o}_n = M_n o_n, \quad (10)$$

where $\epsilon$ is the masking threshold, $\text{sg}(\cdot)$ the stop gradient [44], $1$ the indicator function and $\sigma(\cdot)$ the sigmoid function.

The compression part of this work also uses codebooks to represent geometric attributes, such as scale and rotation, using vector quantization. More specifically, residual vector quantization is used, cascading $L$ stages of vector quantization.

For the color attribute compression, the view-dependent colors are represented via a grid-based neural field. Hash grids

are used for the input positions, features, and view direction, which are fed into an MLP to get the view-dependent color.

Therefore, the end-to-end loss is given by

$$L = L_{ren} + \lambda_m L_m + L_r + L_s, \quad (11)$$

where $L_{ren}$ is the combination of the L1 and SSIM loss as in Eq. 7, $L_m$ is the masking loss term, $L_m = \frac{1}{N} \sum_{n=1}^{N} \sigma(m_n)$, and $L_r$ and $L_s$ are the objective functions for the rotation and scale of the Gaussians [17].

Note that, when combining our visibility-based pruning solution with the one in Lee et al. [17], we use the loss function defined in Eq. 11, while for our method combined with the work in Niedemayr et al. [16], we keep Eq. 7.

# V. EXPERIMENTS

## A. Experimental Setup

1) **Dataset:** We use in our experiments the NeRF-Synthetic 360 – also known as Blender – dataset from the original NeRF [5], which contains 8 sequences with splits of 100 images for training, 100 for validation, and 200 for testing with dimensions of 800 × 800 each and ground-truth camera poses. The ground-truth point clouds for the geometry assessment were obtained from the modified NeRF-Synthetic 360 dataset introduced in [36], available at https://drcfts.github.io/c-ppc/.

Additionally, we also use in our experiments the real-world dataset of the Mip-NeRF 360 [7], containing 5 outdoor and 4 indoor environments for a total of 9 large-scale scenes. Each scene has a variable number of camera poses, with the testing split considered to be every 8th image of the set of the rendering views, and no validation poses, as is generally done in the literature [7].

2) **Baselines:** On the PlenOctrees' side of our visibility-based pruning solution, we compare our proposal against the pruning and compression methods presented in [33], which we refer to as “Compressed PlenOctrees (C-PO)” in this work. For the 3DGS' side, we assess our method against the state-of-the-art compression solutions from [16] and [17], which we call as “Niedermayr” and “Lee” in our benchmark comparisons.

For our proposed methods that use Eq. 7 as their loss function (our solution in Sec. V-C1 and the combination of our pruning with the compression from the work in [16]), the selected value for the $\beta$ hyperparameter was of $1 \times 10^{-5}$. The $\lambda$ and $\lambda_m$ parameter values used were of 0.2 and $5 \times 10^{-4}$ respectively, according to the existing literature.

3) **Performance evaluation:** All the reported PSNR values are the averages of the individual image PSNRs measured for the respective color channels at each of the 200 test poses for the scenes of the NeRF-Synthetic dataset. The sizes reported for the rate-distortion (RD) analysis of the compression schemes are given in bytes, while the analysis of the pruned models is given by the number of retained points. Reporting the sizes in bytes is relevant for applications where the efficient transmission of the models over communication links is required while reporting the sizes as the number of retained points is a (crude) estimation of the memory size needed for fast accessing the uncompressed models at the
inference time. Therefore, both facets of model complexity
are used in the experiments.

For the Receiver Operating Characteristic (ROC) curves, a
“match” between points of the predicted **B** and the reference
**A** geometry is computed on the WCS. As such, a “match” is
given when the distance between points $b_i \in \mathbf{B}$ and $a_j \in \mathbf{A}$
is below a certain threshold $\delta$ in world coordinates. Therefore,
$\delta$ is considered to be the value of the diagonal of the voxel
in $\mathbf{B}$, that is, $\sqrt{3}$, scaled to the world coordinates. The clas-
sification of true positives (TP) and false positives (FP) are
thus given by $TP = \sum_{a_j \in \mathbf{A}} 1(\min_{b_i \in \mathbf{B}} d(b_i, a_j) \le \delta)$ and
$FP = \sum_{b_i \in \mathbf{B}} 1(\min_{a_j \in \mathbf{A}} d(b_i, a_j) > \delta)$, where $d(\cdot, \cdot)$ is the
euclidean distance between points. The positive condition $\mathcal{P}$
is calculated by the amount of points in $\mathbf{A}$, while the negative
condition $\mathcal{N}$ is calculated by subtracting the total amount of
points in a voxelized grid (e.g. $512^3$ for a “resolution 9” grid)
from $\mathcal{P}$. The True Positive Rate (TPR), given by $\frac{TP}{\mathcal{P}}$, measures
the ratio of ground-truth points that have a predicted point
within the distance threshold. The False Positive Rate (FPR)
is given by $\frac{FP}{\mathcal{N}}$ and measures the ratio of predicted points that
do not have a corresponding ground-truth point.

B. Performance Analysis of the Proposed Pruning with PlenOctrees

1) *Selection of Operating Points:* For the PlenOctrees side of our pruning method, the combination of different values of the *MVE*, *thickness* and the voxel resolution (shortened as “reso” in Fig. 5) provide different levels of distortion and model complexity – which we approximate in this analysis by computing the number of points of the models before being conveyed for compression. Fig. 5 shows the rendering average PSNR results for three scenes of the NeRF-Synthetic dataset – namely *hotdog*, *lego*, and *materials* – for multiple operating points. Points with the same combination of *thickness* and voxel resolution are grouped into curves, in which the *MVE* parameter is tested for the values of 0, 1, 3, 5, 10 and 25.

<figure><img src="image_6.png" /><figcaption>Fig. 5: Average PSNR (in dB) vs number of points, comparing the combination of operating points of the parameters *thickness*, *MVE* and *resolution* implemented with PlenOctrees. Results were obtained over scenes *hotdog*, *lego*, and *materials*.</figcaption></figure>

Therefore, we choose an optimal set of operating points
with regard to RD, where the chosen values were the fol-

lowing: (thickness, MVE, reso) = [(1, 10, 8), (3, 0, 8), (5, 0, 8), (10, 0, 8), (25, 0, 9), (100, 25, 9)]. These operating points were chosen using Pareto fronts [45] rather than the combination of parameters obtained from computing the upper convex hull. This was performed to obtain a set of combinations that cover a greater rate range with minimal PSNR loss.

<figure><img src="image_7.png" /><figcaption>Fig. 6: Average PSNR (in dB) as a function of the number of points, comparing our chosen operating points implemented in PlenOctrees against the pruning approach performed in [33] over the sequences *hotdog*, *lego*, and *materials*.</figcaption></figure>

Fig. 6 shows the RD optimized curve for the given set of operating points from Fig. 5. Our solution provides gains over the method in [33] in the medium to low range of number of points.

2) *Geometry Accuracy:* In addition to the rendering assessment for our pruning with PlenOctrees introduced in Sec. V-B1, we also benchmark our pruned PlenOctree models in terms of its scene structure, by comparing their underlying geometry against ground-truth PCs. One could do so by measuring the error via commonly used geometry metrics, such as the point-to-point (D1) or the point-to-plane (D2) errors [46]. Considering a reference PC **A** and reconstructed PC **B**, the D1 and D2 metrics calculate the MSE between the points and their closest neighbors in the other PC, that is, from both **A** to **B**, and **B** to **A**, and taking the lowest value of both directions as the final result. The downside of such a symmetric metric is the assumption that both **A** and **B** have close to the same amount of points, and thus the PSNR in both directions will have closely related values. Here, where **B** can have a significantly larger amount of points than **A**, the PSNR value from the **A** → **B** direction will be considerably higher than in **B** → **A**, as any given point in **A** will be more likely to have a corresponding point (or plane) in **B**. As the number of points from the pruned PCs **B** decreases, the PSNR values in both directions converge, as the values in **A** → **B** decrease and **B** → **A** increase. Therefore, the non-trivial analysis of these metrics led us to benchmark it via ROC curves.

As Fig. 7 shows, our pruning solution for the sequence *drums* presents a higher rate of “hits” (TPR) for a fixed rate of misses (FPR), in particular for the medium to low range in terms of the number of points. The gains provided in both Figs. 6 and 7, corroborate the perception that our solution improves upon the pruning in the SOTA in terms of rendering
Receiver Operating Characteristic Curve

<figure><img src="image_8.png" /><figcaption>Fig. 7: ROC Curve assessing the accuracy of the predicted geometry by the proposed method implemented in PlenOctrees and the one in [33] against the ground-truth. Results are performed over the sequences hotdog, lego, and materials.</figcaption></figure>

performance by proposing a points removal method that is less harmful to the overall geometry of the scene.

3) *Rate-distortion Performance:* We combine our pruning method with the compression scheme from [33] to assess the models over their storage footprints. This compression scheme (see Sec. IV-A) encodes the density $\sigma$ and the SHs from the PlenOctrees with six different attribute QPs. We combine each compression rate with the set of operating points from the pruning parameters chosen in Sec. V-B1 to obtain a set of compression operating points, as seen in Fig. 8.

NeRF-Synthetic

PlenOctrees Implementation

<figure><img src="image_9.png" /><figcaption>Fig. 8: Average PSNR (in dB) vs Bitrate (in bytes) comparing the operating points of thickness, MVE, and resolution of our pruning implemented with PlenOctrees when using 6 values for the attributes QP for the compression of GeS-TM. Results are performed over hotdog, lego, and materials.</figcaption></figure>

Average results from the scenes hotdog, lego, and materials in Fig. 8 show that the addition of the compression scheme step means that the compressed model can achieve low bitrate ranges for higher QPs even with higher combinations of thickness and MVE. As such, we use the set of thickness = 100 and MVE = 25 with the six different compression rates as our operating points to assess our model for the entire NeRF-Synthetic dataset against the solution from [33].

NeRF-Synthetic

PlenOctrees Implementation

<figure><img src="image_10.png" /><figcaption>Fig. 9: Average PSNR (in dB) vs Bitrate (in bytes) comparing our pruning solution with PlenOctrees against the work in [33] for the 8 sequences of the NeRF-Synthetic dataset.</figcaption></figure>

Results over the whole NeRF-Synthetic dataset in Fig. 9 show that using compression favors the models of [33] for the medium to high bitrates, while the compressed models using our method provides gains for the lower bitrates, that is, close to and under 1 MB. For the whole curve, our solution yields a BD-PSNR gain of 0.23 dB, or a BD-rate reduction of -18.19%.

C. Performance Analysis of the Proposed Pruning with 3DGS over Synthetic Data

1) *Number of Gaussians:* For the 3DGS side of our implementation, we first analyze our method according to the number of elements – which in this case is represented by the Gaussians – per iteration during the optimization process.

As an example, we assess our method using a thickness value of 1 and different MVE values against the Vanilla 3DGS [15] ("Vanilla") and the pruning solution by Lee [17] ("Lee").

Drums

<figure><img src="image_11.png" /><figcaption>Fig. 10: Number of Gaussians per Iteration results for our method with a thickness of 1 and MVE values of 0, 1, 2, 3, 5, 10, and 25 implemented with 3DGS compared against the Vanilla 3DGS [15], and Lee's pruning solution [17] for drums.</figcaption></figure>

The results from Fig. 10 show that for higher values of MVE, our solution can generate a more compact version of the scene compared to the *Vanilla* and to *Lee*, reducing the number of kernels by up to 3.32 and 1.70 times, respectively.
<table><caption>TABLE I: Quality metrics vs Number of Gaussians comparison for our solution with 3DGS using values of thickness of 1 and MVE of 0, 5, 10, 25 against the vanilla 3DGS [15] and Lee's pruning and compression solution [17] for drums.</caption><thead><tr><th>Method</th><th>PSNR ↑</th><th>SSIM ↑</th><th>LPIPS ↓</th><th># Gaussians ↓</th></tr></thead><tbody><tr><td>Vanilla [15]</td><td>26.17</td><td><strong>0.955</strong></td><td><strong>0.037</strong></td><td>347623</td></tr><tr><td>Lee [17]</td><td>26.17</td><td>0.953</td><td>0.041</td><td>178548</td></tr><tr><td>Ours - 3DGS (MVE = 0)</td><td><strong>26.18</strong></td><td><strong>0.955</strong></td><td>0.038</td><td>221200</td></tr><tr><td>Ours - 3DGS (MVE = 5)</td><td>26.15</td><td><strong>0.955</strong></td><td>0.038</td><td>175099</td></tr><tr><td>Ours - 3DGS (MVE = 10)</td><td>26.17</td><td><strong>0.955</strong></td><td>0.038</td><td>151701</td></tr><tr><td>Ours - 3DGS (MVE = 25)</td><td>26.10</td><td>0.954</td><td>0.039</td><td>104821</td></tr></tbody></table>

Notice also how our pruning strategy, performed at every 3000 iterations, gradually controls the number of Gaussians during the training from the start, with the pruned geometry shaping the creation of new Gaussians throughout the optimization. Lee, on the other hand, keeps a similar number of kernels in comparison to the Vanilla during training while the densification of the Gaussians is activated, which happens until iteration 15000. Only after the optimization stops producing new Gaussians does the number of kernels start to decrease.

Table I shows the quality metrics and the number of Gaussians of our method with varying MVE values compared to Vanilla and Lee, which demonstrate that the pruning of the Gaussian representation does not result in a significant increase in distortion, with the smallest pruned model presenting values in PSNR, SSIM and LPIPS close to the bigger, vanilla model. However, when comparing the size of the models in terms of bitrate, Lee presents an advantage in terms of size reduction due to its compression mechanism in addition to pruning. Although our smallest model (26.0 MB) is smaller than Vanilla (86.6 MB), Lee achieves even further bitrate savings (6.67 MB). Therefore, we combine our pruning with SOTA compression solutions for Gaussian-based representations to also evaluate our method in terms of bitrate.

2) Rate-distortion Performance: We combine our pruning method with each of the compression solutions in Niedemayr [16] and Lee [17] to achieve even further bitrate savings. We use these combinations to assess our models against the SOTA regarding rendering quality in the context of novel view synthesis and storage costs. As such, the average results for all scenes of the NeRF-Synthetic dataset are shown in Fig. 11, where we compare our methods against 3DGS [15], and the works from Niedermayr [16] and Lee [17]. We re-executed all the reported results from the SOTA for the given scenes.

Results from Fig. 11 show that the combination of our pruning with existing compression methods achieves even smaller bitrates at the cost of minimal loss in quality when compared to these compression methods alone. Moreover, one can observe that, for both combinations, our method that uses a higher value for the MVE parameter (25 vs 10) provides a more advantageous trade-off between rendering quality and model size, as the optimization of the Gaussian kernel can compensate for the more aggressive pruning by our method.

<figure><img src="image_12.png" /><figcaption>Fig. 11: Average PSNR (in dB) vs Bitrate (in bytes) comparing our pruning method (implemented in 3DGS) combined with the compression from both Niedermayr's and Lee's works, against the vanilla 3DGS [15], Niedermayr [16] and Lee [17] for all scenes of NeRF-Synthetic. The used parameters for our method were thickness = 1 and MVE = (10, 25).</figcaption></figure>

The combination of our method with Lee is able to achieve the smallest ranges in terms of bitrate, with a quality decrease of less than 0.2 dB in comparison to the combination of our pruning with Niedermayr. We further detail these comparisons in Tab. II, where we additionally show the quality metrics in SSIM and LPIPS and evaluate the model sizes in terms of the number of Gaussians. The reported results for our method are given with parameter values of thickness = 1 and MVE = 25.

The results from Tab. II further corroborate that our method achieves competitive results compared to the SOTA. Our method combined with Niedemayr's work provides minimal quality loss when compared to standalone work from [16], as the number of kernels decreases by a ratio of 2.60 times and the overall bitrate size by a ratio of 1.40 times with a negligible loss in terms of quality. Our method combined with Lee's solution presents similar results, as the number of Gaussians reduces by 1.70 times and the model size in bytes by 1.40 times, with a decrease of PSNR of less than 0.1 dB and losses of 0.001 on SSIM and LPIPS. When assessing the compression methods against the vanilla 3DGS, our method's compression ratio reaches 26.3 times when combined with Niedemayr's method at the cost of 0.4 dB in average PSNR, while the combination of our solution and Lee's work achieves a compression ratio of 37.5 times at the cost of 0.54 dB on average. One can also observe from Tab. II that the results within 3DGS' framework present more competitive metrics compared to the one implemented within PlenOctrees'. Although the PlenOctrees solution can achieve bitrates of under 1MB, it does at the cost of significant quality loss, of up to 5 dB compared to the splatting approaches.

3) Visualization Results: Fig. 12 provides a visualization for these methods for a test view from materials. In Figs. 12-(d) and (f), our pruning method can reduce the number of Gaussians in the scene without introducing significant losses to its structure, as seen in 3DGS in Fig. 12-(b). Consequently, one can notice the quality preservation even when our pruning is combined with different compression methods.
<table><caption>TABLE II: Average quality metrics, number of Gaussians, and bitrates comparing the proposed solution implemented in 3DGS combined with the compression methods from Niedermayr and Lee against the vanilla 3DGS, and the standalone methods from Niedermayr [16] and Lee [17] over the NeRF-synthetic dataset. Parameter values of thickness of 1, MVE of 25, and reso of 9 are used for our method with 3DGS. Results containing our method's implementation compressed within the PlenOctrees pipeline with values of thickness of 100 and MVE of 25 are added for benchmark, as well as the PlenOctrees [12] baseline.</caption><thead><tr><th>Method</th><th>PSNR ↑</th><th>SSIM ↑</th><th>LPIPS ↓</th><th># Gaussians ↓</th><th>Size ↓ (MB)</th></tr></thead><tbody><tr><td>3DGS [15]</td><td>33.33</td><td>0.969</td><td>0.030</td><td>287,604</td><td>71.33</td></tr><tr><td>Niedermayr [16]</td><td>32.91</td><td>0.968</td><td>0.033</td><td>267,844</td><td>3.79</td></tr><tr><td>Lee [17]</td><td>32.85</td><td>0.967</td><td>0.035</td><td>118,304</td><td>2.66</td></tr><tr><td>Ours - 3DGS + Niedermayr</td><td>32.91</td><td>0.968</td><td>0.034</td><td>102,883</td><td>2.71</td></tr><tr><td>Ours - 3DGS + Lee</td><td>32.79</td><td>0.966</td><td>0.036</td><td><strong>69,435</strong></td><td><strong>1.90</strong></td></tr><tr><td>PlenOctrees [12]</td><td>31.71</td><td>0.958</td><td>0.053</td><td>-</td><td>1.93×10<sup>3</sup></td></tr><tr><td>Ours - PlenOctrees (QP = 22)</td><td>31.38</td><td>0.954</td><td>0.061</td><td>-</td><td>34.36</td></tr><tr><td>Ours - PlenOctrees (QP = 51)</td><td>28.12</td><td>0.917</td><td>0.109</td><td>-</td><td>0.86</td></tr></tbody></table>

<figure><img src="image_13.png" /><figcaption>Fig. 12: Testing view for the scene (a) materials from (b) 3DGS [15], (c) Niedermayr [16], (d) our pruning method with MVE = 25 combined with Niedermayr, (e) Lee [17], (f) our pruning method with MVE = 25 combined with Lee, (g) our pruning method with PlenOctrees with QP = 22, and (h) our pruning method with PlenOctrees with QP = 51.</figcaption></figure>

## D. Performance Analysis of the Proposed Pruning with 3DGS over Real-World Content

We further analyze the effectiveness of our method extending our experiments with large-scale, real-world content by assessing over the Mip-NeRF 360 dataset [7]. This dataset was selected for evaluation due to the disposition of the camera poses in its 9 scenes in an “inwards-facing” layout in its majority, containing scenes both in outdoor and indoor environments with information also in the background. We define the dataset to be arranged in its majority as “inwards-facing” since the camera path does not follow a centered object for all scenes. Going back to the discussion about the significance of the thickness and MVE parameters from Section III, it means that points in the scene can be occluded

from being outside the camera frustum for a certain viewpoint, rather than only being not visible due to self-occlusions from the object’s geometry. This phenomenon combined with the fact that parts of the model are located in the background of the scene propelled us to provide a more detailed analysis on the effects of the parameters for such large-scale scenes.

1) Effects on Parameter Values: For the large real-world scenes of the Mip-NeRF 360 dataset, the MVE parameter tends to affect to a greater degree the Gaussians that are occluded from views due to being outside the camera frustum, rather than self-occlusions from other objects in the scene. For these cases, the kernels of the scene located in the background will be marked as occluded more frequently, being more likely to be pruned for higher values of MVE. Figure 13 illustrates this
<figure><img src="image_14.png" /><figcaption>Fig. 13: Testing view example for the scene (a) *kitchen* from (b) 3DGS [15], (c) our pruning method with a *thickness* value of 1 and *MVE* of 5 (d) our pruning method with a *thickness* value of 1 and *MVE* of 100.</figcaption></figure>

case, where, for the same *thickness* value, a higher value of *MVE* in Fig. 13-(d) presents a significant decrease in terms of PSNR when compared to the vanilla 3DGS [15] – Fig. 13-(b) – due to the under-represented background despite the accurate representation of the lego truck centered in the foreground. Besides, one can notice that a lower value for *MVE* – Fig. 13-(c) – better represents such parts of the scene, although some finer details from the background – around the area of the plant's leaves – cause the rendered view to present a lower PSNR value when compared to the full, vanilla model. It is important to emphasize that, for such cases, higher values of *thickness* would not improve the rendered view significantly, since these points would not be visible regardless of how “deep” ones marches into the scene with each ray within the camera's frustum, which is observed in Fig. 14.

<figure><img src="image_15.png" /><figcaption>Fig. 14: Average PSNR (in dB) vs number of Gaussian kernels, comparing the combination of operating points of the parameters *thickness*, *MVE* implemented with 3DGS. Results were obtained for the average of the training data for the 9 scenes of the Mip-NeRF 360 dataset [7].</figcaption></figure>

2) *Parameter Selection:* We assess the different levels of distortion and model complexity for our pruning method over the Mip-NeRF 360 dataset by looking the combination of the *MVE* and *thickness* parameter values. Here, we approximate the complexity by computing the number of Gaussian kernels. Fig. 14 shows the rendering average PSNR results for the training split of the 9 real-world scenes of the Mip-NeRF 360 dataset [7] for multiple operating points. Points with the same combination of *thickness* are grouped into curves, in which

the *MVE* parameter is tested for the values of (1, 5, 10, 25, 50). As explained in the previous section, the under-representation of the background components results in models with higher thickness values providing marginal gains at the cost of a significant increase in the number of Gaussians, thus making the combination of points in from the *thickness* value of 1 to be more efficient in terms of RD. In order to select the *MVE* value, we detect the elbow point of the curve using the “kneedle” algorithm [47], illustrated by the vertical dotted line in Fig. 14. Therefore, a combination of (*thickness*, *MVE*) = (1, 10) is used when combining our pruning method with the compression schemes from Section IV-B.

<figure><img src="image_16.png" /><figcaption>Fig. 15: Average PSNR (in dB) vs Bitrate (in bytes) comparing our pruning method within 3DGS combined with the compression from both Niedermayr's and Lee's works, against 3DGS [15], *Niedermayr* [16] and *Lee* [17] for the testing split of the outdoor scenes from Mip-NeRF 360 [7]. Used parameter values for our method were *thickness* = 1 and *MVE* = 10.</figcaption></figure>

3) *Rate-distortion Performance:* The Mip-NeRF 360 dataset consists of 5 outdoor scenes, and 4 indoor scenes, which have different characteristics in terms of size and even the arrangement of camera poses. As one can see in Table III, the outdoor scenes have an average of 4.7 million Gaussians for the Vanilla 3DGS [15], while the indoor scenes present an average of 1.4 million Gaussians. The larger scenes of the outdoor environments as well as their camera paths being more centered around an object provide a larger separation between the foreground and the background in these scenes when compared to the indoor ones, allowing our pruning method
<figure><img src="image_17.png" /><figcaption>Fig. 16: Average PSNR (in dB) vs Bitrate (in bytes) comparing our pruning method within 3DGS combined with the compression from both Niedermayr's and Lee's works, against 3DGS [15], *Niedermayr* [16] and *Lee* [17] for the testing split of indoor scenes from Mip-NeRF 360 [7]. Used parameter values for our method were thickness = 1 and MVE = 10.</figcaption></figure>

to perform better in the former than in the latter. As a result, we divide our RD plots between the outdoor (Fig. 15) and the indoor scenes (Fig. 16), when comparing our methods against the vanilla 3DGS [15] and the original works from *Niedermayr* [16] and *Lee* [17]. Here, we use the same name conventions as in Section V-C2. However, we add for the results in Table III the metrics for the CNC method [48], which is a SOTA compression method for scene rendering based on the Instant-NGP (INGP) approach [11]. Although these models present bitrates in the low range, the lack of rendering quality of the baseline INGP approach for the unbounded scenes of the Mip-NeRF 360 dataset compromises this compression approach regarding RD performance. One can observe from the outdoor results from Table III and Fig. 15 that our pruning method reduces the number of Gaussians by 2.9× when combined with the *Niedermayr* compression method, and 3.7× when combined with the *Lee* method, resulting in compression gains of 55× and 43×, respectively at a loss of around 0.4 dB for both methods. When comparing the compression solutions of *Niedermayr* and *Lee* combined with our pruning solution (in blue in Fig. 15) and without (in red), we further reduce the model size of the method from *Niedermayr* by 1.93× at a cost of less than 0.2 dB, while we reduce *Lee's* by 1.38× at a approximately 0.1 dB loss. One can see by the per-scene results in the indoor scenes in Table III and in Fig. 16 that our pruning method is not as efficient as in the outdoor sequences, particularly for the "room" scene. The scene disposition of "room" is directly related to the lack of performance of our method there, as a great part of the objects of interest in the scene are located in the background of its viewpoints, with the center of scene mainly consisting of an empty carpet. Thus, under-representing the background in this scene means that, for some viewpoints, the badly reconstructed objects will be in the near-plane of the camera frustum, becoming more evident for certain views and dropping their quality metrics significantly, thus reducing the average in the testing split (which consists of only 39 rendered views).

## E. Method Scalability

In addition to the limitations of our method for some of the indoor scenes from the Mip-NeRF 360 dataset presented in the last Section, the scalability of the solution with regard to the computational overhead on the training time relies on the number of Gaussians in the scene as well as the number of cameras in which to compute the visibility mask O.

As an example, for an NVIDIA A40 GPU, while the training time for “drums”, the largest scene of the NeRF-Synthetic dataset, increases from approximately 9 to 11 minutes when comparing the introduction of our pruning method over the vanilla version of 3DGS, this value increases from 50 minutes to just under 3 hours for “bicycle”, the largest scene of the Mip-NeRF 360 dataset. Note that our method can be sped up by implementing the computation of the occlusion mask using CUDA programming, taking advantage of the hardware acceleration provided by the CUDA kernels.

In terms of inference time, the reduced number of Gaussians of the reconstructed models with our pruning method makes the scene rendering faster. As an example, for the “bicycle” scene of the Mip-NeRF 360 dataset, the vanilla 3DGS achieves a performance of 45.41 FPS in an NVIDIA A40 GPU, while the pruned model with our method achieves a rendering speed of 85.47 FPS for the same scene. When comparing the solution from *Niedermayr et al.* [16] for the same scene, we notice an increase in rendering speed from 79.22 to 102.25 FPS by applying our pruning method, while in *Lee et al.* [17] our solution increased it from 73.82 to 96.58 FPS.

## VI. CONCLUSION

We propose a pruning framework to reduce the size of 3D “inwards-facing” scene representations adaptable to different types of depiction of the geometry, such as NeRF- or 3DGS-based methods. This is achieved by computing the visibility over the training data of the elements of the given representation, which can be points, voxels, or even Gaussian kernels depending on the model’s underlying structure. We implement our solution in two specific scenarios, with the grid representation of PlenOctrees for the NeRF-based rendering, and the 3DGS for the splatting-based approach.

We show that our pruning solution produces smaller models in terms of the number of points with minimal losses in terms of rendering quality in a novel view synthesis context for both PlenOctrees and Gaussian Splatting implementations.

We further assess the sizes of our methods by combining our pruning approach with existing compression methods to evaluate them over their storage footprints. On synthetic data, results show comparable metrics to existing solutions on the PlenOctrees’ representation, achieving marginal gains for the lower bitrates. On the 3DGS side, the combination of our pruning method and compression solutions achieves a compression ratio of up to 37.5 times over their original, uncompressed counterparts for the Gaussian-based scenes, with only a 0.5 dB decrease in rendering quality. While comparing our model sizes to other SOTA approaches, our solution produces models smaller by 1.4 times, with less than a 0.1 dB loss over novel rendered views. We also assess our pruning method over large-scale, real-world scenes, where our method produces model
<table><caption>TABLE III: Per-scene quality metrics, number of Gaussians and bitrate for our solution within the 3DGS framework using values of thickness of 1 and MVE of 10 for the compression methods from Niedermayr and Lee against the vanilla 3DGS [15], CNC [48], and the 3DGS compressed with the methods from Niedermayr [16] and Lee [17] for the Mip-NeRF 360 dataset.</caption><thead><tr><th rowspan="2">Method</th><th rowspan="2"></th><th colspan="5">Outdoor Scenes</th><th colspan="4">Indoor Scenes</th></tr><tr><th>bicycle</th><th>flowers</th><th>garden</th><th>stump</th><th>treehill</th><th>room</th><th>counter</th><th>kitchen</th><th>bonsai</th></tr></thead><tbody><tr><td rowspan="3">Vanilla</td><td>PSNR ↑</td><td>25.15</td><td>21.47</td><td>27.24</td><td>26.55</td><td>22.47</td><td>32.10</td><td>29.28</td><td>31.10</td><td>32.51</td></tr><tr><td>Gaussians ↓</td><td>5,982,171</td><td>3,548,227</td><td>5,725,511</td><td>4,791,348</td><td>3,760,485</td><td>1,474,918</td><td>1,164,511</td><td>1,796,475</td><td>1,245,869</td></tr><tr><td>Size ↓</td><td>1,483.58</td><td>879.96</td><td>1,419.93</td><td>1,188.26</td><td>932.60</td><td>365.78</td><td>288.80</td><td>445.53</td><td>308.98</td></tr><tr><td rowspan="3">Niedermayr [16]</td><td>PSNR ↑</td><td>24.95</td><td>21.14</td><td>26.84</td><td>26.26</td><td>22.34</td><td>31.69</td><td>28.98</td><td>30.48</td><td>31.84</td></tr><tr><td>Gaussians ↓</td><td>5,128,847</td><td>3,186,815</td><td>5,253,715</td><td>4,310,682</td><td>3,382,724</td><td>1,171,963</td><td>1,003,430</td><td>1,641,640</td><td>1,048,259</td></tr><tr><td>Size ↓</td><td>48.83</td><td>32.36</td><td>48.50</td><td>41.79</td><td>34.86</td><td>14.57</td><td>13.72</td><td>19.25</td><td>13.51</td></tr><tr><td rowspan="3">Lee [17]</td><td>PSNR ↑</td><td>24.78</td><td>20.90</td><td>26.70</td><td>26.33</td><td>22.53</td><td>30.79</td><td>28.66</td><td>30.56</td><td>31.87</td></tr><tr><td>Gaussians ↓</td><td>2,238,541</td><td>1,518,816</td><td>2,321,569</td><td>1,660,830</td><td>1,960,410</td><td>510,463</td><td>529,737</td><td>1,131,206</td><td>597,239</td></tr><tr><td>Size ↓</td><td>42.49</td><td>31.40</td><td>43.22</td><td>33.90</td><td>38.37</td><td>14.86</td><td>15.21</td><td>24.47</td><td>16.76</td></tr><tr><td rowspan="3">Ours - 3DGS + Niedermayr</td><td>PSNR ↑</td><td>24.90</td><td>21.12</td><td>26.30</td><td>26.15</td><td>22.36</td><td>28.48</td><td>27.01</td><td>29.58</td><td>31.33</td></tr><tr><td>Gaussians ↓</td><td>2,308,202</td><td>1,458,863</td><td>1,814,132</td><td>1,272,939</td><td>1,357,154</td><td>456,436</td><td>438,109</td><td>809,327</td><td>496,053</td></tr><tr><td>Size ↓</td><td>28.12</td><td>19.48</td><td>22.54</td><td>17.27</td><td>19.40</td><td>9.22</td><td>9.60</td><td>12.89</td><td>9.50</td></tr><tr><td rowspan="3">Ours - 3DGS + Lee</td><td>PSNR ↑</td><td>24.69</td><td>20.87</td><td>26.47</td><td>26.06</td><td>22.59</td><td>30.48</td><td>28.30</td><td>30.13</td><td>31.86</td></tr><tr><td>Gaussians ↓</td><td>1,571,983</td><td>1,070,767</td><td>1,433,262</td><td>1,079,998</td><td>1,211,233</td><td>437,737</td><td>453,771</td><td>1,047,187</td><td>517,431</td></tr><tr><td>Size ↓</td><td>32.23</td><td>24.65</td><td>29.57</td><td>24.42</td><td>26.80</td><td>13.93</td><td>14.06</td><td>23.07</td><td>15.50</td></tr><tr><td rowspan="2">CNC [48]</td><td>PSNR ↑</td><td>20.65</td><td>19.39</td><td>22.18</td><td>23.69</td><td>19.56</td><td>28.12</td><td>26.54</td><td>27.68</td><td>26.23</td></tr><tr><td>Size ↓</td><td>3.96</td><td>3.99</td><td>3.63</td><td>3.65</td><td>3.87</td><td>2.99</td><td>3.22</td><td>2.68</td><td>3.67</td></tr></tbody></table>

sizes smaller by 1.9 times than other SOTA approaches at the cost of less than 0.2 dB loss when synthesizing novel views on the outdoor scenes of the Mip-NeRF 360 dataset.

REFERENCES

[1] Ricardo L De Queiroz and Philip A Chou, “Motion-compensated compression of dynamic voxelized point clouds,” *IEEE Transactions on Image Processing*, vol. 26, no. 8, pp. 3886–3895, 2017.

[2] Scott Gebhardt, Eliezer Payzer, Leo Salemann, Alan Fettinger, Eduard Rotenberg, and Christopher Seher, “Polygons, point-clouds and voxels: A comparison of high-fidelity terrain representations,” in *Simulation Interoperability Workshop and Special Workshop on Reuse of Environmental Data for Simulation—Processes, Standards, and Lessons Learned*, 2009, p. 9.

[3] Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh, “Neural volumes: Learning dynamic renderable volumes from images,” *arXiv preprint arXiv:1906.07751*, 2019.

[4] Yao Yao, Zixin Luo, Shiwei Li, Tian Fang, and Long Quan, “Mvsnet: Depth inference for unstructured multi-view stereo,” in *Proceedings of the European conference on computer vision (ECCV)*, 2018, pp. 767–783.

[5] 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,” *Communications of the ACM*, vol. 65, no. 1, pp. 99–106, 2021.

[6] 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*, 2021, pp. 5855–5864.

[7] 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*, 2022, pp. 5470–5479.

[8] Kai Gu, Thomas Maugey, Sebastian Knorr, and Christine Guillemot, “Omni-nerf: neural radiance field from 360 image captures,” in *2022 IEEE International Conference on Multimedia and Expo (ICME)*. IEEE, 2022, pp. 1–6.

[9] Kai Gu, Thomas Maugey, Sebastian Knorr, and Christine Guillemot, “Vanishing point aided hash-frequency encoding for neural radiance fields (nerf) from sparse 360°input,” in *2023 IEEE International Symposium on Mixed and Augmented Reality (ISMAR)*, 2023, pp. 1142–1151.

[10] Anpei Chen, Zexiang Xu, Fuqiang Zhao, Xiaoshuai Zhang, Fanbo Xiang, Jingyi Yu, and Hao Su, “Mvsnerf: Fast generalizable radiance field reconstruction from multi-view stereo,” in *Proceedings of the IEEE/CVF international conference on computer vision*, 2021, pp. 14124–14133.

[11] Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller, “Instant neural graphics primitives with a multiresolution hash encoding,” *ACM transactions on graphics (TOG)*, vol. 41, no. 4, pp. 1–15, 2022.

[12] 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*, 2021, pp. 5752–5761.

[13] 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*, 2022, pp. 5501–5510.

[14] Liwen Wu, Jae Yong Lee, Anand Bhattad, Yu-Xiong Wang, and David Forsyth, “Diver: Real-time and accurate neural radiance fields with deterministic integration for volume rendering,” in *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, 2022, pp. 16200–16209.

[15] Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis, “3d gaussian splatting for real-time radiance field rendering,” *ACM Trans. Graph.*, vol. 42, no. 4, pp. 139–1, 2023.

[16] Simon Niedermayr, Josef Stumpfegger, and Rüdiger Westermann, “Compressed 3d gaussian splatting for accelerated novel view synthesis,” in *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, 2024, pp. 10349–10358.

[17] Joo Chan Lee, Daniel Rho, Xiangyu Sun, Jong Hwan Ko, and Eunbyung Park, “Compact 3d gaussian representation for radiance field,” in *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, 2024, pp. 21719–21728.

[18] KL Navaneet, Kossar Pourahmadi Meibodi, Soroush Abbasi Koohpayegani, and Hamed Pirsivash, “Compact3d: Smaller and faster gaussian splatting with vector quantization,” *arXiv preprint arXiv:2311.18159*, 2023.

[19] Zhiwen Fan, Kevin Wang, Kairun Wen, Zehao Zhu, Dejia Xu, and Zhangyang Wang, “Lightgaussian: Unbounded 3d gaussian compression with 15x reduction and 200+ fps,” 2023.

[20] Edward H Adelson, James R Bergen, et al., *The plenoptic function and the elements of early vision*, vol. 2, Vision and Modeling Group, Media Laboratory, Massachusetts Institute of Technology, 1991.

[21] Mai Xu, Chen Li, Shanyi Zhang, and Patrick Le Callet, “State-of-the-art in 360° video/image processing: Perception, assessment and compression,” *IEEE Journal of Selected Topics in Signal Processing*, vol. 14, no. 1, pp. 5–26, 2020.

[22] Changyin Zhou and Shree K. Nayar, “Computational cameras: Convergence of optics and processing,” *Trans. Imgr. Proc.*, vol. 20, no. 12, pp. 3322–3340, dec 2011.

[23] Gustavo Sandri, Ricardo L de Queiroz, and Philip A Chou, “Compression of plenoptic point clouds,” *IEEE Transactions on Image Processing*, vol. 28, no. 3, pp. 1419–1427, 2018.

[24] Maja Krivokuča, Ehsan Miandji, Christine Guillemot, and Philip A Chou, “Compression of plenoptic point cloud attributes using 6-d point
clouds and 6-d transforms,” *IEEE Transactions on Multimedia*, vol. 25, pp. 593–607, 2021.

[25] Yiheng Xie, Towaki Takikawa, Shunsuke Saito, Or Litany, Shiqin Yan, Numair Khan, Federico Tombari, James Tompkin, Vincent Sitzmann, and Srinath Sridhar, “Neural fields in visual computing and beyond,” *Computer Graphics Forum*, 2022.

[26] James T Kajiya and Brian P Von Herzen, “Ray tracing volume densities,” *ACM SIGGRAPH computer graphics*, vol. 18, no. 3, pp. 165–174, 1984.

[27] Eric Penner and Li Zhang, “Soft 3d reconstruction for view synthesis,” vol. 36, no. 6, 2017.

[28] 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*, 2021, pp. 5875–5884.

[29] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt, “Neural sparse voxel fields,” *NeurIPS*, 2020.

[30] Jiaxiang Tang, Xiaokang Chen, Jingbo Wang, and Gang Zeng, “Compressible-composable nerf via rank-residual decomposition,” *Advances in Neural Information Processing Systems*, vol. 35, pp. 14798–14809, 2022.

[31] Daniel Rho, Byeonghyeon Lee, Seungtae Nam, Joo Chan Lee, Jong Hwan Ko, and Eunbyung Park, “Masked wavelet representation for compact neural radiance fields,” in *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, 2023, pp. 20680–20690.

[32] Chenxi Lola Deng and Enzo Tartaglione, “Compressing explicit voxel grid representations: fast nerfs become also small,” in *Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision*, 2023, pp. 1236–1245.

[33] Davi R Freitas, Christine Guillemot, and Ioan Tabus, “Compression of plenoctree model attributes enabling fast communication and rendering of neural radiance fields,” in *2023 31st European Signal Processing Conference (EUSIPCO)*. IEEE, 2023, pp. 590–594.

[34] Li Li, Zhu Li, Shan Liu, and Houqiang Li, “Plenoptic point cloud compression using multiview extension of high efficiency video coding,” *IEEE Transactions on Multimedia*, vol. 25, pp. 2007–2021, 2023.

[35] Diogo C. Garcia, Camilo Dorea, Renan U. B. Ferreira, Davi R. Freitas, Ricardo L. de Queiroz, Rogerio Higa, Ismael Seidel, and Vanessa Testoni, “Differential transform for video-based plenoptic point cloud coding,” *IEEE Transactions on Image Processing*, vol. 31, pp. 1994–2003, 2022.

[36] Davi R. Freitas, Ricardo L. de Queiroz, Ioan Tabus, and Christine Guillemot, “A comparative assessment of implicit and explicit plenoptic scene representations,” in *2024 IEEE 26th International Workshop on Multimedia Signal Processing (MMSP)*, 2024, pp. 1–6.

[37] Wieland Morgenstern, Florian Barthel, Anna Hilsmann, and Peter Eisert, “Compact 3d scene representation via self-organizing gaussian grids,” *arXiv preprint arXiv:2132.13299*, 2023.

[38] D. Graziosi, O. Nakagami, S. Kuma, A. Zaghetto, T. Suzuki, and A. Tabatabai, “An overview of ongoing point cloud compression standardization activities: video-based (V-PCC) and geometry-based (G-PCC),” *APSIPA*, vol. 9, 04 2020.

[39] “G-PCC Codec Description v10,”

[40] Davi R Freitas, Gustavo L Sandri, and Ricardo L De Queiroz, “Geometry-based compression of plenoptic point clouds,” in *2022 IEEE 24th International Workshop on Multimedia Signal Processing (MMSP)*. IEEE, 2022, pp. 1–5.

[41] “WG7, MPEG 3D Graphics Coding and Haptics, “Test model for geometry-based solid point cloud - GeS TM 3.0”,”

[42] Peter Deutsch, “Rcf1951: Deflate compressed data format specification version 1.3,” 1996.

[43] Jacob Ziv and Abraham Lempel, “A universal algorithm for sequential data compression,” *IEEE Transactions on information theory*, vol. 23, no. 3, pp. 337–343, 1977.

[44] Jakob Foerster, Gregory Farquhar, Maruan Al-Shedivat, Tim Rocktäschel, Eric Xing, and Shimon Whiteson, “Dice: The infinitely differentiable monte carlo estimator,” in *International Conference on Machine Learning*. PMLR, 2018, pp. 1529–1538.

[45] David A Van Veldhuizen, Gary B Lamont, et al., “Evolutionary computation and convergence to a pareto front,” in *Late breaking papers at the genetic programming 1998 conference*. Citeseer, 1998, pp. 221–228.

[46] Dong Tian, Hideaki Ochimizu, Chen Feng, Robert Cohen, and Anthony Vetro, “Geometric distortion metrics for point cloud compression,” in *2017 IEEE International Conference on Image Processing (ICIP)*. IEEE, 2017, pp. 3460–3464.

[47] Ville Sapopaa, Jeannie Albrecht, David Irwin, and Barath Raghavan, “Finding a” kneedle” in a haystack: Detecting knee points in system behavior,” in *2011 31st international conference on distributed computing systems workshops*. IEEE, 2011, pp. 166–171.

[48] Yihang Chen, Qianyi Wu, Mehrtash Harandi, and Jianfei Cai, “How far can we compress instant-ngp-based nerf?,” in *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, 2024, pp. 20321–20330.

<figure><img src="image_18.png" /></figure>

**Davi R. Freitas** (Student Member, IEEE) received a B.S. degree in computer engineering and a Master of Science degree in signal processing from the Universidade de Brasília, Brazil, in 2019 and 2021, respectively. He is currently pursuing a Ph.D. degree with INRIA/Université de Rennes 1, France, and Tampere University, Finland. He is part of the PLENOPTIMA Project as an Early-Stage Researcher.

<figure><img src="image_19.png" /></figure>

**Ioan Tabus** (Senior Member, IEEE) received a Ph.D. degree (Hons.) from the Tampere University of Technology, Finland, in 1995. He held teaching positions at the Department of Control and Computers, Politehcnica University of Bucharest, from 1984 to 1995. Since 1996, he has been a Senior Researcher, and since January 2000 till June 2024 he has been a Professor with the Department of Signal Processing, Tampere University of Technology, which was merged into Tampere University in 2019. He is now a Professor emeritus at Tampere University.

He is the coauthor of two books and more than 250 publications in the fields of signal compression, image processing, bioinformatics and system identification. His research interests include light field image processing, plenoptic image compression, point cloud compression, audio, image, data compression, and statistical signal processing. He was an Associate Editor of the IEEE TRANSACTIONS ON IMAGE PROCESSING, IEEE TRANSACTIONS ON SIGNAL PROCESSING and Signal Processing (EURASIP). He was the Editor-in-Chief of the EURASIP Journal on Bioinformatics and Systems Biology from 2006 to 2014.

<figure><img src="image_20.png" /></figure>

**Christine Guillemot** (Fellow, IEEE) received the Ph.D. degree from Ecole Nationale Superieure des Telecommunications, Paris, France, and an Habilitation for Research Direction from the University of Rennes, Rennes, France. She is a Director of Research at INRIA. From 1985 to 1997, she was with FRANCE TELECOM, where she was involved in various projects in the area of image and video coding and processing for TV, HDTV, and multimedia. From January 1990 to mid. 1991, she was with Bellcore, NJ, USA, as a Visiting Scientist. Her

research interests include signal and image processing, and computer vision. She was an Associate Editor for the IEEE Transactions on Image Processing from 2000 to 2003 and from 2014 to 2016, IEEE Transactions on Circuits and Systems for Video Technology from 2004 to 2006, and IEEE Transactions on Signal Processing during 2007–2009. She was a Senior Member of the Editorial Board of the IEEE Journal on Selected Topics in Signal Processing during 2013–2015 and was a Senior Area Editor of the IEEE Transactions on Image Processing during 2016–2020.
APPENDIX A
ABLA TION STUDY

We evaluate the effect of the components of our proposed method in Tab. IV, more specifically the proposed visibility pruning method – with parameters values for thickness of 1 and MVE of 25 – and the regularization term on the scaling values for the Gaussians. These are referred in the table as “Vis. Pruning (MVE = 25)” and “Scaling reg.”, respectively. Results were performed on the sequence drums.

<table><caption>TABLE IV: Average quality metrics per number of Gaussians on the scene drums, evaluating the influence from the individual features introduced in the proposed method, namely the visibility pruning method and the scaling regularization term.</caption><thead><tr><th>Method</th><th>PSNR ↑</th><th>SSIM ↑</th><th>LPIPS ↓</th><th># Gaussians ↓</th></tr></thead><tbody><tr><td>Baseline [15]</td><td>26.17</td><td><strong>0.955</strong></td><td><strong>0.037</strong></td><td>347623</td></tr><tr><td>+ Vis. Pruning (MVE = 25)</td><td>26.10</td><td>0.954</td><td>0.038</td><td>111592</td></tr><tr><td>+ Scaling reg.</td><td><strong>26.18</strong></td><td><strong>0.955</strong></td><td>0.038</td><td>260161</td></tr><tr><td>+Scaling reg. + Vis. Pruning (MVE = 25)</td><td>26.10</td><td>0.954</td><td>0.039</td><td><strong>104821</strong></td></tr></tbody></table>

The results in Tab. IV suggest that the visibility pruning algorithm is responsible for most of the losses in terms of rendering quality, while also reducing the number of Gaussians by a third of the original 3DGS method. The scaling regularization term reduces the amount of Gaussians to a smaller degree, by steering the kernels into larger sizes, producing no noticeable losses in terms of quality metrics.