PointCNN: Convolution On $\mathcal{X}$-Transformed Points cover

📄 Executive Summary

Three-dimensional point clouds generated by modern sensors are vital for computer vision, robotics, and autonomous systems, yet they lack the regular grid structure of standard 2D images. Applying traditional convolutional neural networks directly to point clouds is problematic because points are unordered and irregular, which causes models to lose shape information and become sensitive to arbitrary data ordering. Existing solutions often discard detailed geometry by relying on symmetric pooling functions or incur excessive computation by converting points into dense 3D grids.

The article introduces and evaluates PointCNN, a deep learning framework designed to generalize standard convolutions to irregular point cloud data. The core objective is to demonstrate that learning an adaptive transformation matrix, termed an X-transformation, can effectively weight and order local point features before applying standard convolution operations.

To evaluate this method, the authors developed specialized network architectures for shape classification and part segmentation, testing them across diverse public benchmarks. These benchmarks encompassed 3D object databases (ModelNet40 and ShapeNet Parts), real-world scanned indoor environments (ScanNet and S3DIS), large-scale 2D freehand sketch collections (TU-Berlin and Quick Draw), and standard image datasets converted into point sets (MNIST and CIFAR10). Ablation studies and feature visualizations were conducted to assess the operational impact and computational efficiency of the transformation mechanism.

The analysis yielded four central findings. First, PointCNN established state-of-the-art or competitive accuracy across all evaluated 3D benchmarks, outperforming specialized baselines in indoor scene segmentation and object part segmentation. Second, on the 25-million sample Quick Draw sketch benchmark, PointCNN attained a 59.13% classification accuracy, markedly exceeding competing point-based networks. Third, on image-to-point benchmarks, PointCNN matched image networks on structural tasks (99.54% on MNIST) but reached only 80.22% on CIFAR10 compared to standard image architectures (91.20%), confirming that traditional image convolutions remain optimal for dense, texture-heavy 2D data. Finally, ablation tests and feature visualizations showed that removing the transformation mechanism caused substantial performance drops, with feature classification accuracy falling from 94.72% down to 76.83%.

These results indicate that computer vision systems can process raw, unstructured spatial data with the efficiency and hierarchical learning capability of traditional convolutional architectures. By eliminating the need for rigid 3D voxel grids or lossy pooling simplifications, PointCNN reduces computational overhead while improving segmentation accuracy. Organizations deploying spatial intelligence in automated navigation, augmented reality, and building survey analysis can leverage these designs to improve geometric feature learning with fast runtime performance.

Organizations should consider adopting PointCNN architectures for 3D perception and spatial recognition pipelines where geometric shape preservation is critical. Future implementation work should focus on optimizing representative point selection and developing early-stage fusion pipelines that jointly process 2D camera images and 3D point clouds. However, stakeholders should note that the learned transformation matrices do not achieve mathematically perfect canonical ordering, and performance relies heavily on randomized data augmentation during training.

📚 What to read before this

PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation, Charles R. Qi et al. (2017). PointCNN addresses the same unordered-point-cloud learning problem as PointNet, so PointNet’s permutation-invariant baseline clarifies the limitations its local convolutional operator is designed to overcome.
An Introduction to Convolutional Neural Networks, Keiron O'Shea et al. (2015). Because PointCNN adapts convolution to irregular point sets, this primer on CNN convolution and its locality and weight-sharing principles makes the operator it generalizes easier to follow.

📚 What to read after this

No sufficiently relevant recommendations were found.

PointCNN: Convolution On $X\mathcal{X}$ -Transformed Points

Yangyan Li

†,∗^{\dagger,*}

, Rui Bu

†^{\dagger}

, Mingchao Sun

†^{\dagger}

, Wei Wu

†^{\dagger}

, Xinhan Di

‡^{\ddagger}

, Baoquan Chen

§^{\S}

†^{\dagger}

Shandong University

‡^{\ddagger}

Huawei Inc.

§^{\S}

Peking University

∗^{*}

Part of the work was done during Yangyan's Autodesk Research 2017 summer visit.

Abstract

We present a simple and general framework for feature learning from point clouds. The key to the success of CNNs is the convolution operator that is capable of leveraging spatially-local correlation in data represented densely in grids (e.g. images). However, point clouds are irregular and unordered, thus directly convolving kernels against features associated with the points will result in desertion of shape information and variance to point ordering. To address these problems, we propose to learn an

X\mathcal{X}

-transformation from the input points to simultaneously promote two causes: the first is the weighting of the input features associated with the points, and the second is the permutation of the points into a latent and potentially canonical order. Element-wise product and sum operations of the typical convolution operator are subsequently applied on the

X\mathcal{X}

-transformed features. The proposed method is a generalization of typical CNNs to feature learning from point clouds, thus we call it PointCNN. Experiments show that PointCNN achieves on par or better performance than state-of-the-art methods on multiple challenging benchmark datasets and tasks.

1. Introduction

Spatially-local correlation is a ubiquitous property of various types of data that is independent of the data representation. For data that is represented in regular domains, such as images, the convolution operator has been shown to be effective in exploiting that correlation as the key contributor to the success of CNNs on a variety of tasks [1]. However, for data represented in point cloud form, which is irregular and unordered, the convoralution operator is ill-suited for leveraging spatially-local correlations in the data.

We illustrate the problems and challenges of applying convolutions on point clouds in Figure 1. Suppose the unordered set of the

C

-dimensional input features is the same

F={fa,fb,fc,fd}\mathbb{F}=\{f_a, f_b, f_c, f_d\}

in all the cases (

(i) - (i v)

), and we have one kernel

K=[kα,kβ,kγ,kδ]T\mathbf{K}=[k_\alpha, k_\beta, k_\gamma, k_\delta]^T

of shape

\times C

. In (i), by following the canonical order given by the regular grid structure, the features in the local

\times 2

patch can be cast into

f_a, f_b, f_c, f_d]^T

of shape

\times C

, for convolving with

K\mathbf{K}

, yielding

fi=Conv(K,[fa,fb,fc,fd]T)f_i = Conv(\mathbf{K}, [f_a, f_b, f_c, f_d]^T)

, where

Conv(⋅,⋅)Conv(\cdot, \cdot)

is simply an element-wise product followed by a sum¹. In

(ii)

(iii)

, and

(i v)

, the points are sampled from local neighborhoods, and thus their ordering may be arbitrary. By following orders as illustrated in the figure, the input feature set

F\mathbb{F}

can be cast into

f_a, f_b, f_c, f_d]^T

(ii)

and

(iii)

, and

f_c, f_a, f_b, f_d]^T

in (iv). Based on this, if the convolution operator is directly applied, the output features for the three cases could be computed as depicted in. Note that

fii≡fiiif_{ii} \equiv f_{iii}

holds for all cases, while

fiii≠fivf_{iii} \ne f_{iv}

holds for most cases. This example illustrates that a direct convolution results in deserting shape information (i.e.,

fii≡fiiif_{ii} \equiv f_{iii}

), while retaining variance to the ordering (i.e.,

fiii≠fivf_{iii} \ne f_{iv}

Actually, this is a special instance of convolution — a convolution that is applied in one spatial location. For simplicity, we call it convolution as well.

In this paper, we propose to learn a

\times K

X\mathcal{X}

-transformation for the coordinates of

K

input points

p_1, p_2, ..., p_K)

, with a multilayer perceptron [2], i.e.,

X=MLP(p1,p2,...,pK)\mathcal{X} = \mathit{MLP}(p_1, p_2, ..., p_K)

. Our aim is to use it to simultaneously weight and permute the input features, and subsequently apply a typical convolution on the transformed features. We refer to this process as

X\mathcal{X}

-Conv, and it is the basic building block for our PointCNN. The

X\mathcal{X}

-Conv for

(ii)

(iii)

, and

(i v)

in Figure 1 can be formulated as in, where the

X\mathcal{X}

s are

\times 4

matrices, as

K = 4

in this figure. Note that since

Xii\mathcal{X}_{ii}

and

Xiii\mathcal{X}_{iii}

are learned from points of different shapes, they can differ so as to weight the input features accordingly, and achieve

fii≠fiiif_{ii} \ne f_{iii}

. For

Xiii\mathcal{X}_{iii}

and

Xiv\mathcal{X}_{iv}

, if they are learned to satisfy

Xiii=Xiv×Π\mathcal{X}_{iii} = \mathcal{X}_{iv} \times \Pi

, where

Π\Pi

is the permutation matrix for permuting

(c, a, b, d)

into

(a, b, c, d)

, then

fiii≡fivf_{iii} \equiv f_{iv}

can be achieved.

From the analysis of the example in Figure 1, it is clear that, with ideal

X\mathcal{X}

-transformations,

X\mathcal{X}

-Conv is capable of taking the point shapes into consideration, while being invariant to ordering. In practice, we find that the learned

X\mathcal{X}

-transformations are far from ideal, especially in terms of the permutation equivalence aspect. Nevertheless, PointCNN built with

X\mathcal{X}

-Conv is still significantly better than a direct application of typical convolutions on point clouds, and on par or better than state-of-the-art neural networks designed for point cloud input data, such as PointNet++ [3].

Section 3 contains the details of

X\mathcal{X}

-Conv, as well as PointCNN architectures. We show our results on multiple challenging benchmark datasets and tasks in Section 4, together with ablation experiments and visualizations for a better understanding of PointCNN.

2. Related Work

Feature Learning from Regular Domains. CNNs have been very successful for leveraging spatially-local correlation in images — pixels in 2D regular grids [4]. There has been work in extending CNNs to higher dimensional regular domains, such as 3D voxels [5]. However, as both the input and convolution kernels are of higher dimensions, the amount of both computation and memory inflates dramatically. Octree [6, 7], Kd-Tree [8] and Hash [9] based approaches have been proposed to save computation by skipping convolution in empty space. The activations are kept sparse in [10] to retain sparsity in convolved layers. [11] and [12] partition point cloud into grids and represent each grid with grid mean points and Fisher vectors respectively for convolving with 3D kernels. In these approaches, the kernels themselves are still dense and of high dimension. Sparse kernels are proposed in [13], but this approach cannot be applied recursively for learning hierarchical features. Compared with these methods, PointCNN is sparse in both input representation and convolution kernels.

Feature Learning from Irregular Domains. Stimulated by the rapid advances and demands in 3D sensing, there has been quite a few recent developments in feature learning from 3D point clouds. PointNet [14] and Deep Sets [15] proposed to achieve input order invariance by the use of a symmetric function over inputs. PointNet++ [3] and SO-Net [16] apply PointNet hierarchically for better capturing of local structures. Kernel correlation and graph pooling are proposed for improving PointNet-like methods in [17]. RNN is used in [18] for processing features aggregated by pooling from ordered point cloud slices. [19] proposed to leverage neighborhood structures in both point and feature spaces. While these symmetric pooling based approaches, as well as those in [20, 15, 21], have guarantee in achieving order invariance, they come with a price of throwing away information.

[22, 23, 24] propose to first "interpolate" or "project" features into predefined regular domains, where typical CNNs can be applied. In contrast, the regular domain is latent in our method. CNN kernels are represented as parametric functions of neighborhood point positions to generalize CNNs for point clouds in [25, 26, 27]. The kernels associated with each point are parametrized individually in these methods, while the

X\mathcal{X}

-transformations in our method are learned from each neighborhood, thus could potentially by more adaptive to local structures.

Besides as point clouds, sparse data in irregular domains can be represented as graphs, or meshes, and a few works have been proposed for feature learning from such representations [28, 29, 30]. We refer the interested reader to [31] for a comprehensive survey of work along these directions. Spectral graph convolution on a local graph is used for processing point clouds in [32].

Invariance vs. Equivariance. A line of pioneering work aiming at achieving equivariance has been proposed to address the information loss problem of pooling in achieving invariance [33, 34]. The

X\mathcal{X}

-transformations in our formulation, ideally, are capable of realizing equivariance, and are demonstrated to be effective in practice. We also found similarity between PointCNN and Spatial Transformer Networks [35], in the sense that both of them provided a mechanism to "transform" input into latent canonical forms for being further processed, with no explicit loss or constraint in enforcing the canonicalization. In practice, it turns out that the networks find their ways to leverage the mechanism for learning better. In PointCNN, the

X\mathcal{X}

-transformation is supposed to serve for both weighting and permutation, thus is modelled as a general matrix. This is different than that in [36], where a permutation matrix is the desired output, and is approximated by a doubly stochastic matrix.

3. PointCNN

The hierarchical application of convolutions is essential for learning hierarchical representations via CNNs. PointCNN shares the same design and generalizes it to point clouds. First, we introduce hierarchical convolutions in PointCNN, in analogy to that of image CNNs, then, we explain the core

X\mathcal{X}

-Conv operator in detail, and finally, present PointCNN architectures geared toward various tasks.

3.1 Hierarchical Convolution

Figure 2: Hierarchical convolution on regular grids (upper) and point clouds (lower). In regular grids, convolutions are recursively applied on local grid patches, which often reduces the grid resolution ( $4 \times 4 \to 3 \times 3 \to 2 \times 2$ ), while increasing the channel number (visualized by dot thickness). Similarly, in point clouds, $\mathcal{X}$ -Conv is recursively applied to "project", or "aggregate", information from neighborhoods into fewer representative points ( $9 \to 5 \to 2$ ), but each with richer information.

Before we introduce the hierarchical convolution in PointCNN, we briefly go through its well known version for regular grids, as illustrated in Figure 2 upper. The input to grid-based CNNs is a feature map

F1\mathbf{F}_1

of shape

R1×R1×C1R_1 \times R_1 \times C_1

, where

R_1

is the spatial resolution, and

C_1

is the feature channel depth. The convolution of kernels

K\mathbf{K}

of shape

\times K \times C_1 \times C_2

against local patches of shape

\times K \times C_1

from

F1\mathbf{F}_1

, yields another feature map

F2\mathbf{F}_2

of shape

R2×R2×C2R_2 \times R_2 \times C_2

. Note that in Figure 2 upper,

R_1=4

K = 2

, and

R_2=3

. Compared with

F1\mathbf{F}_1

F2\mathbf{F}_2

is often of lower resolution (

R_2 < R_1

) and of deeper channels (

C_2 > C_1

), and encodes higher level information. This process is recursively applied, producing feature maps with decreasing spatial resolution (

\times 4 \to 3 \times 3 \to 2 \times 2

in Figure 2 upper), but deeper channels (visualized by increasingly thicker dots in Figure 2 upper).

The input to PointCNN is

F1={(p1,i,f1,i):i=1,2,...,N1}\mathbb{F}_1 = \{(p_{1, i}, f_{1, i}) : i=1, 2, ..., N_1\}

, i.e., a set of points

{p1,i:p1,i∈RDim}\{p_{1, i} : p_{1, i} \in \mathbb{R}^{Dim}\}

, each associated with a feature

{f1,i:f1,i∈RC1}\{f_{1, i} : f_{1, i} \in \mathbb{R}^{C_1} \}

. Following the hierarchical construction of grid-based CNNs, we would like to apply

X\mathcal{X}

-Conv on

F1\mathbb{F}_1

to obtain a higher level representation

F2={(p2,i,f2,i):f2,i∈RC2,i=1,2,...,N2}\mathbb{F}_2 = \{(p_{2, i}, f_{2, i}) : f_{2, i} \in \mathbb{R}^{C_2}, i=1, 2, ..., N_2\}

, where

{p_{2, i}\}

is a set of representative points of

{p_{1, i}\}

and

F2\mathbb{F}_2

is of a smaller spatial resolution and deeper feature channels than

F1\mathbb{F}_1

, i.e.,

N_2 < N_1

, and

C_2 > C_1

. When the

X\mathcal{X}

-Conv process of turning

F1\mathbb{F}_1

into

F2\mathbb{F}_2

is recursively applied, the input points with features are "projected", or "aggregated", into fewer points (

\to 5 \to 2

in Figure 2 lower), but each with increasingly richer features (visualized by increasingly thicker dots in Figure 2 lower).

The representative points

{p_{2, i}\}

should be the points that are beneficial for the information "projection" or "aggregation". In our implementation, they are generated by random down-sampling of

{p_{1, i}\}

in classification tasks, and farthest point sampling in segmentation tasks, since segmentation tasks are more demanding on a uniform point distribution. We suspect some more advanced point selections which have shown promising performance in geometry processing, such as Deep Points [37], could fit in here as well. We leave the exploration of better representative point generation methods for future work.

3.2 $X\mathcal{X}$ -Conv Operator

X\mathcal{X}

-Conv is the core operator for turning

F1\mathbb{F}_1

into

F2\mathbb{F}_2

. In this section, we first introduce the input, output and procedure of the operator, and then explain the rationale behind the procedure.

Algorithm 1: $\mathcal{X}$ -Conv Operator

1SetKwInOutInputInput SetKwInOutOutputOutput Input{K\mathbf{K}K, ppp, P\mathbf{P}P, F\mathbf{F}F} Output{Fp\mathbf{F}_pFp​ // Features "projected", or "aggregated", into representative point ppp}
2P′←P−p\mathbf{P}' \leftarrow \mathbf{P}-pP′←P−p // Move P\mathbf{P}P to local coordinate system of ppp
3Fδ←MLPδ(P′)\mathbf{F}_\delta \leftarrow \mathit{MLP}_{\delta}(\mathbf{P}')Fδ​←MLPδ​(P′) // Individually lift each point into CδC_\deltaCδ​ dimensional space
4F∗←[Fδ,F]\mathbf{F}_* \leftarrow [\mathbf{F}_\delta, \mathbf{F}]F∗​←[Fδ​,F] // Concatenate Fδ\mathbf{F}_\deltaFδ​ and F\mathbf{F}F, F∗\mathbf{F}_*F∗​ is a K×(Cδ+C1)K \times (C_\delta+C_1)K×(Cδ​+C1​) matrix
5X←MLP(P′)\mathcal{X} \leftarrow \mathit{MLP}(\mathbf{P}')X←MLP(P′) // Learn the K×KK \times KK×K X\mathcal{X}X-transformation matrix
6FX←X×F∗\mathbf{F}_\mathcal{X} \leftarrow \mathcal{X} \times \mathbf{F}_*FX​←X×F∗​ // Weight and permute F∗\mathbf{F}_*F∗​ with the learnt X\mathcal{X}X
7Fp←\mathbf{F}_p \leftarrowFp​← Conv (K,FX)(\mathbf{K}, \mathbf{F}_\mathcal{X})(K,FX​) // Finally, typical convolution between K\mathbf{K}K and FX\mathbf{F}_\mathcal{X}FX​

To leverage spatially-local correlation, similar to convolution in grid-based CNNs,

X\mathcal{X}

-Conv operates in local regions. Since the output features are supposed to be associated with the representative points

{p_{2, i}\}

X\mathcal{X}

-Conv takes their neighborhood points in

{p_{1, i}\}

, as well as the associated features, as input to convolve with. For simplicity, we denote a representative point in

{p_{2, i}\}

p

, the features with

p

f

and its

K

neighbors in

{p_{1, i}\}

N\mathbb{N}

, thus the

X\mathcal{X}

-Conv input for this specific

p

S={(pi,fi):pi∈N}\mathbb{S} = \{(p_i, f_i) : p_i \in \mathbb{N}\}

. Note that

S\mathbb{S}

is an unordered set. Without loss of generality,

S\mathbb{S}

can be cast into a

\times Dim

matrix

P=(p1,p2,...,pK)T\mathbf{P} = (p_1, p_2, ..., p_K)^T

, and a

\times C_1

matrix

F=(f1,f2,...,fK)T\mathbf{F} = (f_1, f_2, ..., f_K)^T

, and

K\mathbf{K}

denotes the trainable convolution kernels. With these inputs, we would like to compute the features

Fp\mathbf{F}_p

, which are the "projection", or "aggregation", of the input features into the representative point

p

. We detail the

X\mathcal{X}

-Conv operator in Algorithm 1, and summarize it concisely as:

where

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

is a multilayer perceptron applied individually on each point, as in PointNet [14]. Note that all the operations involved in building

X\mathcal{X}

-Conv, i.e., Conv

(⋅,⋅)(\cdot, \cdot)

MLP(⋅)\mathit{MLP}(\cdot)

, matrix multiplication

(⋅)×(⋅)(\cdot) \times (\cdot)

, and

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

, are differentiable. Accordingly.

X\mathcal{X}

-Conv is differentiable, and can be plugged into a neural network for training by back propagation.

Lines 4-6 in Algorithm 1 are the core

X\mathcal{X}

-transformation as described in in Section 1. Here, we explain the rationale behind lines 1-3 of Algorithm 1 in detail.

X\mathcal{X}

-Conv is designed to work on local point regions, and the output should not be dependent on the absolute position of

p

and its neighboring points, but on their relative positions. To that end, we position local coordinate systems at the representative points (line 1 of Algorithm 1, Figure 3 b). It is the local coordinates of neighboring points, together with their associated features, that define the output features. However, the local coordinates are of a different dimensionality and representation than the associated features. To address this issue, we first lift the coordinates into a higher dimensional and more abstract representation (line 2 of Algorithm 1), and then combine it with the associated features (line 3 of Algorithm 1) for further processing (Figure 3 c).

Lifting coordinates into features is done through a point-wise

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

, as in PointNet-based methods. Differently, however, the lifted features are not processed by a symmetric function. Instead, along with the associated features, they are weighted and permuted by the

X\mathcal{X}

-transformation that is jointly learned across all neighborhoods. The resulting

X\mathcal{X}

is dependent on the order of the points, and this is desired, as

X\mathcal{X}

is supposed to permute

F∗\mathbf{F}_*

according to the input points, and therefore has to be aware of the specific input order. For an input point cloud without any additional features, i.e.,

F\mathbf{F}

is empty, the first

X\mathcal{X}

-Conv layer uses only

Fδ\mathbf{F}_\delta

. PointCNN can thus handle point clouds with or without additional features in a robust uniform fashion.

For more details about the

X\mathcal{X}

-Conv operator, including the actual definition of

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

MLP(⋅)\mathit{MLP}(\cdot)

and Conv

(⋅,⋅)(\cdot, \cdot)

, please refer to Supplementary Material Section 6.

3.3 PointCNN Architectures

From Figure 2, we can see that the Conv layers in grid-based CNNs and

X\mathcal{X}

-Conv layers in PointCNN only differ in two aspects: the way the local regions are extracted (

\times K

patches vs.

K

neighboring points around representative points) and the way the information from local regions is learned (Conv vs.

X\mathcal{X}

-Conv). Otherwise, the process of assembling a deep network with

X\mathcal{X}

-Conv layers highly resembles that of grid-based CNNs.

Figure 4 a depicts a simple PointCNN with two

X\mathcal{X}

-Conv layers that gradually transform the input points (with or without features) into fewer representation points, but each with richer features. After the second

X\mathcal{X}

-Conv layer, there is only one representative point left, and it aggregates information from all the points from the previous layer. In PointCNN, we can roughly define the receptive field of each representative point as the ratio

K / N

, where

K

is the neighboring point number, and

N

is the point number in the previous layer. With this definition, the final point "sees" all the points from the previous layer, thus has a receptive field of

1.0

— it has a global view of the entire shape, and its features are informative for semantic understanding of the shape. We can add fully connected layers on top of the last

X\mathcal{X}

-Conv layer output, followed by a loss, for training the network.

Note that the number of training samples for the top

X\mathcal{X}

-Conv layers drops rapidly (Figure 4 a), making it inefficient to train them thoroughly. To address this problem, we propose PointCNN with denser connections (Figure 4 b), where more representative points are kept in the

X\mathcal{X}

-Conv layers. However, we aim to maintain the depth of the network, while keeping the receptive field growth rate, such that the deeper representative points "see" increasingly larger portions of the entire shape. We achieve this goal by employing the dilated convolution idea from grid-based CNNs in PointCNN. Instead of always taking the

K

neighboring points as input, we uniformly sample

K

input points from

\times D

neighboring points, where

D

is the dilation rate. In this case, the receptive field increases from

K / N

\times D) / N

, without increasing actual neighboring point count or kernel size.

In the second

X\mathcal{X}

-Conv layer of PointCNN in Figure 4 b, dilation rate

D = 2

is used, thus all the four remaining representative points "see" the entire shape, and all of them are suitable for making predictions. Note that, in this way, we can train the top

X\mathcal{X}

-Conv layers more thoroughly, as much more connections are involved in the network, compared to PointCNN in Figure 4 a. In test time, the output from the multiple representative points is averaged right before the

so f t ma x

to stabilize the prediction. This design is similar to that of Network in Network [38]. The denser version of PointCNN (Figure 4 b) is the one we used for classification tasks.

For segmentation tasks, high resolution point-wise output is required, and this can be realized by building PointCNN following Conv-DeConv [39] architecture, where the DeConv part is responsible for propagating global information into high resolution predictions (see Figure 4 c). Note that both the "Conv" and "DecConv" in the PointCNN segmentation network are the same

X\mathcal{X}

-Conv operator. The only differences between the "Conv" and "DeConv" layers is that the latter has more points but less feature channels in its output vs. its input, and its higher resolution points are forwarded from earlier "Conv" layers, following the design of U-Net [40].

Dropout is applied before the last fully connected layer to reduce over-fitting. We also employed the "subvolume supervision" idea from [41], to further address the over-fitting problem. In the last

X\mathcal{X}

-Conv layers, the receptive field is set to be less than

1

, such that only partial information is "seen" by the representative points. The network is pushed to learn harder from the partial information during training, and performs better at test time. In this case, the global coordinates of the representative points matter, thus they are lifted into feature space

RCg\mathbb{R}^{C_g}

with

MLPg(⋅)MLP_g(\cdot)

(detailed in Supp. Material Section 6) and concatenated into

X\mathcal{X}

-Conv for further processing by follow-up layers.

Data augmentation. To train the parameters in

X\mathcal{X}

-Conv, it is evidently not beneficial to keep using the same set of neighboring points, in the same order, for a specific representative point. To improve generalization, we propose to randomly sample and shuffle the input points, such that both the neighboring point sets and order may differ from batch to batch. To train a model that takes

N

points as input,

N(N,(N/8)2)\mathcal{N}(N, (N/8)^2)

points are used for training, where

N\mathcal{N}

denotes a Gaussian distribution. We found that this strategy is crucial for successful training of PointCNN.

4. Experiments

We conducted an extensive evaluation of PointCNN for shape classification on six datasets (ModelNet40 [5], ScanNet [42], TU-Berlin [43], Quick Draw [44], MNIST, CIFAR10), and segmentation task on three datasets (ShapeNet Parts [45], S3DIS [46], and ScanNet [42]). The details of the datasets and how we convert and feed data into PointCNN, are described in Supp. Material Section 7, and the PointCNN architectures for the tasks on these datasets can be found in Supp. Material Section 8.

4.1 Classification and Segmentation Results

We summarize our 3D point cloud classification results on ModelNet40 and ScanNet in Table 1, and compare to several neural network methods designed for point clouds. Note that a large portion of the 3D models from ModelNet40 are pre-aligned to the common up direction and horizontal facing direction. If a random horizontal rotation is not applied on either the training or testing sets, then the relatively consistent horizontal facing direction is leveraged, and the metrics based on this setting is not directly comparable to those with the random horizontal rotation. For this reason, we ran PointCNN and reported its performance in both settings. Note that PointCNN achieved top performance on both ModelNet40 and ScanNet.

We evaluate PointCNN on the segmentation of ShapeNet Parts, S3DIS, and ScanNet datasets, and summarize the results in Table 2. More detailed segmentation result comparisons can be found in Supplementary Material Section 9. We note that PointCNN outperforms all the compared methods, including SSCN [47], SPGraph [49] and SGPN [48], which are specialized segmentation networks with state-of-the-art performance. Note that the part averaged IoU metric for ShapeNet Parts is the one used in [50]. Compared with mean IoU, the part averaged IoU puts more emphasis on the correct prediction of small parts.

Sketches are 1D curves in 2D space, thus can be more effectively represented with point clouds, rather than with 2D images. We evaluate PointCNN on TU-Berlin and Quick Draw sketches, and present results in Table 3, where we compare its performance with the competitive PointNet++, as well as image CNN based methods. PointCNN outperforms PointNet++ on both datasets, with a more prominent advantage on Quick Draw (25M data samples), which is significantly larger than TU-Berlin (0.02M data samples). On the TU-Berlin dataset, while the performance of PointCNN is slightly better than the generic image CNN AlexNet [51], there is still a gap with the specialized Sketch-a-Net [52]. It is interesting to study whether architectural elements from Sketch-a-Net can be adopted and integrated into PointCNN to improve its performance on the sketch datasets.

Since

X\mathcal{X}

-Conv is a generalization of Conv, ideally, PointCNN should perform on par with CNNs, if the underlying data is the same, but only represented differently. To verify this, we evaluate PointCNN on the point cloud representation of MNIST and CIFAR10, and show results in Table 4. For MNIST data, PointCNN achieved comparable performance with other methods, indicating its effective learning of the digits' shape information. For CIFAR10 data, where there is mostly no "shape" information, PointCNN has to learn mostly from the spatially-local correlation in the RGB features, and it performed reasonably well on this task, though there is a large gap between PointCNN and the mainstream image CNNs. From this experiment, we can conclude that CNNs are still the better choice for general images.

4.2 Ablation Experiments and Visualizations

Ablation test of the core $X\mathcal{X}$ -Conv operator. To verify the effectiveness of the

X\mathcal{X}

-transformation, we propose PointCNN without it as a baseline, where lines 4-6 of Algorithm 1 are replaced by

Fp←\mathbf{F}_p \leftarrow

Conv

(K,F∗)(\mathbf{K}, \mathbf{F}_*)

. Compared with PointCNN, the baseline has less trainable parameters, and is more "shallow" due to the removal of

MLP(⋅)\mathit{MLP}(\cdot)

in line 4 of Algorithm 1. For a fair comparison, we further propose PointCNN w/o

X\mathcal{X}

-W/D, which is wider/deeper, and has approximately the same amount of parameters as PointCNN. The model depth of PointCNN w/o

X\mathcal{X}

(deeper) also compensates for the decrease in depth caused by the removal of

MLP(⋅)\mathit{MLP}(\cdot)

from PointCNN. The comparison results are summarized in Table 5. Clearly, PointCNN outperforms the proposed variants by a significant margin, and the gap between PointCNN and PointCNN w/o

X\mathcal{X}

is not due to model parameter number, or model depth. With these comparisons, we conclude that

X\mathcal{X}

-Conv is the key to the performance of PointCNN.

Visualization of $X\mathcal{X}$ -Conv features. Each representative point, with its neighboring points in a particular order, has a corresponding

F∗\mathbf{F}_*

and

FX\mathbf{F}_\mathcal{X}

RK×C\mathbb{R}^{K \times C}

, where

C=Cδ+C1C=C_\delta+C_1

. For the same representative point, if its neighboring points in different orders are fed into the network, we get a set of

F∗\mathbf{F}_*

and

FX\mathbf{F}_\mathcal{X}

, and we denote them as

F∗\mathcal{F}_*

and

FX\mathcal{F}_\mathcal{X}

. Similarly, we define the set of

F∗\mathbf{F}_*

in PointCNN w/o

X\mathcal{X}

Fo\mathcal{F}_o

. Clearly,

F∗\mathcal{F}_*

can be quite scattering in the

RK×C\mathbb{R}^{K \times C}

space, since differences in input point order will result in a different

F∗\mathbf{F}_*

. On the other hand, if the learned

X\mathcal{X}

can perfectly canonize

F∗\mathbf{F}_*

FX\mathcal{F}_\mathcal{X}

is supposed to stay at a canonical point in the space.

To verify this, we show T-SNE visualization of

Fo\mathcal{F}_o

F∗\mathcal{F}_*

and

FX\mathcal{F}_\mathcal{X}

15

randomly picked representative points from the ModelNet40 dataset in Figure 5, each with one color, and consistent in the sub-figures. Note that

Fo\mathcal{F}_o

is quite "blended", which indicates that the features from different representative points are not discriminative against each other (Figure 5 a). While

F∗\mathcal{F}_*

is better than

Fo\mathcal{F}_o

, it is still "fuzzy" (Figure 5 b). In Figure 5 c,

F∗\mathcal{F}_*

are "concentrated" by

X\mathcal{X}

, and the features of each representative point become highly discriminative. To give an quantitative reference of the "concentration" effect, we firstly compute the feature centers of different representative points, then classify all the feature points to the representative points they belong to, based on nearest search to the centers. The classification accuracies are 76.83%, 89.29% and 94.72% for

Fo\mathcal{F}_o

F∗\mathcal{F}_*

and

FX\mathcal{F}_\mathcal{X}

, respectively. With the qualitative visualization and quantitative investigation, we conclude that though the "concentration" is far from reaching a point, the improvement is significant, and it explains the performance of PointCNN in feature learning.

Optimizer, model size, memory usage and timing. We implemented PointCNN in tensorflow [53], and use ADAM optimizer [54] with an initial learning rate

0.01

for the training of our models. As shown in Table 6, we summarize our running statistics based with the model for classification with batch size 16, 1024 input points on nVidia Tesla P100 GPU, in comparison with several other methods. PointCNN achieves 0.031/0.012 second per batch for training/inference on this setting. In addition, the model for segmentation with

2048

input points has

4.4

M parameters runs on nVidia Tesla P100 with batch size

12

at 0.61/0.25 second per batch for training/inference.

5. Conclusion

We proposed PointCNN, which is a generalization of CNN into leveraging spatially-local correlation from data represented in point cloud. The core of PointCNN is the

X\mathcal{X}

-Conv operator that weights and permutes input points and features before they are processed by a typical convolution. While

X\mathcal{X}

-Conv is empirically demonstrated to be effective in practice, a rigorous understanding of it, especially when being composited into a deep neural network, is still an open problem for future work. It is also interesting to study how to combine PointCNN and image CNNs to jointly process paired point clouds and images, probably at the early stages. We open source our code at https://github.com/yangyanli/PointCNN to encourage further development.

Acknowledgments

Yangyan would like to thank Leonidas Guibas from Stanford University and Mike Haley from Autodesk Research for insightful discussions, and Noa Fish from Tel Aviv University and Thomas Schattschneider from Technical University of Hamburg for proof reading. The work is supported in part by National Key Research and Development Program of China grant No. 2017YFB1002603, the National Basic Research grant (973) No. 2015CB352501, National Science Foundation of China General Program grant No. 61772317, and "Qilu" Young Talent Program of Shandong University.

\textbfPointCNN Supplementary Material

6. $X\mathcal{X}$ -Conv Details

We implement

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

in Line 2 of Algorithm 1 with two fully connected (FC) layers, each followed by ELU [55] activation function and batch normalization (BN) [56], i.e.,

C_\delta) \rightarrow ELU \rightarrow BN \rightarrow FC(C_\delta, C_\delta) \rightarrow ELU \rightarrow BN

. We set

CδC_\delta

C_1/4

MLP(⋅)\mathit{MLP}(\cdot)

in Line 4 of Algorithm 1 can be implemented in a similar way:

\rightarrow ELU \rightarrow BN \rightarrow FC(K*K, K*K) \rightarrow ELU \rightarrow BN \rightarrow FC(K*K, K*K) \rightarrow BN \rightarrow Reshape(K*K, K \times K)

, where

K * K

denotes a vector in

RK∗K\mathbb{R}^{K*K}

, and

\times K

denotes a

K

-by-

K

square matrix. However, this implementation results in

O(K^4)

parameters. To reduce the parameter number and computation, as well as the overfitting risk due to a large number of parameters, we propose to replace

F C (K * K, K * K)

with a depthwise convolution

\times C, C*F)

, which applies

F

different filters to each of the

C

column of the input

\times C

matrix, yielding a

C * F

vector, where

R * C * F

parameters are involved. More specifically,

MLP(⋅)\mathit{MLP}(\cdot)

is implemented with

\rightarrow ELU \rightarrow BN \rightarrow Reshape(K*K, K \times K) \rightarrow DC(K \times K, K*K) \rightarrow ELU \rightarrow BN \rightarrow Reshape(K*K, K \times K) \rightarrow DC(K \times K, K*K) \rightarrow BN \rightarrow Reshape(K*K, K \times K)

, which results in

O(K^3)

parameters.

Conv

(⋅,⋅)(\cdot, \cdot)

in Line 6 of Algorithm 1, if implemented with typical convolution, has

(C_1+C_\delta) * C_2

trainable parameters. We implemented it with separable convolution [57], which has

(C_1+C_\delta) * DM + (C_1+C_\delta) * DM * C_2

trainable parameters, where

D M

is the depth multiplier, and we use

\lceil C_2/(C_1+C_\delta) \rceil

in our implementation. Separable convolution reduces both parameter number and computation compared with that of a typical convolution.

MLPg(⋅)MLP_g(\cdot)

is used to harvest the global position information of the representative points in the last

X\mathcal{X}

-Conv layer. It is implemented similar to

MLPδ(⋅)\mathit{MLP}_{\delta}(\cdot)

, i.e.,

C_g) \rightarrow ELU \rightarrow BN \rightarrow FC(C_g, C_g) \rightarrow ELU \rightarrow BN

. We set

C_g

C_2/4

. The

C_g

dimensional output of

MLPg(⋅)MLP_g(\cdot)

is concatenated with the

C_2

dimensional output of the last

X\mathcal{X}

-Conv layer for further processing.

In our implementation, a

K

nearest neighbor search is applied for extracting the

K

neighboring points. This assumes a more or less uniform distribution of input points. For point clouds with non-uniform distribution, a radius search can be applied first, and then

K

points can be randomly picked out of the radius search results.

In theory, the

X\mathcal{X}

-transformation can be applied on either the features or the kernels. We opt to apply it on the features, in which way the follow up operation is a standard convolution operation that is highly optimized by popular deep learning frameworks.

7. Dataset Details

We conducted extensive evaluation of PointCNN on datasets of various types and scales. Here we introduce the details of the datasets, as well as how we pre-process and feed them into PointCNN:

Object datasets: ModelNet40 [5] and ShapeNet Parts [45].
- ModelNet40 is composed of $12311$ 3D mesh models from $40$ categories, with a $9843/2468$ training/testing split. Both the gravity and "facing" directions of the models are mostly aligned in the dataset. In the "Pre-aligned" setting, the models are used for training and testing, without random horizontal rotations. In which way, the relative consistent "facing" direction is leveraged by the network. In the "Unaligned" setting, random horizontal rotations are explicitly applied on either the training or the testing models, not as a data augmentation, but to "forget" the relative consistent "facing" directions thus better approximate the scenarios in real world applications, where the "facing" direction of the objects are often unknown. We use the point cloud conversion of ModelNet40 provided by [14] as our input, where $2048$ points are sampled from each mesh, and we further sample $N(1024,1282)\mathcal{N}(1024, 128^2)$ points to train a model for testing with $1024$ points on the classification task.
- ShapeNet Parts contains $16880$ models ( $14006$ / $2874$ training/testing split) from $16$ shape categories, each annotated with 2 to 6 parts and there are 50 different parts in total. Each point sampled from the models is associated with a part label. The task is to predict the part label for each point, thus a segmentation task, and can be treated as a dense point-wise classification problem. The category label for each model is given, and can be used for trimming irrelevant predictions, same as that in [47]. $N(2048,2562)\mathcal{N}(2048, 256^2)$ points are sampled from each point cloud to train a model for testing with $2048$ input points on the segmentation task. Each testing point cloud is sampled multiple times to make sure all the points are evaluated at least $r$ ( $r = 10$ in our experiments) times at testing time.
Indoor scene datasets: S3DIS [46] and ScanNet [42]. While ModelNet40 and ShapeNet models are mostly made by 3D modeling tools, S3DIS and ScanNet are from real scans of indoor environments.
- S3DIS contains 3D scans from Matterport scanners in $6$ areas including $271$ rooms. Each point with RGB features in the scan is annotated with one of the semantic labels from 13 categories. The task is segmentation. The data is firstly split by room, and then the rooms are sliced into $1.5$ m by $1.5$ m blocks, with $0.3$ m padding on each side. The points in the padding areas serve as context of the internal points, and themselves are not linked to loss in the training phase, nor used for prediction in the testing phase. Each block is moved to a local coordinate system defined by its center. Random horizontal rotations are applied on the sliced blocks for data augmentation. The rotated blocks are handled in the same way as the object point clouds in ShapeNet Parts.
- ScanNet contains $1513$ scanned and reconstructed indoor scenes, with $1201/312$ scenes for training/testing in semantic voxel labeling of $17$ categories. We firstly prepare data in the same way as that of S3DIS to train a segmentation model, and the segmentation results on testing data are then converted into semantic voxel labeling, as that in [3], for a fair comparison with previous methods. The $9305/2606$ training/testing object instances from the $17$ categories in ScanNet are also used for evaluating classification task. Note that ScanNet comes with RGB information for each point. However, they are not used in previous methods. To make fair comparisons, we do not use them either.
2D sketch datasets: TU-Berlin [43] and Quick Draw [44]. Similar to surfaces in 3D space, line sketches in 2D are inherently of less dimension than the ambient space, and can be represented as point cloud, thus we consider 2D sketches good arena for evaluating neural networks that are designed to consume point cloud data. TU-Berlin has sketches from $250$ categories, with $80$ sketches from each category, where $2/3$ are used for training and the rest $1/3$ for testing. Quick Draw is the largest available sketch dataset, with sketches from $345$ categories, each with $70000/2500$ training/testing samples. We sample $N(512,642)\mathcal{N}(512, 64^2)$ points from the sketch stokes to train a model for testing with $512$ points on sketch classification task.
Image datasets: MNIST and CIFAR10. MNIST and CIFAR10 are widely used for sanity check of image CNNs. Since PointCNN is a generalization of CNNs, we would like to evaluate PointCNN on the point cloud representation of MNIST and CIFAR10. For MNIST, we randomly sample $160$ foreground pixels and convert them into point cloud representation, with the gray-scale pixel value as the input feature. For CIFAR10, we randomly sampled $512$ pixels out of the $32 \times 32$ pixels for converting into point cloud with RGB features. Note that there is "shape" information in the MNIST point cloud, sine the point cloud follow the digits' structure, but this is not the case for the CIFAR10 point cloud, where the points are mostly the same blob for all the data samples.

8. PointCNN Model Zoo

In Figure 6, we list the PointCNNs used for classification and segmentation tasks on multiple benchmark datasets. PointCNNs are easy to implement, setup, and tune. Larger

C

are used for layers with more abstract/semantic information, such as the top layers in classification networks, and middle layers in "Conv-DeConv" segmentation networks. To relax the memory demand, smaller

K

s are used at layers with large number of representative points, such as bottom layers of classification networks, and top and bottom layers of segmentation networks. Deeper PointCNN with larger receptive field in the last

X\mathcal{X}

-Conv layer are used for larger or harder datasets. The skip-links, together with the dilation parameter

D

, make it easy to fuse information from different scales (receptive fields), as illustrated in (d) and (e), which is essential for segmentation tasks.

9. Detailed Segmentation Results

We show detailed segmentation result comparisons on ShapeNet Parts in Table 7, we can see our approach achieves the best overall performance and are best on 7 of the 16 categories.

We show detailed segmentation result comparisons on S3DIS in Table 8, we can see our approach achieves the best overall performance and are best on 6 of the 13 categories. The detailed segmentation result comparisons on S3DIS Area 5 are summarized in Table 9, as some of the literatures only report the performance on this area.

References

[1] Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.

[2] David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning internal representations by error propagation. In David E. Rumelhart, James L. McClelland, and CORPORATE PDP Research Group, editors, Parallel Distributed Processing: Explorations in the Microstructure of Cognition, Vol. 1, pages 318–362. MIT Press, Cambridge, MA, USA, 1986.

[3] Charles R Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In NIPS, pages 5105–5114, 2017.

[4] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.

[5] Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In CVPR, pages 1912–1920, 2015.

[6] Gernot Riegler, Ali Osman Ulusoys, and Andreas Geiger. Octnet: Learning deep 3d representations at high resolutions. In CVPR, 2017.

[7] Peng-Shuai Wang, Yang Liu, Yu-Xiao Guo, Chun-Yu Sun, and Xin Tong. O-cnn: Octree-based convolutional neural networks for 3d shape analysis. ACM Trans. Graph., 36(4):72:1–72:11, July 2017.

[8] Roman Klokov and Victor Lempitsky. Escape from cells: Deep kd-networks for the recognition of 3d point cloud models. In ICCV, 2017.

[9] Tianjia Shao, Yin Yang, Yanlin Weng, Qiming Hou, and Kun Zhou. H-CNN: spatial hashing based CNN for 3d shape analysis. arXiv preprint arXiv:1803.11385, 2018.

[10] Benjamin Graham and Laurens van der Maaten. Submanifold sparse convolutional networks. arXiv preprint arXiv:1706.01307, 2017.

[11] Binh-Son Hua, Minh-Khoi Tran, and Sai-Kit Yeung. Point-wise convolutional neural network. In CVPR, 2018.

[12] Yizhak Ben-Shabat, Michael Lindenbaum, and Anath Fischer. 3d point cloud classification and segmentation using 3d modified fisher vector representation for convolutional neural networks. arXiv preprint arXiv:1711.08241, 2018.

[13] Yangyan Li, Sören Pirk, Hao Su, Charles R Qi, and Leonidas J Guibas. Fpnn: Field probing neural networks for 3d data. In NIPS, pages 307–315, 2016.

[14] Charles R. Qi, Hao Su, Kaichun Mo, and Leonidas J. Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In CVPR, pages 77–85, July 2017.

[15] Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R. Salakhutdinov, and Alexander J Smola. Deep sets. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, NIPS, pages 3394–3404, 2017.

[16] Jiaxin Li, Ben M. Chen, and Gim Hee Lee. So-net: Self-organizing network for point cloud analysis. In CVPR, 2018.

[17] Yiru Shen, Chen Feng, Yaoqing Yang, and Dong Tian. Mining point cloud local structures by kernel correlation and graph pooling. In CVPR, 2018.

[18] Qiangui Huang, Weiyue Wang, and Ulrich Neumann. Recurrent slice networks for 3d segmentation on point clouds. In CVPR, 2018.

[19] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E. Sarma, Michael M. Bronstein, and Justin M. Solomon. Dynamic graph cnn for learning on point clouds. arXiv preprint arXiv:1801.07829, 2018.

[20] Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. In Proceedings of the 33rd International Conference on International Conference on Machine Learning - Volume 48, ICML'16, pages 1889–1898. JMLR.org, 2016.

[21] Siamak Ravanbakhsh, Jeff Schneider, and Barnabas Poczos. Deep learning with sets and point clouds. arXiv preprint arXiv:1611.04500, 2016.

[22] Hang Su, Varun Jampani, Deqing Sun, Subhransu Maji, Evangelos Kalogerakis, Ming-Hsuan Yang, and Jan Kautz. Splatnet: Sparse lattice networks for point cloud processing. In CVPR, 2018.

[23] Matan Atzmon, Haggai Maron, and Yaron Lipman. Point convolutional neural networks by extension operators. ACM Trans. Graph., 37(4):71:1–71:12, July 2018.

[24] Maxim Tatarchenko, Jaesik Park, Vladlen Koltun, and Qian-Yi Zhou. Tangent convolutions for dense prediction in 3d. In CVPR, 2018.

[25] Shenlong Wang, Simon Suo, Wei-Chiu Ma, Andrei Pokrovsky, and Raquel Urtasun. Deep parametric continuous convolutional neural networks. In CVPR, 2018.

[26] Fabian Groh, Patrick Wieschollek, and Hendrik P. A. Lensch. Flex-convolution (deep learning beyond grid-worlds). arXiv preprint arXiv:1803.07289, 2018.

[27] Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, and Yu Qiao. Spidercnn: Deep learning on point sets with parameterized convolutional filters. arXiv preprint arXiv:1803.11527, 2018.

[28] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodolà, Jan Svoboda, and Michael M. Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In CVPR, July 2017.

[29] Li Yi, Hao Su, Xingwen Guo, and Leonidas Guibas. Syncspeccnn: Synchronized spectral cnn for 3d shape segmentation. In CVPR, pages 6584–6592, July 2017.

[30] Haggai Maron, Meirav Galun, Noam Aigerman, Miri Trope, Nadav Dym, Ersin Yumer, Vladimir G. Kim, and Yaron Lipman. Convolutional neural networks on surfaces via seamless toric covers. ACM Trans. Graph., 36(4):71:1–71:10, July 2017.

[31] Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.

[32] Chu Wang, Babak Samari, and Kaleem Siddiqi. Local spectral graph convolution for point set feature learning. arXiv preprint arXiv:1803.05827, 2018.

[33] Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks, pages 44–51. Springer, 2011.

[34] Sara Sabour, Nicholas Frosst, and Geoffrey E. Hinton. Dynamic routing between capsules. In NIPS, pages 3859–3869, 2017.

[35] Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pages 2017–2025, 2015.

[36] Rodrigo Santa Cruz, Basura Fernando, Anoop Cherian, and Stephen Gould. Deeppermnet: Visual permutation learning. In CVPR, July 2017.

[37] Shihao Wu, Hui Huang, Minglun Gong, Matthias Zwicker, and Daniel Cohen-Or. Deep points consolidation. ToG, 34(6):176:1–176:13, October 2015.

[38] Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. In ICLR, 2014.

[39] Hyeonwoo Noh, Seunghoon Hong, and Bohyung Han. Learning deconvolution network for semantic segmentation. In ICCV, ICCV '15, pages 1520–1528, Washington, DC, USA, 2015. IEEE Computer Society.

[40] Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In Nassir Navab, Joachim Hornegger, William M. Wells, and Alejandro F. Frangi, editors, MICCAI, pages 234–241, Cham, 2015. Springer International Publishing.

[41] Charles R. Qi, Hao Su, Matthias Nießner, Angela Dai, Mengyuan Yan, and Leonidas J. Guibas. Volumetric and multi-view cnns for object classification on 3d data. In CVPR, pages 5648–5656, 2016.

[42] Angela Dai, Angel X. Chang, Manolis Savva, Maciej Halber, Thomas Funkhouser, and Matthias Nießner. Scannet: Richly-annotated 3d reconstructions of indoor scenes. In CVPR, 2017.

[43] Mathias Eitz, James Hays, and Marc Alexa. How do humans sketch objects? ToG, 31(4):44:1–44:10, 2012.

[44] David Ha and Douglas Eck. A neural representation of sketch drawings. arXiv preprint arXiv:1704.03477, 2017.

[45] Li Yi, Vladimir G. Kim, Duygu Ceylan, I-Chao Shen, Mengyan Yan, Hao Su, Cewu Lu, Qixing Huang, Alla Sheffer, and Leonidas Guibas. A scalable active framework for region annotation in 3d shape collections. ToG, 35(6):210:1–210:12, November 2016.

[46] Iro Armeni, Ozan Sener, Amir R. Zamir, Helen Jiang, Ioannis Brilakis, Martin Fischer, and Silvio Savarese. 3d semantic parsing of large-scale indoor spaces. In CVPR, pages 1534–1543, 2016.

[47] Benjamin Graham, Martin Engelcke, and Laurens van der Maaten. 3d semantic segmentation with submanifold sparse convolutional networks. arXiv preprint arXiv:1711.10275, 2017.

[48] Weiyue Wang, Ronald Yu, Qiangui Huang, and Ulrich Neumann. SGPN: similarity group proposal network for 3d point cloud instance segmentation. In CVPR, 2018.

[49] Loïc Landrieu and Martin Simonovsky. Large-scale point cloud semantic segmentation with superpoint graphs. CoRR, abs/1711.09869, 2017.

[50] Li Yi, Hao Su, Lin Shao, Manolis Savva, Haibin Huang, Yang Zhou, Benjamin Graham, Martin Engelcke, Roman Klokov, Victor Lempitsky, et al. Large-scale 3d shape reconstruction and segmentation from shapenet core55. arXiv preprint arXiv:1710.06104, 2017.

[51] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pages 1097–1105, 2012.

[52] Qian Yu, Yongxin Yang, Feng Liu, Yi-Zhe Song, Tao Xiang, and Timothy M. Hospedales. Sketch-a-net: A deep neural network that beats humans. IJCV, 122(3):411–425, May 2017.

[53] Martín Abadi and et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. Software available from tensorflow.org.

[54] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.

[55] Djork-Arné Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In ICLR, 2016.

[56] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pages 448–456, 2015.

[57] François Chollet. Xception: Deep learning with depthwise separable convolutions. arXiv preprint arXiv:1610.02357, 2016.

[58] Lyne P. Tchapmi, Christopher B. Choy, Iro Armeni, JunYoung Gwak, and Silvio Savarese. Segcloud: Semantic segmentation of 3d point clouds. In 3DV, 2017.

Method	TU-Berlin	Quick Draw
Sketch-a-Net [52]	77.95	-
AlexNet [51]	68.60	-
PointNet++ [3]	66.53	51.58
PointCNN	70.57	59.13

Method	MNIST	CIFAR10
LeNet [4]	99.20	84.07
Network in Network [38]	99.53	91.20
PointNet++ [14]	99.49	10.0
PointCNN	99.54	80.22

PointCNN: Convolution On X\mathcal{X}X-Transformed Points

Abstract

1. Introduction

2. Related Work

3. PointCNN

3.1 Hierarchical Convolution

3.2 X\mathcal{X}X-Conv Operator

3.3 PointCNN Architectures

4. Experiments

4.1 Classification and Segmentation Results

4.2 Ablation Experiments and Visualizations

5. Conclusion

Acknowledgments

6. X\mathcal{X}X-Conv Details

7. Dataset Details

8. PointCNN Model Zoo

9. Detailed Segmentation Results

References

PointCNN: Convolution On $X\mathcal{X}$ -Transformed Points

3.2 $X\mathcal{X}$ -Conv Operator

6. $X\mathcal{X}$ -Conv Details