A Convolutional Decoder for Point Clouds using Adaptive Instance Normalization
Isaak Lim Moritz Ibing Leif Kobbelt



[width=]figures/teaser
(15.5,20)2500 points
(40.5,20)2500 points
(65.5,20)15000 points
(91,20)500 points

 We show decoding results (blue) for an input shape (red) from the test set.
 Our convolutional autoencoder with Adaptive Instance Normalization was trained to output 2500 points for inputs with 2500 points.
 We also visualize outputs from our decoder with a much higher (15000) or lower (500) number of points than the number used during training.
 Note that with 15000 points we are able to robustly and densely sample the underlying geometry of the input point cloud.
 Conversely, with 500 points our method is still able to capture the overall shape of the original input.
 
 


Single-lined Spectroscopic Binary Star Candidates from a Combination of the and Gaia DR2 surveys
    [
    December 30, 2023
================================================================================================



   Automatic synthesis of high quality 3D shapes is an ongoing and challenging area of research.
   While several data-driven methods have been proposed that make use of neural networks to generate 3D shapes, none of them reach the level of quality that deep learning synthesis approaches for images provide.
   In this work we present a method for a convolutional point cloud decoder/generator that makes use of recent advances in the domain of image synthesis.
   Namely, we use Adaptive Instance Normalization and offer an intuition on why it can improve training.
   Furthermore, we propose extensions to the minimization of the commonly used Chamfer distance for auto-encoding point clouds.
   In addition, we show that careful sampling is important both for the input geometry and in our point cloud generation process to improve results.
   The results are evaluated in an auto-encoding setup to offer both qualitative and quantitative analysis.
   The proposed decoder is validated by an extensive ablation study and is able to outperform current state of the art results in a number of experiments.
   We show the applicability of our method in the fields of point cloud upsampling, single view reconstruction, and shape synthesis.
   












<ccs2012>
<concept>
<concept_id>10010147.10010371.10010396.10010402</concept_id>
<concept_desc>Computing methodologies Shape analysis</concept_desc>
<concept_significance>500</concept_significance>
</concept>
<concept>
<concept_id>10010147.10010371.10010396.10010400</concept_id>
<concept_desc>Computing methodologies Point-based models</concept_desc>
<concept_significance>300</concept_significance>
</concept>
</ccs2012>


[500]Computing methodologies Shape analysis
[300]Computing methodologies Point-based models

  



§ INTRODUCTION

The question of how to represent 3D geometry as input for neural networks is still an ongoing field of research.
Most recent papers (e.g. <cit.>) focus on how to encode the input in a manner such that its latent representation can then be used for tasks such as classification or segmentation.
However, a smaller amount of work has been done on how high-fidelity 3D shapes can be generated by a decoder/generator network.
We investigate the problem of generating 3D shapes in an auto-encoding setup.
This allows us to evaluate results both qualitatively and quantitatively.
While a number of previous works focus on the encoder, we mainly target the decoder/generator in this paper.

Synthesis of 3D shapes is a time consuming task (especially for non-expert users), which is why a number of data-driven approaches have been proposed to tackle this problem.
Methods range from combining parts of a shape collection to create novel configurations over deformation based approaches to the full synthesis of voxelized, meshed or point sampled 3D shapes.
While impressive results have been presented, generated 3D shapes have not yet reached a quality that is comparable to the state of the art in image generation, such as recently presented by Karras et al. <cit.>.

We are interested in the complete synthesis of 3D shapes. In particular we investigate the generation of 3D point clouds since voxelized representation incur a heavy memory cost.
At the same time we want to benefit from recent advances in generating high-fidelity images.
Thus, in this work we propose a convolutional decoder for point clouds.
As shown by Groueix et al. <cit.>, it is difficult to achieve high-quality auto-encoding results by training a naïve point cloud decoder (i.e. a simple multi-layer perceptron).
In order to tackle this problem we propose several measures that allow for a better conditioning of the optimization problem.

Our contributions can be summarized as follows.

    
  * We propose a convolutional decoder for point clouds that is able to outperform current state of the art results on autoencoding tasks.
    
  * Our autoencoder is able to handle a varying number of points both for its input and output. This property makes it straight-forward to apply our architecture to the task of point cloud upsampling.
    
  * To the best of our knowledge we are the first to apply Adaptive Instance Normalization as used in current image synthesis research <cit.> to the area of point cloud generation. We give an intuition on why this technique is beneficial to training.
    
  * We propose several additional losses to the commonly used Chamfer distance that consider both voxel-based and point cloud differences.

Code and our sampling of the ShapeNet Core dataset (v2) <cit.> can be found at the project page [https://graphics.rwth-aachen.de/publication/03303graphics.rwth-aachen.de/publication/03303].



§ RELATED WORK

Most work on content synthesis with neural networks has been done on images.
The natural extension to 3D data is that of a voxel grid.
This allows a straightforward transfer of many image based methods (e.g. by replacing 2D with 3D convolutions).
Examples are methods that deal with tasks such as 
single image shape reconstruction <cit.>, shape completion <cit.>, and shape generation <cit.>.
Another option is to represent geometry as planar patches inserted into an Octree <cit.>.
However, as we are interested in point cloud methods we will restrict our discussion of related work to this domain.



  
*Point-Based Encoders
Voxel-based approaches have its drawbacks when it comes to memory consumption, as the required memory scales cubically with the resolution of the grid.
To deal with these problems several architectures have emerged, that give up the regular grid structure and instead work directly on unordered point clouds. PointNet <cit.> is one of the first among those approaches and does not take any structure or neighbourhood into account. The internal shape representation here is created by aggregating point descriptors. 
As the relation between nearby points is often important to characterize shape, this work has been extended in PointNet++ <cit.> where points are hierarchically grouped based on their neighbourhood and PointNet is applied to those local point clouds.
On the other hand, dynamic graph CNNs <cit.> encode the information of a local neighborhood via graph convolutions.
PCNNs <cit.> generalize convolutions 
over points via the extension of the convolution operation to continuous volumetric functions.
In this manner they benefit from translational invariance and parameter sharing of convolutions, without the drawback of the memory size of high resolution voxel grids. 
Rethage et al. <cit.> propose to combine the advantages of point clouds and grid structures by extracting features from points in the local neighbourhood of each grid cell using a network similar to PointNet.
On the resulting representation, 3D convolutions can be applied.
As a single grid cell encodes details of the point cloud and not just a binary occupancy value, a low resolution grid is sufficient.
This approach is most similar to the encoder used in our framework.



  
*Point Set Generation
Most current approaches <cit.> for the generation of point clouds employ fully connected layers, sometimes in combination with upsampling and convolution layers, to generate a fixed number of points.
<cit.> employ both a convolution branch to recover the coarse shape and a fully connected branch for the details of the object. Unlike our approach they propose 2D convolutions that result in images with 3 channels, which are interpreted as point coordinates.
A different approach is taken by <cit.> where instead of learning to output points directly, Sinha et al. propose to learn a mapping from 2D to 3D.
By sampling the 2D domain one can obtain a point cloud.
This allows the number of generated points to be flexible.
Groueix et al. <cit.> propose a method that builds on this approach.
However, instead of a single mapping a whole atlas of those is learned by training several networks in the style of <cit.> that do not share parameters.
The loss then ensures that each network learns a different mapping and is responsible for a different part of the shape.
We employ a similar point generation technique in the sense that we also learn a mapping from 2D to 3D, instead of using fully connected layers to directly generate a fixed number of points.
However, we arrive at these maps in a different manner by generating them per grid cell with our proposed convolutional decoder. A different class of networks recently emerged to represent 3D shapes as an implicit function <cit.>. This function can then be sampled to reconstruct explicit geometry.



§ CONVOLUTIONAL AUTO-ENCODER FOR POINT CLOUDS


We want to represent our geometry as point clouds since they can approximate 3D shapes at a higher resolution without incurring the memory costs that voxel grids entail.
However, we also want to benefit from the advantages of grid structures, enabling the use of convolutional layers and Adaptive Instance Normalization (AdaIN).
To this purpose we propose our convolutional decoder (Section <ref>), which starts out with a low resolution grid and successively increases the resolution up to the final desired grid size.
We then generate points for each grid cell.
Conversely, for our encoder (Section <ref>) we embed the input point cloud into a voxel grid.
A network then encodes and stores local parts of the point cloud for each corresponding (closest) grid cell.
This voxel grid can then be encoded with a 3D convolutional network.

In traditional convolutional autoencoders the output of the encoder is passed to the decoder, 
who repeatedly upsamples it in order to produce the reconstruction of the input.
This means that even the encoding of fine details of the shape has to pass through the entire decoder, since high- and low-level features are not distinguished.
In contrast, our proposed decoder inserts the encoded shape information at various stages of the upsampling process.
We will explain our decoder in detail first, followed by the encoder.
In order to achieve high-quality results we introduce several additional losses.


 §.§ Decoder


Inspired by Karras et al. <cit.> we propose a convolutional decoder for point clouds based on Adaptive Instance Normalization (AdaIN) as used in a number of style-transfer methods <cit.>.
Given is an encoder that maps an input point cloud 𝒳∈ℝ^n × 3 to a latent vector z ∈ℝ^1024.
A naïve decoder would map z to 𝒴∈ℝ^m × 3 via a multi-layer perceptron (MLP). One problem with this approach is that a series of fully connected layers means adding a large number of parameters to the network.

Another problem is that in order to reconstruct fine detail of 𝒳 in 𝒴 every layer of the network is required to preserve the entire shape information.
A small change in one of the parameters during back-propagation can have wide-reaching global effects on 𝒴.
While, one can reduce the number of parameters used by introducing a convolutional decoder, the problem of the interplay of different parameters during back-propagation remains.
Karras et al. <cit.> show that using AdaIN with a convolutional decoder/generator can produce impressive results for images.
An AdaIN layer works by first normalizing its input features and then applying an affine transformation per instance. The transformation parameters are an additional input (e.g. computed from z).
In practise, this means that our decoder is constructed via a series of upsampling, convolution, instance normalization <cit.> and affine feature transformation layers followed by a nonlinearity (see Figure <ref>).
In contrast to traditional convolutional networks, the entire shape specific information is introduced through the affine transformations and is not passed through all layers of the decoder. Instead the upsampling process is applied to a learnable parameter block P.
For more details on the architecture see Appendix <ref>.

Thus a given z (by some encoder) is mapped to a vector w that contains the scaling and translation coefficients for each affine feature transformation layer.
For every layer i with feature dimension d where AdaIN is applied we select a slice w_i ∈ℝ^2d.
We interpret w_i = [s_i; t_i] such that s_i, t_i ∈ℝ^d. As we regard only a single layer, we omit i in the following.
The intermediate features x = x^(1)…  x^(d) are first normalized and then scaled and translated:

    x̂^(k) = x^(k) - μ(x^(k))/√(σ^2(x^(k))+ϵ)· s^(k) + t^(k),

where μ(x^(k)) and σ^2(x^(k)) are the mean and variance of x^(k) over one instance.
Since all operations are done for each channel separately, in the following we will omit k for readability.

As a result of this localized interaction the optimization problem becomes more well behaved.
Let ∇_x̂ℒ be the gradient of a loss function (see Section <ref>) with respect to the output of an intermediate normalization layer.
The gradient w.r.t. a single cell i of its input x is given as

    ∇_x_iℒ   = s/√(σ^2(x)+ϵ) (∇_x̂_iℒ - 1^⊺(∇_x̂ℒ)/m- x̂_i(∇_x̂ℒ)^⊺x̂/m),

where x̂∈ℝ^m and m is the number of cells.
For a scaling a ∈ℝ and a constant translation b·1∈ℝ^m, consider the case where ∇_x̂ℒ = a ·x̂ + b·1.
Then because x̂ has zero mean and unit variance

    ∇_x_iℒ   = s/√(σ^2(x) + ϵ) (a ·x̂_̂î + b - b - a ·x̂_i ) 
       = 0.

Thus, there is no gradient w.r.t. a scaling and translation of x running through the normalization layer, which is only natural as such a transformation would be cancelled out by the normalization anyways.
AdaIN allows us to set this affine transformation individually for each object.
Therefore, the gradient w.r.t. its parameters does not have to pass through the entire decoder. 
Consequently, the convolutional layers only have to learn non-affine interactions.



  §.§.§ Point Cloud Generation


Our proposed convolutional decoder so far only generates volumetric grids. We are however interested in generating point clouds.
Therefore, as shown in Figure <ref>, for each cell c we feed its encoded information f_c into a simple MLP.
This MLP predicts two values p_c and δ_c. p_c is a binary variable predicting whether a cell is filled or empty. 
δ_c is a probability density function (i.e. the likelihood, that a sample should be generated for a particular cell).
Distributing the estimation of this information over two variables helps us in dealing with empty cells, as the density prediction seldom actually reaches zero and we thus would introduce points at unwanted locations.
For all cells that are classified as filled we then distribute the total number of output samples proportionally to the density estimates of the cells. Thus our network is independent of the number of points we want to generate. This number can even be changed between training and inference (see Figure <ref>).

The actual generation of points is done in a similar manner to Groueix et al. <cit.> and Yin et al. <cit.>.
The idea is to learn a parameterization from a k-dimensional domain to ℝ^3. Then by randomly sampling this domain from a uniform distribution and applying the map, we get our 3-dimensional points. 
In all our experiments we set k=2, since we assume that locally the shape can be approximated with a surface patch.
In practice we apply this map by concatenating the k-dimensional sample to the encoded cell information f_c and feeding
the resulting vector into a MLP, which outputs a 3-dimensional point.
Thus the MLP represents a map m_f_c: ℝ^k→ℝ^3 conditioned on f_c.
During inference we sample the k-dimensional domain uniformly and then apply a number of steps of Lloyd's algorithm <cit.> to ensure an even coverage of the space.
This further improves our results as shown in Section <ref>. The predicted samples of each cell are offset by the corresponding cell centers.



 §.§ Encoder



For our encoder (see Figure <ref>) we follow a similar approach to Rethage et al. <cit.>.
We isotropically normalize the input point cloud such that the longest edge of its axis-aligned bounding box is scaled to the range [-0.5, 0.5].
This point cloud 𝒳 is then embedded into a volumetric grid consisting of 32^3 cells.
For each grid cell we encode the local neighborhood of 𝒳 (all points within a radius r = √(3)/2 to the cell center) via a small PointNet (proposed by Qi et al. <cit.>).
Apart from using fewer number of parameters we also aggregate the final encoding of point clouds by computing the mean of the point features instead of the maximum as proposed in the original paper.
Since we make use of a PointNet we are able to handle input point clouds with varying number of points.

This results in a grid where each cell has an η-dimensional feature vector (η=32 in all our experiments).
This grid can then be passed through a 3D CNN, which consists of a series of convolution, batchnorm and max-pooling layers.
The output is an encoding z ∈ℝ^1024 of 𝒳.
For more details on the architecture see Appendix <ref>.


 §.§ Loss Functions


We define the distance of a point s_𝒳 to a point cloud 𝒴 as

    d(s_𝒳, 𝒴) = min_s_𝒴∈𝒴s_𝒳 - s_𝒴_2.

In order to compare the input point cloud 𝒳∈ℝ^n × 3 to the reconstructed point cloud 𝒴∈ℝ^m × 3 we measure the difference with the commonly used Chamfer distance as proposed for point clouds in <cit.>,

    L_c(𝒳,𝒴) 
        = 1/n∑_s_𝒳∈𝒳 d(s_𝒳, 𝒴)^2 
        + 1/m∑_s_𝒴∈𝒴 d(s_𝒴, 𝒳)^2.

This gives us a gradient for every point in 𝒴.
However, we found that additionally formulating a sharper version of the Chamfer distance benefits training (see Section <ref>).
With the formulation

    L_p(𝒳,𝒴) 
        = 1/n√(∑_s_𝒳∈𝒳 d(s_𝒳, 𝒴)^p)
        + 1/m√(∑_s_𝒴∈𝒴 d(s_𝒴, 𝒳)^p).

the gradients of points that incur a larger error are weighted more heavily with p > 2. For high p this measure can be seen as similar to the Hausdorff distance. In our experiments we used p = 5.

Since 𝒴 is generated by offsetting generated per-cell point clouds 𝒴_c by the corresponding cell centers c_o, we want to enforce a notion of locality (i.e. each cell only contributes to the part of 𝒴 in its vicinity).
Thus we add a loss

    L_o(𝒴) = ∑_c ∑_s_c ∈𝒴_cmax( dist(s_c,c_o) - m,  0 ),

This penalizes any generated points that are too far away from their cell centers. We choose m = √(3) to allow points to be distributed within their generating cell and its direct neighbours.

We cannot directly train the density estimates and filled cell predictions using only the point-wise differences shown above.
This is because the differences do not give a gradient w.r.t. the number of points per cell.
For this reason we generate ground truth densities and label the filled cells based on the input.
Training the MLP that predicts the density δ and probability that a cell c is filled p is done by using the mean squared error

    L_d(δ, δ̂) = 1/32^3∑_c   (δ_c - δ̂_c )^2,

and the binary cross entropy loss

    L_f(p, p̂) = -1/32^3∑_c p̂_c·log(p_c) + (1-p̂_c) ·log(1 - p_c)

respectively.
Here δ̂ and p̂ denote the ground truth.
Thus our loss during training is

    λ_1 L_c(𝒳,𝒴)    + λ_2 L_p(𝒳,𝒴) + λ_3 L_d(δ,δ̂)
       + λ_4 L_f(p, p̂) + λ_5 L_o(𝒴)

In all our experiments we chose λ_1 = 1e3, λ_2 = 1e1, λ_3 = 1e10, λ_4 = 1e2, and λ_5 = 1.



§ EXPERIMENTS


We evaluate our decoder network both by showing the effectiveness of several design choices and by comparing our results with the current state of the art on the task of autoencoding 3D point clouds. 
All our experiments with our proposed method were done on the ShapeNet dataset <cit.>, where we evaluated both our method and the methods proposed in <cit.>.
Additionally, we performed experiments using their respective settings and datasets.
This is necessary for a thorough comparison, since prior work employs different datasets, data normalization techniques and evaluation criteria.
Furthermore, we can assume that their proposed network architectures were tuned according to the respective datasets.
Our networks were trained using AMSGrad <cit.> (β_1 = 0.9, β_2 = 0.999, learning rate = 0.0046).
For evaluation on the testing set we used the network weights that performed best on the validation set.
All other networks were trained using the hyper-parameters settings suggested in the respective works.



  
*Dataset
For our experiments we made use of the official training, validation, and testing split of the ShapeNet Core dataset (v2), which consists of ca. 50k models in 55 different categories.
We found that a high quality sampling is important to achieve good results (see Table <ref>), as the loss is strongly affected by it.
Minimizing the Chamfer distance on a non-even sparse sampling does not necessarily mean that we are able to achieve a good approximation of the underlying surface.
A large distance from a reconstructed point to the closest target point can be either caused by a great distance to the underlying surface (which we want to penalize) or by the lack of samples in this particular part of the surface (which we do not want to penalize).
Therefore, it is desirable that the sampling is as even as possible over the entire shape.
To achieve such a sampling, we strongly oversampled the objects uniformly (with roughly 80k points) and then chose a subset (16k points) of those with farthest point sampling.

As our encoder sorts all points into a grid, we normalize the point clouds to the size of the unit cube centered in the origin. No further data augmentation is applied. All metrics are however computed on unnormalized shapes to simplify future comparisons. When not mentioned otherwise, all distances are reported between point clouds with 2500 points.



 §.§ Ablation Study








To motivate our design choices we performed an extensive ablation study, reporting the Chamfer distance obtained on the testing set for different changes in our input, architecture or loss function (Table <ref>). 
To show the effect of an evenly distributed point cloud, we trained the network on a uniform random sampling (1) as used in <cit.>. 
We evaluated on our high quality point clouds.
To motivate the use of AdaIN, we implemented a strong baseline in the form of a convolutional autoencoder.
We used the same encoder as in our proposed network.
However, for the decoder we used a convolutional decoder without AdaIN (2) (i.e. z is passed directly into the decoder and P is no longer necessary).
To ensure a fair comparison we used a similar number of parameters.

While our proposed architecture enables the possible application of nine layers of AdaIN (7), we found that this lead to some overfitting on the training data.
Therefore, we limit the number of affine feature transformations to the first three layers (8).
All subsequent outputs of instance normalization layers are not scaled and translated.
This architecture achieved the best result (marked in bold in Table <ref>).

To show the effectiveness of the additionally introduced losses, we trained networks without them and show the difference in the resulting Chamfer distance (3,4).
For further comparison, we trained a network in a fairly simple manner by only using the chamfer distance as a loss and no AdaIN on randomly sampled point clouds (5).
Finally, we show that sampling the learned map from 2D to 3D at fixed, well distributed positions (as done in <cit.>) instead of randomly during inference further improves the results (6).
Not using the cell classification loss has a minor negative impact on the results in the order of the fourth decimal. 
To put these numbers into context, we compare a random sampling of the shape with the ground truth (9).





 §.§ Comparison

We compare against AtlasNet <cit.> and SO-Net <cit.> both on our own dataset (Table <ref>) as well as on their respective datasets (Table <ref>).
For AtlasNet we trained their best performing network (125 Patches) on our dataset.
SO-Net does not allow to output point clouds with 2500 points without changing the suggested architecture.
Instead, we compare against the two presented versions of the network.
One generates 1280 points (Table <ref>) and one has an output size of 4608 points (Table <ref>).
The numbers reported in their paper are from a network outputting 1280 points, consequently we trained ours similarly (i.e. 1024 input points and 1280 output points).
Furthermore, they use a slightly different definition of the Chamfer distance.
They compute the Euclidean distance between closest points instead of its squared version. 
For a fair comparison on our dataset we report the Chamfer distance between a target of 2500 points and the entire point cloud (4608 points) as well as subsamplings (2500 points) of it. 


Note that the computed distances are not comparable across datasets due to differences in normalization and evaluation methods.
As can be seen in Tables <ref> and <ref> our method outperforms AtlasNet and SO-Net on our dataset as well as on the ones used by the respective authors. Qualitative results are shown in Figure <ref>.
For these examples, our method is less prone to produce outliers and reconstructs the shape contours more faithfully.



§ APPLICATIONS


To demonstrate the usefulness of our convolutional decoder we show results in three applications.
Our hyper-parameters and architecture were not tuned particularly for these demonstrations.
We expect that with more carefully chosen settings, better results could be achieved.


  
*Single View Reconstruction

For single view reconstruction (see Figure <ref>) we follow <cit.> and use a subset of ShapeNet consisting of 13 classes.
To be comparable we use their rendered views, as well as their sampling.
Similar to <cit.> we used a pretrained VGG-11 <cit.> as an encoder. The rest of our network is unchanged to the autoencoder setting.
We manage to achieve competitive quantitative results as shown in Table <ref>.




  
*Point Cloud Upsampling

As our network architecture is indifferent to the number of input or output points, it is straightforward to use our model for the task of point cloud upsampling.
We train our network on our training set to take between 50 and 500 input points, but output 5000.
Although there are several methods that use neural networks for point cloud upsampling <cit.>, their setting is different as they regard local patches of the geometry and compute a denser sampling there.
In contrast, we regard the shape as a whole.
As a result these methods require the input to be sampled densely enough that local patches convey geometric meaning.
For our method it is sufficient that the general shape is conveyed in order to get results of a good quality. We demonstrate this on severely under-sampled point clouds of the test set with only 50 points as input (Figure <ref>).
Note that our method is able to robustly output point clouds of size 16000 even though the network was trained to output 5000 points.



  
*Point Cloud Synthesis
Our decoder can not only be used to reconstruct point clouds for a given input but is also able to generate new shapes as well. 
A commonly used generative model is the variational autoencoder (VAE) as proposed by Kingma et al. <cit.>.
We implemented a conditional VAE version of our network, with only minor changes to the original autoencoder.
Conditioning on different classes is done by passing the category as a one-hot encoding vector into a MLP, which generates P (see Figure <ref>).
The latent vector z is sampled from a multivariate Gaussian, whose parameters are predicted by the encoder.
This allows us to sample the latent space in order to generate shapes for a specified category as shown in Figure <ref>.



§ CONCLUSION

In this work we have introduced a convolutional decoder that can generate high quality point clouds of arbitrary size.
Our method is able to achieve state of the art results for auto-encoding tasks by making use of the benefits offered by AdaIN, careful consideration of even sampling, as well as several additions to the Chamfer distance as losses.
We outline several possible applications for our method in the fields of single view reconstruction, point cloud upsampling and synthesis.

Our architecture inherits some of the common limitations that come with voxel-based representations. That is, our method is not invariant to rotations of the input and could incur a larger memory cost at higher grid resolutions. However, we show that with a relatively low resolution (32^3) we are able to generate results of a high quality.
Furthermore, we approximate the geometry in each filled grid cell as a surface patch.
For locally more complex geometries this might be a limitation.

Nevertheless, we are convinced that our method is useful in future research on 3D shape synthesis.
One direction is the use of a generator similar to our decoder in the setting of generative adversial networks (GANs) as originally proposed by Goodfellow et al. <cit.>.
Another interesting research direction are more detailed shape modifications enabled by affine feature transformations at varying levels of detail.



  
*AcknowledgementsThe research leading to these results has received funding from the European Research Council under the European Union's Seventh Framework Programme
(FP7/2007-2013)/ERC grant agreement n^∘ [340884], as well as the Deutsche Forschungsgemeinschaft DFG – 392037563.



§ NETWORK ARCHITECTURE


Our encoder consists of a small PointNet and an 3D CNN.
The PointNet is constructed as FC8-FC16-FC32-FC32.
FCx is a fully connected layer (in this case without bias) with output dimensionality x.
After every fully connected layer we apply batchnorm as proposed by Ioffe and Szegedy <cit.>.
We also apply the exponential linear unit (ELU) as an activation function as proposed by Clevert et al. <cit.> after every batchnorm layer except for the last one.
In order to construct the final 32-dimensional feature vector for each cell we compute the mean feature instead of taking the maximum.

The 3D CNN is constructed as C64-C64-C64-MP-C128-C128-MP-C256-C256-MP-C512-C512-MP-C512-C1024.
Cx is a 3D convolution layer with kernel size 3×3×3, zero-padding of 1, stride of 1, and output feature dimensionality x.
For C1024 we use no padding and a kernel size of 2×2×2 in order to reduce the output to a 1024-dimensional vector.
We do not use bias for our convolution operations.
After every convolution layer we apply batchnorm and ELU.
MP refers to a max-pooling layer with kernel size 2×2×2 and stride 1.

For our decoder we use a fully connected layer with bias to map z to w.
The convolutional decoder is constructed as P-C512-U-C512-C256-U-C256-C128-U-C128-C64-U-C64-C62.
P refers to the learnable constant parameter block of size 512×2×2×2.
Cx refers to 3D convolution layers with output feature dimensionality x, kernel size 3×3×3, stride of 1, and zero-padding of 1.
We do not use bias for our convolution operations.
After every convolution and P we apply dropout as proposed by Srivastava et al. <cit.> with a probabilty of 0.2.
AdaIN is applied after every dropout layer and after P with the scaling and translation parameters provided by w.
For every convolution layer we apply ELU after AdaIN.

Our point cloud generation MLP is structured as FC64-FC64-FC32-FC32-FC16-FC16-FC8-FC3.
We apply ELU after every FC layer except for the last one.

The MLP that estimates the density and classifies whether a grid cell contains points or not is constructed as FC16-FC8-FC4-FC2.
After every fully connected layer we apply batchnorm and ELU except for the last one.



eg-alpha-doi  
        




