Original: L EARNING L OCALIZED G ENERATIVE M ODELS FOR 3D P OINT C LOUDS VIA G RAPH C ONVOLUTION
Revised: L EARNING L OCALIZED G ENERATIVE M ODELS FOR 3D P OINT C LOUDS VIA G RAPH C ONVOLUTION

Original: magli@
Revised: magli@

Original: A BSTRACT
Revised: A BSTRACT

Original: Point clouds are an important type of geometric data and have widespread use in computer graphics and vision.
Revised: Point clouds are an important type of geometric data and have widespread use in computer graphics and vision.

Original: However, learning representations for point clouds is particularly challenging due to their nature as being an unordered collection of points irregularly distributed in 3D space.
Revised: However, learning representations for point clouds is particularly challenging due to their nature as being an unordered collection of points irregularly distributed in 3D space.

Original: Graph convolution, a generalization of the convolution operation for data de ﬁ ned over graphs, has been recently shown to be very successful at extracting localized features from point clouds in supervised or semi-supervised tasks such as classi ﬁ cation or segmentation.
Revised: Graph convolution, a generalization of the convolution operation for data de ﬁ ned over graphs, has been recently shown to be very successful at extracting localized features from point clouds in supervised or semi-supervised tasks such as classi ﬁ cation or segmentation.

Original: This paper studies the unsupervised problem of a generative model exploiting graph convolution.
Revised: This paper studies the unsupervised problem of a generative model exploiting graph convolution.

Original: We focus on the generator of a GAN and de ﬁ ne methods for graph convolution when the graph is not known in advance as it is the very output of the generator.
Revised: We focus on the generator of a GAN and de ﬁ ne methods for graph convolution when the graph is not known in advance as it is the very output of the generator.

Original: The proposed architecture learns to generate localized features that approximate graph embeddings of the output geometry.
Revised: The proposed architecture learns to generate localized features that approximate graph embeddings of the output geometry.

Original: We also study the problem of de ﬁ ning an upsampling layer in the graph-convolutional generator, such that it learns to exploit a self-similarity prior on the data distribution to sample more effectively.
Revised: We also study the problem of de ﬁ ning an upsampling layer in the graph-convolutional generator, such that it learns to exploit a self-similarity prior on the data distribution to sample more effectively.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Convolutional neural networks are at the core of highly successful models in image generation and understanding.
Revised: Convolutional neural networks are at the core of highly successful models in image generation and understanding.

Original: This success is due to the ability of the convolution operation to exploit the principles of locality, stationarity and compositionality that hold true for many data of interest.
Revised: This success is due to the ability of the convolution operation to exploit the principles of locality, stationarity and compositionality that hold true for many data of interest.

Original: In particular, feature locality and weight sharing across the data domain greatly reduce the number of parameters in the model, simplifying training and countering over ﬁ tting.
Revised: In particular, feature locality and weight sharing across the data domain greatly reduce the number of parameters in the model, simplifying training and countering over ﬁ tting.

Original: However, while images are de ﬁ ned on an underlying regular grid structure, several other types of data naturally lie on irregular or nonEuclidean domains (Bronstein et al., 2017).
Revised: However, while images are de ﬁ ned on an underlying regular grid structure, several other types of data naturally lie on irregular or nonEuclidean domains (Bronstein et al., 2017).

Original: Examples include problems in 3D models (Boscaini et al., 2016; Masci et al., 2015), computational biology (Alipanahi et al., 2015; Duvenaud et al., 2015) or social network graphs (Kipf & Welling, 2016).
Revised: Examples include problems in 3D models (Boscaini et al., 2016; Masci et al., 2015), computational biology (Alipanahi et al., 2015; Duvenaud et al., 2015) or social network graphs (Kipf & Welling, 2016).

Original: De ﬁ ning convolutional architectures on these domains is key to exploit useful priors on the data to obtain more powerful representations.
Revised: De ﬁ ning convolutional architectures on these domains is key to exploit useful priors on the data to obtain more powerful representations.

Original: Graph convolution is emerging as one of the most successful approaches to deal with data where the irregular domain can be represented as a graph.
Revised: Graph convolution is emerging as one of the most successful approaches to deal with data where the irregular domain can be represented as a graph.

Original: In this case, the data are de ﬁ ned as vectors on the nodes of a graph.
Revised: In this case, the data are de ﬁ ned as vectors on the nodes of a graph.

Original: De ﬁ ning a convolution-like operation for this kind of data is not trivial, as even simple notions such as shifts are unde ﬁ ned.
Revised: De ﬁ ning a convolution-like operation for this kind of data is not trivial, as even simple notions such as shifts are unde ﬁ ned.

Original: The literature has identi ﬁ ed two main approaches to de ﬁ ne graph convolution, namely spectral or spatial.
Revised: The literature has identi ﬁ ed two main approaches to de ﬁ ne graph convolution, namely spectral or spatial.

Original: In the former case (Henaff et al., 2015;
Revised: In the former case (Henaff et al., 2015;

Original: Defferrard et al., 2016; Kipf & Welling, 2016), the convolution operator is de ﬁ ned in the spectral domain through the graph Fourier transform (Shuman et al., 2013).
Revised: Defferrard et al., 2016; Kipf & Welling, 2016), the convolution operator is de ﬁ ned in the spectral domain through the graph Fourier transform (Shuman et al., 2013).

Original: Fast polynomial approximations (Defferrard et al., 2016) exist that allow an ef ﬁ cient implementation of the operation.
Revised: Fast polynomial approximations (Defferrard et al., 2016) exist that allow an ef ﬁ cient implementation of the operation.

Original: This spectral approach has been successfully used in semi-supervised classi ﬁ cation (Kipf & Welling, 2016) and link prediction (Schlichtkrull et al., 2017).
Revised: This spectral approach has been successfully used in semi-supervised classi ﬁ cation (Kipf & Welling, 2016) and link prediction (Schlichtkrull et al., 2017).

Original: However, the main drawback of these techniques is that the structure of the graph is supposed to be ﬁ xed and it is not clear how to handle the case where the graph structure varies.
Revised: However, the main drawback of these techniques is that the structure of the graph is supposed to be ﬁ xed and it is not clear how to handle the case where the graph structure varies.

Original: The latter class of methods (Simonovsky & Komodakis, 2017; Wang et al., 2018) de ﬁ nes the convolution operator using a spatial approach by means of local aggregations, i.e., weighted combinations of the vectors restricted to a neighborhood.
Revised: The latter class of methods (Simonovsky & Komodakis, 2017; Wang et al., 2018) de ﬁ nes the convolution operator using a spatial approach by means of local aggregations, i.e., weighted combinations of the vectors restricted to a neighborhood.

Original: Since this kind of convolution is de ﬁ ned at a neighborhood level, the operation remains well de ﬁ ned even when the graph varies.
Revised: Since this kind of convolution is de ﬁ ned at a neighborhood level, the operation remains well de ﬁ ned even when the graph varies.

Original: Point clouds are a challenging data type due to the irregular positioning of the points and the fact that a point cloud is an unordered set of points, and therefore any permutation of its members, while changing the representation, does not change its semantic meaning.
Revised: Point clouds are a challenging data type due to the irregular positioning of the points and the fact that a point cloud is an unordered set of points, and therefore any permutation of its members, while changing the representation, does not change its semantic meaning.

Original: Some works have addressed supervised problems on point clouds such as classi ﬁ cation or segmentation, either through voxelization (Maturana & Scherer, 2015b; Wu et al., 2015), where the irregular point structure is approximated with a regular 3D grid, or by networks like PointNet (Qi et al., 2017a;b) that address the problem of permutation invariance by processing each point identically and independently before applying a globally symmetric operation.
Revised: Some works have addressed supervised problems on point clouds such as classi ﬁ cation or segmentation, either through voxelization (Maturana & Scherer, 2015b; Wu et al., 2015), where the irregular point structure is approximated with a regular 3D grid, or by networks like PointNet (Qi et al., 2017a;b) that address the problem of permutation invariance by processing each point identically and independently before applying a globally symmetric operation.

Original: The most recent approaches (Simonovsky & Komodakis, 2017;
Revised: The most recent approaches (Simonovsky & Komodakis, 2017;

Original: Wang et al., 2018) build graphs in the Euclidean space of the point cloud and use graph convolution operations.
Revised: Wang et al., 2018) build graphs in the Euclidean space of the point cloud and use graph convolution operations.

Original: This approach has shown multiple advantages in i) reducing the degrees of freedom in the learned models by enforcing some kind of weight sharing, ii) extracting localized features that successfully capture dependencies among neighboring points.
Revised: This approach has shown multiple advantages in i) reducing the degrees of freedom in the learned models by enforcing some kind of weight sharing, ii) extracting localized features that successfully capture dependencies among neighboring points.

Original: Generative models are powerful tools in unsupervised learning aiming at capturing the data distribution.
Revised: Generative models are powerful tools in unsupervised learning aiming at capturing the data distribution.

Original: However, so far little work has been done on generative models for point clouds.
Revised: However, so far little work has been done on generative models for point clouds.

Original: Generative models of point clouds can be useful for many tasks that range from data augmentation to shape completion or inpainting partial data thanks to the features learned by the model.
Revised: Generative models of point clouds can be useful for many tasks that range from data augmentation to shape completion or inpainting partial data thanks to the features learned by the model.

Original: Generative Adversarial Networks (GANs) have been shown on images to provide better approximations of the data distribution than variational autoencoders (VAEs) (Larsen et al., 2016), being able to generate sharper images and to capture semantic properties in their latent space.
Revised: Generative Adversarial Networks (GANs) have been shown on images to provide better approximations of the data distribution than variational autoencoders (VAEs) (Larsen et al., 2016), being able to generate sharper images and to capture semantic properties in their latent space.

Original: For this reason, it is interesting to study them for unordered point sets.
Revised: For this reason, it is interesting to study them for unordered point sets.

Original: In the ﬁ rst work on the topic, Achlioptas et al.
Revised: In the ﬁ rst work on the topic, Achlioptas et al.

Original: (2017) studied some GAN architectures to generate point clouds.
Revised: (2017) studied some GAN architectures to generate point clouds.

Original: Such architectures use the PointNet approach to deal with the permutation problem at the discriminator and employ a dense generator.
Revised: Such architectures use the PointNet approach to deal with the permutation problem at the discriminator and employ a dense generator.

Original: However, this means that they are unable to learn localized features or exploit weight sharing.
Revised: However, this means that they are unable to learn localized features or exploit weight sharing.

Original: This paper studies a generative model for point clouds based on graph convolution.
Revised: This paper studies a generative model for point clouds based on graph convolution.

Original: In particular, we focus on the GAN generator which is not well explored by the graph convolution literature.
Revised: In particular, we focus on the GAN generator which is not well explored by the graph convolution literature.

Original: This poses a unique challenge: how can one apply a localized operation (the graph convolution) without knowing the domain (the graph) in advance because it is the very output of the generator?
Revised: This poses a unique challenge: how can one apply a localized operation (the graph convolution) without knowing the domain (the graph) in advance because it is the very output of the generator?

Original: We show that the proposed architecture learns domain and features simultaneously and promotes the features to be graph embeddings, i.e. representations in a vector space of the local dependencies between a point and its neighbors.
Revised: We show that the proposed architecture learns domain and features simultaneously and promotes the features to be graph embeddings, i.e. representations in a vector space of the local dependencies between a point and its neighbors.

Original: Such localized features learned by the generator provide a ﬂ exible and descriptive model.
Revised: Such localized features learned by the generator provide a ﬂ exible and descriptive model.

Original: Moreover, we address the problem of upsampling at the generator.
Revised: Moreover, we address the problem of upsampling at the generator.

Original: While downsampling based on graph coarsening is a staple in (semi-)supervised problems using graph convolution, it is not obvious how to properly upsample the intermediate layers of a graph-convolutional
Revised: While downsampling based on graph coarsening is a staple in (semi-)supervised problems using graph convolution, it is not obvious how to properly upsample the intermediate layers of a graph-convolutional

Original: GAN generator.
Revised: GAN generator.

Original: We propose a method exploiting non-local self-similarities in the data distribution.
Revised: We propose a method exploiting non-local self-similarities in the data distribution.

Original:  M ETHOD 2. G RAPH - CONVOLUTIONAL GAN
Revised:  M ETHOD 2. G RAPH - CONVOLUTIONAL GAN

Original: GANs (Goodfellow et al., 2014) are state-of-the-art generative models composed of a generator and a discriminator network.
Revised: GANs (Goodfellow et al., 2014) are state-of-the-art generative models composed of a generator and a discriminator network.

Original: The generator learns a function mapping a latent vector z to a sample x from the data distribution.
Revised: The generator learns a function mapping a latent vector z to a sample x from the data distribution.

Original: In the original formulation, the discriminator worked as a classi ﬁ er trained to separate real samples from generated ones.
Revised: In the original formulation, the discriminator worked as a classi ﬁ er trained to separate real samples from generated ones.

Original: Recently, the Wasserstein GAN (Arjovsky et al., 2017) addressed the instability and mode collapse issues of the original formulation by modifying the loss function to be a dual formulation of an optimal transport problem using the Wasserstein metric:
Revised: Recently, the Wasserstein GAN (Arjovsky et al., 2017) addressed the instability and mode collapse issues of the original formulation by modifying the loss function to be a dual formulation of an optimal transport problem using the Wasserstein metric:

Original: [Equation]
Revised: [Equation]

Original: with a discriminator D and a generator G .
Revised: with a discriminator D and a generator G .

Original: In this paper, we use the Wasserstein GAN with the gradient penalty method (Gulrajani et al., 2017) to enforce the Lipschitz constraint at the discriminator.
Revised: In this paper, we use the Wasserstein GAN with the gradient penalty method (Gulrajani et al., 2017) to enforce the Lipschitz constraint at the discriminator.

Original: In the proposed generative model, we use the Edge-Conditioned Convolution (Simonovsky &
Revised: In the proposed generative model, we use the Edge-Conditioned Convolution (Simonovsky &

Original: Komodakis, 2017) which falls under the category of spatial approaches to graph convolution and is suitable for dealing with multiple arbitrary graphs.
Revised: Komodakis, 2017) which falls under the category of spatial approaches to graph convolution and is suitable for dealing with multiple arbitrary graphs.

Original: Given a layer l with N l feature vectors h lj ∈ R d l of dimensionality d l , the convolution yields the feature vectors h l +1 j ∈ R d l
Revised: Given a layer l with N l feature vectors h lj ∈ R d l of dimensionality d l , the convolution yields the feature vectors h l +1 j ∈ R d l

Original: [Equation]
Revised: [Equation]

Original: 1 of the next layer by performing, for each node i of the graph, a weighted local aggregation of the feature vectors on
Revised: 1 of the next layer by performing, for each node i of the graph, a weighted local aggregation of the feature vectors on

Original: DENSE
Revised: DENSE

Original: [Figure]
Revised: [Figure]

Original: GCONV GCONV
Revised: GCONV GCONV

Original: GRAPH
Revised: GRAPH

Original: GRAPH GRAPH
Revised: GRAPH GRAPH

Original: [Figure]
Revised: [Figure]

Original: X H
Revised: X H

Original: H
Revised: H

Original: H L
Revised: H L

Original: A
Revised: A

Original: A
Revised: A

Original: A L the neighboring nodes j ∈ N li , where N li is the neighborhood of node i .
Revised: A L the neighboring nodes j ∈ N li , where N li is the neighborhood of node i .

Original: The weights of the local aggregation are de ﬁ ned by a fully-connected network F l : R d l → R d l × d l +1 , which takes as input the difference between the features of two neighboring nodes and outputs the corresponding weight matrix Θ l,ji = F l w l
Revised: The weights of the local aggregation are de ﬁ ned by a fully-connected network F l : R d l → R d l × d l +1 , which takes as input the difference between the features of two neighboring nodes and outputs the corresponding weight matrix Θ l,ji = F l w l

Original: [Equation]
Revised: [Equation]

Original: l
Revised: l

Original: [Equation]
Revised: [Equation]

Original: l +1 .
Revised: l +1 .

Original: Hence, the convolution operation is de ﬁ ned as:
Revised: Hence, the convolution operation is de ﬁ ned as:

Original: [Equation]
Revised: [Equation]

Original: where w l are the weights parametrizing network F l , W l ∈ R d l × d l +1 is a linear transformation of the node itself, b l a bias, and σ a non-linearity.
Revised: where w l are the weights parametrizing network F l , W l ∈ R d l × d l +1 is a linear transformation of the node itself, b l a bias, and σ a non-linearity.

Original: It is important to note that the weights Θ l,ij depend only on the difference between the features of the two nodes.
Revised: It is important to note that the weights Θ l,ij depend only on the difference between the features of the two nodes.

Original: This means that two pairs of nodes that have the same difference will have the same weight Θ l,ij , even if they are in two different regions of the space.
Revised: This means that two pairs of nodes that have the same difference will have the same weight Θ l,ij , even if they are in two different regions of the space.

Original: This creates weight sharing like in the classical CNNs and represents a strong advantage because it reduces the number of degrees of freedom of the model.
Revised: This creates weight sharing like in the classical CNNs and represents a strong advantage because it reduces the number of degrees of freedom of the model.

Original: G RAPH - BASED GENERATOR
Revised: G RAPH - BASED GENERATOR

Original: The focus of this paper is to design a GAN generator that uses localized operations in the form of graphs convolutions.
Revised: The focus of this paper is to design a GAN generator that uses localized operations in the form of graphs convolutions.

Original: Notice that such operations are able to deal with data in the form of unordered sets, such as points clouds, because they are by design invariant to permutations.
Revised: Notice that such operations are able to deal with data in the form of unordered sets, such as points clouds, because they are by design invariant to permutations.

Original: However, there are some issues peculiar to the generative problem to be addressed.
Revised: However, there are some issues peculiar to the generative problem to be addressed.

Original: First, while in supervised problems (Simonovsky & Komodakis, 2017; Wang et al., 2018) or in unsupervised settings involving autoencoders (Yang et al., 2018) the point cloud is known in advance, the intermediate layers of the GAN generator do not know it in advance as it is the very result of the generation operation.
Revised: First, while in supervised problems (Simonovsky & Komodakis, 2017; Wang et al., 2018) or in unsupervised settings involving autoencoders (Yang et al., 2018) the point cloud is known in advance, the intermediate layers of the GAN generator do not know it in advance as it is the very result of the generation operation.

Original: It is therefore not obvious how to de ﬁ ne an operation that is localized to neighborhoods of a graph that is not known in advance.
Revised: It is therefore not obvious how to de ﬁ ne an operation that is localized to neighborhoods of a graph that is not known in advance.

Original: The solution to this problem is to exploit the pairwise distances ( � h l − 1 j − h l − 1 i � ) between node features of the preceding layer to build a k -nearest neighbor graph.
Revised: The solution to this problem is to exploit the pairwise distances ( � h l − 1 j − h l − 1 i � ) between node features of the preceding layer to build a k -nearest neighbor graph.

Original: Figure 1 shows a block diagram of a graph-based generator where each graph convolution block uses the graph constructed from the input features of the block itself.
Revised: Figure 1 shows a block diagram of a graph-based generator where each graph convolution block uses the graph constructed from the input features of the block itself.

Original: The intuition behind this solution is that this promotes the features to become graph embeddings, i.e. representations in a high-dimensional metric space of relationships between points.
Revised: The intuition behind this solution is that this promotes the features to become graph embeddings, i.e. representations in a high-dimensional metric space of relationships between points.

Original: Going through the generator network from the latent space towards the point cloud output, these embeddings are assembled hierarchically and their associated graphs represent better and better approximations of the graph of the output point cloud.
Revised: Going through the generator network from the latent space towards the point cloud output, these embeddings are assembled hierarchically and their associated graphs represent better and better approximations of the graph of the output point cloud.

Original: According to the de ﬁ nition of graph convolution in (2), the new features of a node are a weighted combination of the features of the node itself and of the neighbors as determined by the graph construction.
Revised: According to the de ﬁ nition of graph convolution in (2), the new features of a node are a weighted combination of the features of the node itself and of the neighbors as determined by the graph construction.

Original: Notice that this localized approach differs from the one in Achlioptas et al.
Revised: Notice that this localized approach differs from the one in Achlioptas et al.

Original: (2017) where the generator of the r-GAN model is a fully-connected network, therefore unable to provide any localized interpretation of its hidden layers.
Revised: (2017) where the generator of the r-GAN model is a fully-connected network, therefore unable to provide any localized interpretation of its hidden layers.

Original: It also differs from the PointNet (Qi et al., 2017a) and
Revised: It also differs from the PointNet (Qi et al., 2017a) and

Original: PointNet++ (Qi et al., 2017b) architectures.
Revised: PointNet++ (Qi et al., 2017b) architectures.

Original: PointNet processes each point independently with the same weights and then aggregates them using a globally symmetric operation to deal with the permutation invariance problem.
Revised: PointNet processes each point independently with the same weights and then aggregates them using a globally symmetric operation to deal with the permutation invariance problem.

Original: PointNet++ extends this work using some localized operations.
Revised: PointNet++ extends this work using some localized operations.

Original: However, the key difference with the work in this paper is that PointNet and PointNet++ are not generative models, but are used in supervised problems such as classi ﬁ cation or segmentation.
Revised: However, the key difference with the work in this paper is that PointNet and PointNet++ are not generative models, but are used in supervised problems such as classi ﬁ cation or segmentation.

Original: Other works explore likelihood-based generative models, typically in the form of variational autoencoders (Fan et al., 2017; Nash & Williams, 2017; Litany et al., 2017).
Revised: Other works explore likelihood-based generative models, typically in the form of variational autoencoders (Fan et al., 2017; Nash & Williams, 2017; Litany et al., 2017).

Original: The most similar approach to the method of this paper is the one in Grover et al.
Revised: The most similar approach to the method of this paper is the one in Grover et al.

Original: (2018), with the key difference being that a distribution over adjacency matrices of graphs is learned using a spectral graph-convolutional VAE.
Revised: (2018), with the key difference being that a distribution over adjacency matrices of graphs is learned using a spectral graph-convolutional VAE.

Original: DENSE
Revised: DENSE

Original: GCONV GCONV
Revised: GCONV GCONV

Original: GCONV
Revised: GCONV

Original: GRAPH GRAPH
Revised: GRAPH GRAPH

Original: GRAPH z
Revised: GRAPH z

Original: X H
Revised: X H

Original: H
Revised: H

Original: H L
Revised: H L

Original: A
Revised: A

Original: A
Revised: A

Original: A L
Revised: A L

Original: UPSAMP
Revised: UPSAMP

Original: GRAPH
Revised: GRAPH

Original: UPSAMP
Revised: UPSAMP

Original: GRAPH
Revised: GRAPH

Original: H 2,UP
Revised: H 2,UP

Original: H
Revised: H

Original: H 3,UP ...
Revised: H 3,UP ...

Original: B B
Revised: B B

Original: 2. U PSAMPLING
Revised: 2. U PSAMPLING

Original: The previous section presented the basic outline of a graph-based generator in a GAN.
Revised: The previous section presented the basic outline of a graph-based generator in a GAN.

Original: However, one evident shortcoming is the ﬁ xed number of points throughout the generator, which is determined by the number of output points.
Revised: However, one evident shortcoming is the ﬁ xed number of points throughout the generator, which is determined by the number of output points.

Original: Many data of interest typically display some kind of regularity in the form of multi-resolution or other kinds of compositionality whereby points can be predicted from a smaller number of neighboring points.
Revised: Many data of interest typically display some kind of regularity in the form of multi-resolution or other kinds of compositionality whereby points can be predicted from a smaller number of neighboring points.

Original: In the case of 2D images, lower resolutions provide a prediction of higher resolutions by supplying the low-frequency content and the upsampling operation is straightforward.
Revised: In the case of 2D images, lower resolutions provide a prediction of higher resolutions by supplying the low-frequency content and the upsampling operation is straightforward.

Original: In fact, convolutional GANs for image generation are composed of a sequence of upsampling and convolutional layers.
Revised: In fact, convolutional GANs for image generation are composed of a sequence of upsampling and convolutional layers.

Original: Extending upsampling to deal with the generation of sets of points without a total ordering is not a trivial task.
Revised: Extending upsampling to deal with the generation of sets of points without a total ordering is not a trivial task.

Original: Many works have addressed the problem of upsampling 3D point clouds, e.g., by creating grids in the 3D space (Maturana & Scherer, 2015a).
Revised: Many works have addressed the problem of upsampling 3D point clouds, e.g., by creating grids in the 3D space (Maturana & Scherer, 2015a).

Original: Notice, however, that introducing upsampling to interleave the graph-convolutional layers outlined in the previous section is a more complex problem because the high dimensionality of the feature vectors makes the gridding approach unfeasible.
Revised: Notice, however, that introducing upsampling to interleave the graph-convolutional layers outlined in the previous section is a more complex problem because the high dimensionality of the feature vectors makes the gridding approach unfeasible.

Original: If we consider the l -th generator layer, we want to de ﬁ ne an upsampling operation that, starting from the graph convolution output H l ∈ R N l × d l , generates N l new feature vectors ˜H l ∈ R N l × d l .
Revised: If we consider the l -th generator layer, we want to de ﬁ ne an upsampling operation that, starting from the graph convolution output H l ∈ R N l × d l , generates N l new feature vectors ˜H l ∈ R N l × d l .

Original: Then, these new feature vectors are concatenated to H l in order to obtain the output H l, up ∈ R 2 N l × d l .
Revised: Then, these new feature vectors are concatenated to H l in order to obtain the output H l, up ∈ R 2 N l × d l .

Original: We propose to de ﬁ ne an upsampling operation using local aggregations.
Revised: We propose to de ﬁ ne an upsampling operation using local aggregations.

Original: In this case, the upsampling operation becomes similar to a graph convolution.
Revised: In this case, the upsampling operation becomes similar to a graph convolution.

Original: Given a feature vector h li ∈ R d l , we consider a set of neighbors N li and we de ﬁ ne the new feature vector ˜h li ∈ R d l as follows
Revised: Given a feature vector h li ∈ R d l , we consider a set of neighbors N li and we de ﬁ ne the new feature vector ˜h li ∈ R d l as follows

Original: [Equation]
Revised: [Equation]

Original:  where U l : R d l → R d l is a fully-connected network which given the difference between h li and h lj outputs the weight vector γ l,ij ∈ R d l , which is used to create the diagonal matrix Γ l,ji = diag � γ l,ji � .
Revised:  where U l : R d l → R d l is a fully-connected network which given the difference between h li and h lj outputs the weight vector γ l,ij ∈ R d l , which is used to create the diagonal matrix Γ l,ji = diag � γ l,ji � .

Original: ˜w l and b l are model parameters that are updated only during training.
Revised: ˜w l and b l are model parameters that are updated only during training.

Original: It is important to note that, differently from the graph convolution described in 2.1 where Θ l,ij and ˜ W l are dense matrices, in this case we use diagonal matrices.
Revised: It is important to note that, differently from the graph convolution described in 2.1 where Θ l,ij and ˜ W l are dense matrices, in this case we use diagonal matrices.

Original: This means that during the upsampling operation the local aggregation treats each feature independently.
Revised: This means that during the upsampling operation the local aggregation treats each feature independently.

Original: This also reduces the number of parameters.
Revised: This also reduces the number of parameters.

Original: 2. G RAPH EMBEDDING INTERPRETATION
Revised: 2. G RAPH EMBEDDING INTERPRETATION

Original: Graph embeddings (Goyal & Ferrara, 2017) are representations of graphs in a vector space where a feature vector is associated to each node of the graph.
Revised: Graph embeddings (Goyal & Ferrara, 2017) are representations of graphs in a vector space where a feature vector is associated to each node of the graph.

Original: For what concerns this paper we consider the following de ﬁ nition of graph embedding, focused on predicting edges from the feature vectors.
Revised: For what concerns this paper we consider the following de ﬁ nition of graph embedding, focused on predicting edges from the feature vectors.

Original: De ﬁ nition 1 Given a graph G =
Revised: De ﬁ nition 1 Given a graph G =

Original: ( V , E ) , a graph embedding is a mapping f : i → h i ∈ R d , ∀ i ∈ V , such that d � |V| and the function f is de ﬁ ned
Revised: ( V , E ) , a graph embedding is a mapping f : i → h i ∈ R d , ∀ i ∈ V , such that d � |V| and the function f is de ﬁ ned

Original: such that if we consider two pairs of nodes ( i, j ) and ( i, k ) where ( i, j )
Revised: such that if we consider two pairs of nodes ( i, j ) and ( i, k ) where ( i, j )

Original: ∈ E and ( i, k )
Revised: ∈ E and ( i, k )

Original: / ∈ E then � h
Revised: / ∈ E then � h

Original: i − h j � < � h
Revised: i − h j � < � h

Original: i − h k � .
Revised: i − h k � .

Original: The graph-convolutional generator presented in this paper can be interpreted as generating graph embeddings of the nearest-neighbor graph of the output point cloud at each hidden layer, thus creating features that are able to capture some properties of the local topology.
Revised: The graph-convolutional generator presented in this paper can be interpreted as generating graph embeddings of the nearest-neighbor graph of the output point cloud at each hidden layer, thus creating features that are able to capture some properties of the local topology.

Original: In order to see why this is the case, we analyze the architecture in Fig.
Revised: In order to see why this is the case, we analyze the architecture in Fig.

Original: 1 backwards from the output to the input.
Revised: 1 backwards from the output to the input.

Original: The ﬁ nal output x is the result of a graph convolution aggregating features localized to the nearest-neighbor
Revised: The ﬁ nal output x is the result of a graph convolution aggregating features localized to the nearest-neighbor

Original: [Table]
Revised: [Table]

Original: graph computed from the features of the preceding layer.
Revised: graph computed from the features of the preceding layer.

Original: Since the GAN objective is to match the distribution of the output with that of real data, the neighborhoods identi ﬁ ed by the last graph must be a good approximation of the neighborhoods in the true data.
Revised: Since the GAN objective is to match the distribution of the output with that of real data, the neighborhoods identi ﬁ ed by the last graph must be a good approximation of the neighborhoods in the true data.

Original: Therefore, we say that features H L are a graph embedding in the sense that they allow to predict the edges of the output graph from their pairwise distances.
Revised: Therefore, we say that features H L are a graph embedding in the sense that they allow to predict the edges of the output graph from their pairwise distances.

Original: Proceeding backwards, there is a hierarchy of graph embeddings as the other graphs are constructed from higher-order features.
Revised: Proceeding backwards, there is a hierarchy of graph embeddings as the other graphs are constructed from higher-order features.

Original: Notice that the upsampling operation in the architecture of Fig.
Revised: Notice that the upsampling operation in the architecture of Fig.

Original: 2 affects this chain of embeddings by introducing new points.
Revised: 2 affects this chain of embeddings by introducing new points.

Original: While the graph convolution operation promotes the features of all the points after upsampling to be graph embeddings, the upsampling operation affects which points are generated.
Revised: While the graph convolution operation promotes the features of all the points after upsampling to be graph embeddings, the upsampling operation affects which points are generated.

Original: In the experiments we show that the upsampling method approximately maintains the neighborhood shape but copies it elsewhere in the point cloud.
Revised: In the experiments we show that the upsampling method approximately maintains the neighborhood shape but copies it elsewhere in the point cloud.

Original: This suggests a generation mechanism exploiting self-similarities between the features of the point cloud at different locations.
Revised: This suggests a generation mechanism exploiting self-similarities between the features of the point cloud at different locations.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We tested the proposed architecture by using three classes of point clouds taken from the ShapeNet repository (Chang et al., 2015): “chair”, “airplane” and “sofa”.
Revised: We tested the proposed architecture by using three classes of point clouds taken from the ShapeNet repository (Chang et al., 2015): “chair”, “airplane” and “sofa”.

Original: A class-speci ﬁ c model is trained for the desired class of point clouds.
Revised: A class-speci ﬁ c model is trained for the desired class of point clouds.

Original: Since the focus of this paper is the features learned by the generator, the architecture for the discriminator is the same as the one of the r-GAN in Achlioptas et al.
Revised: Since the focus of this paper is the features learned by the generator, the architecture for the discriminator is the same as the one of the r-GAN in Achlioptas et al.

Original: (2017), with 4 layers with weights shared across points (number of output features: 64, 128, 256, 512) followed by a global maxpool and by 3 dense layers.
Revised: (2017), with 4 layers with weights shared across points (number of output features: 64, 128, 256, 512) followed by a global maxpool and by 3 dense layers.

Original: The generator architecture is reported in Table 1.
Revised: The generator architecture is reported in Table 1.

Original: The graph is built by selecting the 20 nearest neighbors in terms of Euclidean distance in the feature space.
Revised: The graph is built by selecting the 20 nearest neighbors in terms of Euclidean distance in the feature space.

Original: We use Leaky ReLUs as nonlinearities and RMSProp as optimization method with a learning rate equal to 10 − 4 for both generator and discriminator.
Revised: We use Leaky ReLUs as nonlinearities and RMSProp as optimization method with a learning rate equal to 10 − 4 for both generator and discriminator.

Original: Batch normalization follows every graph convolution.
Revised: Batch normalization follows every graph convolution.

Original: The gradient penalty parameter of the WGAN is 1 and the discriminator is optimized for 5 iterations for each generator step.
Revised: The gradient penalty parameter of the WGAN is 1 and the discriminator is optimized for 5 iterations for each generator step.

Original: The models have been trained for 1000 epochs.
Revised: The models have been trained for 1000 epochs.

Original: For the “chair” class this required about 5 days without upsampling and 4 days with upsampling.
Revised: For the “chair” class this required about 5 days without upsampling and 4 days with upsampling.

Original: 3. G ENERATED POINT CLOUD ASSESSMENT
Revised: 3. G ENERATED POINT CLOUD ASSESSMENT

Original: In this section we perform qualitative and quantitative comparisons with the generated point clouds.
Revised: In this section we perform qualitative and quantitative comparisons with the generated point clouds.

Original: V ISUAL RESULTS
Revised: V ISUAL RESULTS

Original: We ﬁ rst visually inspect the generated point clouds from the classes “chair” and “airplane”, as shown in Fig.
Revised: We ﬁ rst visually inspect the generated point clouds from the classes “chair” and “airplane”, as shown in Fig.

Original: The results are convincing from a visual standpoint and the variety of the generated objects is high, suggesting no mode collapse in the training process.
Revised: The results are convincing from a visual standpoint and the variety of the generated objects is high, suggesting no mode collapse in the training process.

Original: The distribution of points on the object is quite uniform, especially for the method with upsampling.
Revised: The distribution of points on the object is quite uniform, especially for the method with upsampling.

Original: C OMPARISONS WITH STATE - OF - THE - ART
Revised: C OMPARISONS WITH STATE - OF - THE - ART

Original: To the best of our knowledge this is the ﬁ rst work addressing GANs for point clouds learning localized features.
Revised: To the best of our knowledge this is the ﬁ rst work addressing GANs for point clouds learning localized features.

Original: We compare the proposed GAN for point cloud generation with other GANs able to
Revised: We compare the proposed GAN for point cloud generation with other GANs able to

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: deal with unordered sets of points.
Revised: deal with unordered sets of points.

Original: In particular, the “r-GAN-dense” architecture in Achlioptas et al.
Revised: In particular, the “r-GAN-dense” architecture in Achlioptas et al.

Original: (2017) has a dense generator, which is unable to generate localized representations because there is no mapping between points and feature vectors.
Revised: (2017) has a dense generator, which is unable to generate localized representations because there is no mapping between points and feature vectors.

Original: As an additional baseline variant, dubbed “r-GANconv”, we study the use of a generator having as many feature vectors as the points in the point cloud and using a size-1 convolution across the points.
Revised: As an additional baseline variant, dubbed “r-GANconv”, we study the use of a generator having as many feature vectors as the points in the point cloud and using a size-1 convolution across the points.

Original: Notice that the graph convolution we use can be seen as a generalization of this model, aggregating the features of neighboring points instead of processing each point independently.
Revised: Notice that the graph convolution we use can be seen as a generalization of this model, aggregating the features of neighboring points instead of processing each point independently.

Original: We point out that we cannot compare the proposed method in a fair way with the variational autoencoders mentioned in Sec. 2.1: Fan et al.
Revised: We point out that we cannot compare the proposed method in a fair way with the variational autoencoders mentioned in Sec. 2.1: Fan et al.

Original: (2017) generate point clouds conditioned on an input image; Nash & Williams (2017) use object segmentation labels to generate point clouds by parts; Litany et al.
Revised: (2017) generate point clouds conditioned on an input image; Nash & Williams (2017) use object segmentation labels to generate point clouds by parts; Litany et al.

Original: (2017) focus on generating vertices on meshes with a ﬁ xed and given topology.
Revised: (2017) focus on generating vertices on meshes with a ﬁ xed and given topology.

Original: In order to perform a quantitative evaluation of the generated point clouds we use the evaluation metrics proposed in Achlioptas et al.
Revised: In order to perform a quantitative evaluation of the generated point clouds we use the evaluation metrics proposed in Achlioptas et al.

Original: (2017), employing three different metrics to compare a set of generated samples with the test set.
Revised: (2017), employing three different metrics to compare a set of generated samples with the test set.

Original: The ﬁ rst one is the Jensen-Shannon divergence (JSD) between marginal distributions de ﬁ ned in the 3D space.
Revised: The ﬁ rst one is the Jensen-Shannon divergence (JSD) between marginal distributions de ﬁ ned in the 3D space.

Original: Then, we also evaluate the coverage (COV) and the minimum matching distance (MMD), as de ﬁ ned in Achlioptas et al.
Revised: Then, we also evaluate the coverage (COV) and the minimum matching distance (MMD), as de ﬁ ned in Achlioptas et al.

Original: (2017), using two different point-set distances, the earth mover’s distance (EMD) and the Chamfer distance (CD).
Revised: (2017), using two different point-set distances, the earth mover’s distance (EMD) and the Chamfer distance (CD).

Original: Table 2 shows the obtained results.
Revised: Table 2 shows the obtained results.

Original: As can be seen, the proposed methods achieve better values for the metrics under consideration.
Revised: As can be seen, the proposed methods achieve better values for the metrics under consideration.

Original: In particular, the method with upsampling operations is consistently the better.
Revised: In particular, the method with upsampling operations is consistently the better.

Original: Notice that Achlioptas et al.
Revised: Notice that Achlioptas et al.

Original: (2017) report that the Chamfer distance is often unreliable as it fails to penalize non-uniform distributions of points.
Revised: (2017) report that the Chamfer distance is often unreliable as it fails to penalize non-uniform distributions of points.

Original: Fig.
Revised: Fig.

Original: 4 visually shows that the proposed methods generate point clouds with better-distributed points,
Revised: 4 visually shows that the proposed methods generate point clouds with better-distributed points,

Original: con ﬁ rming the quantitative results.
Revised: con ﬁ rming the quantitative results.

Original: In particular, the r-GAN-dense shows clusters of points, while the r-GAN-conv also exhibits noisy shapes.
Revised: In particular, the r-GAN-dense shows clusters of points, while the r-GAN-conv also exhibits noisy shapes.

Original: 3. G ENERATOR F EATURE A NALYSIS
Revised: 3. G ENERATOR F EATURE A NALYSIS

Original: In this section we quantitatively study the properties of the features in the layers of the generator.
Revised: In this section we quantitatively study the properties of the features in the layers of the generator.

Original: [Table]
Revised: [Table]

Original: G RAPH EMBEDDING AND FEATURE RADIUS WITHOUT UPSAMPLING
Revised: G RAPH EMBEDDING AND FEATURE RADIUS WITHOUT UPSAMPLING

Original: Referring to Table 1, the output of each layer is a matrix where every point is associated to a feature vector.
Revised: Referring to Table 1, the output of each layer is a matrix where every point is associated to a feature vector.

Original: In Sec.
Revised: In Sec.

Original: 2.3 we claimed that these features learned by the generator are graph embeddings.
Revised: 2.3 we claimed that these features learned by the generator are graph embeddings.

Original: [Figure]
Revised: [Figure]

Original: We tested this hypothesis by measuring how much the adjacency matrix of the ﬁ nal point cloud, constructed as a nearest-neighbor graph in 3D, is successfully predicted by the nearest-neighbor adjacency matrix computed from hidden features.
Revised: We tested this hypothesis by measuring how much the adjacency matrix of the ﬁ nal point cloud, constructed as a nearest-neighbor graph in 3D, is successfully predicted by the nearest-neighbor adjacency matrix computed from hidden features.

Original: This is shown in Fig.5 which reports the percentage of edges correctly predicted as function of the number of neighbors considered for the graph of the output point cloud and a ﬁ xed number of 20 neighbors in the feature space.
Revised: This is shown in Fig.5 which reports the percentage of edges correctly predicted as function of the number of neighbors considered for the graph of the output point cloud and a ﬁ xed number of 20 neighbors in the feature space.

Original: Notice that layers closer to the output correctly predict a higher percentage of edges and in this sense are better graph embeddings of the output geometry.
Revised: Notice that layers closer to the output correctly predict a higher percentage of edges and in this sense are better graph embeddings of the output geometry.

Original: Fig.
Revised: Fig.

Original: 6 shows another experiment concerning localization of features.
Revised: 6 shows another experiment concerning localization of features.

Original: We applied k -means with 6 clusters to the features of intermediate layers and represented the cluster assignments onto the ﬁ nal point cloud.
Revised: We applied k -means with 6 clusters to the features of intermediate layers and represented the cluster assignments onto the ﬁ nal point cloud.

Original: This experiment con ﬁ rms that the features are highly localized and progressively more so in the layers closer to the output.
Revised: This experiment con ﬁ rms that the features are highly localized and progressively more so in the layers closer to the output.

Original: We further investigated the effective receptive ﬁ eld of the convolution operation in Fig.
Revised: We further investigated the effective receptive ﬁ eld of the convolution operation in Fig.

Original: 7a.
Revised: 7a.

Original: This ﬁ gure reports histograms of Euclidean distances measured on the output point cloud between neighbors as determined by the nearest neighbor graph in one of the intermediate layers.
Revised: This ﬁ gure reports histograms of Euclidean distances measured on the output point cloud between neighbors as determined by the nearest neighbor graph in one of the intermediate layers.

Original: We can see that layers closer to the output aggregate points which are very close in the ﬁ nal point cloud, thus implementing a highly localized operation.
Revised: We can see that layers closer to the output aggregate points which are very close in the ﬁ nal point cloud, thus implementing a highly localized operation.

Original: Conversely, layers close to the latent space perform more global operations.
Revised: Conversely, layers close to the latent space perform more global operations.

Original: U PSAMPLING RESULTS
Revised: U PSAMPLING RESULTS

Original: The main drawback of the model without upsampling is the unnecessarily large number of parameters in the ﬁ rst dense layer.
Revised: The main drawback of the model without upsampling is the unnecessarily large number of parameters in the ﬁ rst dense layer.

Original: This is solved by the introduction of the upsampling layers which aim at
Revised: This is solved by the introduction of the upsampling layers which aim at

Original: [Figure]
Revised: [Figure]

Original: exploiting hierarchical priors to lower the number of parameters by starting with a lower number of points and progressively predicting new points from the generated features.
Revised: exploiting hierarchical priors to lower the number of parameters by starting with a lower number of points and progressively predicting new points from the generated features.

Original: The proposed upsampling technique based on local aggregations computes a new point as a weighted aggregation of neighboring points.
Revised: The proposed upsampling technique based on local aggregations computes a new point as a weighted aggregation of neighboring points.

Original: The weights of the aggregation are learned by the network, thus letting the network decide the best method to create a new point from a neighborhood, at the expense of an increased number of total parameters.
Revised: The weights of the aggregation are learned by the network, thus letting the network decide the best method to create a new point from a neighborhood, at the expense of an increased number of total parameters.

Original: The experiment in Figs.
Revised: The experiment in Figs.

Original: 7b and 8 shows an interesting behavior.
Revised: 7b and 8 shows an interesting behavior.

Original: First, the generated points are not close to the original point: Fig.
Revised: First, the generated points are not close to the original point: Fig.

Original: 7b shows the ratio between the generator-generated distance and the average neighborhood distance (neighborhoods are de ﬁ ned in the feature space, while distances are measured as Euclidean distances on the output 3D point cloud) and since it is usually signi ﬁ cantly larger than 1, we can conclude that the generated point is far from the original generating neighborhood.
Revised: 7b shows the ratio between the generator-generated distance and the average neighborhood distance (neighborhoods are de ﬁ ned in the feature space, while distances are measured as Euclidean distances on the output 3D point cloud) and since it is usually signi ﬁ cantly larger than 1, we can conclude that the generated point is far from the original generating neighborhood.

Original: Then, the clusters in Fig.
Revised: Then, the clusters in Fig.

Original: 8 show that the points in the ﬁ rst layers are not uniformly distributed over the point cloud, but rather form parts of it.
Revised: 8 show that the points in the ﬁ rst layers are not uniformly distributed over the point cloud, but rather form parts of it.

Original: The mechanism learned by the network to generate new points is essentially to apply some mild transformation to a neighborhood and copy it in a different area of the feature space.
Revised: The mechanism learned by the network to generate new points is essentially to apply some mild transformation to a neighborhood and copy it in a different area of the feature space.

Original: The generated points will no longer be close to their generators, but the structure of the neighborhood resembles the one of the generating neighborhood.
Revised: The generated points will no longer be close to their generators, but the structure of the neighborhood resembles the one of the generating neighborhood.

Original: This notion is similar to the second-order proximity in the graph embedding literature (Goyal & Ferrara, 2017) and it seems that this operation is exploiting the inherent self-similarities between the data features at distant points.
Revised: This notion is similar to the second-order proximity in the graph embedding literature (Goyal & Ferrara, 2017) and it seems that this operation is exploiting the inherent self-similarities between the data features at distant points.

Original: To validate this hypothesis we measured two relevant quantities.
Revised: To validate this hypothesis we measured two relevant quantities.

Original: First, we considered a point i , its neighbors N li before upsampling, their corresponding points generated by the upsampling operation { i up , N l, up i } and the neighborhood
Revised: First, we considered a point i , its neighbors N li before upsampling, their corresponding points generated by the upsampling operation { i up , N l, up i } and the neighborhood

Original: N li up of point i up .
Revised: N li up of point i up .

Original: We measured the average percentage of points in N l, up i that were generated from points in N li , i.e. |N li up ∩ N l, up i | / |N li | , as reported in Table 3.
Revised: We measured the average percentage of points in N l, up i that were generated from points in N li , i.e. |N li up ∩ N l, up i | / |N li | , as reported in Table 3.

Original: The result shows that the neighborhood of a generated point is almost entirely generated by the points that were neighbors of the generator, and that the new points are not neighbors of the original ones.
Revised: The result shows that the neighborhood of a generated point is almost entirely generated by the points that were neighbors of the generator, and that the new points are not neighbors of the original ones.

Original: This behavior is consistent over different layers.
Revised: This behavior is consistent over different layers.

Original: Then, we measured the Euclidean distances in the feature space between point i and its neighbors N li and between point i up and N l, up i .
Revised: Then, we measured the Euclidean distances in the feature space between point i and its neighbors N li and between point i up and N l, up i .

Original: Table 3 reports the correlation coef ﬁ cient between those distance vectors, which suggests that the shape of the neighborhood is fairly conserved.
Revised: Table 3 reports the correlation coef ﬁ cient between those distance vectors, which suggests that the shape of the neighborhood is fairly conserved.

Original: [Table]
Revised: [Table]

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: We presented a GAN using graph convolutional layers to generate 3D point clouds.
Revised: We presented a GAN using graph convolutional layers to generate 3D point clouds.

Original: In particular, we showed how constructing nearest neighbor graphs from generator features to implement the graph convolution operation promotes the features to be localized and to approximate a graph embedding of the output geometry.
Revised: In particular, we showed how constructing nearest neighbor graphs from generator features to implement the graph convolution operation promotes the features to be localized and to approximate a graph embedding of the output geometry.

Original: We also proposed an upsampling scheme for the generator that exploits self-similarities in the samples to be generated.
Revised: We also proposed an upsampling scheme for the generator that exploits self-similarities in the samples to be generated.

Original: The main drawback of the current method is the rather high complexity of the graph convolution operation.
Revised: The main drawback of the current method is the rather high complexity of the graph convolution operation.

Original: Future work will focus on reducing the overall complexity, e.g., in the graph construction operation, and study new upsampling schemes.
Revised: Future work will focus on reducing the overall complexity, e.g., in the graph construction operation, and study new upsampling schemes.

Original:  A CKNOWLEDGEMENTS
Revised:  A CKNOWLEDGEMENTS

Original: The research leading to these results has been partially funded by the SmartData@PoliTO center for
Revised: The research leading to these results has been partially funded by the SmartData@PoliTO center for

Original: Big Data and Machine Learning technologies.
Revised: Big Data and Machine Learning technologies.

Revised: The research leading to this publication has received funding from Regione Piemonte under research grant “DISLOMAN: dynamic integrated shop ﬂ oor operation management for Industry 4.0”.

Original: We thank Nvidia for donating a Quadro P6000 GPU for this work.
Revised: We thank Nvidia for donating a Quadro P6000 GPU for this work.

Original:  A PPENDIX
Revised:  A PPENDIX

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]