[ECCV'20] Convolutional Occupancy Networks
Efficiently reconstructing complex and intricate surfaces at scale is a long-standing goal in machine perception. To address this problem we introduce Deep Local Shapes (DeepLS), a deep shape representation that enables encoding and reconstruction of high-quality 3D shapes without prohibitive memory requirements. DeepLS replaces the dense volumetric signed distance function (SDF) representation used in traditional surface reconstruction systems with a set of locally learned continuous SDFs defined by a neural network, inspired by recent work such as DeepSDF. Unlike DeepSDF, which represents an object-level SDF with a neural network and a single latent code, we store a grid of independent latent codes, each responsible for storing information about surfaces in a small local neighborhood. This decomposition of scenes into local shapes simplifies the prior distribution that the network must learn, and also enables efficient inference. We demonstrate the effectiveness and generalization power of DeepLS by showing object shape encoding and reconstructions of full scenes, where DeepLS delivers high compression, accuracy, and local shape completion.READ FULL TEXT VIEW PDF
[ECCV'20] Convolutional Occupancy Networks
Learning Implicit Surfaces from Point Clouds (ECCV 2020)
A docker image of conv occupancy networks
A signed distance function (SDF) represents three-dimensional surfaces as the zero-level set of a continuous scalar field. This representation has been used by many classical methods to represent and optimize geometry based on raw sensor observations [11, 29, 44, 34, 35]
. In a typical use case, an SDF is approximated by storing values on a regularly-spaced voxel grid and computing intermediate values using linear interpolation. Depth observations can then be used to infer these values and a series of such observations are combined to infer the most likely SDF using a process called fusion.
Voxelized SDFs have been widely adopted and used successfully in a number of applications, but they have some fundamental limitations. First, the dense voxel representation requires significant amounts of memory (typically on a resource-constrained parallel computing device), which imposes constraints on resolution and the spatial extent that can be represented. These limits on resolution, as well as sensor limitations, typically lead to surface estimates that are missing thin structures and fine surface details. Second, as a non-parametric representation, SDF fusion can only infer surfaces that have been directly observed. Some surfaces are difficult or impossible for a typical range sensor to capture, and observing every surface in a typical environment is a challenging task. As a result, reconstructions produced by SDF fusion are often incomplete.
Recently, deep neural networks have been explored as an alternative representation for signed distance functions. According to the universal approximation theorem , a neural network can be used to approximate any continuous function, including signed distance functions [32, 37, 33, 9]
. With such models, the level of detail that can be represented is limited only by the capacity and architecture of the network. In addition, a neural network can be made to represent not a single surface but a family of surfaces by, for example, conditioning the function on a latent code. Such a network can then be used as a parametric model capable of estimating the most likely surface given only partial noisy observations. Incorporating shape priors in this way allows us to move from the maximum likelihood (ML) estimation of classical reconstruction techniques to potentially more robust reconstruction via maximum a posteriori (MAP) inference.
These neural network representations have their own limitations, however. Most of the prior work on learning SDFs is object-centric and does not trivially scale to the detail required for scene-level representations. This is likely due to the global co-dependence of the SDF values at any two locations in space, which are computed using a shared network and a shared parameterization. Furthermore, while the ability of these networks to learn distributions over classes of shapes allows for robust completion of novel instances from known classes, it does not easily generalize to novel classes or objects, which would be necessary for applications in scene reconstruction. In scanned real-world scenes, the diversity of objects and object setups is usually too high to be covered by an object-centric training data distribution.
In this work, we introduce Deep Local Shapes (DeepLS) to combine the benefits of both worlds, exposing a trade-off between the prior-based MAP inference of memory efficient deep global representations (e.g., DeepSDF), and the detail preservation of computationally efficient, explicit volumetric SDFs. We divide space into a regular grid of voxels, each with a small latent code representing signed distance functions in local coordinate frames and making use of learned local shape priors. These voxels can be larger than is typical in fusion systems without sacrificing on the level of surface detail that can be represented (c.f. Sec. 5.2.1), increasing memory efficiency. The proposed representation has several favorable properties, which are verified in our evaluations on several types of input data:
It relies on readily available local shape patches as training data and generalizes to a large variety of shapes,
provides significantly finer reconstruction and orders of magnitude faster inference than global, object-centric methods like DeepSDF, and
outperforms existing approaches in dense 3D reconstruction from partial observations, showing thin details with significantly better surface completion and high compression.
The key contribution of this paper is the application of learned local shape priors for reconstruction of 3D surfaces. This section will therefore discuss related work on traditional representations for surface reconstruction, learned shape representations, and local shape priors.
Traditionally, scene representation methods can broadly be categorized into two categories, namely local and global approaches.
Our work falls into the local surface representation category. It is related to the partition of unity approach , however, instead of using quadratic functions as local shapes, we use data-driven local priors to approximate implicit SDFs, which are robust to noise and can locally complete supported surfaces. While we also experimented with partition of unity blending of neighboring local shapes, we found it to be not required in practice, since our training formulation already includes border consistency (c.f. Sec 4.1), thus saving function evaluations during decoding. In comparison to volumetric SDF integration methods, such as SDF Fusion , our approach provides better shape completion and denoising, while at the same time uses less memory to store the representation. Unlike point- or surfel-based methods, our method leads to smooth and connected surfaces.
Recently there has been lot of work on 3D shape learning using deep neural networks. This class of work can also be classified into four categories: point-based methods, mesh-based methods, voxel-based methods and continuous implicit function-based methods.
Voxels. These methods provide non-parametric shape representation using 3D voxel grids which store either occupancy [52, 10] or SDF information [13, 45, 31], similarly to the traditional techniques discussed above. These methods thus inherit the limitations of traditional voxel representations with respect to high memory requirements. Octree-based methods [46, 40, 22] relax the compute and memory limitations of dense voxel methods to some degree and have been shown on voxel resolutions of up to .
Meshes. These methods use existing  or learned [20, 3] parameterization techniques to describe 3D surfaces by morphing 2D planes. When using mesh representations, there is a tradeoff between the ability to support arbitrary topology and the ability to reconstruct smooth and connected surfaces. Works such as [42, 3] are variations on deforming a sphere into more complex 3D shape, which produces smooth and connected shapes but limits the topology to shapes that are homeomorphic to the sphere. AtlasNet, on the other hand, warps multiple 2D planes into 3D which together form a shape of arbitrary topology, but this results in disconnected surfaces. Other works, such as Scan2Mesh  and Mesh-RCNN, use deep networks to predict meshes corresponding to range scans or RGB images, respectively.
Implicit Functions. Very recently, there has been significant work on learning continuous implicit functions for shape representations. Occupancy Networks  and PiFU  represent shapes using continuous indicator functions which specify which subset of 3D space the shapes occupy. Similarly, DeepSDF  approximates shapes using Signed Distance Fields. We adopt the DeepSDF model as the backbone architecture for our local shape network.
Much of the work in this area has focused on learning object-level representations. This is especially useful when given partial observations of a known class, as the learned priors can often complete the shape with surprising accuracy. However, this also introduces two key difficulties. First, the object-level context means that generalization will be limited by the extent of the training set – objects outside of the training distribution may not be well reconstructed. Second, object-level methods do not trivially scale to full scenes composed of many objects as well as surfaces (e.g. walls and floors). In contrast, DeepLS maintains separate representations for small, distinct regions of space, which allows it to scale easily. Furthermore, the local representation makes it easier to compile a representative training set; at a small enough scale most surfaces have similar structure.
In early work on using local shape priors, Gal et al.  used a database of local surface patches to match partial shape observations. However, the ability to match general observations was limited by the size of the database as the patches could not be interpolated. Ricao et al. 
used both PCA and a learned autoencoder to map SDF subvolumes to lower-dimensional representations, approaching local shape priors from the perspective of compression. With this approach the SDF must be computed by fusion first, which serves as an information bottleneck limiting the ability to develop priors over fine-grained structures. In another work, Xu et al. developed an object-level learned shape representation using a network that maps from images to SDFs . This representation is conditioned on and therefore not independent of the observed image. Williams et al.  showed recently that a deep network can be used to fit a representation of a surface by training and evaluating on the same point cloud, using a local chart for each point which is then combined to form a surface atlas. Their results are on complete point clouds in which the task is simply to densify and denoise, whereas we also show that our priors can locally complete surfaces that were not observed. Other work on object-level shape representation has explored representations in which shapes are composed of smaller parts. Structured implicit functions used anisotropic Gaussian kernels to compose global implicit shape representations . Similarly, CvxNets compose shapes using a collection of convex subshapes . Like ours, both of these methods show the promise of compositional shape modelling, but surface detail was limited by the models used. Last, concurrent work of Genova et al.  combines a set of irregularly positioned implicit functions to improve details in full object reconstruction.
We will briefly review DeepSDF . Let be a signed surface distance function modeled as a fully-connected neural network with trainable parameters and shape code . Then a shape is defined as the zero level set of :
In order to simultaneously train for a variety of shapes, a is optimized for each shape while network parameters are shared for the whole set of shapes.
The key idea of DeepLS is to compose complex general shapes and scenes from a collection of simpler local shapes as depicted in Fig. 2. Scenes and shapes
of arbitrary complexity cannot be described with a compact fixed length shape code such as used by DeepSDF.
Instead it is more efficient and flexible to encode the space of smaller local shapes and to compose the global shape from an adaptable amount of local codes.
To describe a shape defined over the space using DeepLS, we first define a partition of the space into local volumes with associated local coordinate systems. Like in DeepSDF, but at a local level, we describe the surface in each local volume using a code . With the transformation of the global location into the local coordinate system, the global surface can be described as
where weighs the contribution of the th local shape to the global shape , combines the contributions of local shapes, and is a shared autodecoder network for local shapes with trainable parameters . Various ways of designing the combination operation and weighting function can be explored. From voxel-based tesselations of the space to more RBF-like point-based sampling to – in the limit – collapsing the volume of a local code into a point and thus making a continuous function of the global space.
Here we focus the straight forward way of defining local shape codes over a sparsely allocated voxelization of the 3D space as illustrated in Fig. 2.
We define to transform a global point into the local coordinate system of voxel cell by subtracting its center from . The weighting function becomes the indicator function over the volume of voxel .
Thus, DeepLS describes the global surface as:
This can further be simplified to
where determines the voxel index from the global position .
We found that with the proposed division of space (i.e. disjoint voxels for local shapes), training codes based only on samples within the voxel leads to inconsistent surface estimates at the voxel boundaries. One possible solution is to construct the surface as a partition of unity  with locally supporting basis functions to combine the decoded SDF values. We experimented with trilinear interpolation as an instance of this. However, such methods increase the number of required decoder evaluations to query an SDF value by a factor of eight.
Instead, we simply train the decoder weights and codes such that a local code can predict SDF values beyond the bounds of the voxel. In this regime we expect that the SDF values on the boundaries between voxels should be accurately computable from any of the abutting local codes.
We experimented with spheres (i.e. the norm) and voxels (i.e. the norm) for the extended indicator function and found that using an norm with a radius of times the voxel side-length provides accurate surfaces and is more efficient to compute than other alternatives (c.f. Figure 3). Our experiments show that the extended range is enough to effectively fight border artifacts (c.f. Sec. 5) while still providing the most efficient rendering.
Given a set of SDF pairs , sampled from a set of training shapes, we aim to optimize both the parameters of the shared shape decoder and all local shape codes during training and only the codes during inference.
Let denote the set of all training samples , falling within a radius of voxel with local code under the distance metric . Similar to DeepSDF, we train DeepLS by minimizing the negative log posterior over the training data :
In order to encode a new scene or shape into a set of local codes, we fix decoder weights and find the maximum a-posteriori codes as
given partial observation samples with defined as above.
For sampling data pairs , we distinguish between sampling from meshes and depth observations. For meshes, the method proposed by Park et al.  is used. For depth observations, we estimate normals from the depth map and sample points in 3D that are displaced slightly along the normal direction, where the SDF value is assumed to be the magnitude of displacement. In addition to those samples, we obtain free space samples along the observation rays. The process is described formally in the supplemental materials.
The experiment section is structured as follows. First, we compare DeepLS against recent deep learning methods (e.g. DeepSDF, AtlasNet) in Sec.5.1. Then, we present results for scene reconstruction and compare them against related approaches on both synthetic and real scenes in Sec. 5.2.2.
The models used in the following experiments were trained on a set of local shape patches, obtained from 200 primitive shapes (e.g. cuboids and ellipsoids) and a total of 1000 shapes from the ShapeNet training set (200 each for the airplane, table, chair, lamp, and sofa classes). Our decoder is a four layer MLP, mapping from latent codes of size to the SDF value. We present examples from the training set, several additional results, comparisons and further details about the experimental setup in the supplemental materials.
|AtlasNet-Sph. ||0.752||0.188||0.725||2.381||0.445||3.6 M||1.0 K|
|AtlasNet-25 ||0.368||0.216||0.328||1.182||0.411||43.5 M||1.0 K|
|DeepSDF ||0.204||0.143||0.553||0.832||0.132||1.8 M||0.3 K|
|DeepLS||0.030||0.018||0.032||0.078||0.044||0.05 M||312 K|
We quantitatively evaluate surface reconstruction accuracy of DeepLS and other shape learning methods on various classes from the ShapeNet dataset. Quantitative results for the chamfer distance error are shown in Table 1. As can be seen DeepLS improves over related approaches by approximately one order of magnitude. It should be noted that this is not a comparison between equal methods since the other methods infer a global, object-level representation that comes with other advantages. Also, the parameter distribution varies significantly (c.f. Tab. 1). Nonetheless, it proves that local shapes lead to superior reconstruction quality and that implicit functions modeled by a deep neural network are capable of representing fine details. Qualitatively, DeepLS encodes and reconstructs much finer surface details as can be seen in Fig. 4.
Further, we show the superior inference efficiency of DeepLS with a simple experiment, illustrated in Figure 5. A DeepLS model was trained on a dataset composed only of randomly oriented primitive shapes. It is used to infer local codes that pose an implicit representation of the Stanford Bunny. Training and inference together took just one minute on a single GPU. The result is an RMSE of only 0.03% relative to the length of the diagonal of the minimal ground truth bounding box, highlighting the ability of DeepLS to generalize to novel shapes. For comparison, we also trained a DeepSDF model to represent only the Stanford Bunny (jointly training latent code and decoder). In order to achieve the same surface error, this model required over 8 days of GPU time, showing that the high compression rates and object-level completion capabilities of DeepSDF and related techniques comes at the cost of long training and inference times. This is likely caused at least in part by gradient computation amongst all training samples, which we avoid by subdividing physical space and optimizing local representations in parallel.
We evaluate the ability of DeepLS to reconstruct at scene scale using synthetic (in order to provide quantitative comparisons) and real depth scans. For synthetic scans, we use the ICL-NUIM RGBD benchmark dataset . The evaluation on real scans is done using the 3D Scene Dataset . For quantitative evaluation, the asymmetric Chamfer distance metric provided by the benchmark  is used.
|TSDF Fusion||5.42 mm||5.35 mm||5.88 mm||5.17 mm||5.27 mm|
|DeepLS||4.92 mm||5.15 mm||5.48 mm||4.32 mm||4.71 mm|
We provide quantitative measurements of surface reconstruction quality on all four ICL-NUIM sequences in Table 2, where each system has been tuned for lowest surface error. We also show results qualitatively in Fig. 6 and show additional results, e.g. on data with artificial noise, in the supplemental materials. Most surface reconstruction techniques involve a tradeoff between surface accuracy and completeness. For TSDF fusion systems such as KinectFusion , this tradeoff is driven by choosing a truncation distance and the minimum confidence at which surfaces are extracted by marching cubes. With DeepLS, we only extract surfaces up to some fixed distance from the nearest observed depth point, and this threshold is what trades off accuracy and completion of our system. For a full and fair comparison, we derived a pareto-optimal curve by varying these parameters for the two methods on the ‘kt0‘ sequence of the ICL-NUIM benchmark and plot the results in Figure 7. We measure completion by computing the fraction of ground truth points for which there is a reconstructed point within . Generally, DeepLS can reconstruct more complete surfaces at the same level of accuracy as SDF Fusion.
The number of representation parameters used by DeepLS is theoretically independent of the rendering resolution and only depends on the resolution of the local shapes. In contrast, traditional volumetric scene reconstruction methods such as TSDF Fusion have a tight coupling between number of parameters and the desired rendering resolution. We investigate the relationship between representation size per unit volume of DeepLS and TSDF Fusion by evaluating the surface error and completeness as a function of the number of parameters. As a starting point we choose a representation that uses parameters per volume ( mm voxel resolution). To increase compression we increase the voxel size for TSDF Fusion and the local shape code volume size for DeepLS. We provide the quantitative and qualitative analysis of the scene reconstruction results with varying representation size in Fig. 7 (a and b) and Fig. 8 respectively. The plots in Fig. 7 show conclusively that TSDF Fusion drops to about 50% less complete reconstructions while DeepLS maintains completeness even at the highest compression rate, using only K parameters for the full scene. Quantitatively, TSDF Fusion also achieves low surface error for high compression. However, this can be contributed to the used ICL-NUIM benchmark metric, which does not strongly punish missing surfaces.
|TSDF F. ||10.11||85.46||11.71||85.17||12.35||83.99||14.23||91.02||13.03||83.73|
We evaluate DeepLS on the 3D Scene Dataset , which contains several scenes captured by commodity structured light sensors, and a challenging scan of thin objects.
In order to also provide quantitative errors we assume the reconstruction performed by volumetric fusion  of all depth frames to be the ground truth. We then apply DeepLS and TSDF fusion on a small subset of depth frames, taking every 10th frame in the capture sequence. The quantitative results of this comparison are detailed in Table 3 for various scenes. It is shown that DeepLS produces both more accurate and more complete 3D reconstructions. Furthermore, we provide qualitative examples of this experiment in Fig. 9 for the outdoor scene “Burghers of Calais” and for the indoor scene “Lounge”. Notice, that DeepLS preserves more details on the faces of the statues in “Burghers of Calais” scene and reconstructs thin details such as leaves of the plants in “Lounge” scene.
Further, we specifically analyse the strength of DeepLS in representing and completing thin local geometry. We collected a scan from an object consisting of two thin circles kept on a stool with long but thin cylindrical legs (see Fig. 10). The 3D points were generated by a structured light sensor [49, 7, 43]. It was scanned from limited directions leading to very sparse set of points on the stool’s surface and legs. We compared our results on this dataset to several 3D methods including TSDF Fusion , Multi-level Partition of Unity (MPU) , Smooth Signed Distance Function , Poisson Surface Reconstruction , PFS  and TSR . We found that due to lack of points and thin surfaces most of the methods failed to either represent details or complete the model. MPU , which fits quadratic functions in local grids and is very related to our work, fails in this experiment (see Fig. 9(b)). This indicates that our learned shape priors are more robust than fixed parameterized functions. Methods such as PSR , SSD  and PFS  fit global implicit function to represent shapes. These methods made the thin shapes thicker than they should be. Moreover, they also had issues completely reconstructing the thin rings on top of the stool. TSR  was able to fit to the available points but is unable to complete structures such as bottom surface of the stool and it’s cylindrical legs, where no observations exist. This shows how our method utilizes local shape priors to complete partially scanned shapes. Please refer to the supplemental materials for further qualitative comparisons and results.
In this work we presented DeepLS, a method to combine the benefits of volumetric fusion and deep shape priors for 3D surface reconstruction from depth observations. A key to the success of this approach is the decomposition of large surfaces into local shapes. This decomposition allowed us to reconstruct surfaces with higher accuracy and finer detail than traditional SDF fusion techniques, while simultaneously completing unobserved surfaces, all using less memory than storing the full SDF volume would require. Compared to recent object-centric shape learning approaches, our local shape decomposition leads to greater efficiency for both training and inference while improving surface reconstruction accuracy by an order of magnitude.
Reconstruction and representation of 3d objects with radial basis functions. In Proceedings of the 28th annual conference on Computer graphics and interactive techniques, pp. 67–76. Cited by: §2.1.
Compressed voxel-based mapping using unsupervised learning. Robotics 6 (3), pp. 15. Cited by: §2.3.