{'fraction_non_alphanumeric': 0.032824390713804066, 'fraction_numerical': 0.015196031210866006, 'mean_word_length': 4.793108258928571, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Neural Sparse Voxel Fields

Photo-realistic free-viewpoint rendering of real-world scenes using classical computer graphics techniques is challenging, because it requires the difficult step of capturing detailed appearance and geometry models. Recent studies have demonstrated promising results by learning scene representations that implicitly encode both geometry and appearance without 3D supervision. However, existing approaches in practice often show blurry renderings caused by the limited network capacity or the difficulty in finding accurate intersections of camera rays with the scene geometry. Synthesizing high-resolution imagery from these representations often requires time-consuming optical ray marching. In this work, we introduce Neural Sparse Voxel Fields (NSVF), a new neural scene representation for fast and high-quality free-viewpoint rendering. NSVF defines a set of voxel-bounded implicit fields organized in a sparse voxel octree to model local properties in each cell. We progressively learn the underlying voxel structures with a diffentiable ray-marching operation from only a set of posed RGB images. With the sparse voxel octree structure, rendering novel views can be accelerated by skipping the voxels containing no relevant scene content. Our method is over 10 times faster than the state-of-the-art (namely, NeRF) at inference time while achieving higher quality results. Furthermore, by utilizing an explicit sparse voxel representation, our method can easily be applied to scene editing and scene composition. We also demonstrate several challenging tasks, including multi-scene learning, free-viewpoint rendering of a moving human, and large-scale scene rendering.


Introduction
Realistic rendering in computer graphics has a wide range of applications including mixed reality, visual effects, visualization, and even training data generation in computer vision and robot navigation. Photo-realistically rendering a real world scene from a free viewpoint is a tremendous challenge, because it is often infeasible to acquire high-quality scene geometry and material models, as done in high-budget visual effects productions. Researchers therefore have developed image-based rendering (IBR) approaches that combine vision-based scene geometry modeling with image-based view interpolation (Shum and Kang, 2000;Zhang and Chen, 2004;Szeliski, 2010). Despite their significant progress, IBR approaches still have sub-optimal rendering quality and limited control over the results, and are often scene-type specific. To overcome these limitations, recent works have employed deep neural networks to implicitly learn scene representations encapsulating both geometry and appearance from 2D observations with or without a coarse geometry. Such neural representations are commonly combined with 3D geometric models, such as voxel grids (Yan et al., 2016;Sitzmann et al., 2019a;Lombardi et al., 2019), textured meshes (Thies et al., 2019;Kim et al., 2018;Liu et al., 2019aLiu et al., , 2020, multi-plane images (Zhou et al., 2018;Flynn et al., 2019;Mildenhall et al., 2019), point clouds (Meshry et al., 2019;Aliev et al., 2019), and implicit functions (Sitzmann et al., 2019b;Mildenhall et al., 2020).
Unlike most explicit geometric representations, neural implicit functions are smooth, continuous, and can -in theory -achieve high spatial resolution. However, existing approaches in practice often show blurry renderings caused by the limited network capacity or the difficulty in finding accurate intersections of camera rays with the scene geometry. Synthesizing high-resolution imagery from these representations often requires time-consuming optical ray marching. Furthermore, editing or re-compositing 3D scene models with these neural representations is not straightforward.
In this paper, we propose Neural Sparse Voxel Fields (NSVF), a new implicit representation for fast and high-quality free-viewpoint rendering. Instead of modeling the entire space with a single implicit function, NSVF consists of a set of voxel-bounded implicit fields organized in a sparse voxel octree. Specifically, we assign a voxel embedding at each vertex of the voxel, and obtain the representation of a query point inside the voxel by aggregration the voxel embeddings at the eight vertices of the corresponding voxel. This is further passed through a multilayer perceptron network (MLP) to predict geometry and appearance of that query point. Our method can progressively learn NSVF from coarse to fine with a differentiable ray-marching operation from only a set of posed 2D images of a scene. During training, the sparse voxels containing no scene information will be pruned to allow the network to focus on the implicit functions learning for volume regions with scene contents. With the sparse voxels, rendering at inference time can be greatly accelerated by skipping empty voxels without scene content.
Our method is over 10 times faster than the state-of-the-art (namely, NeRF (Mildenhall et al., 2020)) at inference time while achieving higher quality results. We extensively evaluate our method on a variety of challenging tasks including multi-object learning, free-viewpoint rendering of dynamic and indoor scenes. Our method can be used to edit and composite scenes. To summarize, our technical contributions are: • We present NSVF that consists of a set of voxel-bounded implicit fields, where for each voxel, voxel embeddings are learned to encode local properties for high-quality rendering; • NSVF utilizes the sparse voxel structure to achieve efficient rendering; • We introduce a progressive training strategy that efficiently learns the underlying sparse voxel structure with a differentiable ray-marching operation from a set of posed 2D images in an end-to-end manner.

Background
Existing neural scene representations and neural rendering methods commonly aim to learn a function that maps a spatial location to a feature representation that implicitly describes the local geometry and appearance of the scene, where novel views of that scene can be synthesized using rendering techniques in computer graphics. To this end, the rendering process is formulated in a differentiable way so that the neural network encoding the scene representation can be trained by minimizing the difference between the renderings and 2D images of the scene. In this section, we describe existing approaches to representation and rendering using implicit fields and their limitations.

Neural Rendering with Implicit Fields
Let us represent a scene as an implicit function F θ : (p, v) → (c, ω), where θ are parameters of an underlying neural network. This funciton describes the scene color c and its probability density ω at spatial location p and ray direction v. Given a pin-hole camera at position p 0 ∈ R 3 , we render a 2D image of size H × W by shooting rays from the camera to the 3D scene. We thus evaluate a volume rendering integral to compute the color of camera ray p(z) = p 0 + z · v as: Note that, to encourage the scene representation to be multiview consistent, ω is restricted as a function of only p(z) while c takes both p(z) and v as inputs to model view-dependent color. Different rendering strategies to evaluate this integral are feasible.
Surface Rendering. Surface-based methods (Sitzmann et al., 2019b;Liu et al., 2019b; assume ω(p(z)) to be the Dirac function δ(p(z) − p(z * )) where p(z * ) is the intersection of the camera ray with the scene geometry.
Volume Rendering. Volume-based methods (Lombardi et al., 2019;Mildenhall et al., 2020) estimate the integral C(p 0 , v) in Eq. 1 by densely sampling points on each camera ray and accumulating the colors and densities of the sampled points into a 2D image. For example, the state-of-the-art method NeRF (Mildenhall et al., 2020) estimates C(p 0 , v) as: are the colors and the volume densities of the sampled points.

Limitations of Existing Methods
For surface rendering, it is critically important that an accurate surface is found for learnt color to be multi-view consistent, which is hard and detrimental to training convergence so that induces blur in the renderings. Volume rendering methods need to sample a high number of points along the rays for color accumulation to achieve high quality rendering. However, evaluation of each sample points along the ray as NeRF does is inefficient. For instance, it takes around 30 seconds for NeRF to render an 800 × 800 image. Our main insight is that it is important to prevent sampling of points in empty space without relevant scene content as much as possible. Although NeRF performs importance sampling along the ray, due to allocating fixed computational budget for every ray, it cannot exploit this opportunity to improve rendering speed. We are inspired by classical computer graphics techniques such as the bounding volume hierarchy (BVH, Rubin and Whitted, 1980) and the sparse voxel octree (SVO, Laine and Karras, 2010) which are designed to model the scene in a sparse hierarchical structure for ray tracing acceleration. In this encoding, local properties of a spatial location only depend on a local neighborhood of the leaf node that the spatial location belongs to. In this paper we show how hierarchical sparse volume representations can be used in a neural network-encoded implicit field of a 3D scene to enable detailed encoding, and efficient, high quality differentiable volumetric rendering, even of large scale scenes.

Neural Sparse Voxel Fields
In this section, we introduce Neural Sparse-Voxel Fields (NSVF), a hybrid scene representation that combines neural implicit fields with an explicit sparse voxel structure. Instead of representing the entire scene as a single implicit field, NSVF consists of a set of voxel-bounded implicit fields organized in a sparse voxel octree. In the following, we describe the building block of NSVF -a voxel-bounded implicit field ( § 3.1) -followed by a rendering algorithm for NSVF ( § 3.2), and a progressive learning strategy ( § 3.3).

Voxel-bounded Implicit Fields
We assume that the relevant non-empty parts of a scene are contained within a set of sparse (bounding) voxels V = {V 1 . . . V K }, and the scene is modeled as a set of voxel-bounded implicit functions: Each F i θ is modeled as a multi-layer perceptron (MLP) with shared parameters θ: Here c and σ are the color and density of the 3D point p, v is ray direction, g i (p) is the representation at p which is defined as: g i (p) = ζ (χ ( g i (p * 1 ), . . . , g i (p * 8 ))) (4) Figure 1: Illustration of the differenitable volume rendering procedure with NSVF. For any given camera position p 0 and the ray direction v, we first intersect the ray with a set of sparse voxels, then predict the colors and densities with neural networks for points sampled along the ray inside voxels, and accumulate the colors and densities of the sampled points to get the rendered color C(p 0 , v).
Compared to using the 3D coordinate of point p as input to F i θ as most of previous works do, in NSVF, the feature representation g i (p) is aggregated by the eight voxel embeddings of the corresponding voxel where region-specific information (e.g. geometry, materials, colors) can be embeded. It significantly eases the learning of subsequent F i θ as well as facilitates high-quality rendering.
Special Cases. NSVF subsumes two classes of earlier works as special cases.

Volume Rendering
NSVF encodes the color and density of a scene at any point p ∈ V. Compared to rendering a neural implicit representation that models the entire space, rendering NSVF is much more efficient as it obviates sampling points in the empty space. As illustrated in Figure 1, rendering is performed in two steps: (1) ray-voxel intersection; and (2) ray-marching inside voxels, which we explain now for a ray.
Ray-voxel Intersection. We first apply Axis Aligned Bounding Box intersection test (AABBtest) (Haines, 1989) for each ray. It checks whether a ray intersects with a voxel by comparing the distances from the ray origin to each of the six bounding planes of the voxel. The AABB test is very efficient especially for a hierarchical octree structure (e.g. NSVF), as it can readily process millions of voxels in real time. Our experiments show that 10k ∼ 100k sparse voxels in the NSVF representation are enough for photo-realistic rendering of complex scenes.
Ray Marching inside Voxels. We return the color C(p 0 , v) by sampling points along a ray using Eq. (2). To handle the case where a ray misses all the objects, we additionally add a background term and c bg is learnable RGB values for background. As discussed in § 2, volume rendering requires dense samples along the ray in non-empty space to achieve high quality rendering. Densely evaluating at uniformly sampled points in the whole space (Figure 2 (a)) is inefficient because empty regions are frequently and unnecessarily tested. To focus on sampling in more important regions, Mildenhall et al. (2020) learned two networks where the second network is trained with samples from the distribution estimated by the first one (Figure 2 (b)). However, this further increases the training and inference complexity. In contrast, NSVF does not employ a secondary sampling stage while achieving better visual quality. As shown in Figure 2 (c), we create a set of query points using rejection sampling based on sparse voxels. Compared to the aforementioned approaches, we are able to sample more densely at the same evaluation cost. We include all voxel intersection points as additional samples and perform color accumulation with the midpoint rule. Our approach is summarized in Algorithm 1 Figure 2: Illustrations of (a) uniform sampling; (b) importance sampling based on the results in (a); (c) the proposed sampling approach based on sparse voxels.
Algorithm 1: Neural Rendering with NSVF Input: camera p0, ray direction v, step size τ , threshold , voxels V = {V1, . . . , VK }, background c bg , background maximum depth zmax, parameters of the MLPs θ Initialize: Obtain midpoints and intervals:ẑj ←z j +z j+1 where we additionally return the transparency A, and the expected depth Z which can be further used for visualizing the normal with finite difference.
Early Termination. NSVF can represent transparent and solid objects equally well. However, for solid surfaces, the proposed volume rendering disperses the surface color along the ray, which means that it takes many unnecessary accumulation steps behind the surface to make the accumulated transparency A(p 0 , v) reach 0. We therefore use a heuristic and stop evaluating points earlier when the accumulated transparency A(p 0 , v) drops below a certain threshold . In our experiments, we find that the setting = 0.01 significantly accelerates the rendering process without causing any noticeable quality degradation.

Learning
Since our rendering process is fully differentiable, NSVF can be optimized end-to-end through back-propagation by comparing the rendered outputs with a set of target images, without any 3D supervision. To this end, the following loss is minimized: where R is a batch of sampled rays, C * is the ground-truth color of the camera ray, and Ω(.) is a beta-distribution regularizer proposed in Lombardi et al. (2019). Next, we propose a progressive training strategy to better facilitate learning and inference: Voxel Initialization We start by learning implicit functions for an initial set of voxels subdividing an initial bounding box (with volume V ) that roughly encloses the scene with sufficient margin. The initial voxel size is set to l ≈ 3 V /1000. If a coarse geometry (e.g. scanned point clouds or visual hull outputs) is available, the initial voxels can also be initialized by voxelizing the coarse geometry. Self-Pruning Existing volume-based neural rendering works (Lombardi et al., 2019;Mildenhall et al., 2020) have shown that it is feasible to extract scene geometry on a coarse level after training. Based on this observation, we propose -self-pruning -a strategy to effectively remove non-essential voxels during training based on the coarse geometry information which can be further described using model's prediction on density. That is, we determine voxels to be pruned as follows: where {p j } G j=1 are G uniformly sampled points inside the voxel V i (G = 16 3 in our experiments), σ(g i (p j )) is the predicted density at point p j , γ is a threshold (γ = 0.5 in most of our experiments). Since this pruning process does not rely on other processing modules or input cues, we call it selfpruning. We perform self-pruning on voxels periodically after the coarse scene geometry emerges.
Progressive Training The above pruning strategy enables us to progressively adjust voxelization to the underlying scene structure and adaptively allocate computational and memory resources to important regions. Suppose that the learning starts with an initial ray-marching step size τ and voxel size l. After certain steps of training, we halve both τ and l for the next stage. Specifically, when halving the voxel size, we subdivide each voxel into 2 3 sub-voxels and the feature representations of the new vertices (i.e.g(.) in § 3.1) are initialized via trilinear interpolation of feature representations at the original eight voxel vertices. Note that, when using embeddings as voxel representations, we essentially increase the model capacity progressively to learn more details of the scene. In our experiments, we train synthetic scenes with 4 stages and real scenes with 3 stages. An illustration of self-pruning and progressive training is shown in Figure 3.

Experiments
We evaluate the proposed NSVF on six datasets. We provide qualitative and quantitative comparisons to three recent methods on four datasets and show our results on several challenging tasks including multi-scene learning, rendering of dynamic and large-scale indoor scenes, and scene editing and composition. We also perform ablation studies to validate different kinds of feature representations and different options in progressive training. Please see the Appendix for implementation details, pre-processing details of datasets and additional results. Please also refer to the supplemental video which shows the rendering quality.

Experimental Settings
Datasets We conduct experiments on the following synthetic datasets and real datasets: • Synthetic-NeRF: The synthetic dataset used in Mildenhall et al. (2020) includes eight objects rendered in 800 × 800. • Synthetic-NSVF: To demonstrate the ability of NSVF to handle various conditions, we additionally render eight objects 2 in 800 × 800 with more complex geometry and lighting effects. • BlendedMVS: We test on four objects from Yao et al. (2020). The rendered images are blended with the real images to have realistic ambient lighting with a resolution of 768 × 576. • Tanks&Temples: We evaluate on five objects from the Tanks&Temples real dataset (Knapitsch et al., 2017). Here we use the images and label the object masks ourselves. The image resolution is 1920 × 1080.  • ScanNet: We use two real scenes from ScanNet (Dai et al., 2017). We extract both RGB and depth images from the original video and scale the images to 640 × 480.
• Maria Sequence: This sequence is provided by Volucap with the meshes of 200 frames of a moving female. We render each mesh to create a dataset.
Baselines We adopt the following three recently proposed methods as baselines: Scene Representation Networks (SRN, Sitzmann et al., 2019b), Neural Volumes (NV, Lombardi et al., 2019), and Neural Radiance Fields (NeRF, Mildenhall et al., 2020), representing surface-based rendering, explicit and implict volume rendering, respectively. See the Appendix for implementation details.

Results
Quality Comparison We show the qualitative comparisons in Figure 4. SRN tends to produce overly smooth rendering and incorrect geometry; NV and NeRF work better but are still not able to synthesize images as sharply as NSVF does. NSVF can achieve photo-realistic results on various kinds of scenes with complex geometry, thin structures and lighting effects.
Also, as shown in Table 1, NSVF significantly outperforms the three baselines on all the four datasets across all metrics. Note that NSVF with early termination ( = 0.01) produces almost the same quality as NSVF without early termination (denoted as NSVF 0 in Table 1). This indicates that where the x-axis stands for ascending foreground to background ratio and the y-axis for rendering time in second. We also show a plot curve for rendering time of NSVF on one synthetic scene in (d) when the camera is zooming out where the x-axis stands for the distance from the camera to the center of the object and the y-axis for rendering time in second. early termination would not cause noticeable quality degradation while significantly accelerating computation, as will be seen next.

Speed Comparison
We provide speed comparisons on the models of four datasets in Figure 5 where we merge the results of Synthetic-NeRF and Synthetic-NSVF in the same figure considering their image sizes are the same. For our method, the average rendering time is correlated to the average ratio of foreground to background as shown in Figure 5 (a)-(c). That is because the higher the average ratio of foreground is, the more rays intersect with voxels. Thus, more evaluation time is needed. The average rendering time is also correlated to the number of intersected voxels. When a ray intersects a large number of voxels in the rendering of a solid object, early termination significantly reduces rendering time by avoiding many unnecessary accumulation steps behind the surface. These two factors can be seen in Figure 5 (d) where we show a zoom-out example. At the beginning, only part of sparse voxels are shown in the view so the rendering time is not at the peak. As the camera zooms out, the rendering time reaches the peak when all the voxels are in the view. After that, the rendering time decreases as the ratio of foreground to background decreases.
For other methods, the rendering time is almost constant. This is because they have to evaluate all pixels with fixed steps, indicating a fixed number of points are sampled along each ray no matter whether the ray hits the scene or not, regardless of the scene complexity. In general, our method is around 10 ∼ 20 times faster than the state-of-the-art method NeRF, and gets close to SRN and NV.
Rendering of Large-scale Indoor Scenes We demonstrate the effectiveness of our method on ScanNet dataset under challenging inside-out reconstruction scenarios. Our results are shown in Figure 6 where the initial voxels are built upon the point clouds from the depth images.
Rendering with Dynamic Scenes As shown in Figure 6, we validate our approach on a corpus with dynamic scenes using the Maria Sequence. In order to accommodate temporal sequence with NSVF, we apply the hypernetwork proposed in Sitzmann et al. (2019b).

Multi-scene Learning
We train a single model for all 8 objects from Synthetic-NeRF together with 2 additional objects (wineholder, train) from Synthetic-NSVF. We use different voxel embeddings for each object while using the same MLPs to predict density and color. For comparison, we train NeRF model for the same datasets based on a hypernetwork (Ha et al., 2016). Without voxel   embeddings, NeRF has to encode all the scene details with the network parameters. Compared to single object learning results (Table 1), our model easily scales to encoding multiple objects, with only slight decreases 1.40, 0.011, 0.002 on PSNR, SSIM and LPIPS. In contrast, NeRF has much worse performance drop as 4.24, 0.074, 0.090, indicating drastic degradation in terms of quality due to its limited network capacity. Scene Editing and Scene Composition. As shown in Figure 7, the learnt multi-object model can be readily used to compose more complex scenes by duplicating and moving voxels, and be rendered in the same way without overhead. Furthermore, our approach also supports scene editing by directly adjusting the presence of sparse voxels (See the re-composition of wineholder in Figure 7).

Ablation Studies
We use one object (wineholder) from the Synthetic-NSVF dataset which consists of parts with complex local patterns (grids) for ablation studies. Figure 8 shows the comparison on different kinds of feature representations for encoding a spatial location. Voxel embeddings bring larger improvements to the quality than using positional encoding. Also, with both positional encoding and voxel embeddings, the model achieves the best quality, especially for recovering high frequency patterns.

Effect of Progressive Training
We also investigate different options for progressive training (see Table 2). Note that all the models are trained with voxel embeddings only. The performance is improved with more rounds of progressive training. But after a certain number of rounds, the quality improves only slowly while the rendering time increases. Based on this observation, our model performs 3-4 rounds of progressive training in the experiments.

Related Work
Neural Rendering Recent works have shown impressive results by replacing or augmenting the traditional graphics rendering with neural networks, which is typically referred to as neural rendering.
We refer the reader to recent surveys for neural rendering (Tewari et al., 2020;Kato et al., 2020). first render a given geometry with explicit or neural textures into coarse RGB images or feature maps which are then translated into high-quality images. However, these works need 3D geometry as input and the performance would be affected by the quality of the geometry. • Novel View Synthesis without 3D inputs: Other approaches learn scene representations for novel-view synthesis from 2D images. Generative Query Networks (GQN) (Eslami et al., 2018) learn a vectorized embedding of a 3D scene and render it from novel views. However, they do not learn geometric scene structure as explicitly as NSVF, and their renderings are rather coarse. Following-up works learned more 3D-structure aware representations and accompanying renderers (Flynn et al., 2016;Zhou et al., 2018;Mildenhall et al., 2019) with Multiplane Images (MPIs) as proxies, which only render a restricted range of novel views interpolating input views. RenderNet (Nguyen-Phuoc et al., 2018) and its follow-up works (Nguyen-Phuoc et al., 2019;Liu et al., 2019c) use a CNN-based decoder for differentiable rendering to render a scene represented as coarse-grained voxel grids. However, this CNN-based decorder cannot ensure view consistency due to 2D convolution kernels.
To enforce view consistency, the other research line (Lombardi et al., 2019;Sitzmann et al., 2019a) use classical rendering techniques for differentiable rendering of the learnt scene represented as fine-grained voxel grids which makes scene structure more explicit but limits achievable spatial resolution. SRN (Sitzmann et al., 2019b) and NeRF (Mildenhall et al., 2020) introduce a neural implicit function to model the entire scene. However, their results are either blurry or suffer from slow rendering process. In addition, these approaches do not easily permit scene editing and composition. The proposed NSVF allows efficient and higher-quality novel view synthesis even of larger scenes, and enables scene editing and composition.
Neural Implicit Representations. Implicit representations have been studied to model 3D geometry with neural networks. Compared to explicit representations (such as point cloud, mesh, voxels), implicit representations are continuous and have high spatial resolution. Most works require 3D supervision during training to infer the SDF value or the occupancy probability of any 3D point (Michalkiewicz et al., 2019;Chen and Zhang, 2019;Park et al., 2019;Peng et al., 2020), while other works learn 3D representations only from images with differentiable renderers (Liu et al., 2019d;Saito et al., 2019Saito et al., , 2020Jiang et al., 2020).

Limitations and Future Work
Although NSVF can efficiently generate high-quality novel views and significantly outperform existing methods, there are three major limitations: (i) Our method cannot handle scenes with complex background. We assume a simple constant background term (c bg ). However, real scenes usually have different backgrounds when viewed from different points. This makes it challenging to capture their effects correctly without the interference on the learning of the target scenes. Figure 9: A comparison between NSVF output (left) and the groud-truth (right) of a cropped view sampled from scene lifestyle (Synthetic-NSVF dataset).
(ii) Similar to Sitzmann et al. (2019b); Mildenhall et al. (2020), NSVF learns the color and density as a "blackbox" function of the query point location and the camera-ray direction. Therefore, the rendering performance highly depends on the distribution of training images, and may produce severe artifacts when the training data is insufficient or biased for predicting complex geometry, materials and lighting effects (see Figure 9 where the refraction on the glass bottle is not learnt correctly). A possible future direction is to incorporate the traditional radiance and rendering equation as a physical inductive bias into the neural rendering framework. This can potentially improve the robustness and generalization of the neural network models.
(iii) The current learning paradigm requires known camera poses as inputs to initialize rays and their direction. For real world images, there is currently no mechanism to handle unavoidable errors in camera calibration. When our target data consists of single-view images of multiple objects, it is even more difficult to obtain accurately registered poses in real applications. A promising avenue for future research would be to use unsupervised techniques such as GANs (Nguyen-Phuoc et al., 2019) to simultaneously predict camera poses for high-quality free-viewpoint rendering results.

Conclusion
We propose NSVF, a hybrid neural scene representations for fast and high-quality free-viewpoint rendering. Extensive experiments show that NSVF is over 10 times faster than the state-of-the-art (namely, NeRF) while achieving better quality. NSVF can be easily applied to scene editing and composition. We also demonstrate a variety of challenging tasks, including multi-scene learning, free-viewpoint rendering of a moving human, and large-scale scene rendering.

Broader Impact
NSVF provides a new way to learn a neural implicit scene representation from images that is able to better allocate network capacity to relevant parts of a scene. In this way, it enables learning representations of large-scale scenes at higher detail than previous approaches, which also leads to higher visual quality of the rendered images. In addition, the proposed representation enables much faster rendering than the state-of-the-art, and enables more convenient scene editing and compositing. This new approach to 3D scene modeling and rendering from images complements and partially improves over established computer graphics concepts, and opens up new possibilities in many applications, such as mixed reality, visual effects, and training data generation for computer vision tasks. At the same time it shows new ways to learn spatially-aware scene representations of potential relevance in other domains, such as object scene understanding, object recognition, robot navigation, or training data generation for image-based reconstruction.
The ability to capture and re-render, only from 2D images, models of real world scenes at very high visual fidelity, also enables the possibility to reconstruct and re-render humans in a scene. Therefore, any research on and practical application of this and all related reconstruction methods have to strictly respect personality rights and privacy regulations.
• Tanks & Temples. We evaluate on five objects of Tanks and Temples (Knapitsch et al., 2017) 4 real scene dataset. We label the object masks ourselves with the software of Altizure 5 , and sample One eighth of the images for testing. The image resolution is 1920 × 1080.
• ScanNet. We use two real scenes of an RGB-D video dataset for large-scale indoor scenes, ScanNet (Dai et al., 2017) 6 . We extract both the RGB and depth images of which we randomly sample 20% as training set and use the rest for testing. The image is scaled to 640 × 480.
For the multi-scene learning, we show our result of training with all the scenes of Synthetic-NeRF and two out of Synthetic-NSVF, and the result of training with all the frames of a moving human: • Maria Sequence. This sequence is provided by Volucap with the meshes of 200 frames of a moving female. We render each mesh from 50 viewpoints sampled on the upper hemisphere at 1024 × 1024 pixels. We also render 50 additional views in a circular trajectory as the test set.

A.2 Implementation Details
Architecture The proposed model assigns a 32-dimentional learnable voxel embedding to each vertex, and applies positional encoding with maximum frequency as L = 6 (Mildenhall et al., 2020) to the feature embedding aggregated by eight voxel embeddings of the corresponding voxel via trilinear interpolation. As a comparison, we also train our model without positional encoding where we set the voxel embedding dimension d = 416 in order to have comparable feature vectors as the complete model. We use around 1000 initial voxels for each scene. The final number of voxels after pruning and progressive training varies from 10k to 100k (the exact number of voxels differs scene by scene due to varying sizes and shapes), with an effective number of 0.32 ∼ 3.2M learnable parameters in our default voxel embedding settings.
The overall network architecture of our default model is illustrated in Figure 10 with ∼ 0.5M parameters, not including voxel embeddings. Note that, our implementation of the MLP is slightly shallower than many of the existing works (Sitzmann et al., 2019b;Mildenhall et al., 2020). By utilizing the voxel embeddings to store local information in a distributed way, we argue that it is sufficient to learn a small MLP to gather voxel information and make accurate predictions.
Training & Inference We train NSVF using a batch size of 32 images on 8 Nvidia V100 GPUs, and for each image we sample 2048 rays. To improve training efficiency, we use a biased sampling strategy to sample rays where it hits at least one voxel. We use Adam optimizer with an initial learning rate of 0.001 and linear decay scheduling. By default, we set the step size τ = l/8, while the initial voxel size (l) is determined as discussed in § 3.3.
For all experiments, we prune the voxels with Eq (6) periodically for every 2500 steps. All our models are trained with 100 ∼ 150k iterations by progressively halving the voxel and step sizes at 5k, 25k and 75k, separately. At inference time, we use the threshold of = 0.01 for early termination for all models. As a comparison, we also conduct experiments without setting up early termination. Our model is implemented in PyTorch using Fairseq framework 7 . Evaluation We measure the quality on test sets with three metrics: PSNR, SSIM and LPIPS (Zhang et al., 2018). For the comparisons in speed, we render NSVF and the baselines with one image per batch and calculate the average rendering time using a single Nvidia V100 GPU.
Multi-scene Learning Our experiments also require learning NSVF on multiple objects where a voxel location may be shared by different objects. In this work, we present two ways to tackle this issue. First, we use the navie approach that learns saperate embedding matrices for each object and only the MLP are shared. This is well suitable when the categories of target objects are quite distinct, and this can essentially increase the model capacity by extending the number of embeddings infinitely. We validate this method on Synthetic-10 dataset.
However, when modeling multiple objects that have similarities (e.g., a class of objects, or a moving sequence of the target object), it is more suitable to have shared voxel representations. Here we learn a set of voxel embeddings for each voxel position, while maintaining a unique embedding vector for each object. We compute the final voxel representation based on hypernetworks (Sitzmann et al., 2019b) with the object embedding as the input. We show our results on Maria Sequence.

A.3 Additional Baseline Details
Scene Representation Networks (SRN, Sitzmann et al., 2019b) We use the original code opensourced by the authors 8 . To enable training on higher resolution images, we employ the ray-based sampling strategy that is similarly used in neural volumes and NeRF. We use the batch size of 8 and 5120 rays per image. We found that clipping gradient norm to 1 greatly improves stability during training. All models are trained for 300k iterations.

B.1 Per-scene breakdown
We show the per-scene breakdown analysis of the quantitative results presented in the main paper (Table 1) for the four datasets (Synthetic-NeRF, Synthetic-NSVF, BlendedMVS and Tanks&Temples). Table 3 reports the comparisons with the three baselines in three metrics. Our approach achieves the best performance on both PSNR and LPIPS metrics across almost all the scenes, especially for datasets with real objects.

B.2 Additional Examples
In Figure 11, we present additional examples for individual scenes not shown in the main paper. We would like to highlight how well our method performs across a wide variety of scenes, showing much better visual fidelity than all the baselines.

B.3 Additional Analysis
Effects of Voxel Sizes. In Table 4, we show additional comparison on wineholder where we fix the ray marching step size as the initial values, while training the model with different voxel sizes. The first column shows the ratio compared to the initial voxel size. It is clear that reducing the voxel size helps improve the rendering quality, indicating that progressively increasing the model's capacity alone helps model details better for free-viewpoint rendering.

Geometry Reconstruction Accuracy
We would like to expand on the observation that we have briefly touched on in the main paper regarding the nature of surface-based and volume-based renderers. As we have mentioned, surfacebased rendering methods (e.g. SRN) require an accurate surface to be able to learn the color well. A failure case where geometry fails to be learnt is seen in the "Character" scene in Figure 11. In addition, we observe that SRN frequently gets stuck in a local minima so that the geometry is incorrect but is nevertheless approximately multi-view consistent. We find that this phenomenon occurs much less frequently in volume rendering methods including ours. NV, due to limited spatial resolution, is unable to capture high frequency details. NeRF generally works well while is still not able to synthesize images as sharply as NSVF does. Furthermore, NeRF suffers from a slow rendering process due to its inefficient sampling strategy. For instance. it takes 30s to render an 800 × 800 image with NeRF.  Figure 13: Our sampled results on ScanNet of two different rooms. From left to right: the predicted image, the initial voxels from the point clouds, and the predicted geometry normals. . Figure 14: Illustration of scene editing and rendering with NSVF.

Zoom-In & -Out
Our model naturally supports zooming in and out for a trained object. We show the results in Figure 12.

B.4 Details for Experiments on ScanNet
We list the details of learning on the ScanNet dataset. We first extract point clouds from all the RGBD images using known camera poses, and register them in the same 3D space. We then initialize a voxel based on the extracted points instead of using a bounding box. No pruning or progressive training are applied in this case. Furthermore, we integrate an additional depth loss based on the provided depth image, that is, where Z * is the ground truth depth and Z is the expected distance where each ray terminates at this distance in Algorithm 1. We show more qualitative results in Figure 13.

B.5 Details for Experiments on Maria Sequence
We present additional details for learning on the Maria sequence. The Maria sequence consists of 200 frames of different poses if the same character. Since there exists strong correlation from frame to frame, we model all frames with the same set of initial voxels (a bounding box covers all 200 frames) and utilize a hypernetwork described in (Sitzmann et al., 2019b) to output the weights of the MLPs with the frame index as inputs. Different from single-object learning, we always start from the initial voxels and perform self-pruning at every training iteration.

B.6 Procedure for Scene Editing and Composition
The learnt NSVF representations can be readily used for editing and composition. We show the basic procedure to edit a real scene in the following three steps: (1) learn and extract sparse voxels with multi-view 2D input images; (2) apply editing (e.g. translation, cloning, removal, etc.) on the voxels; (3) read the modified voxels and render new images. We illustrate the procedure in Figure 14. Furthermore, by learning the model with multiple objects, we can easily render composed scenes by rearranging learned voxels and rendering at the same time.