3D Point Cloud Generative Adversarial Network Based on Tree Structured Graph Convolutions

TL;DR

This paper introduces tree-GAN, a novel 3D point cloud generative model using tree-structured graph convolutions, achieving superior quality and diversity in generated point clouds through a new evaluation metric.

Contribution

It presents a new GAN architecture with tree-structured graph convolutions for improved 3D point cloud generation and a novel metric for evaluation.

Findings

Tree-GAN outperforms existing GANs in quality and diversity.

The proposed FPD metric effectively evaluates 3D point cloud generation.

Tree-GAN can generate semantic part-specific point clouds without prior knowledge.

Abstract

In this paper, we propose a novel generative adversarial network (GAN) for 3D point clouds generation, which is called tree-GAN. To achieve state-of-the-art performance for multi-class 3D point cloud generation, a tree-structured graph convolution network (TreeGCN) is introduced as a generator for tree-GAN. Because TreeGCN performs graph convolutions within a tree, it can use ancestor information to boost the representation power for features. To evaluate GANs for 3D point clouds accurately, we develop a novel evaluation metric called Frechet point cloud distance (FPD). Experimental results demonstrate that the proposed tree-GAN outperforms state-of-the-art GANs in terms of both conventional metrics and FPD, and can generate point clouds for different semantic parts without prior knowledge.

Tables

Table 1. Table 1: Quantitative comparison in terms of the metrics used by Achlioptas et al.   [ 1 ] . Red and blue values denote the best and the second-best results, respectively. Because the original paper by Valsesia et al.   [ 39 ] only presented point cloud results for chair and airplane classes, our tree-GAN was compared to [ 39 ] based on these classes. However, we additionally evaluated the proposed tree-GAN quantitatively for all 16 16 16 classes, as shown below. For networks with ⋆ ⋆ \star , we used results reported in  [ 39 ] . Higher COV-CD and COV-EMD, and lower JSD, MMD-CD, and MMD-EMD indicate better methods.

Class	Model	JSD $\downarrow$	MMD-CD $\downarrow$	MMD-EMD $\downarrow$	COV-CD $\uparrow$	COV-EMD $\uparrow$
	r-GAN (dense)⋆	0.238	0.0029	0.136	33	13
	r-GAN (conv)⋆	0.517	0.0030	0.223	23	4
	Valsesia et al. (no up.)⋆	0.119	0.0033	0.104	26	20
	Valsesia et al. (up.)⋆	0.100	0.0029	0.097	30	26
Chair	tree-GAN (Ours)	0.119	0.0016	0.101	58	30
	r-GAN (dense)⋆	0.182	0.0009	0.094	31	9
	r-GAN (conv)⋆	0.350	0.0008	0.101	26	7
	Valsesia et al. (no up.)⋆	0.164	010010	0.102	24	13
	Valsesia et al. (up.)⋆	0.083	0.0008	0.071	31	14
Airplane	tree-GAN (Ours)	0.097	0.0004	0.068	61	20
All ($16$ classes)	r-GAN (dense)	0.171	0.0021	0.155	58	29
	tree-GAN (Ours)	0.105	0.0018	0.107	66	39

Equations

$$L_{gen}=-{\mathbb{E}}_{z\sim \mathcal{Z}}[D(G(z))],$$

$$\begin{array}{rl}{L}_{disc}& ={\mathbb{E}}_{z\sim \mathcal{Z}}[D(G(z))]-{\mathbb{E}}_{x\sim \mathcal{R}}[D(x)]\\ & +{\lambda }_{gp}{\mathbb{E}}_{\hat{x}}[({\Vert {\nabla }_{\hat{x}}D(\hat{x})\Vert }_2-1{)}^2],\end{array}$$

$$p_i^{l+1}=\sigma \left(W^l{p}_i^l+\sum _{q_j^l\in N(p_i^l)}{U}^l{q}_j^l+b^l\right),$$

$$p_i^{l+1}=\sigma \left({\mathbf{F}}_K^l(p_i^l)+\sum _{q_j\in A(p_i^l)}{U}_j^l{q}_j+b^l\right),$$

$$S_i^{l+1}={\mathbf{F}}_K^l(p_i^l),$$

$$\sum _{q_j\in A(p_i^l)}{U}_j^l{q}_j,$$

$$p_j^{l+1}=[V_i^{l+1}\cdot p_i^l{]}_j,\text{for}j=1,\cdots ,d_l$$

$${\Vert p_s-p_i\Vert }^2={\Vert S_s-S_i\Vert }^2,$$

$${\Vert p_d-p_i\Vert }^2\le \sum _{l=1}^{L-1}{\Vert S_{A_l(p_d)}^l-S_{A_l(p_i)}^l\Vert }^2+{\Vert S_d-S_i\Vert }^2,$$

$$\text{FPD}(\mathbb{P},\mathbb{Q})={\Vert {\mathbf{m}}_{\mathbb{P}}-{\mathbf{m}}_{\mathbb{Q}}\Vert }_2^2+\text{Tr}({\Sigma }_{\mathbb{P}}+{\Sigma }_{\mathbb{Q}}-2({\Sigma }_{\mathbb{P}}{\Sigma }_{\mathbb{Q}}{)}^{\frac{1}{2}}),$$

Full text

{strip} Figure 1: Unsupervised 3D point clouds generated by our tree-GAN for multiple classes (e.g., Motorbike, Laptop, Table, Guitar, Skateboard, Knife, Table, Pistol, and Car from top-left to bottom-right). Our tree-GAN can generate more accurate point clouds than baseline (i.e., r-GAN [1]), and can also produce point clouds for semantic parts of objects, which are denoted by different colors.

1 Introduction

Recently, 3D data generation problems based on deep neural networks have attracted significant research interest and have been addressed through various approaches, including image-to-point cloud [11, 19], image-to-voxel [45], image-to-mesh [40], point cloud-to-voxel [6, 50], and point cloud-to-point cloud [47]. The generated 3D data has been used to achieve outstanding performance in a wide range of computer vision applications (e.g., segmentation [30, 37, 44], volumetric shape representation [46], object detection [4, 35], feature extraction [24], contour detection [15], classification [29, 34], and scene understanding [20, 43]).

However, little effort has been devoted to the development of generative adversarial networks (GANs) that can generate 3D point clouds in an unsupervised manner. To the best of our knowledge, the only works on GANs for transforming random latent codes (i.e., $z$ vectors) into 3D point clouds are [1] and [39]. The method in [1] generates point clouds using only fully connected layers. The method in [39] exploits local topology by using $k$-nearest neighbor techniques to produce geometrically accurate point clouds. However, it suffers from high computational complexity as the number of dynamic graph updates increases. Additionally, it can only generate a limited number of object categories (e.g., chair, airplane, and sofa) using point clouds.

In this paper, we present a novel method called tree-GAN that can generate 3D point clouds from random latent codes in an unsupervised manner. It can also generate multi-class 3D point clouds without training on each class separately (e.g., [39]). To achieve state-of-the-art performance in terms of both accuracy and computational efficiency, we propose a novel tree-structured graph convolution network (TreeGCN) as a generator for tree-GAN. The proposed TreeGCN preserves the ancestor information of each point and utilizes this information to extract new points via graph convolutions. A branching process and loop term with $K$ supports in TreeGCN further enhance the representation power of points. These two properties enable TreeGCN to produce more accurate point clouds and express more diverse object categories. Additionally, we demonstrate that using the ancestors of features in TreeGCN is more efficient computationally than using the neighbors of features in traditional GCNs.. Fig.3D Point Cloud Generative Adversarial Network Based on Tree Structured Graph Convolutions shows the effectiveness of our tree-GAN.

The main contributions of this paper are fourfold.

$\bullet$ We present the novel tree-GAN method, which is a deep generative model that can generate multi-class 3D point clouds in unsupervised settings (Section 3).

$\bullet$ We introduce the TreeGCN based generator. The performance of traditional GCNs can be improved significantly by adopting the proposed tree structures for graph convolutions. Based on the proposed tree structures, tree-GAN can generate parts of objects by selecting particular ancestors (Section 4).

$\bullet$ We mathematically interpret the TreeGCN and highlight its desirable properties (Section 5).

$\bullet$ We present the Fréchet point cloud distance (FPD) metric to evaluate GANs for 3D point clouds. FPD can be considered as a nontrivial extension of Fréchet inception distance (FID) [17], which has been widely used for the evaluation of GANs (Section 6).

2 Related Work

**Graph Convolutional Networks: ** Over the past few years, a number of works have focused on the generalization of deep neural networks for graph problems [3, 9, 16, 25]. Defferrard et al. [8] proposed fast-learning convolutional filters for graph classification problems. Using these filters, they significantly accelerated the spectral decomposition process, which was one of the main computational bottlenecks in traditional graph convolution problmes with large datasets. Kipf and Welling [22] introduced scalable GCNs based on first-order approximations of spectral graph convolutions for semi-supervised classification, in which convolution filters only use the information from neighboring vertices instead of the information from the entire network.

Because the aforementioned GCNs were originally designed for classification problems, the connectivity of graphs was assumed to be given as prior knowledge. However, this setting is not appropriate for problems of dynamic model generation. For example, in unsupervised settings for 3D point cloud generation, the typologies of 3D point clouds are non-deterministic. Even for the same class (e.g., chairs), 3D point clouds can be represented by various typologies. To represent the diverse typologies of 3D point clouds, our TreeGCN utilizes no prior knowledge regarding object models.

**GANs for 3D Point Clouds Generation: ** GANs [13] for 2D image generation tasks have been widely studied with great success [10, 18, 23, 26, 31, 36, 41, 42, 48, 49], but GANs for 3D point cloud generation have rarely been studied in the computer vision field. Recently, Achlioptas et al. [1] proposed a GAN for 3D point clouds called r-GAN, generator of which is based on fully connected layers. As fully connected layers cannot maintain structural information, the r-GAN has difficulty in generating realistic shapes with diversity. Valsesia et al. [39] used graph convolutions for generators for GANs. At each layer of graph convolutions during training, adjacency matrices were dynamically constructed using the feature vectors from each vertex. Unlike traditional graph convolutions, the connectivity of a graph was not assumed to be given as prior knowledge. However, to extract the connectivity of a graph, computing the adjacency matrix at a single layer incurs quadratic computational complexity $O(V^{2})$ where $V$ indicates the number of vertices. Therefore, this approach is intractable for multi-batch and multi-layer networks.

Similar to the method in [39], our tree-GAN requires no prior knowledge regarding the connectivity of a graph. However, unlike the method in [39], the tree-GAN is computationally efficient because it does not construct adjacency matrices. Instead, the tree-GAN uses ancestor information from the tree to exploit the connectivity of a graph, in which only a list of tree structure is needed.

**Tree-structured Deep Networks: ** There have been several attempts to represent convolutional neural networks or long short-term memory using tree structures [5, 21, 27, 28, 32]. However, to the best of our knowledge, no previous methods have used tree structures for either graph convolutions or GANs. For example, Gadelha et al. [12] used tree-structured networks to generate 3D point clouds via variational autoencoder (VAE). However, this method needed the assumption that inputs are the 1D-ordered lists of points obtained by space-partitioning algorithms such as K-dimensional tree and random projection tree [7]. Thus, it required additional preprocessing steps for valid implementations. Because its network only comprised 1D convolution layers, the method could not extract the meaningful information from unordered 3D point clouds. In contrast, the proposed tree-GAN can not only deal with unordered points, but also extract semantic parts of objects.

3 3D Point Cloud GAN

Fig.2 presents the pipeline of the proposed tree-GAN. To generate 3D point clouds $x^{\prime}$ from latent code $z$, we utilize the objective function introduced in Wasserstein GAN [2]. The loss function of a generator, $L_{gen}$, is defined as

[TABLE]

where $G$ and $D$ denote the generator and discriminator, respectively, and $\mathcal{Z}$ represents a latent code distribution. We design $\mathcal{Z}$ with a Normal distribution, $z\in\mathcal{N}(\mathbf{0},I)$. The loss function of a discriminator, $L_{disc}$, is defined as

[TABLE]

where $\hat{x}$ are sampled from line segments between real and fake point clouds, $x^{\prime}\sim G(z)$ and $x$ denote generated and real point clouds, respectively, and $\mathcal{R}$ represents a real data distribution. In (2), we use a gradient penalty to satisfy the $1$-Lipschitz condition [14], where $\lambda_{gp}$ is a weighting parameter.

4 Proposed TreeGCN

To implement $G$ in (1), we consider multi-layer graph convolutions with first-order approximations of the Chebyshev expansion introduced by [22] as follows:

[TABLE]

where $\sigma(\cdot)$ is the activation unit, $p_{i}^{l}$ is the $i$-th node in the graph (i.e., 3D coordinate of a point cloud) at the $l$-th layer, $q_{j}^{l}$ is the $j$-th neighbor of $p_{i}^{l}$, and $N(p_{i}^{l})$ is the set of all neighbors of $p_{i}^{l}$. Then, $z$ and $x^{\prime}$ in (2) can be represented by $[p_{1}^{0}]$ and $[p_{1}^{L}~{}p_{2}^{L}~{}\cdots~{}p_{n}^{L}]$, respectively, where $L$ is the final layer and $n$ is the number of points at $L$.

During training, GCNs find the best weights $W^{l}$ and $U^{l}$ and best bias $b^{l}$ at each layer, then generate 3D coordinates for point clouds by using these parameters to ensure similarity to real point clouds. The first and second terms in (3) are called the loop and neighbors terms, respectively.

To enhance a conventional GCN such as that used in [22], we propose a novel GCN augmented with tree structures (i.e., TreeGCN). The proposed TreeGCN introduces a tree structure for hierarchical GCNs by passing information from ancestors to descendants of vertices. The main unique characteristic of the TreeGCN is that each vertex updates its value by referring to the values of its ancestors in the tree instead of thosed of its neighbors. Traditional GCNs, such as those defined in (3), can be considered as methods that only refer to neighbors at a single depth. Then, the proposed graph convolution is defined as

[TABLE]

where there are two major differences compared to (3). One is an improved conventional loop term using a subnetwork $\mathbf{F}_{K}^{l}$, where $S_{i}^{l+1}$ is generated by $K$ supports from $\mathbf{F}_{K}^{l}$. We call this term a loop with $K$-supports, as explained in Section 4.1. The other difference is the consideration of values from, all ancestors in the tree to update the value of a current point, where $A(p_{i}^{l})$ denotes the set of all ancestors of $p_{i}^{l}$. We call this term ancestors, as explained in Section 4.1.

4.1 Advanced Graph Convolution

The proposed tree-structured graph convolution (i.e., GraphConv in Fig.2) aims to modify the coordinates of points using the loop with $K$-supports and ancestor terms.

**Loop term with $K$-supports: ** The goal of the new loop term in (4) is to propose the next point based on $K$ supports instead of using only the single parameter $W^{l}$ in (3) as follows:

[TABLE]

where $\mathbf{F}^{l}_{K}$ is a fully connected layer containing $K$ nodes. A conventional GCN using first-order approximations adopts a single parameter in its loop term to generate the next point from the current point. However, for large graphs, the representation capacity of a single parameter is insufficient for describing a complex point distribution. Therefore, our loop term utilizes $K$ supports to represent a more complex distribution of points, as illustrated in Fig.3.

**Ancestor term: ** For graph convolution, knowing the connectivity of a graph is very important because this information allows a GCN to propagate useful information from a vertex to other connected vertices. However, in our point cloud generation setting, it is impossible to use prior knowledge regarding connectivity because we must be able to generate diverse typologies of point clouds, even for the same object category. Therefore, the dynamic 3D point generation problem cannot be addressed using traditional GCNs because such networks assume that the connectivity of a graph is given. As a replacement for the neighbor term in (3), we define the ancestor term in (4) as follows:

[TABLE]

where $A(p_{i}^{l})$ denotes the set of all ancestors of $p_{i}^{l}$. This term combines all information from the ancestors $q_{j}$ through a linear mapping $U_{j}^{l}$. Because each ancestor belongs to a different feature space at a different layer, our ancestor term can fuse all information from previous layers and different feature spaces. To generate the next point, the current point refers to its ancestors in various feature spaces to find the best mapping $U_{j}^{l}$ to combine ancestor information effectively. By using this new ancestor term, our tree-GAN obtains several desirable mathematical properties, as explained in Section 5. Fig.4 illustrates the graph convolution process with the ancestor term.

4.2 Branching

Branching is a procedure for increasing the total number of points and is similar to up-sampling in 2D convolution. In branching, $V_{i}^{l+1}$ transforms a single point $p_{i}^{l}\in R^{3}$ into $d_{l}$ child points, where $[V_{i}^{l+1}\cdot p_{i}^{l}]\in R^{3\times d_{l}}$. Therefore,

[TABLE]

where $[A]_{j}$ denotes the $j$-th column of matrix $A$. Then, the total number of points in the $(l+1)$-th layer is $|p^{l}|\times d_{l}$, where $|p^{l}|$ is the number of points in the $l$-th layer. In our experiments, we use different branching degrees for different layers (e.g., $\{d_{l}\}_{l=1}^{7}=\{1,2,2,2,2,2,64\}$). Note that the number of points in the final layer is $\prod_{l=1}^{7}d_{l}=2048$. Fig.5 presents an example of branching with degree $2$.

5 Mathematical Properties

In this section, we mathematically analyze the geometric relationships between generated points and demonstrate how these relationships are formulated in the output Euclidean space via tree-structured graph convolutions.

Proposition 1**.**

Let $p_{s}^{L}$ and $p_{d}^{L}$ in (4) be generated points that share the same parents and different parents, respectively, with $p_{i}^{L}$ in the final layer $L$. Let $S_{i}^{l}$ in (5) be the loop of point $p_{i}^{l}$ at the $l$-th layer. Hereafter, we omit the superscripts of $p_{s}^{l}$ and $S_{i}^{l}$ if the superscript $l$ indicates the fianl layer $L$. Then,

[TABLE]

and

[TABLE]

where $A_{l}(p)$ are all ancestors of point $p$ in the $l$-th layer. For simplicity, we ignore the branch process and $U_{j}^{l}$ in (5).

Based on Proposition 1, we can prove that following two statements are true:

$\bullet$ The geometric distance between two points is determined by the number of shared ancestors. If two points $p_{d}$ and $p_{i}$ have different ancestors, then the geometric distance between these points is calculated as the sum of differences between their ancestors in each layer $l$ $\left(\emph{i.e.},~{}\left\lVert S_{A_{l}(p_{d})}^{l}-S_{A_{l}(p_{i})}^{l}\right\rVert^{2}~{}\text{in}~{}\eqref{eq:d_2}\right)$ and the differences between their loops $\left(\emph{i.e.},~{}\left\lVert S_{d}-S_{i}\right\rVert^{2}~{}\text{in}~{}\eqref{eq:d_2}\right)$. Thus, as their ancestors become increasingly different, the geometric distance between two points increases.

$\bullet$ Geometrically related points share the same ancestors. If two points $p_{s}$ and $p_{i}$ share the same ancestors, the geometric distance between these points is affected by only their loops, as shown in (8). Thus, the geometric distance between points with the same ancestors in (8) can decreases compared to that between points with different ancestors in (9) as $\left\lVert S_{A_{l}(p_{s})}^{l}-S_{A_{l}(p_{i})}^{l}\right\rVert^{2}=0$.

Based on these two properties, our tree-GAN can generate semantic parts of objects, as shown in Fig.6, where points with the same ancestors are assumed to belong to the same parts of objects. We will explore this part generation problem for the proposed tree-GAN in Section 7.1.

6 Fréchet Point Cloud Distance

For quantitative comparisons between GANs, we require evaluation metrics that can accurately measure the quality of the 3D point clouds generated by GANs. In the case of 2D data generation problems, FID [17] is the most common metric. FID adopts pre-trained inception V3 models [38] to utilize their feature spaces for evaluation. Although the conventional metrics proposed by Achlioptas et al. [1] can be used to evaluate the quality of generated points by directly measuring matching distances between real and generated point clouds, they can be considered as sub-optimal metrics because the goal of a GAN is not to generate the similar samples (e.g., MMD or CD) but to generate synthetic probability measures that are as close as possible to real probability measures. This perspective has been explored in unsupervised 2D image generation tasks using GANs [33, 17]. Therefore, we propose a novel evaluation metric for generated 3D point clouds called FPD.

Similar to FID, the proposed FPD calculates the 2-Wasserstein distance between real and fake Gaussian measures in the feature spaces extracted by PointNet [29] as follows:

[TABLE]

where $\mathbf{m}_{\mathbb{P}}$ and $\Sigma_{\mathbb{P}}$ are the mean vector and covariance matrix of the points calculated from real point clouds $\{x\}$, respectively, and $\mathbf{m}_{\mathbb{Q}},\Sigma_{\mathbb{Q}}$ are the mean vector and covariance matrix calculated from generated point clouds $\{x^{\prime}\}$, respectively, where $x\sim\mathbb{P}$ and $x^{\prime}=G(z)\sim\mathbb{Q}$. In (10), $\text{Tr}(A)$ is the sum of the elements along the main diagonal of matrix $A$. In this paper, for evaluation purposes, we use both conventional evaluation metrics [1] and the proposed FPD.

7 Experimental Results

**Implementation details: ** We used the Adam optimizer for both the generator and discriminator networks with a learning rate of $\alpha=10^{-4}$ and other coefficients of $\beta_{1}=0$ and $\beta_{2}=0.99$. In generator, we used LeakyReLU as a nonlinearity function without batch normalization. The network architecture of discriminator was the same as that in $r$-GAN [1]. The gradient penalty coefficient was set to $10$ and the discriminator was updated five times per iteration, while the generator was updated one time per iteration. As shown in Fig.2, a latent vector $z\in\mathbb{R}^{96}$ was sampled from a normal distribution $\mathcal{N}(0,I)$ ) to act as an input. Seven layers ($L=7$) were used for the TreeGCN. The loop term of the TreeGCN in (5) had $K=10$ supports. The total number of points in the final layer was set to $n=2048$.

**Comparison: ** There are only two conventional GANs for 3D point cloud generation: r-GAN [1] and the GAN proposed by Valsesia et al. [39]. Thus, the proposed tree-GAN was compared to these two GANs. While the conventional GANs in [39, 1] train separate networks for each class, our tree-GAN trains only a single network for multiple classes of objects.

**Evaluation metrics: ** We evaluated the tree-GAN using ShapeNet111https://www.shapenet.org/, which is a large-scale dataset of 3D shapes, containing $16$ object classes. Evaluations were conducted in terms of the proposed FPD (Section 6) and the metrics used by Achlioptas et al [1]. As a reference model for FPD, we used the classification module of PointNet [29] because it can handle partial inputs of objects. This property is suitable for FPD because generated point clouds gradually form shapes, meaning point clouds can be partially complete during training. For the implementation of FPD, we first trained a classification module for $40$ epochs to attain an accuracy of $98\%$ for classification tasks. We then extracted a $1808$-dimensional feature vector from the output of the dense layers to calculate the mean and covariance in (10).

7.1 Ablation Study

We analyze the proposed tree-GAN and examine its useful properties, namely unsupervised semantic part generation, latent space representation via interpolation, and branching.

**Unsupervised semantic part generation: ** Our tree-GAN can generate point clouds for different semantic parts, even with no prior knowledge regarding those parts during training. The tree-GAN can perform this semantic generation owing to its tree-structured graph convolution, which is a unique characteristic among GAN-based 3D point cloud methods. As stated in Proposition 1, the geometric distance between points is determined by their ancestors in the tree. Different ancestors imply geometrically different families of points. Therefore, by selecting different ancestors, our tree-GAN can generate semantically different parts of point clouds. Note that these geometric families of points are consistent between different latent code inputs. For example, let $z_{1},z_{2}\sim\mathcal{N}(0,I)$ be sampled latent codes. Let $G(z_{1})=[p_{1}~{}p_{2}~{}\dots~{}p_{2048}]$ and $G(z_{2})=[q_{1}~{}q_{2}~{}\dots~{}q_{2048}]$ be their corresponding generated point clouds. Let $J$ be a certain subset of $2048$ point indices. Then, $G^{J}(z_{1})=[p_{j}]_{j\in J}$ denotes the subset of $G(z_{1})$ from the indices $J$. As shown in Fig. 6, if we select the same subsets of indices of point clouds, it results in the same semantic parts, even though the latent code inputs are different. For example, all red points indexed by $J_{h}$ (e.g., $G^{J_{h}}(z_{1})$ and $G^{J_{h}}(z_{2})$) represent the cockpits of airplanes, while all blue points indexed by $J_{t}$ (e.g., $G^{J_{t}}(z_{1})$ and $G^{J_{t}}(z_{2})$) represent the tails of airplanes.

From this ablation study, we can verify that the differences between ancestors determine the semantic differences between points and that two points with the same ancestor (e.g., green and purple points in the left wings in Fig. 6) maintain their relative distances for different latent codes.

**Interpolation: ** We interpolated 3D point clouds by setting the input latent code to $z_{\alpha}=(1-\alpha)z_{1}+\alpha z_{2}$ based on six alphas $\alpha=[\alpha_{1},\dots,\alpha_{6}]$. The leftmost and rightmost point clouds of the airplanes in Fig.6 were generated by $G(z_{1})$ and $G(z_{2})$, respectively. Our tree-GAN can also generate realistic interpolations between two point clouds.

**Branching strategy: ** We conducted the experiments to show that the convergence dynamics of the proposed metric is not sensitive to different branching strategies. Like other experiments, the total number of the generated points are $2048$ but different branching degrees were set (e.g., $\{d_{l}\}^{7}_{1}=\{1,2,2,2,2,2,64\}$, $\{1,2,4,16,4,2,2\}$, $\{1,32,4,2,2,2,2\}$). Please refer to convergence graphs in supplementary materials.

7.2 Comparisons with Other GANs

The proposed tree-GAN was quantitatively and qualitatively compared to other state-of-the-art GANs for point cloud generation, in terms of both accuracy and computational efficiency. Supplementary materials contain more results and comparisons for 3D point clouds generation.

**Comparisons: ** Tables 1 and 2 contain quantitative comparisons in terms of the metrics used by Achlioptas et al. [1] (i.e., JSD, MMD-CD, MMD-EMD, COV-CD, and COV-EMD) and the proposed FPD, respectively. The proposed tree-GAN consistently outperforms other GANs at a large margin in terms of all metrics, demonstrating the effectiveness of the proposed treeGCN.

For qualitative comparisons, we equally divided the entire index set into four subsets and painted the points in each subset with the same color. Although the real 3D point clouds were unordered as shown in Figs.3D Point Cloud Generative Adversarial Network Based on Tree Structured Graph Convolutions and 7, our tree-GAN successfully generated 3D point clouds with intuitive semantic meaning without any prior knowledge, whereas r-GAN failed to generate semantically ordered point clouds. Additionally, our tree-GAN could generate detailed and complex parts of objects, whereas r-GAN generated more dispersed point distributions. Fig.7 presents qualitative results of our tree-GAN. The tree-GAN generated realistic point clouds for multi-object categories and produced very diverse typologies of point clouds for each class.

**Computational cost: ** In methods using static links for graph convolution, adjacency matrices are typically used for the convolution of vertices. Although these methods are known to produce good results for graph data, prior knowledge regarding connectivity is required. In other methods that use dynamic links for graph convolution, adjacency matrices must be constructed from vertices to derive connectivity information for every convolution layer instead of using prior knowledge. For example, let $L,B,V_{l}$ denote the number of layers, batch size, and induced vertex size of an output graph at the $l$-th layer, respectively. The methods described above require additional computations to utilize connectivity information. These computations require time and memory resources on the order of $\sum_{l=1}^{L}B\times V_{l}\times V_{l}$. However, our TreeGCN does not require any prior connectivity information like static link methods and does not require additional computation like dynamic link methods. Therefore, our network can use time and memory resources much more efficiently and requires less resources on the order of $\sum_{l=1}^{L}B\times V_{l}$.

8 Conclusion

In this paper, we proposed a generative adversarial network called the tree-GAN that can generate 3D point clouds in an unsupervised manner. The proposed generator for tree-GAN, which is called tree-GCN, preforms graph convolutions based on tree structures. The tree-GCN utilizes ancestor information from a tree and employs multiple supports to represent 3D point clouds. Thus, the proposed tree-GAN outperforms other GAN based point cloud generation methods in terms of accuracy and computational efficiency. Through various experiments, we demonstrated that the tree-GAN can generate semantic parts of objects without any prior knowledge and can represent 3D point clouds in latent spaces via interpolation.