\section{Appendix}
\subsection{Data generation}

\paragraph{Camera pose distribution.}
Our RTMV dataset is designed to be more challenging than existing novel view synthesis datasets.
In addition to its diversity in terms of scene lighting and objects materials and textures (see Figure~\ref{fig:dataset}),
it contains two types of camera placements: hemisphere and free.
The `hemisphere' camera placement is an easy setup where cameras are placed at an equal distance from the scene (\ie, on a hemisphere).
Therefore, trained multi view synthesis models do not need to reason about multi-scale.
In the `free' camera placement, the camera is allowed to roam freely within a cube surrounding the scene,
thus providing a variety of multi-scale images of the scene.
Figure~\ref{fig:camera_dist} shows the distribution of camera azimuth and elevation for each of our four environments.

\paragraph{Python-based ray tracer.}
Our python-based ray-tracing renderer is built on NVIDIA OptiX~\cite{optix} with a C++/CUDA backend.
It uses path tracing to render high-quality and physically-based images.
In addition, it appeals to non-graphics experts through its simple Python API.
The scripting capability makes it easy to install, use and share.
Figure~\ref{fig:nvisii} shows a simple code example highlighting the simplicity of our Python API.

\subsection{Additional qualitative results}
We show more qualitative results on each of our four environments in Figures~\ref{fig:more_qual_results_1},~\ref{fig:more_qual_results_2},~\ref{fig:more_qual_results_3},~\ref{fig:more_qual_results_4},
and the corresponding depth maps in Figures~\ref{fig:more_qual_results_1_depth},~\ref{fig:more_qual_results_2_depth},~\ref{fig:more_qual_results_3_depth},~\ref{fig:more_qual_results_4_depth}.
SVLF trains with depth supervision, and thus constructs better depth maps compared to NeRF and mip-NeRF.
Instant-NGP gives the best results but suffers from floating artifacts which can also be seen in the recovered depth maps.
All baselines perform reasonably well on the Google Scanned Objects and the Bricks environments.
However, the performance of both NeRF~\cite{mildenhall2020nerf} and SVLF drops on the ABC environment due its challenging camera poses and lighting conditions.
And eventually, all baselines struggle on our most challenging environment (Amazon Berkeley).
The multi-scale training of mip-NeRF~\cite{barron2021mip} makes it more robust to random camera poses compared to the other baselines, especially on the Amazon Berkeley environment.
Instant-NGP suffers from floating artifacts especially with random camera poses (\eg, ABC and Amazon Berkeley environments).
But overall, Instant-NGP recovers fine details, renders sharp results, and achieves the best performance on our dataset.

The voxel-based formulation of SVLF allows for a better representation of the scene that accommodates free-moving cameras.
This is because SVLF focuses on rays intersecting voxels, rather than where rays originated and ends.
In contrast, the near and far render planes parametrization of NeRF and mip-NeRF poses a limitation.
On one hand, setting near and far planes to tightly bound the scene leads to better point sampling along the ray during training,
but allows for less flexibility for moving the camera at render time.
On the other hand, setting the near and far plane to loosely enclose the scene allows for more flexible camera movement at inference time,
but leads to poor training quality as NeRF and mip-NeRF are sensitive to how densely points are sampled along the ray.
Figure~\ref{fig:render_planes} highlights this limitation,
by showing example results for when the camera is placed at very close (first two rows) or far (third row) distance from the scene.

\input{supp_figures/fig_nvisii}

\input{supp_figures/fig_render_planes}


\subsection{SVLF limitations}

In this section we discuss some of the limitations of the proposed SVLF approach.

\paragraph{Voxel resolution.}
SVLF uses a sparse octree to represent a voxel grid of size $128^3$.
While this voxel resolution allows for high quality results over the test set of our scenes,
it can produce voxel boundary artifacts if the camera zooms in too close to the scene.
Specifically, the between voxels become more visible as the camera zooms in (see Figure~\ref{fig:limitations}).

\paragraph{Sub-optimal training of optical thickness.}
SVLF learns voxel-based functions.
Although using a shared decoder as well as the tri-linear interpolation between voxel features provides a degree of continuity between adjacent voxels,
voxel features could still suffer from a degree of independence.
This especially happens to the optical thickness features, $\zdensity$, where the tri-linear interpolations happens at the intersection points, $(x_1, x_2)$, between the ray and the voxel, rather than at the estimated surface point $\hat{x}_s$.
This could lead to a lack of global context between voxels along the ray, thus resulting in errors in the learned optical thickness $\tau$.
Figure~\ref{fig:limitations} show example failures where incorrect predictions of the optical thickness $\tau$ lead to either floaters or holes in the rendered image.
Note the holes inside and beside the red shoe in Figure~\ref{fig:limitations}-(a),
and random floaters in Figure~\ref{fig:limitations}-(a), (b).

\paragraph{Translucent surfaces.}
SVLF evaluates the ray color within a voxel at a single point location (the estimated surface hit $\hat{x}_s$).
Therefore, we assume solid surfaces, and bootstrap the training using surface rendering (Sec.~{\color{red} 4.4} of the main paper).
While SVLF utilizes a volumetric training stage to learn non-binary optical thicknesses/densities, the support for translucent surfaces remains limited 
due to the sampling a single point within each voxel.

\paragraph{View-dependent effects.}
We observe that SVLF does not capture view dependent effects very well (\eg, specular highlight on the vase in Figure~\ref{fig:limitations}-column 3.)
We hypothesize this is due to the absence of an explicit view direction input to our network.
Adding the view direction as an extra input besides the estimated surface hit $\hat{x}_s$ could help mitigate the problem. 


\input{supp_figures/fig_limitations}

\input{supp_figures/fig_more_qual_results}


\section{Introduction}


Since the publication of NeRF~\cite{mildenhall2020nerf},
there has been an explosion of interest in neural volume rendering for novel view synthesis \cite{barron2021mip,martinbrualla2020nerfw,liu2020neural,neff2021donerf,yu2020pixelnerf,park2021nerfies,tewari2021advances}.
This heightened attention of the research community is due to the impressive high-fidelity results that had long remained elusive but which are now possible.
Further, these techniques are able to capture the 3D geometry of the scene with precision \cite{Oechsle2021ICCV,wang2021neus,takikawa2021nglod}, thus opening up an entirely new family of algorithms for 3D scene reconstruction.

Despite this progress, it is not yet clear what are the limitations of such techniques.
Because of the difficulty of acquiring multi-view images of complex scenes with ground truth, only a handful of scenes has been available to date.
As a result, since the existing methods have only been tested on a small number of scenes, it is unclear how they will perform on a wider variety of scenes.  For example, can these methods simultaneously handle multiple objects, diverse materials and textures, challenging lighting conditions, and free camera poses?
Can they generalize to new complex scenes from a few views?
Questions such as these point to the need for a large-scale dataset to evaluate algorithms for novel view synthesis.


In this paper we propose to address this problem by sharing a large-scale dataset for novel view synthesis.
Comparison to existing datasets is shown in Table~\ref{tab:related_work}.
Our dataset consists of nearly 2000 scenes composed of multiple objects, with complex materials and textures illuminated by various light sources (see Fig.~\ref{fig:header}).
We selected these objects from 4 distinct sources of large collections, thus providing significant variety to the dataset.
Approximately 300k high-resolution ($1600 \times 1600$) synthetic images were created using ray tracing to ensure high fidelity, with the virtual camera placed either on a hemisphere or freely within the environment (see Fig.~\ref{fig:cam_single}).
Using synthetic data enables the following advantages:  1) noise-free annotations, 2) rich metadata that otherwise would not be possible, and 3) full control over variations.
Moreover, recent efforts at real-time ray tracing have made tremendous progress in reducing the sim-to-real gap for
different computer vision applications, {\em e.g.}, pose estimation~\cite{labbe2020} or facial analysis~\cite{wood2001iccv:fakeit}.
As a result, synthetic data is becoming increasingly important for training and evaluating deep networks~\cite{dosovitskiy2015iccv:flychairs,tremblay2018wad:car,tremblay:corl2018}.

We use this dataset to benchmark several existing algorithms, thus highlighting existing limitations and pointing out the need for future research.
However, we are only able to evaluate available methods on a small subset of our dataset due to their high computational demands.
To reduce the computational cost, we propose a novel algorithm called SVLF (Sparse Voxel Light Field) that is an order of magnitude faster than NeRF to train on synthetic scenes, and nearly two orders of magnitude faster to render.
This speedup is achieved by a novel combination of an octree representation, querying each voxel only once, and using a much smaller network, as well as leveraging depth maps for training.
We show that SVLF achieves results comparable to NeRF while being much more computationally efficient.

Our dataset has many uses beyond evaluation.
First, a large dataset like ours is useful for training neural networks by exposing the network to more variety than is possible with existing datasets.
Second, the size of the dataset allows for investigating few-show view synthesis, where an algorithm trained on a larger set of scenes is then able to process new scenes without training from scratch.
Third, because the synthetic data allows for rich metadata such as ground truth depth, geometry, camera poses, object positions, and so forth, it facilitates research on networks that require these inputs for training (\eg, novel view synthesis algorithms that train on ground truth depth).
Finally, the dataset can be used for problems other than novel view synthesis, such as 3D reconstruction and pose estimation.



\begin{table}
\begin{footnotesize}
    \centering
    \resizebox{\columnwidth}{!}{
    \begin{tabular}{lccccccccc}

        \toprule
         Datasets & \cite{mildenhall2020nerf} & \cite{Knapitsch2017} & \cite{yao2020blendedmvs} & \cite{jensen2014large} & \cite{sitzmann2019srns,yu2020pixelnerf} & \cite{mildenhall2019llff}& \cite{reizenstein2021common}&\textbf{Ours}\\
         \midrule
         scenes & 8 & 15 & 502 & 124 & 3511&24 &20k &2000                  \\
         resolution & 800 & 1080 & 1536 & 1200 & 128&480 &1088& 1600               \\
         multi-object & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark} & \textcolor{darkgreen}{\checkmark} & \redxmark & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark} \\
         free camera & \redxmark & \textcolor{darkgreen}{\checkmark} & \textcolor{darkgreen}{\checkmark} & \redxmark & \redxmark & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark}          \\
         full GT & \textcolor{darkgreen}{\checkmark} & \redxmark & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark} & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark}                          \\
         HDR export & \redxmark & \redxmark & \redxmark & \redxmark & \redxmark & \redxmark & \redxmark & \textcolor{darkgreen}{\checkmark} \\
         \bottomrule
    \end{tabular}
    }
    \caption{Comparison of novel view synthesis datasets.
    From top to bottom:  the number of scenes, image resolution (smallest dimension), whether the scene is composed of multiple objects, whether the camera can freely move about the scene (as opposed to front-facing, hemisphere, etc.), whether ground truth (GT) information is available (\eg, depth, lighting, object material), and whether high dynamic range (HDR) is exported.}
    \label{tab:related_work}
    \vspace{-0.3cm}
\end{footnotesize}
\end{table}





\begin{figure}
\centering
\resizebox{0.9\linewidth}{!}{
\begin{tabular}{ccc}
\rotatebox{90}{\footnotesize \ \ \ \ \ \ \ \ \ \ \ \ \ Goog. Scan.} &
\includegraphics[trim = {500px 100px 500px 150px},clip, width=0.42\columnwidth]{figures/cams/google/005.jpg} &
\includegraphics[trim = {500px 100px 500px 150px},clip, width=0.42\columnwidth]{figures/cams/google/071.jpg} \\
\vspace{-0.15cm}
\rotatebox{90}{\footnotesize \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ABC} &
\includegraphics[trim = {500px 100px 500px 100px},clip, width=0.42\columnwidth]{figures/cams/abc/005.jpg} &
\includegraphics[trim = {500px 100px 500px 100px},clip, width=0.42\columnwidth]{figures/cams/abc/071.jpg} \\
\vspace{-0.15cm}
\rotatebox{90}{\footnotesize \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Bricks} &
\includegraphics[trim = {600px 100px 600px 250px},clip, width=0.42\columnwidth]{figures/cams/lego/005.jpg} &
\includegraphics[trim = {600px 100px 600px 250px},clip, width=0.42\columnwidth]{figures/cams/lego/071.jpg} \\
\vspace{-0.15cm}
\rotatebox{90}{\footnotesize \ \ \ \ \ \ \ \ \ \ \ \ \ \ Amz. Ber.} &
\includegraphics[trim = {600px 300px 600px 200px},clip, width=0.42\columnwidth]{figures/cams/amazon/005.jpg} &
\includegraphics[trim = {600px 300px 600px 200px},clip, width=0.42\columnwidth]{figures/cams/amazon/071.jpg} \\
\end{tabular}
}
\caption{
	Camera distributions for a single scene per environment, for each scene we present 2 example view points.
}
\label{fig:cam_single}
\vspace{-0.4cm}
\end{figure}

\section{Related work}

\medskip \noindent \textbf{Novel view synthesis.} Novel view synthesis is a long-standing problem in computer vision and graphics.
Image-based rendering (IBR) techniques~\cite{gortler1996lumigraph,debevec1996modeling,buehler2001unstructured,sinha2009piecewise,chaurasia2011silhouette,chaurasia2013depth,penner2017soft,riegler2020free} synthesize a novel view from a set of reference images by computing blend weights of nearby reference views.
Another class of work builds a volumetric representation of the scene such as voxel grids~\cite{kar2017learning,penner2017soft,tulsiani2017multi,henzler2020learning,lombardi2019neural} or multi-plane images (MPI)~\cite{choi2019extreme,srinivasan2019pushing,zhou2018stereo,flynn2019deepview,li2020crowdsampling,mildenhall2019llff}.
To render such representations, techniques like alpha compositing or volume rendering are typically used to synthesize novel views.

\medskip \noindent \textbf{Neural implicit representations.}
More recently,
neural implicit representations~\cite{Park_2019_CVPR,Occupancy_Networks,chen2019learning} have shown great potential for novel view synthesis by storing scene properties as the weights of a fully connected network.
Most notably, NeRF~\cite{mildenhall2020nerf} optimizes a 5D radiance field that maps a point and viewing direction to its density and color values, which can then be integrated for rendering.
Mip-NeRF~\cite{barron2021mip} uses integrated positional encoding over a cone frustum to render anti-aliased multi-scale images.
NeRF has opened the door to many exciting research directions~\cite{tewari2021advances,dellaert2020neural,barron2021mip,kaizhang2020,rebain2021derf,tancik2021learned,park2021nerfies,xian2021space,li2021neural,pumarola2020d,du2021nerflow,Gafni_2021_CVPR,Gao-portraitnerf,martinbrualla2020nerfw,Schwarz2020NEURIPS,chanmonteiro2020pi-GAN}.
However, NeRF (and closely-related variants) are slow to train and render, as rendering a single pixel requires evaluating hundreds of samples along a ray, each constituting an expensive neural network query.
To increase speed, some works~\cite{yu2021plenoctrees,liu2020neural} utilize an octree to prune empty space and only sample points close to the surface.
Another alternative, DONeRF~\cite{neff2021donerf}, utilizes depth images to train a depth prediction network, thus achieving high-quality synthesis by evaluating only a few point samples around the estimated depth.  Instant-NGP~\cite{mueller2022instant}, which was developed concurrently with this work, is yet another alternative that uses multiple tricks to achieve orders of magnitude speedup over NeRF.

While NeRF focuses on fitting single scenes,
several works aim to generalize across multiple scenes~\cite{grf2020,yu2020pixelnerf,wang2021ibrnet,chen2021mvsnerf}.
First, a prior is learned over a feature volume by training on a dataset of multiple scenes. Then, presented only with few-shot images of a new scene, the learned prior is utilized to render novel views of the new scene.

\medskip \noindent \textbf{Data synthesizer.}~Given the high demand for large annotated datasets for deep learning, there has been an increase in both synthetic datasets \cite{tremblay2018arx:fat,ros2016cvpr:syn,mayer2016cvpr:flythings,handa2015arx:sn,zhang2016arx:unst,Richter_2016_ECCV,gaidon2016cvpr:vkitti} and in tools for generating such data \cite{kolve2017ai2,to2018ndds,unity2020perception,denninger2019blenderproc,xiang2020sapien}.
The Cycles renderer included in Blender
has been widely used in the research community for generating synthetic data because of its ray tracing ability~\cite{Gu_2017_CVPR,mildenhall2020nerf,iraci2013blender,sajjan2019cleargrasp,wood2015_iccv,ron2020expohd,robotpose_etfa2019_cheind}.
In an attempt to more easily generate synthetic images, Denninger {\em et al.}~\cite{denninger2019blenderproc} introduced an extension to Blender that renders objects falling onto a plane with randomized camera poses.
Other tools, like SAPIEN \cite{xiang2020sapien}, have also used the OptiX backend~\cite{optix} to optimize
ray tracing performance.
We believe that our proposed Python ray tracer adds to this suite by providing scripting capabilities, along with the ease of installation and development.

\medskip \noindent \textbf{Datasets for novel view synthesis.} The original NeRF paper~\cite{mildenhall2020nerf} introduced 8 synthetic scenes with
360-degree views.
Since their release, the accessibility of these scenes has allowed for rapid progress in novel view synthesis, yet, the small number of such scenes makes it difficult to assess performance at scale.
Wang~{\em et al.}~\cite{wang2021ibrnet} introduced a synthetic dataset including Google Scanned Objects.
Other datasets for training multi-view algorithms include
DTU~\cite{jensen2014large},
LLFF~\cite{mildenhall2019llff},
Tanks and Temples~\cite{Knapitsch2017},
Spaces~\cite{flynn2019deepview},
RealEstate10K~\cite{zhou2018stereo},
SRN~\cite{sitzmann2019srns, yu2020pixelnerf},
Transparent Objects~\cite{IchnowskiAvigal2021DexNeRF},
ROBI~\cite{yang2021robi},
CO3D~\cite{reizenstein2021common,henzler2021unsupervised},
SAPIEN~\cite{xiang2020sapien},
and
BlendedMVS~\cite{yao2020blendedmvs}.
See Table~\ref{tab:related_work} for further information.
During the preparation of this manuscript, Reizenstein {\em et al.}~\cite{reizenstein2021common,henzler2021unsupervised} introduced a large real dataset for
multi-view synthesis, using camera
views around the object.
We believe our proposed dataset nevertheless provides unprecedented scale, variety, and quality.













\section{Ray-Traced Multi-View Dataset}


\subsection{NViSII}
Recent advances in ray tracing have allowed researchers
to generate photo-realistic images with unprecedented speed and quality.
Such advancements are accessible via tools integrated within existing rendering frameworks with complex interfaces (\eg, \cite{denninger2019blenderproc}).
In contrast, we propose an accelerated standalone
Python-enabled ray tracing / path tracing renderer built on NVIDIA OptiX~\cite{optix} with a C++/CUDA backend.
The Python API allows for non-graphics experts to easily install the renderer,
quickly create 3D scenes with the full power that scripting provides, and is simply 
installed through {\tt pip} package management\footnote{{\tt pip install nvisii}. See \url{https://nvisii.com/} for extended documentation.}.

NViSII allows for complex visual material definitions using Disney's principled BSDF~\cite{burley2015extending} model.
This model takes sixteen parameters, whose combinations result in physically-plausible, well-behaved results across their entire range.
These parameters, which include color, metallic, transmission, and roughness components, have a perceptually linear effect on the appearance of the BSDF.\@
The linearity property is well-suited to uniform random sampling in order to create a variety of different materials, such as smooth and rough plastics, metals, and dielectrics (\eg, glass and water).
We drive these parameters using either scalar values or textures to create a diverse dataset.

Our solution also supports advanced rendering capabilities, such as multi-GPU ray tracing, physically-based light controls, accurate camera models (including defocus blur and motion blur), native headless rendering, and exporting various metadata (\eg, segmentation, motion vectors, optical flow, depth, surface normals, and albedo).


















\subsection{Data generation}

We use NViSII~\cite{morrical2021nvisii} to generate 1927 unique scenes in total from 4 different environments, each environment being a collection of 3D models drawn from a different data source (see Tab.~\ref{table:highlevel}).
For each scene, we normalize it to be contained within a unit cube and generate 150 unique image frames.
Ground truth annotations include a depth/distance map, background alpha mask, segmentation mask, scene point cloud,
and various metadata (\eg, camera poses, entity poses, material properties, and light positions).
Images are exported in the `EXR' format as it allows for storing colors in a high dynamic range without tonemapping and/or gamma correction pre-applied.
Each image is rendered at 4000 samples per pixel. %
We use 2 types of camera placements: hemisphere and free (\eg, Fig.~\ref{fig:cam_single}). The former places the camera on the hemisphere surrounding the
scene, while the latter moves the camera freely within a cube avoiding collisions with the objects
(please refer to the supp.~material for the distribution of camera azimuth and elevation over the entire dataset).
Overall the dataset is orders of magnitude larger than what is typically used for novel
view synthesis.
Since it is time consuming for an algorithm like NeRF~\cite{mildenhall2020nerf} to process the entire dataset,
we also provide a smaller subset composed of 40 scenes, 10 from each environment.

\subsection{Environments}

These 4 different environments are as follows.



\begin{table}
\begin{footnotesize}
\begin{tabular}{rccc}
\toprule
Environment  	  & Camera type & Lighting & \# scenes\\
\midrule
Google Scanned 	  & hemisphere  & white dome 		& 300\\
ABC   	 	      & free 		& spotlight 		& 300\\
Bricks  	  	  & hemisphere  & white dome \& sun & 1027\\
Amazon-Berkeley   & free 		& HDRI dome light 	& 300\\
\bottomrule
\end{tabular}
\end{footnotesize}
\caption{High level parameters for the four environments.}
\label{table:highlevel}
\vspace{-0.4cm}
\end{table}




\begin{figure*}
    \vspace{-0.1cm}
    \centering
    \includegraphics[trim={0, 0, 20px, 0}, clip, width=.9\linewidth]{figures/svlf/svlf_overview-3col-v3.jpg}
    \vspace{-0.3cm}
    \caption{SVLF overview for a given voxel $v$. (a) Rays are parameterized by the normalized intersection points with the bounding sphere,
    $\ensuremath{\textbf{r}} = [\Tilde{p}_1 \,\,|\,\, \Tilde{p}_2]$, where $\tilde{p}_i = \hat{p}_i/\|\hat{p}_i\|$.
        (b) SVLF first estimates the optical thickness $\tau$ and a within-voxel depth $\eta$ to the surface hit, if any.
        (c) Color features are sampled at the estimated surface point $\hat{x}_s$ and a color decoder predicts the final ray color $c$.}
    \label{fig:svlf}
    \vspace{-0.5cm}
\end{figure*}



\medskip \noindent \textbf{Google Scanned Objects.} All the $\sim$1000 Google scanned models~\cite{GoogleScanned} were used to generate 300 falling objects scenes.
In each scene, we randomly selected 20 3D models, added collision shapes, and let the objects fall onto each other and onto a table using the PyBullet physics simulator~\cite{coumans2019:pybullet}.
We applied a random material to the texture since BRDF materials are not provided with the models (they are mostly plastic-like).
Note that the provided textures from these 3D models have light baked into the textures, which can cause the object to look unrealistic, {\em e.g.}, having highlights where it should be dark.
The camera remains at a constant distance from the center and always points toward the center of the scene.
The scenes are lit by a single white dome light.
This dataset is the most similar to NeRF's synthetic data~\cite{mildenhall2020nerf}.
This is also the easiest of our 4 environments: it has a small number of objects and
views distributed on the hemisphere.

\medskip \noindent \textbf{ABC.} We used all the 3D models ($\sim$1.5M) from the ABC dataset~\cite{Koch_2019_CVPR}.
In each scene, we randomly selected 50 3D models and scaled them so that they are all of a similar size.
Similar to the previous environment, we constructed 300 scenes of falling objects using physical simulation.
Each object was also given a random BRDF material (plastic, metallic, rough metallic, {\em etc.}), and a random bright color, so that this environment has multiple view-dependent materials.
The scenes were illuminated by a uniform dome light, and by a bright point light simulating a directional light to produce hard shadows.
The camera was allowed to freely move within the unit cube and look at any of the objects, thus producing both close and far images.
As a result, this environment has the most challenging viewpoints.

\medskip \noindent \textbf{Bricks.} We downloaded 1027 unique models from \href{https://mecabricks.com}{Mecabricks}.
For each model, we generated a single scene where the model was placed in the middle of the scene.
The camera was randomly placed on a hemisphere at a fixed distance from the center.
The camera was aimed at random locations within 1/10 of the unit volume used to scale the object,
thus producing images that are not centered on the model.
Each scene was illuminated by a white dome light and a warm sun placed randomly on the horizon.
These detailed scenes are challenging due to the variety of textures and presence of self-reflections.
This is our largest environment, since it has 1027 scenes.


\medskip \noindent \textbf{Amazon-Berkeley.} Similar to ABC and Google Scanned Objects, we loaded 40 3D models from the \href{https://amazon-berkeley-objects.s3.amazonaws.com/index.html}{Amazon Berkeley Objects (ABO)  dataset} \cite{collins2021abo}, scaled them, and let them fall onto a plane.
Since the 3D models are accompanied with high-quality textures and material definitions, we light the scene with a full HDRI map and apply a random texture on the floor, both from \href{https://polyhaven.com}{Poly Haven}.
Similar to ABC scenes, the camera was allowed to move freely within the unit cube and to look at any object.
Also similar to ABC, the materials are quite challenging, such as metallic (mirror-like) objects.
We believe this is the most challenging environment of the dataset offering interesting views, materials, textures, lighting, and photo-realistic backgrounds.



\section{Sparse Voxel Light Field (SVLF)} \label{sec:method}




Given the size and complexity of our dataset,
in this section we present an efficient and lightweight multi-view voxel-based algorithm for novel view synthesis.
At a high level,
our method learns a voxel-based function that maps a ray $\ensuremath{\textbf{r}}$ to the optical thickness $\tau_{v_i}$\footnote{Optical thickness is defined, as in~\cite{novak2018monte}, as the integral of the density along a segment of a ray, so that $\alpha=(1 - e^{-\tau_{v_i}})$ is the opacity.} and color $c_{v_i}$ associated with a particular voxel $v_i$.
This mapping is realized by evaluating two small decoder networks.
Rendering a single pixel consists of a volumetric integration that amounts to only a handful of network queries, determined by the number of voxels intersected along the ray.
This is in contrast to evaluating hundreds of queries along the ray as in NeRF~\cite{mildenhall2020nerf}.
























\begin{figure*}
\centering
\resizebox{0.9\linewidth}{!}{
\begin{tabular}{ccc|cc|cc|cc}
&
\multicolumn{2}{c}{Google Scanned Objects} &
\multicolumn{2}{c}{ABC} &
\multicolumn{2}{c}{Bricks} &
\multicolumn{2}{c}{Amazon Berkeley} \\
\rotatebox{90}{\small Ground truth} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/google_00105_gt-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/google_00105_gt-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/abc_00105_gt-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/abc_00105_gt-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/lego_00105_gt-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/lego_00105_gt-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/amazon_00105_gt-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/gt/amazon_00105_gt-zoom.jpg}

\\
\rotatebox{90}{\small \ \ \ \ \ \ SVLF} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/google-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/google-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/abc-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/abc-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/lego-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/lego-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/amazon-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/svlf/amazon-zoom.jpg}

\\
\rotatebox{90}{\small Ins.-NGP} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/google-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/google-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/abc-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/abc-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/lego-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/lego-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/amazon-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/hash/amazon-zoom.jpg}

\\
\rotatebox{90}{\small mip-NeRF} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/google-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/google-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/abc-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/abc-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/lego-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/lego-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/amazon-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/mip/amazon-zoom.jpg}

\\
\rotatebox{90}{\small \ \ \ \ \ \ NeRF} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/google-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/google-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/abc-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/abc-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/lego-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/lego-zoom.jpg} &

\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/amazon-rect.jpg} &
\includegraphics[trim=0 0 0 -5, width=0.2\columnwidth]{figures/results/nerf/amazon-zoom.jpg}



\end{tabular}
}
\vspace{-0.2cm}
\caption{
Single-scene novel view synthesis results of the baselines on a sample scene from each environment.
}
\label{fig:qual_comp}
\vspace{-0.4cm}
\end{figure*}

\subsection{Representation}
\label{sec:svlf_representation}

\paragraph{Scene volume.}
Given depth maps provided with our dataset,
we partition the scene into a voxel grid $\mathcal{V}$ and represent the space using an octree~\cite{takikawa2021nglod}.
This allows for efficient memory utilization as the octree only represents voxels that contain a surface.
We use $\mathcal{Z}$ to represent a collection of feature vectors over the feature volume.
Each voxel $v$ in the octree stores learnable feature embeddings $z_{v,j} \in \mathcal{Z}$ at each of its eight corners ($j \in \{1, 2, \dots 8\}$), where feature embeddings are shared between spatially adjacent voxels.
In other words, each vertex in the octree is associated with one feature embedding.
The feature embedding $z_p$ is defined for any point $p \in \R^3$ in the space as $z_p = \psi(p; \mathcal{Z})$, where $\psi(.)$ is the tri-linear interpolation between corner features of the voxel in which $p$ is contained.
The collection of feature embeddings $\mathcal{Z}$ is learned to encode local properties of each voxel, while the tri-linear interpolation and shared features between adjacent voxels ensure a degree of continuity in the feature space. %

\medskip \noindent \textbf{Ray parameterization.}
Since we aim at learning voxel-based functions, we parameterize a given ray $\ensuremath{\textbf{r}}$ in the local coordinates of each voxel.
Specifically, as shown in Fig.~\ref{fig:svlf}~(a), we compute the intersection points $p_1, p_2 \in \R^3$ of $\ensuremath{\textbf{r}}$ with the minimum bounding sphere around the voxel, define vectors $\hat{p}_i$ from the voxel origin to these intersections, then scale them to unit norm:  $\Tilde{p}_i = \hat{p}_i / \| \hat{p}_i \|$, $i=1,2$.
This gives us the overparameterized representation $\ensuremath{\textbf{r}} = [\begin{matrix}\Tilde{p}_1 \,\,|\,\, \Tilde{p}_2\end{matrix}] \in \mathbb{R}^6$.

\subsection{Voxel-based light field function}
\label{sec:svlf_fn}

The collection $\mathcal{Z}$ is split into feature embeddings $\mathcal{Z}^\mathcal{T}$ for optical thickness, and feature embeddings $\mathcal{Z}^\mathcal{C}$ for color.
Each of these sub-collections has an associated small decoder network:  $\fdensity$ for optical thickness, and $\fcolor$ for color.


Given a voxel $v$ and a ray $\ensuremath{\textbf{r}}$, we first compute the ray-voxel intersection points $x_1, x_2$ (see Fig.~\ref{fig:svlf}~(b)) using an efficient ray-AABB intersection algorithm~\cite{majercik2018ray}.
We then estimate the optical thickness and color of the ray in two steps.
The first step estimates whether the ray hits a surface within $v$, and produces an estimate for the location of the hit surface point $\hat{x}_s$ as a convex combination of $x_1$ and $x_2$.
Specifically, we have:
\begin{equation}
    \tau, \eta = \fdensity(\ensuremath{\textbf{r}}, z^\mathcal{T}),
\end{equation}
where $\tau$ is the estimated optical thickness,
$\eta \in [0, 1]$ is the mixing factor interpolating between $x_1, x_2$
, and $z^\mathcal{T} = [\begin{matrix}\psi(x_1; \zdensity ) \,\,|\,\, \psi(x_2; \zdensity )\end{matrix}]$ is the combined interpolated feature embedding at the two intersection points.
If $\tau\neq 0$, the surface point $\hat{x}_s$ is estimated as $\hat{x}_s = \eta x_1 + (1 - \eta) x_2$, where $\eta$ can be seen as a within-voxel depth.
Otherwise, if $\tau=0$, the ray does not hit any surface.
We estimate surface points to encourage continuous sampling of color features between adjacent voxels.

The second step samples color features $\zcolor$ at the estimated surface point $\hat{x}_s$ and computes the color value $c$ as
\begin{equation}
    c = \fcolor(\ensuremath{\textbf{r}}, z^\mathcal{C}),
    \label{eq:ceqfc}
\end{equation}
where $z^\mathcal{C} = \psi(\hat{x}_s; \zcolor)$ is the interpolated feature embedding at $\hat{x}_s$ (see Fig.~\ref{fig:svlf}~(c)).

\subsection{Rendering}
\label{sec:svlf_rendering}



To render a pixel from an SVLF, we perform volume rendering.
We first evaluate the color $c$ and optical thickness $\tau$ for all voxels intersected by the ray,
then we aggregate the color values using alpha compositing.

\medskip \noindent \textbf{Evaluating intersected voxels.}
We first compute a list of all voxels intersected by the ray.
We use the sparse ray-octree intersection algorithm of~\cite{takikawa2021nglod} that leverages the hierarchical octree structure and parallel scan kernels~\cite{merrill2017cub} for accelerated computation.
This step yields $x_1$ and $x_2$ for each intersected voxel.
We then evaluate the optical thickness $\tau$ and color $c$ at each intersected voxel as described in Sec.~\ref{sec:svlf_fn}.
Each voxel is evaluated only once by querying two lightweight decoder networks~$\fdensity$ and ~$\fcolor$ to compute the optical thickness and color, respectively.

\medskip \noindent \textbf{Aggregating color values along the ray.}
We use alpha compositing to compute the ray color $c(\ensuremath{\textbf{r}})$ as:
\begin{equation}
    c(\ensuremath{\textbf{r}}) = \sum_{i=1}^N T_{v_i} (1 - e^{-\tau_{v_i}}) c_{v_i}, \quad T_{v_i} = \prod_{j < i} e^{-\tau_{v_j}}
    \label{eqn:rendering}
\end{equation}
where $N$ is the number of intersected voxels, $T_{v_i}$ is the transmittance up until voxel $v_i$, and voxels are indexed by the order of their intersection along the ray.

\begin{table*}
\centering
\begin{footnotesize}
\resizebox{0.82\linewidth}{!}{
\begin{tabular}{ccrclrclrclrcrrcr}
\toprule
\multirow{2}{*}{Method} & \multirow{2}{*}{Env.} & \multicolumn{9}{c}{Image-based metrics} & \multicolumn{6}{c}{Depth-based metrics} \\
\cmidrule(lr){3-11}\cmidrule(lr){12-17}%
& & \multicolumn{3}{c}{PSNR $\uparrow$} & \multicolumn{3}{c}{SSIM $\uparrow$} & \multicolumn{3}{c}{LPIPS $\downarrow$} & \multicolumn{3}{c}{RMSE ($10^3$) $\downarrow$} & \multicolumn{3}{c}{MAE ($10^3$) $\downarrow$} \\\midrule
NeRF &Goog. Scan. &29.627 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.863 &0.937 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.026 &0.046 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.015 &24.101 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}14.234 &43.854 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}7.523 \\
mip-NeRF &Goog. Scan. &31.727 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.681 &0.952 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.019 &0.032 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.010 &18.726 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}9.791 &36.932 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}7.464 \\
Ins.-NGP &Goog. Scan. &\textbf{32.772} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.985 &\textbf{0.963} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.012 &\textbf{0.017} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.007 &\textbf{1.920} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.542 &\textbf{7.515} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}2.784 \\
SVLF &Goog. Scan. &30.868 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.941 &0.954 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.020 &0.019 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.009 &9.200 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}4.341 &16.844 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}12.567 \\
\hline
NeRF &ABC &29.956 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}4.267 &0.947 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.042 &0.041 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.043 &66.312 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}146.052 &167.650 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}330.674 \\
mip-NeRF &ABC &32.191 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.328 &0.956 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.037 &\textbf{0.024} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.027 &22.497 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}11.307 &41.285 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}10.008 \\
Ins.-NGP &ABC &\textbf{34.250} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}4.564 &\textbf{0.971} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.027 &0.025 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.024 &\textbf{2.121} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}2.798 &\textbf{14.230} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}5.016 \\
SVLF &ABC &29.998 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.035 &0.949 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.044 &0.029 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.032 &10.238 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}7.008 &18.816 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}11.844 \\
\hline
NeRF &Bricks &28.279 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.363 &0.940 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.036 &0.041 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.023 &60.762 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}43.947 &34.122 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}30.115 \\
mip-NeRF &Bricks &31.329 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.361 &0.956 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.030 &0.023 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.014 &40.941 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}29.233 &23.717 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}6.869 \\
Ins.-NGP &Bricks &\textbf{32.255} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.277 &\textbf{0.970} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.019 &0.023 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.013 &\textbf{4.491} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.299 &\textbf{7.977} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.023 \\
SVLF &Bricks &29.244 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.265 &0.949 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.032 &\textbf{0.022} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.014 &20.300 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}13.938 &13.869 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}9.300 \\
\hline
NeRF &Amz. Ber. &25.778 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.704 &0.796 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.092 &0.184 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.108 &28.490 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}192.051 &74.041 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}21.488 \\
mip-NeRF &Amz. Ber. &\textbf{26.859} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.231 &0.784 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.088 &\textbf{0.141} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.077 &14.919 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}67.881 &66.027 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}17.342 \\
Ins.-NGP &Amz. Ber. &25.405 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}5.657 &\textbf{0.836} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.089 &0.161 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.103 &\textbf{12.693} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}112.870 &\textbf{36.202} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}33.896 \\
SVLF &Amz. Ber. &25.197 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.936 &0.795 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.103 &0.161 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.106 &15.305 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}49.771 &38.119 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}48.792 \\
\hline
NeRF \hspace{4ex}{\tiny (0.15 fps)} &all &28.363 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.819 &0.905 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.049 &0.078 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.046 &44.916 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}99.071 &79.917 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}97.450 \\
mip-NeRF \hspace{1ex}{\tiny (0.3 fps)} &all &30.526 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}2.900 &0.912 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.043 &\textbf{0.055} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.032 &24.271 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}29.090 &41.990 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}10.421 \\
Ins.-NGP \hspace{2ex}{\tiny (60 fps)}&all &\textbf{31.170} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.871 &\textbf{0.935} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.037 &0.056 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.037 &\textbf{5.306} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}30.127 &\textbf{16.481} &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}11.180 \\
SVLF \hspace{3ex}{\tiny (12.10 fps)} &all &28.827 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.044 &0.912 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.050 &0.058 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.040 &13.761 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}18.764 &21.912 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}20.626 \\
\bottomrule
\end{tabular}
}
\end{footnotesize}
\vspace{-0.2cm}
\caption{Comparison of baseline methods on the 40-scene subset of our dataset at $400 \times 400$ resolution.
}
\label{table:results}
\vspace{-0.2cm}
\end{table*}



\begin{table*}
\centering
\begin{minipage}{.7\linewidth}
\begin{footnotesize}
\resizebox{0.98\linewidth}{!}{
\begin{tabular}{crclrclrclrcrrcr}
\toprule
\multirow{1}{*}{Env.} & \multicolumn{9}{c}{Image-based metrics} & \multicolumn{6}{c}{Depth-based metrics} \\
\cmidrule(lr){2-10}\cmidrule(lr){11-16}
& \multicolumn{3}{c}{PSNR $\uparrow$} & \multicolumn{3}{c}{SSIM $\uparrow$} & \multicolumn{3}{c}{LPIPS $\downarrow$} & \multicolumn{3}{c}{RMSE ($10^3$) $\downarrow$} & \multicolumn{3}{c}{MAE ($10^3$) $\downarrow$}\\
\midrule
Goog. Scan. &31.269 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}1.461 &1.486 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.014 &0.054 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.013 &0.634 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.591 &6.790 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}2.829 \\
ABC &33.888 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.842 &0.975 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.017 &0.034 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.024 &1.311 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}2.075 &13.913 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}5.104 \\
Bricks &31.170 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.281 &0.966 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.020 &0.045 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.029 &2.526 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}8.298 &7.863 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}8.112 \\
Amz. Ber. &23.129 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}4.882 &0.851 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.078 &0.254 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.097 &17.766 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}164.130 &47.861 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}53.498 \\
\hline
all &30.358 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}3.334 &1.030 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.027 &0.077 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}0.036 &4.412 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}30.355 &14.854 &\hspace{-2.7ex}$\pm$ &\hspace{-2.6ex}13.878 \\
\bottomrule
\end{tabular}
}
\end{footnotesize}
\vspace{-0.2cm}
\caption{Results for for the full dataset at $1600 \times 1600$ res. with Instant-NGP \cite{mueller2022instant}}
\label{table:results_full}
\end{minipage}
~\quad
\begin{minipage}{.25\linewidth}
\begin{footnotesize}
    \centering
    \vspace{1ex}  %
    \begin{tabular}{ccc}
         \toprule
         env. & PSNR $\uparrow$ & SSIM $\uparrow$ \\
         \midrule
         Goog. Scan. & 14.588 & 0.483 \\
         ABC & 12.149 &  0.629\\
         Bricks & 12.149 & 0.523\\
         Amz. Ber. & 12.126 & 0.318\\
         \midrule
         all & 12.753 & 0.488 \\
        \bottomrule
    \end{tabular}
\end{footnotesize}
\vspace{-0.2cm}
\caption{Pixel-NeRF results.}
\label{tab:pixelnerf}
\end{minipage}
\vspace{-0.4cm}
\end{table*}

\subsection{Multi-stage training}
\label{sec:svlf_training}
We train SVLF in three stages:
\begin{enumerate}[leftmargin=*]
    \item Voxel training:
    We begin our training using surface rendering.
    For each ray, we use the corresponding depth to find the voxel containing the surface hit by the ray.
    We learn local features for each voxel to produce the correct color $c$, within-voxel depth $\eta$ and optical thickness $\tau$ using the following loss:
    \begin{equation}
        \mathcal{L} = \sum_v \|c_v - c_{\text{gt}}\|^2 + \lambda_{\eta} \|\eta_v - \eta_{\text{gt}}\|^2 + \lambda_\tau \|e^{-\tau_v}\|^2
        \label{eqn:loss}
    \end{equation}
    where the last term encourages predicting a zero transparency for the ray segment through $v$.

    \item Volumetric training of optical thickness: Next, we freeze the color features $\zcolor$ and decoder $\fcolor$ (Eq.~\ref{eq:ceqfc}), and train the optical thickness network to predict the correct integral weights for volume rendering (Eq.~\ref{eqn:rendering}). We use the same loss function (Eq.~\ref{eqn:loss})
    except that
    we compute the photometric loss with the aggregated ray color, $c(\ensuremath{\textbf{r}})$, and
    we set $\lambda_\tau$ to zero to turn off direct supervision on the optical thickness $\tau$. We observe that freezing the color network is important for convergence, otherwise the network gets stuck in poor local minima.
    \item Fine-tuning: Finally, we unfreeze the color features $\zcolor$ and decoder $\fcolor$, and fine-tune the full model using the same loss function, but with a lowered learning rate.
\end{enumerate}


\subsection{Implementation details}
\label{sec:implementation_details}
\noindent \textbf{Architecture.}
We represent a scene using a sparse octree, constructed at $128^3$ voxel resolution.
The octree implementation comes from the Kaolin library~\cite{Kaolin}.
Specifically, we leverage the Structured Point Cloud (SPC) representation which supports efficient CUDA kernels for ray tracing.
We have additionally implemented CUDA kernels for volumetric rendering using efficient scan primitives from CUB~\cite{merrill2017cub},
which we leverage for fast and efficient rendering of our SVLF model.
Both the optical thickness and color decoders $\fdensity$, $\fcolor$ are ReLU MLP networks.
We use a single hidden layer for $\fdensity$ and 3 hidden layers for $\fcolor$, all with size 128.
We apply a ReLU activation to the output optical thickness $\tau$, and a sigmoid activation to both the mixing ratio $\eta$ and color $c$ outputs.
We set the embedding size of the feature collections $\zdensity$ and $\zcolor$ to 64 and 32, respectively.

\medskip \noindent \textbf{Training.}
We run our staged training (Sec.~\ref{sec:svlf_training}) for 300 epochs, which takes $\sim$160 minutes on a single NVIDIA V100 GPU.
We use the Adam optimizer~\cite{adamOptimizer} with a learning rate of 1e-3 and a batch size of a single image down-scaled to a $400 \times 400$ resolution.
We train using surface rendering for 100 epochs.
We then freeze the weights of the color features $\zcolor$ and decoder $\fcolor$ and run the volume\-tric training stage for 150 epochs.
Finally, we unfreeze the color weights ($\zcolor, \fcolor$), and continue volumetric training for another 50 epochs with a learning rate of 2e-4.




\section{Experiments}
\label{sec:experiments}

In this section, we benchmark different baselines against our dataset on two main tasks: single scene view synthesis and few-shot view synthesis.
We evaluate the view reconstruction quality of baselines using PSNR and SSIM (higher is better) and LPIPS~\cite{zhang2018perceptual} (lower is better).
We also evaluate the reconstructed depth maps using RMSE and MAE (lower is better).

\subsection{Single scene view synthesis}

In our dataset, each scene is composed of 150 unique views.
We propose to use 100 views for training,
5 views for validation, and 45 views for testing.
For this task we evaluate four baselines:
NeRF~\cite{mildenhall2020nerf}, mip-NeRF~\cite{barron2021mip}, the concurrent work of Instant-NGP~\cite{mueller2022instant} and our proposed SVLF.
We use the author-provided implementations for NeRF\footnote{\url{https://github.com/bmild/nerf}}, mip-NeRF\footnote{\url{https://github.com/google/mipnerf}}, and Instant-NGP\footnote{\url{https://github.com/NVlabs/instant-ngp}} and train all methods until convergence.
The number of training steps was determined by the saturation of the mean PSNR value over the validation set for a few scenes and then was fixed for all scenes.
As NeRF and mip-NeRF have quite large training time, we propose a smaller subset composed of 10 scenes per environment,
for a total of 40 scenes.
Finally, we mask out the background in the Amazon Berkeley environment as the baselines are not designed to handle complex backgrounds.

Table~\ref{table:results} presents high level results for image and depth-based metrics, and
Figure~\ref{fig:qual_comp} presents qualitative comparisons.
All methods perform reasonably well on the Google Scanned Objects and the Bricks environments
which have a setup similar to
the NeRF Synthetic dataset~\cite{mildenhall2020nerf}.
NeRF and SVLF performance degrade on the ABC environment, and
none of the baselines performs well on our most challenging environment, Amazon Berkeley,
with Instant-NGP being the most robust of the baselines, followed by mip-NeRF as it is trained on multi-scale images.
SVLF benefits from depth supervision during training and therefore constructs better depth maps than NeRF and mip-NeRF.
In our experiments we have observed that SVLF does not always capture view dependent effects due to a lack of global context in our voxel-based formulation and the absence of an explicit view direction input.

Finally, we show results using Instant-NGP for all 1927 scenes of the dataset at full resolution in Table~\ref{table:results_full}.
Please refer to the supp.~material for more qualitative results and depth map visualizations.




\begin{table}
\centering
\begin{footnotesize}
\resizebox{0.92\linewidth}{!}{
\begin{tabular}{ccccc}
\toprule
\multirow{1}{*}{Method} & \multicolumn{2}{c}{Training} & \multicolumn{2}{c}{Rendering} \\
\cmidrule(lr){2-3}\cmidrule(lr){4-5}
& \# steps & time (hrs) & time/frame (sec) & FPS \\
\midrule
NeRF & 500K  & 26.3 & 6.86 & 0.15  \\
mip-NeRF & 500K & 35.0 & 3.30 & 0.30 \\
SVLF & 30K & 2.7 & 0.08 & 12.10\\
\bottomrule
\end{tabular}
}
\end{footnotesize}
\vspace{-0.2cm}
\caption{Training and inference time comparison on the single-scene novel view synthesis task.}
\label{table:runtime}
\vspace{-0.4cm}
\end{table}










\medskip
\noindent \textbf{Runtime comparison}
We compare the training and rendering speed of SVLF to the baselines in Table~\ref{table:runtime}.
Training is done on a single V100 GPU, while inference is done on a single RTX 3090 GPU.
SVLF trains an order of magnitude faster than the other baselines as it utilizes depth maps during training.
This observation is also consistent with \cite{neff2021donerf}, a depth-supervised NeRF.

To compare inference time, we compute the average rendering time over the 45 test images of the first scene of the Google Scanned Objects environment.
SVLF is over 80x faster to render than NeRF, and approximately 40x faster than mip-NeRF on our test scene.
There are two main reasons for this speedup.
First, rendering SVLF requires significantly fewer network queries per ray compared to NeRF.
The number of queries is determined by the number of voxels intersected along the ray, which is efficiently computed using the ray-octree intersection algorithm of~\cite{takikawa2021nglod}.
On average, we have less than~$10$ voxel evaluations per ray on our scenes.
Second, the cost per query is much cheaper for SVLF.
This is due to moving much of the network capacity to the learned local features, and thus enabling using a much smaller decoder architecture ($\sim$16x smaller) than the NeRF network.

\subsection{Few-shot view synthesis}




Given that each environment includes multiple scenes with shared characteristics, camera distributions, object types,
and/or lighting, we can use any environment to train few-shot view synthesis algorithms.
Different methods \cite{sitzmann2019srns,yu2020pixelnerf} have shown that a single or few views ($<5$)
can be used to predict new views.
We propose to partition our dataset as follows: 280 scenes for training, 2 scenes for validation,
and 18 scenes for testing.
Since the Bricks environment is bigger, we propose to use 900 scenes for training, 30 for validation, and 100 for testing.
We use the freely available training code\footnote{\url{https://github.com/sxyu/pixel-nerf}} for PixelNeRF~\cite{yu2020pixelnerf}.
We found the algorithm unstable to train,
especially when having random camera poses, and eventually diverging after a few hundred epochs.
We terminate the training when the model diverges and use the latest proper checkpoint for evaluation.
We show qualitative results for a 3-shot input experiment in Fig.~\ref{fig:pixelnerf} and report quantitative metrics in Table~\ref{tab:pixelnerf}.
Even though the results are encouraging, it is clear that future work is needed
in the area of few-shot view synthesis.




\begin{figure}
     \centering
    \begin{footnotesize}
    \resizebox{0.96\linewidth}{!}{
     \begin{tabular}{cc|c|c}
    \multicolumn{2}{c}{input views} & GT & PixelNeRF~\cite{yu2020pixelnerf} \\
        \rotatebox{90}{\footnotesize Goog. Scan.} &
	     \includegraphics[trim={0 0 513px 129px}, clip, height=1.2cm]{figures/pixelnerf/goog/1134_0000_vis.jpg}
        &
         \includegraphics[trim={385px 0 385px 129px}, clip, height=1.2cm]{figures/pixelnerf/goog/1134_0000_vis.jpg}
         &
         \includegraphics[trim={641px 0 129px 129px}, clip, height=1.2cm]{figures/pixelnerf/goog/1134_0000_vis.jpg}
         \\
          \rotatebox{90}{\footnotesize \ \ \ \ \ \ Bricks} &
	     \includegraphics[trim={0 0 513px 129px}, clip, height=1.2cm]{figures/pixelnerf/lego/0746_0200_vis.jpg}
        &
         \includegraphics[trim={385px 0 385px 129px}, clip, height=1.2cm]{figures/pixelnerf/lego/0746_0200_vis.jpg}
         &
         \includegraphics[trim={641px 0 129px 129px}, clip, height=1.2cm]{figures/pixelnerf/lego/0746_0200_vis.jpg}
         \\
                     \rotatebox{90}{\footnotesize \ \ \ \ \ \ ABC} &
         \includegraphics[trim={0 0 513px 129px}, clip, height=1.2cm]{figures/pixelnerf/abc/1181_0000_vis.jpg}
         &
         \includegraphics[trim={385px 0 385px 129px}, clip, height=1.2cm]{figures/pixelnerf/abc/1181_0000_vis.jpg}
         &
         \includegraphics[trim={641px 0 129px 129px}, clip, height=1.2cm]{figures/pixelnerf/abc/1181_0000_vis.jpg}
         \\
         \rotatebox{90}{\footnotesize Amz. Ber.} &
	     \includegraphics[trim={0 0 513px 129px}, clip, height=1.2cm]{figures/pixelnerf/amz/0144_0000_vis.jpg}
        &
         \includegraphics[trim={385px 0 385px 129px}, clip, height=1.2cm]{figures/pixelnerf/amz/0144_0000_vis.jpg}
         &
         \includegraphics[trim={641px 0 129px 129px}, clip, height=1.2cm]{figures/pixelnerf/amz/0144_0000_vis.jpg}
     \end{tabular}
     }
    \end{footnotesize}
    \vspace{-0.3cm}
    \caption{Sample results of PixelNeRF~\cite{yu2020pixelnerf} on our dataset. }
    \vspace{-0.5cm}
    \label{fig:pixelnerf}
\end{figure}

\section{Conclusion}
In this work, we proposed RTMV, a large-scale, high quality and ray-traced synthetic dataset for novel view synthesis.
Our dataset is orders of magnitude larger than currently used datasets and offers a challenging variety in terms of camera poses, lighting conditions, object material and textures.
Thus, RTMV is suitable as a demanding benchmark to evaluate view synthesis algorithms that will help advance novel view synthesis research.
We also proposed SVLF, a voxel-based accelerated algorithm for novel view synthesis.
SVLF is an order of magnitude faster to train on synthetic images, and two orders of magnitude faster to render than NeRF, while retaining output quality.
Finally, we propose a Python-based ray tracing renderer that is easy to use by non-experts and suitable for fast scripting and rendering high-quality physically-based images.


\vspace{-0.2cm}
\begin{small}
  \paragraph{Acknowledgments.}
  We thank Chen-Hsuan Lin for his valuable feedback. MM was partially funded by DARPA SemaFor (HR001119S0085).
\end{small}


\begin{figure*}[hbt!]
    \centering
    \captionsetup{type=figure}
    \includegraphics[width=1\textwidth]{figures/results/all_training.jpg} \\
    \label{tab:dataset}
    \caption{Examples of multiple views from different environments:
      Google Scanned ($1^\mathit{st}$ row),
      ABC ($2^\mathit{nd}$ row),
      Bricks ($3^\mathit{rd}$ row), and
      Amazon-Berkeley ($4^\mathit{th}$ row).
      (Best viewed when zoomed.)
    }
    \vspace{-0.1cm}
    \label{fig:dataset}
    \vspace{-0.2cm}
\end{figure*}%






