OctField: Hierarchical Implicit Functions for 3D Modeling
Year: 2022

Abstract:
Recent advances in localized implicit functions have enabled neural implicit representation to be scalable to large scenes. However, the regular subdivision of 3D space employed by these approaches fails to take into account the sparsity of the surface occupancy and the varying granularities of geometric details. As a result, its memory footprint grows cubically with the input volume, leading to a prohibitive computational cost even at a moderately dense decomposition. In this work, we present a learnable hierarchical implicit representation for 3D surfaces, coded OctField, that allows high-precision encoding of intricate surfaces with low memory and computational budget. The key to our approach is an adaptive decomposition of 3D scenes that only distributes local implicit functions around the surface of interest. We achieve this goal by introducing a hierarchical octree structure to adaptively subdivide the 3D space according to the surface occupancy and the richness of part geometry. As octree is discrete and non-differentiable, we further propose a novel hierarchical network that models the subdivision of octree cells as a probabilistic process and recursively encodes and decodes both octree structure and surface geometry in a differentiable manner. We demonstrate the value of OctField for a range of shape modeling and reconstruction tasks, showing superiority over alternative approaches.

heading: 1 Introduction
text: Geometric 3D representation has been central to the tasks in computer vision and computer graphics, ranging from high-level applications, such as scene understanding, object recognition and classification, etc, to low-level tasks, including 3D shape reconstruction, interpolation and manipulation. To accommodate with various application scenarios, a universal and effective 3D representation for 3D deep learning should have the following properties: (1) compatibility with arbitrary topologies, (2) capacity of modeling fine geometric details, (3) scalability to intricate shapes, (4) support efficient encoding of shape priors, (5) compact memory footprint, and (6) high computational efficiency.
While explicit 3D representations have been widely used in recent 3D learning approaches, none of these representations can fulfill all the desirable properties. In particular, point cloud and voxel representations struggle to capture the fine-scale shape details – often at the cost of high memory
∗Contributed equally. †Corresponding author is Lin Gao (gaolin@ict.ac.cn).
35th Conference on Neural Information Processing Systems (NeurIPS 2021), virtual.
consumption. Mesh-based learning approaches typically rely on deforming a template model, limiting its scalability to handle arbitrary topologies. The advent of neural implicit function [44, 7, 37] have recently brought impressive advances to the state-of-the-art across a range of 3D modeling and reconstruction tasks. However, using only a global function for encoding the entirety of all shapes, the aforementioned methods often suffer from limited reconstruction accuracy and shape generality.
To overcome these limitations, follow-up works have proposed to decompose the 3D space into regular grid [27, 4], or local supporting regions [19], where each subdivided shape is approximated by a locally learned implicit function. The decomposition of scenes simplifies the shape priors that each local network has to learn, leading to higher reconstruction accuracy and efficiency. However, these approaches do not take into account the varying granularities of local geometry, resulting in two major shortcomings. Efficiency-wise, their memory usage grows cubically with the volume of the 3D scenes. Even a moderately dense decomposition could impose severe memory bottleneck. Scalability-wise, the regular gridding has difficulty scaling to high resolutions, limiting its expressiveness when dealing with intricate shapes with small and sharp geometric features (Figure 4).
We observe that most 3D shapes are typically consisting of large smooth regions and smallscale sharp features. In addition, the surface of interest often consumes only a small portion of the entire space, leading to an extremely sparse space occupancy. Based on these observations, we propose a novel 3D representation called OctField, that introduces hierarchies to the organization of local implicit functions to achieve better memory efficiency and stronger modeling capacity. As shown in Figure 1, OctField leverages a hierarchical data structure, Octree, to adaptively subdivide the 3D space according to the surface occupancy and the richness of geometrical details. In particular, regions enclosing intricate geometries will be further subdivided to allocate more implicit kernels for higher modeling accuracy. In contrast, we stop subdivision for octants containing smooth part geometry as a single implicit kernel would suffice for modeling. Further, we do not allocate
any implicit functions in the unoccupied regions. Hence, OctField could obtain significantly higher representation accuracy with a slightly deeper octree subdivision, as the modeling capacity has been adaptively optimized to accommodate the varying granularity of surface details.
As the octree structure is discrete and non-differentiable, it is non-trivial to directly employ octree in a learning-based framework. We propose a novel hierarchical network that recursively encodes and decodes both octree structure and geometry features in a differentiable manner. Specifically, at the decoder side, we model the subdivision of octree cells as a probabilistic process to make the learning of octree structure differentiable. We employ a classifier to predict whether to subdivide current cell based on its enclosed geometry features. We validate the efficacy of our new representation in a variety of tasks on shape reconstruction and modeling. Experimental results demonstrate the superiority of OctField over the state-of-the-art shape representations in terms of both shape quality and memory efficiency. Our contributions can be summarized as follows:
• A learnable hierarchical implicit representation for 3D learning, named OctField, that combines the state-of-the-art hierarchical data structure with local implicit functions.
• A novel hierarchical encoder-decoder network that models the construction of octree as a probabilistic process and is able to learn both discrete octree structure and surface geometry in a differentiable manner.
• We achieve significantly higher surface approximation accuracy with reduced memory cost in the 3D modeling related tasks by using our proposed representation.

heading: 2 Related Works
text: Representations for 3D Shape Learning. Various 3D representations have been extensively studied in 3D deep learning [28]. These surveys [2, 62] discuss various shape representations comprehensively. As the raw output of 3D scanning devices, point cloud [46, 47, 65, 49, 53] has received much attention in recent years. Despite for its simplicity, generating dense point clouds with high precision remains notoriously difficult. Unlike the other 3D representations, the convolutional network can be directly employed on 3D voxels [36, 11, 20, 59, 60, 61, 64, 23, 10]. Due to the prohibitive computational cost of generating voxels, recent works [55, 57, 56, 52, 32] have introduced octree to the voxel representation to reduce memory cost. The polygon mesh is the another widely used representation in modeling and surface reconstruction. However, current learning-based mesh generation approaches [6, 54, 50, 24, 29, 21, 12, 43] mostly rely on deforming a template mesh, limiting its scalability to shapes with arbitrary topologies. Recent advances in neural implicit functions [44, 37, 7, 27, 14, 63, 8, 45] have significantly improved the surface reconstruction accuracy thanks to its flexibility of handling arbitrary topologies. More recently, [27, 4, 19] have introduced shape decomposition and local implicit functions to further improve the modeling capacity by locally approximating part geometry. [33] introduces implicit moving least-squares (IMLS) surface formulation on discrete point-set to reconstruct high-quality surfaces. However, these methods mostly rely on a regular decomposition and cannot account for sparse surface occupancy and the varying granularities of geometry details, imposing memory bottleneck when dealing with moderately dense subdivision. OpenVDB [42] incorporates B+ tree with implicit field to achieve hierarchical modeling. However, the goal of OpenVDB is pursuing extremely fast modeling speed with constant time access in 3D simulation. Hence, the B+ tree is non-differentiable and too complex to be incorporated into a learning-based framework. In contrast, OctField is a learnable hierarchical implicit representation that can be differentiably implemented in our hierarchical network. Further, our representation can achieve higher modeling accuracy with even less memory compared to the previous local implicit function approaches [27, 4, 19]. In a concurrent work NGLOD [51], it proposes a similar idea of leveraging level of details to encode local SDFs hierarchically. A corresponding rendering algorithm is proposed to render the neural SDFs in an interactive rate. However, NGLOD cannot learn the hierarchical structure of the underlying octree. In contrast, our hierarchical encoder-decoder network learns the non-differentiable structural information in differentiable manner via modeling it as a probabilistic process. We believe the structural information is crucial for improving the modeling accuracy and future applications(e.g. 3D semantic understanding, editing).
Learning-based Generative Models. The deep generative models, such as GAN [22] and VAE [30], have shown promising ability of synthesizing realistic images in 2D domain. 3D learning approaches have strived to duplicate the success of 2D generative models into 3D shape generation. 3D-GAN [60] pioneers at applying the GAN technology on the 3D voxels to learn a deep generator that can synthesize various 3D shapes. Generative models on point cloud [1, 15, 67] mainly leverage MLP layers but struggle to generate dense point sets with high fidelity due to the large memory consumption and high computational complexity. Recent works on synthesizing 3D meshes either rely on deforming an initial mesh using graph CNN [54, 58] or assembling surface patches [24, 13] to achieve more flexible structure manipulation. To better model man-made objects composed of hierarchical regular shapes, structural relationship has been considered in [18, 66, 17, 38, 40, 39], where the box-like primitives are used for initial shape to enhance shape regularity. To fully exploit the modeling capacity of implicit surface generator, IM-Net [7] has experimented with both VAE and GAN models to learn stronger shape priors. In a concurrent work, DeepSDF [44] proposes a auto-decoder structure to train latent space and decoder without using a traditional shape encoder. Recently, the local implicit methods [27, 4] combine regular space decomposition with local implicit generators for modeling 3D scenes with fine geometric details. ACORN [35] introduces an adaptive multiscale neural scene representation for 2D and 3D complex scenes, which enables to fit the targets faster and better in an optimized multiscale fashion. In our paper, we propose a hierarchical implicit generative model for 3D modeling. Compared to other methods, our approach can generate high-quality 3D surfaces with intricate geometric details in a memory-efficient manner.

heading: 3 Method
text: Overview. OctField combines the good ends of both localized implicit representation and the hierarchical data structure. By adaptively allocating local implicit functions according to the surface
occupancy and the richness of geometry, OctField is able to achieve high modeling accuracy with a low memory and computation budget. In particular, we decompose the 3D space into hierarchical local regions using octree structure, where the finest octant encodes the partial shape within its enclosed space using a learned implicit function. Our decomposition protocol not only considers the surface occupancy but also the richness of geometry. As show in Figure 2, the octants that carry an embedded implicit kernel will only be allocated around the surface. Moreover, only the octants containing intricate geometries will be further divided. This ensures an adaptive memory and computation allocation that the richer surface details will be captured with more local implicit functions – hence with higher modeling accuracy. In contrast, the unoccupied regions will not be allocated with any implicit kernels to save the memory and computational budget.
The octree itself is a non-differentiable discrete data structure. We propose a novel differentiable hierarchical encoder-decoder network that learns both the octree structure and the geometry features simultaneously. In particular, we formulate the construction of octree as a probabilistic process where the probability of subdividing an octant is predicted by a MLP layer. This makes it possible to learn discrete octree structure in a fully differentiable manner. In addition, we train our network in a VAE manner such that the trained latent space and decoder can be used for a variety of downstream applications including shape reconstruction, generation, interpolation, single-view reconstruction, etc. We provide detailed description of the OctField representation and the proposed network in Section 3.1 and 3.2 respectively.

heading: 3.1 OctField Representation
text: Octree Construction. To build an octree for the input model, we first uniformly scale the 3D shape into an axis-aligned bounding box and then recursively subdivide the bounding region into child octants in a breadth-first order. The octant to be subdivided has to satisfy two requirements simultaneously: (1) the octant encloses the surface of interest; and (2) its enclosed geometry needs to have sufficient complexity that is worth subdividing. We use the normal variance of the surface as an indicator of its geometric complexity. Specifically, we formulate the normal variation of a surface patch S as follows:
V(S) = Ei(V({nix}) + V({niy}) + V({niz})) (1)
where the nix,n i y,n i z are the x, y, z-component of the normal vector n i at the i-th sampling point on the surface; {nix} denotes the collection of nix; V (·) calculates the variations of the input while Ei (·) returns the expectation. In our experiments, we perform regular sampling on the surface where the sampling points are pre-computed. We repeat the decomposition until the pre-defined depth d is reached or V(S) is smaller than a pre-set threshold τ . We set τ = 0.1 throughout our experiments. Local Implicit Representation. The implicit function associated with each octant is designed to model only part of the entire shape. This enables more training samples and eases the training as most 3D shapes share similar geometry at smaller scales. At each octant, the enclosed surface is
continuously decoded from the local latent code. However, as the finest octant may have different sizes, when querying for the value of the local implicit function, we normalize the input world coordinate x against the center of the octant xi. Formally, we encode the surface occupancy as: f(ci,x) = Dθd(ci,N (x−xi)), where Dθd is the learned implicit decoder with trainable parameter θd, ci is the local latent code and N (·) normalizes the input coordinate into the range of [−1, 1] according to the bounding box of the octant. To prevent the discontinuities across the octant boundaries, we propose to enlarge each octant such that it overlaps with its neighboring octant at the same level. In our implementation, we let each octant has 50% overlap along the axis direction with its neighbors. When the implicit value at the overlapping regions is queried, we perform tri-linear interpolation over all the octants that intersect with this query position.

heading: 3.2 Hierarchical OctField Network
text: To enable a differentiable framework for learning the octree structure and its encoded geometry, we propose a novel hierarchical encoder-decoder network that organizes local encoders and decoders in a recursive manner. We embed both the octree structure information and the geometry feature into the latent code of each octant. As shown in right part of Figure 2, the latent code ei = (gi,αi,βi) for octant Oi is a concatenation of three parts: (1) a geometry feature gi that encodes the local 3D shape; (2) a binary occupancy indicator αi that indicates whether the octant encloses any 3D surface; and (3) a binary geometry subdivision indicator βi that denotes whether the enclosed geometry is intricate enough that needs further subdivision. We will show in the following subsections that how this configuration of latent vector guides the recursive decoding and encoding in our network. Note that, unlike the prior tree structure-based generative models [66, 38, 31], our approach does not require a manually labeled part hierarchy, e.g. the PartNet [41] dataset, for training, and can generate the hierarchical structure automatically using our octree construction algorithm.
3.2.1 Hierarchical Encoder
As shown in Figure 2, the encoder E of our network is composed of a hierarchy of local encoders {Ei} that encodes local geometry feature and octree structure into the latent code. While our framework supports general geometry encoders, we employ a 3D voxel CNN V for extracting geometry features due to its simplicity of implementation. After constructing the octree for input model, we voxelize the surface enclosed in each octant in a resolution of 323.
The encoding process starts from the octants at the finest level in a bottom-up manner. For each octant Oi, we first compute its binary indicators (αi,βi) according to its enclosed geometry. In particular, αi is set to 1 if there exist surfaces inside Oi and 0 if otherwise; βi is set to 1 if Oi’s enclosed geometry (if αi = 1) satisfies the subdivision criteria as detailed in Section 3.1 and 0 if otherwise. We then extract Oi’s geometry feature gi by passing its enclosed voxelized geometry Gi to the voxel CNN V . When proceeding to a higher level, our network will
aggregate the children’s latent features to its parent octant. In particular, for a parent octant Ok, we denote the octant features of its children as {ecj =
(
gcj ,αcj ,βcj
)
|cj ∈ Ck}, where Ci represents the child octants of Ok. Its encoder Ek then aggregates the latent features of Ok’s child octants into Ok’s geometry feature gk : gk = Ek (ec0 , ec1 , · · · , ec7) . (2) We then obtain Ok’s latent feature by concatenating gk with Ok’s structure features (αk,βk). We perform the recursive feature encoding and aggregation until the root node has been processed. Specifically, the encoder Ei consists of a multi-layer perceptron (MLP), one max pooling layer and another MLP for output. At the end of encoder, we leverage the VAE re-parameterization technique
to encourage the distribution of the latent space to fit a normal distribution. Note that all the local encoders Ei share its parameters to leverage the similarity of local geometries and to reduce the network parameters.

heading: 3.2.2 Hierarchical Decoder
text: The hierarchical decoder D aims to decode the octree structure and local octant codes from the input global feature. It consists of a hierarchy of local decoders {Di} with a mirrored structure with respect to the encoder E. On the contrary to E, the decoding process starts from the root node and recursively decodes the latent code of its child octants in a top-down manner. Specifically, for a parent octant Ok with geometry feature gk, we decode the geometry features of its child octants using the decoder Dk: (ec0 , ec1 , · · · , ec7) = Dk (gk) , (3) where cj ∈ Ck denotes the child octant of Ok and ecj = ( gcj ,αcj ,βcj ) stands for the geometric feature and two indicators of the child octant Ocj . The two indicators provide the probability of whether the child octants need to be decoded or subdivided. Note that we decode all the 8 child octants at one time.
In particular, Dk consists of two MLPs and two classifiers (see Figure 3). We first decode gk into hidden vectors vcj for all 8 child octants by a MLP. To decode the structure information, we apply two classifiers Ig and Ih to infer the probability of surface occupancy and the necessity of further subdivision, respectively. For child octant Ocj , we feed its hidden vector vcj into Ig and Ih, and calculate αcj = Ig(vcj ) and βcj = Ih(vcj ). For predicting the gcj , we apply the other MLP on vcj . If αcj ≤ 0.5, it indicates that Ocj does not contain any geometry and will not be further processed. If αcj > 0.5, it means that Ocj is occupied by the surface and we will further check the value of βcj . If βcj ≤ 0.5, we will not further subdivide the octant and will infer its enclosed surface using the implicit octant decoder G and the geometric feature gcj . If βcj > 0.5, we will proceed to subdivide the octant by predicting the latent features of its child octants with the same procedure. We repeat this process until no octants need to be subdivided.
Implicit Octant Decoder. We use a local implicit decoder G to reconstruct the 3D surface within the octant. For octant Oi, we feed its latent geometry feature gi and the 3D query location x to the implicit decoder G for occupancy prediction. We train G with binary cross entropy loss on the point samples. The training loss for octant Oi is: Lgeo = ∑ j∈P Lc(G(gi,xj),F(xj))·wj∑
j∈P wj , where F (·)
returns the ground-truth label (inside/outside) for input point, Lc (·, ·) is the binary cross entropy loss, P denotes the set of sampling points, wj describes the inverse of sampling density near xj for compensating the density change as proposed in [7]. Note that G is pre-trained on all the local shape crops to encode stronger shape prior.
In order to obtain stronger supervision, we strive to recover the local geometry of all the octants that are occupied by the surface regardless if it belongs to the finest level. Hence, the total loss for training our hierarchical encoder-decoder network is formulate as follows:
Ltotal = EOi∈O[λLgeo + Lh + Lk + βLKL], (4) where Lh and Lk denote the binary cross entropy loss of classifying whether the octant contains geometry and needs to be subdivided, respectively, LKL is the KL divergence loss, and E[·] returns the expected value over the set of all octants O that enclose surface geometry. We set λ = 10.0, β = 0.01 throughout our experiments.

heading: 4 Experiments
text: In the section, we will first introduce our data preparation process and then evaluate our approach in a variety of applications, including shape reconstruction, shape generation and interpolation, scene reconstruction and shape completion. We also provide ablation study, more comparisons and implementation details in the supplemental materials.

heading: 4.1 Data Preparation
text: Our network is trained and evaluated on the five biggest and commonly used object categories in the ShapeNet dataset [5]: chair, table, airplane, car, and sofa. For fair comparison, we use the
officially released training and testing data splits. All the shapes are normalized to fit a unit sphere and converted into watertight meshes [26] for computing ground-truth signed distance field. We first build the octree for each model according to the protocol defined in Section 3.1. To account for the sparse occupancy of surfaces, we apply importance sampling to sample more points near the surface and exponentially decrease the point density as the distance to surface increases. We sample 10000 points in total for each octant, and calculate its corresponding signed distance to surface. To deploy 3D CNN, we adaptively voxelize the part shape in each octant to ensure it maintains the 323 resolution regardless the size of the host octant. We use the voxelization code provided by [25].
Metrics. We follow the commonly used reconstruction metrics: Chamfer distance (CD) [3] and Earth Mover’s Distance (EMD) [48] for quantitative evaluation and comparison with prior methods.
4.2 Shape Reconstruction
In this section, we evaluate the performance on shape reconstruction and compare with the following state-of-the-art approaches that are closely related with our method: IMNet [7], OccNet [37], Local Implicit Grid (LIG) [27], ConvOccNet [45], Adaptive OCNN (AOCNN) [57], and OGN [52]. In particular, IM-Net and OccNet use a global implicit function to depict the the entirety of 3D shape while LIG decomposes the input shape into regular grid and leverages local implicit kernels to approximate part geometry. AOCNN and OGN also utilizes the octree structure. However, instead of using local implicit functions, AOCNN uses a single plane to approximate the local geometry enclosed in each octant. OGN predicts
occupancy in octant without further local geometric feature. We show the visual comparisons in Figure 4. While IM-Net and OccNet are capable of reconstructing the global shape of the object, they fail to reconstruct detailed structures. LIG can recover some of the fine-scale geometries but has difficulty in modeling sharp and thin structures as shown in the second row. Since AOCNN only uses a primitive plane to approximate local geometry, it suffers from the discrepancy between adjacent octants and cannot recover complex local structures due to its limited approximation capability. In comparison, our approach achieves the best performance in all categories and is able to faithfully reconstruct intricate geometry details, such as the slats of chair backs, the hollowed bases of the tables and and the wheels of the cars.
We report the result of quantitative comparisons in Table 2, 1. Our approach outperforms the alternative approaches over all categories and achieves the best mean accuracy in terms of CD, EMD, mIoU, and F1 score metrics. In particular, our reconstruction accuracy is significantly higher than IM-Net, OccNet and AOCNN over all categories.
Computational Cost. In Table 3, we compare the computational cost with the local implicit approach using regular decomposition – LIG [27]. We show the consumption of local implicit cells/octants used for surface modeling and the computation memory with an increasing decomposition level. Thanks to our adaptive subdivision, our approach consumes significantly less local kernels compared to LIG to achieve similar or even better modeling accuracy. This leap becomes more prominent with
Mean 8.46 3.45 8.62 3.74 3.27 2.63 10.57 4.98 4.98 3.712 10.45 4.94 2.97 2.19
Table 2: Quantitative evaluation on shape reconstruction. In this table, we report the CD (×10−4) and EMD (×10−2) scores (smaller is better) on five categories. OctField can achieve the best performance on average score and each category by comparing to six baselines (IM-Net [7], OccNet [37], Local Implicit Grids [27], Adaptive O-CNN [57], ConvOccNet [45] and OGN [52]).
the increasing level of decomposition. As OctField requires additional memory to maintain octree structure, at low decomposition level, our memory cost is slightly higher than LIG. However, with a finer subdivision, our memory consumption drops significantly and becomes much lower than that of LIG. It indicates an increasing advantage of our method in modeling intricate geometry in higher resolution.

heading: 4.3 Shape Generation & Interpolation
text: Figure 5: Shape Generation. We show the results generated by randomly sampling the latent codes in the latent space.
As we train our network in a VAE manner, our model is able to generate diversified 3D shapes by feeding our pre-trained decoder with random noise vectors sampled from a normal distribution. Our network learns a smooth latent space that captures the continuous shape structures and geometry variations. To generate novel 3D shapes, we randomly sample a latent vector in our learned latent space, and decode it into
shape space by extracting its zero-isosurface using MarchingCubes [34]. In Figure 5, we show the generated results on chair and table categories respectively. Despite the random sampling, our approach is still able to synthesize high-quality 3D shapes with complex structure and fine geometric details, e.g. the second and the fourth table in the second row.
(a) (b) (c) (d) (e) (f)
Figure 6: Shape Interpolation. The figure shows two interpolated results in two categories: table and chair. (a) is source shape, (f) is target shape.
Another approach to synthesize new shapes is to interpolate between the given shapes in the latent space. For two input shapes, we interpolate their latent codes linearly and feed the obtained latent vectors to the pre-trained decoder for shape interpolation. Figure 6 shows the interpolated results on the chair and table categories. Our approach can achieve smooth and continuous interpolation even between two highly diversified objects with distinct structures. In addition, the sharp geometry features, e.g. the six-square-grid base of the table in the
first row, can be well maintained during the interpolation. This indicates that our network is capable of learning a smooth manifold to generate novel shapes in high fidelity.

heading: 4.4 Scene Reconstruction
text: Compared with a single object, our representation is more advantageous when dealing with large scenes. Our representation can obtain better reconstruction details while saving computational overhead. In this section, we illustrate the superiority of OctField on large scene dataset 3D-Front [16]. Further, we compare it with local implicit approach using regular decomposition – LIG [27], convolutional occupancy network [45], NGLOD [51] and ACORN [35] quantitatively and qualitatively. In Figure 7, we present two camera views in a large scene from 3D-Front [16] dataset.
From the visualization results, we can observe that our results is capable of capturing more fine-grained geometric and structure details compared to LIG. The other two methods that introduce hierarchical structure also perform well. It is worth mentioning that high-quality visualized results can be generated by rendering
directly from the SDF of NGLOD[51]. However, extracting the mesh from the implicit field could cause loss of reconstruction accuracy. Table 4 shows quantitative comparison results. Our approach outperforms the alternative approaches over the large scene models and achieves the best performance in terms of CD and EMD metrics.
4.5 Shape Completion
We evaluate our method in the task of shape completion. Furthermore, We compare with the IF-Net [9] and and demonstrate that our method achieves more robust completion performance with less artifacts in Figure 8. Specifically, we first voxelize the partial point cloud and then map it to the latent space of OctField representation via a 3DCNN encoder. The retrieved latent code is fed to our hierarchical decoder for reconstructing the octree structure, as well as the geometric surface. For IF-Net, we also
adopt same voxelization and map the partial voxels to the complete shape by its shape completion model.
Shape completion results (see Figure 8 and Table 5) on the table category show that our method achieves more robust completion performance with less artifacts. Compared to another octree-based method [56], our method predicts the complete mesh of partial input rather than dense point cloud.

heading: 4.6 Shape Editing
text: With the proposed differential octree generative model, our framework enables some potential applications, such as part editing that modifies or replaces only part of the target geometry. In order
to realize parting edit, we re-parameterize the latent code of the partial local shape, introducing the local VAE to modify and replace the local geometric shape. In Figure 9, we show the results of the part editing of our method comparing with a naive method of directly blending two implicit fields from the source and target shapes. Our approach can generate a smooth transition even between two distinct structures while the naive blending method cannot guarantee a continuous connection for local shape editing.
5 Conclusions and Discussions
We have proposed a novel hierarchical implicit representation for 3D surfaces, coded OctField. OctField takes advantages of the sparse voxel octree representation to adaptively generate local supporting regions around the surface of interest. By associating a local implicit function with each octant cell, OctField is able to model large-scale shape with fine-level details using compact storage. To accommodate the nondifferentiable nature of octree, we further propose a novel hierarchical network that models the octree construction as a probabilistic process and recursively encodes and decodes both structural and geometry information in a differentiable manner. The experimental results have shown superior performance of OctField over
the alternative approaches in a variety of tasks related to shape modeling, reconstruction, and editing. In the future, we would like to incorporate semantic meaning into the organization of octree to encode structural information and enable flexible editing of part-level geometry. In addition, it is also an interesting avenue to explore adaptive length of local latent code such that local implicit functions with higher modeling capacity are only dealing with geometries with more intricate details.

heading: 6 Broader Impact
text: The proposed OctField can serve as a fundamental representation of 3D geometry and thus can have a positive impact in a broad range of research fields, including computer vision, computer graphics, and human-computer interaction, etc. Specifically, due to the cost-effective nature of our representation, our method can reduce the economic cost of 3D environment acquisition from raw scanning, while maintaining a high-fidelity modeling performance. This could benefit a number of real-world applications, including modeling large-scale 3D scenes, compressing and transmitting high-quality 3D models for telecommunication and telepresence. Our generative model can also be used for low-cost 3D shape generation without the need of performing actual 3D scanning and post processing, which are expensive and time-consuming. However, at the same time, special care must be taken not to violate the privacy and security of the private scene owners during the process of data collection for our model training.
Acknowledgments. This work was supported by CCF-Tencent Open Fund, the National Natural Science Foundation of China (No. 61872440 and No. 62061136007), the Beijing Municipal Natural Science Foundation (No. L182016), the Royal Society Newton Advanced Fellowship (No. NAF\R2\192151) and the Youth Innovation Promotion Association CAS.

Review summaries:
The paper proposes a hierarchical implicit grid representation for modeling implicit shape-spaces. While concurrent research has focused either on hierarchical representations in overfitting mode, or on fixed grids in shape-space mode, the paper proposes a technique that simultaneously satisfies these two objectives. The method is tested on a few classes from the synthetic SDF'ied shapenet against a few methods, and has seemingly good reconstruction performance.

This paper presents a new efficient 3D shape representation to reduce computation cost while also being able to preserve geometric details. The authors propose to represent 3D shapes using octree structures such that the hierarchies focus on modeling the surface geometry, where the leaf nodes additionally predicts implicit functions that returns the occupancy for each query 3D point. Both the hierarchical inference and prediction are designed to be differentiable such that the octree structures can be discovered and learned from data. Experiments show that the proposed representation achieves the state of the art on the ShapeNet reconstruction with applications of shape interpolation and completion.

This paper describes a learned shape representation that is based on hierarchical oct trees that store local implicit functions at the voxels. The implicit functions represent the geometry. It offers higher fidelity and smaller memory footprint than using local implicits without oct trees (LIG, [26]). In comparison to other oct-tree based methods, the proposed approach offers the ability to learn oct-tree hierarchy.