{'fraction_non_alphanumeric': 0.02962383806793502, 'fraction_numerical': 0.013465380939970463, 'mean_word_length': 4.828523206751055, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Global Context Aware Convolutions for 3D Point Cloud Understanding

Recent advances in deep learning for 3D point clouds have shown great promises in scene understanding tasks thanks to the introduction of convolution operators to consume 3D point clouds directly in a neural network. Point cloud data, however, could have arbitrary rotations, especially those acquired from 3D scanning. Recent works show that it is possible to design point cloud convolutions with rotation invariance property, but such methods generally do not perform as well as translation-invariant only convolution. We found that a key reason is that compared to point coordinates, rotation-invariant features consumed by point cloud convolution are not as distinctive. To address this problem, we propose a novel convolution operator that enhances feature distinction by integrating global context information from the input point cloud to the convolution. To this end, a globally weighted local reference frame is constructed in each point neighborhood in which the local point set is decomposed into bins. Anchor points are generated in each bin to represent global shape features. A convolution can then be performed to transform the points and anchor features into final rotation-invariant features. We conduct several experiments on point cloud classification, part segmentation, shape retrieval, and normals estimation to evaluate our convolution, which achieves state-of-the-art accuracy under challenging rotations.


Introduction
Scene understanding has long been a challenging problem in computer vision. Recently, there have been significant advances in applying deep learning [19] to train neural networks for numerous tasks such as object classification and semantic segmentation. With the wide availability of consumer-grade depth sensors, acquiring 3D data has become more intuitive and robust with many 3D datasets available publicly [40,4,14,7,2,43,36]. This leads to increased interests in tackling scene understanding in the 3D * Corresponding author domain.
Among the representations for 3D data, a promising direction is to let neural networks consume point cloud data directly since point cloud data is the common data format acquired from depth sensors such as RGB-D or LiDAR cameras. However, since a point cloud is a mathematical set and so it fundamentally differs from an image, passing a point cloud to a traditional neural network like those in the image domain does not work. In principle, it is necessary to design a convolution-equivalent operator in the 3D domain that can take a point cloud as input and output its per-point features. Several attempts have been made with promising results [27,29,15,20,42,47].
Despite such research efforts, a problem often overlooked in point cloud convolution is that the operator does not exhibit rotation invariance. A viable solution in 2D deep learning is to augment training data with random rotations. However, in 3D, such data augmentation becomes less effective due to the additional degree of freedom in representing 3D rotations, which can make training prohibitively expensive. A few works turn to learn rotation-invariant features [46,30,26,8,5], which allows consistent predictions given arbitrarily rotated point clouds.
Unfortunately, a limitation from previous works is that rotation-invariant convolution does not yield features that are as distinctive as translation-invariant convolution. This makes performing object classification with aligned data more accurate than performing the same task with data with arbitrary rotations. For exact rotation invariance, it is expected that the rotation-invariant convolution is as accurate as its translation-invariant sibling.
In this paper, we propose a novel approach for performing rotation-invariant convolution for point clouds. Our key observation is that when rotation invariance is added, it introduces some ambiguities and thus reduces feature distinctiveness. To address this problem, we propose to integrate global context information from the input point cloud to the convolution, resulting in a global context aware convolution for 3D point clouds. The main contributions of this work are: • GCAConv, a novel rotation-invariant convolution operator that output features from local point sets and global anchors. Each anchor is built from subdivided spaces using a globally-weighted local reference frame at each keypoint. By explicit encoding the relation between local point sets and the global anchors, GCA-Conv can capture both local and global context; • GCANet, a neural network architecture that uses GCAConv for learning rotation-invariant features for 3D point clouds. The network allows consistent performance across training/testing scenarios that involves different rotation modes; • Applications of GCANet on object classification, object part segmentation, shape retrieval, and normals estimation that achieve the state-of-the-art performance under challenging rotations.

Related Works
Deep learning in the 2D domain has witnessed great success in solving scene understanding tasks such as object classification, semantic segmentation, normal estimation, etc. Drawing from this inspiration, techniques for deep learning in the 3D domain has recently been developed with promising results. In this section, we review the state-ofthe-art research in deep learning with 3D data, and then focus on techniques that enable feature learning on point clouds for scene understanding tasks.
Early research in 3D deep learning focus on regular and structured representations of 3D scenes such as multiple 2D images [33,28,10], 3D volumes [28,21], hierarchical data structures like octree [31] or kd-trees [18,38]. Such representations yield good performance. However, they face challenges from a practical point of view due to memory consumption, imprecise representation, or lack of scalability when high-resolution data is employed.
Many recent works in 3D deep learning switched to investigate how to learn with 3D point cloud, a more compact and intuitive representation compared to volumes and image sets. However, performing deep learning with 3D point clouds is not as straightforward as extending 2D image convolution to 3D because mathematically, a point cloud is a set. To define a valid convolution for a point cloud, it is necessary to ensure that the output features from a convolution is invariant to the permutation of the point set. PointNet [27] pioneered such a solution to output global features by maxpooling per-point features from MLPs. Several follow-up works focus on designing convolutions that can learn local features for a point cloud efficiently [15,29,20,42,39,47]. Please also refer to the technical report by Guo et al. [13] for further summary of many deep learning techniques for 3D point clouds.
A fundamental missing feature in the previously mentioned convolution for point clouds is that rotation invari-ance is not supported. A common solution is to augment the training data with arbitrary rotations, but a limitation of doing so is that generalizing the predictions to unseen rotations is challenging, not mentioning that the training time becomes longer due to the increased amount of training data. Instead, it is desirable to have a point cloud convolution with rotation-invariant features.
To this end, Rao et al. [30] map a point cloud to a spherical domain to define a rotation-invariant convolution. Zhang et al. [46] proposed a convolution that operates on features built from Euclidean distances and angles. Poulenard et al. [26] proposed to integrate spherical harmonics to a convolution. You et al. [44] transform the point cloud onto spherical voxel grids and apply convolution in the transformed domain. A great benefit of such techniques is that it allows consistent predictions across training/testing scenarios with or without rotations being applied to the data, and they can generalize robustly to inputs with unseen rotations. Despite that, so far these techniques share a common limitation: their performance is inferior to that in translation-invariant point cloud convolution. A typical example is the accuracy in object classification task on Mod-elNet40 dataset [40]. State-of-the-art techniques such as PointNet [27], PointNet++ [29], PointCNN [20], or Shell-Net [47] report between 89% to 93% of accuracy while techniques with rotation-invariant convolution only report up to 86% of accuracy [46,26]. Our work in this paper is dedicated to analyze and address this problem.

Background
Let us first analyze the performance of existing point cloud convolutions and their rotation-invariant counterparts. We select object classification task as the key task for our analysis. An observation is that the classification accuracy drops when rotation-invariant convolution is applied. We further dissect this phenomenon by visualizing the latent space learnt by the neural networks using t-SNE [37]. The results are shown in Figure 1.
In this figure, we follow Esteves et al. [9] and Zhang et al. [46] to evaluate three scenarios for object classification: z/z, SO3/SO3, and z/SO3. In case z/z, we use data augmented with rotation about gravity axis for training and testing. In case SO3/SO3, we use data augmented with arbitrary rotations for training and testing. In case z/SO3, we train with data by z-rotations and test with data by SO3 rotations. The first scenario has been extensively evaluated by previous point cloud convolution methods. The second and third scenario is specially designed to evaluate rotation invariance. The third scenario is the most challenging as it is designed to test whether a convolution can generalize well to unseen rotations.
As can be seen, latent space learnt by rotation-invariant convolution such as RIConv by Zhang et al. [46] does  [29], RIConv [46], and our method under three different rotation settings. The clusters in the t-SNEs show that to make good decisions in object classification, it is desirable to have the cluster boundaries as separated as possible.
not exhibit good discrimination among classes. The main difference between such convolution and traditional point cloud convolution is that it no longer works with point coordinates at start. In the case of RIConv, the points are transformed into Euclidean based features including distances and angles, which are not as unique as point coordinates since many points can share the same distance and angles. This is well reflected into the t-SNE in the first column (z/z) in Figure 1. PointNet++ [29] has a good separation among the clusters while RIConv [46] has more condensed clusters in the center, resulting in more ambiguities during classification.
Similarly, in the second column (SO3/SO3), PointNet++ and RIConv has similar clustering, which explains their similar performance in the classification (see more quantitative comparisons in Table 1). Finally, the third column (z/SO3) highlights the strength of rotation-invariant convolutions as they can still maintain consistent predictions and generalize well to unseen conditions. In this case, the t-SNEs show that PointNet++ cannot generalize effectively.
The goal of our work is to devise a convolution that can output highly distinctive rotation-invariant features. Here we achieve this by introducing features from a global context to design a new rotation-invariant convolution. We are inspired by the fact that for each point in a point cloud, its 3D coordinates encode global information. Such global information is lost when one converts the coordinates into some rotation-invariant features such as distance and angles as done by Zhang et al. [46].

Our Method
Our rotation-invariant convolution is built upon two key concepts: a repeatable and robust local reference frame and a global context using anchors. The idea of using local reference frames is related to spatial transformer [17] which is also leveraged by PointNet [27]. However, as spatial transformer is data-driven, it does not work well to unseen conditions such as the z/SO3 test in Figure 1. To achieve robustness, we build local reference frames (LRFs) at the keypoints of the point cloud so that features can be learnt in such local spaces. At a keypoint, not only points in its local neighborhood can strongly affect the construction of the reference frame, but non-neighboring points can also contribute to such construction. It is well known that repeatable and robust LRFs are keys to traditional 3D point descriptors [35].
After the LRFs are constructed, theoretically we can simply proceed to learn features of the local point sets. However, as previously mentioned, global shape information are also useful for feature learning. We also retain such global information and integrate them into the convolution. Here we achieve this through anchors. Each anchor is defined as a representative point in each subspace formed by the axes of the LRF. Given a LRF, it is possible to construct eight subspaces. At each LRF, the anchors thus approximate global features of the point cloud and we integrate such features to define our convolution.

Globally Weighted Local Reference Frames
For an input point set, we use farthest point sampling to select a set of keypoints which can fully cover the underlying point cloud and denoted as Q. For each keypoint p ∈ Q, we use it as a query to obtain local region Ω p centroid at p. We wish to use deep learning to extract rotation invariant features from the local region. To begin with local features learning, it is necessary to construct a local reference frame (LRF) such that the 3D coordinates can be transformed into rotation invariant features. The unit vectors of the LRF at p can be determined by normalizing the eigenvectors of the covariance matrix where N sub is the number of points in the local region and x i ∈ Ω p . However, the LRF via such computation is unstable and sensitive to noise. Slight point variations can affect the LRF and make it not repeatable. Moreover, when a local region Ω p undergoes some rotations, ambiguity can arise, reducing the distinctiveness of the local features. For example, it is hard to tell apart a corner region on a bed and on a floor/wall/ceiling in the presence of arbitrary rotations.
To solve these problems, we establish more reliable LRFs by utilizing all query points of Q in the construction: where w i is the weight that controls how a point in the point set contributes to the matrix. The weight is defined by where m = max i=1..N ( q i − p ). Intuitively, this weight allows nearby points of p to have large contributions to the covariance matrix, and thus greatly affect the LRF. Points further away from p however can contribute globally to the robustness of the LRF. Such weighted LRF construction is a fundamental step in 3D hand-crafted features [35], which can be easily integrated into our proposed convolution. A typical problem in defining LRFs is the sign flipping, i.e., the LRF signs should not vary for the same point set [35]. There are multiple ways to resolve the ambiguity; here we disambiguate the signs of the eigenvectors by orienting them to the global vector O defined by which represents the main orientation of the whole model from the perspective of point p.

Anchor Point Generation
Theoretically, it is possible to perform convolution on the point set transformed into local coordinates using the constructed LRF. However, it is wasteful to discard global information from the original coordinates as such information can further improve feature distinctiveness. Our idea here is to use anchor points to retain such information in a compact way.
Specifically, to establish the anchors, we divide the whole input point cloud into eight bins, as shown in Figure 2. In each bin, we use the barycenter of the local point set in that bin as the anchor point. Such anchors are crude approximations to the global input shape, and therefore they convey useful information for the convolution.
It is worth noting that there are many ways to define anchors in our case. For example, one can choose to use more bins or all the original point coordinates as anchors, but those will significantly increase computation time for the convolution. We empirically use eight bins as it strikes a balance between the amount of global information retained and the running time.

Global Context Aware Convolution
With the LRFs and anchors points defined, we are now ready to construct our Global Context Aware Convolution (GCAConv) to learn the rotation invariant features. Let us consider a point set P = {x i } where x i represents 3D coordinates of the point i. Let Ω i be a local point set centered at x i . A typical convolution to learn the features of Ω i can be written as This formula indicates that features of each point in the point set are first transformed before being aggregated by the aggregation function A and passed to an activation function σ. A popular choice of A is maxpooling, which supports permutation invariance in the orders of the input point features [27]. There are a few ways to define the transformation function T . In PointNet [27], it is defined by where · indicates the element-wise product. This product however ignores the contribution of features from neighboring points x j to center x i . To further incorporate such neighbor information, Liu et al. [22] proposed to define the weights by a mapping from a relation vector h ij between a point x i and its neighbor x j . Here our goal is to define the weights by using the local point set and the anchors. We project both the local point set and anchor points onto the LRF system such that the global 3D coordinates are transformed to a local frame: where x i and a i represents the global point and anchor, and x i and a i represents the local point and anchor, respectively. From here, we aim to relate the weights to such coordinates. Given a pair of a local point x i and an anchor a j , we define their relation as which can be represented by a 1 × 4 vector. We stack the features over eight anchors into an 8 × 4 matrix. Our convolution can then be defined as a 1D convolution K that transforms such matrix into a feature vector. The kernel of the convolution is 1 × 8.
Note that in this formula, we operate on local coordinates, and we use the anchors a i to approximate features from neighboring points. This allows us to have two main advantages. First, our convolution only needs local features to operate. Second, the LRFs allow that the learnt features are rotation invariant by definition, without the need of data augmentation during training. Our features can generalize easily to unseen rotations, and we also save a lot of computation during training.  Figure 3. Our network architecture with the proposed point cloud convolution. We use three convolution layers to extract point cloud features before fully connected layers for object classification. We use the same encoder-decoder style architecture with skip connections for object part segmentation and normal estimation task.

Network Architecture
We use the proposed convolution to design three neural networks for object classification, object part segmentation, and normals estimation, respectively. The architecture is shown in Figure 3. Our classification network has a standard architecture and uses three consecutive layers of convolution (with point downsampling) followed by fully connected layers (256, 128) to output the probability map. In three layers of convolutions, the output channels are set as 128, 256, 512 respectively, and the downsampling numbers are set as 512, 128 and 32 respectively. The neural network for object part segmentation and normal estimation has a decoder branch that includes skip connections and gradually upsamples the point cloud to the original resolution. We use MLP after a skip connection to unify and transform the combined features to have a valid size before deconvolution. Our deconvolution is defined similarly to GCAConv. The minor difference is that it gradually outputs denser points with fewer features.

Experimental Results
In this section, we evaluate our method on the 3D object classification, object part segmentation, shape retrieval, and normal estimation task. We implemented our method in TensorFlow [1]. We use a batch size of 32 to train object classification and 16 to train object part segmentation, shape retrieval, and normal estimation. The training is performed with Adam optimizer with an initial learning rate set to 0.001. The experiments are conducted on a machine with an Intel(R) Core(TM) i7-6900K CPU equipped with an NVIDIA GTX TITAN X GPU.

Classification on ModelNet40
Object classification is the main task in our evaluation. We train the classification network by using the Model-Net40 variant of the ModelNet dataset [41] [46], we evaluate the performance of object classification with three scenarios: (1) using data augmented with rotation about gravity axis (z/z) for training and testing, (2) using data augmented with arbitrary rotations (SO3/SO3) for training and testing, and (3) training with data by z-rotations and testing with data by SO3 rotations (z/SO3). It is expected that rotation-invariant convolutions should work well in the z/SO3 scenario. Table 1 details the results of this experiment, which confirms the effectiveness of the proposed rotation-invariant convolution. As can be seen, on average, not only our classification accuracy outperforms the state-of-theart translation-invariant point cloud convolution, the performance is also consistent across three scenarios. For rotation-invariant convolutions, our method outperforms the accuracy of RIConv [46], SPHNet [26], and ClusterNet [5] by a good margin. Our method is slightly more accurate than SFCNN [30] but much more consistent.

Ablation Studies
Network Design. We conduct an ablation study on the ModelNet40 dataset for the classification task (Table 2). We examine four settings in our convolution: (1) the globally weighted LRFs with main orientation (Weight), (2) the use of main orientation to resolve the LRF sign ambiguity (O vector), (3) the use of anchors for global context (Anchor), and (4) the data augmentation with rotations used for the training (Rot. Aug.). Five models (A-E) are used to study the effects of these settings by turning them on/off. Model A is our baseline setting with all settings on. Model B tests the importance of the weights for computing LRFs and the main orientation. It can be seen that without such weights, the accuracy decreases to 87.1%. The main reason is that the LRFs and the main orientation are more noisy and less repeatable in such case. Next, in model C we further turn off the O vector to test the stability of the LRFs without sign correction. The accuracy further decreases to 86.7%. This verifies that constructing stable LRFs is key to good network performance. In model D, we turn off the global anchor. In this case, only the local points are used for feature extraction. Thanks to the LRFs, the local features are still effective despite of mild accuracy drop. In model E, we test the performance without rotation augmentation scheme during the training procedure. We find the accuracy is not affected by data augmentation as GCAConv already achieves exact rotation invariance.
Comparison to learned LRFs. It is generally tempting to learn the LRFs to design rotation-invariant convolution.
Here we compare this method to our proposed LRFs. We use a two-layer MLP to predict the LRFs and then use them to transform the input point coordinates into a local coordinates before proceeding for convolution as described in the main paper. We found that predicting LRFs works well in z/z and SO3/SO3 mode, with both scenarios achieved accuracies of 89.3% and 89.2%, respectively. However, using data-driven LRFs makes the convolution only rotationaware, but not exactly rotation-invariant. Such convolution fails to generalize to unseen rotations in the z/SO3 scenario with the accuracy of 36.2%.

Number of Anchors.
From the ablation studies, we see that without global anchors, the performance is decreased.
Here, we further analyze the effects of the number of anchors by investigating the performance on ModelNet40 with a different number of anchors. The qualitative results are shown in Table 3. We can see that with only one anchor, the accuracy decreases to 87.3%, but still higher than RI-Conv which is around 86.4%. This shows the advantages of global information. With the number goes on, the accuracy also increases. We empirically use eight anchors as it strikes a balance between the amount of global information retained and the running time.

Object Part Segmentation on ShapeNet
In addition to object classification, we evaluate our method to output a label for each point in the point cloud, resulting in object part segmentation. We use the 3D models in ShapeNet [4] to train our network with point size of 2048 in this task. It takes roughly 36 hours for the training to complete 300 epochs.
The quantitative and qualitative results are shown in Table 4 and Figure 4, respectively. In this task, we achieve start-of-the-art results for both SO3/SO3 and z/SO3 scenarios. Our method outperforms RIConv [46] by almost 2% of accuracy. From Figure 4, we can clearly see that with z/SO3 mode methods like PointNet++ and SpiderCNN can not work well. This is easy to explain as these methods use the raw xyz coordinates as input for training, thus cannot well understand unknown rotations. RIConv [46] [46], PointNet++ [29], SpiderCNN [42] under the z/SO3 rotation mode (from the left column to the right column).
better as it converts xyz coordinates into rotation invariant format like distances and angles before training. However, it still has difficulties in recognizing the boundaries while our method can treat these regions well by incorporating global context information (see column 2 and 3 in Figure 4).

Shape Retrieval
A popular evaluation of rotation invariance on 3D shape is the shape retrieval task [32]. Here we conducted experiments on ShapeNet Core [41], following the perturbed protocol of the SHREC17 3D shape retrieval contest [32] and the experiment setting of SFCNN [30]. We use the same output features from the bottleneck layer in the network (similar to features used in the classification task; see Figure 3). We compare with methods proposed in SHREC17 [11,34,3] and two recent methods on rotationinvariant convolution [9,30]. The results are shown in Table 5. It can be seen that our method achieves the state-ofthe-art accuracy, outperforming previous methods for most evaluation metrics.  Table 5. Comparisons of 3D shape retrieval on the ShapeNet Core [41]. The accuracy (%) is reported based on the standard evaluation metrics including precision, recall, f-score, mean average precision (mAP) and normalized discounted cumulative gain (NDCG).  Table 6. Comparisons of the normal estimation on ModelNet40.
The accuracy is reported on three test cases: training and testing with z/z, SO3/SO3 and z/SO3 rotation, respectively. Our method has good accuracy and lowest accuracy deviation in all cases. Figure 5. Qualitative comparisons of normal estimation for GCA-Conv, RIConv [46], RS-CNN [22], and PointNet++ [29] under the z/SO3 rotation mode (from the left column to the right column).

Normals Estimation
Normals estimation for point clouds is instrumental in many applications such as point cloud rendering, feature extraction, and surface reconstruction. Here we conduct normals estimation on point clouds using the ModelNet40 dataset. For each model, we uniformly sample 1024 points from the original data for training. We compute a loss based on the cosines between the predicted unit vectors and the ground truth normals to guide the training. Our results are shown in Table 6.
In this table, our method achieves the best consistency in predicting normals across three test scenarios. In SO3/SO3 and z/SO3 case, our method is the most accurate. It outperforms other methods by a wide margin. The predicted normals are depicted in Figure 5. We quantize the errors by calculating the angles between the predicted and ground truth normals. In Figure 5, the blue and red vectors depict normals with less than 30 • and greater than 90 • of error. It can be seen that our method is the most accurate visually. It is worth noting that RIConv [46] performs poorly in the normals estimation task because it uses rotation-invariant features that discard the reference coordinate frames, and so the normals of RIConv is not globally consistent.

Conclusion
In this work, we introduced a novel approach to design rotation-invariant convolution for 3D point clouds. We show that building robust and repeatable local reference frames is critical to boosting the performance of rotationinvariant object classification. In this task, our newly proposed convolution can match the performance of state-ofthe-art translation-invariant convolutions. Our work opens up opportunities to narrow down the performance gap between rotation-invariant and translation-invariant convolution in general 3D deep learning, making robust convolutions for 3D point clouds feasible.
Here we detail a few potential ideas for future research. First, while our proposed method achieves good performance, it is not clear whether local reference frames can be set robustly by a neural network. There is a recent work [48] that attempts to solve this problem, but the performance on object classification needs further investigation. Second, generalizing point cloud convolutions and object classification to support non-rigid transformations and deformable objects could further improve overall robustness. Finally, more thorough benchmarking rotation-invariant convolutions with real-world data [36] is necessary to understand the impact of such data on the learning of rotation-invariant features.

A.1. Baseline 1: Predicting LRFs
As mentioned in the main text, it could be tempting to learn the LRFs to design rotation-aware convolution. For completeness, here we discuss this baseline again. We use a two-layer MLP to predict the LRFs and then use them to transform the input point coordinates into a local coordinates before proceeding for convolution as described in the main paper. We found that predicting LRFs works well in z/z and SO3/SO3 mode, with both scenarios achieved accuracies of 89.3% and 89.2%, respectively. However, using data-driven LRFs makes the convolution only rotationaware, but not exactly rotation-invariant. Such convolution fails to generalize to unseen rotations in the z/SO3 scenario with accuracy 36.2%.

A.2. Baseline 2: Pooling with Sign-Ambiguous LRFs
Taking the insight from Baseline 1, we proceed to only resolve the ambiguity in constructing the LRFs using learning while using the covariance matrices and their eigenvectors to determine the LRF axes. Here the signs of the LRFs axes are not determined, and instead of resolving this ambiguity as what described in the main paper, here we establish all eight candidates of the LRFs and perform feature learning with all such candidates. The final output features are pooled from the features of each individual candidate. We call this convolution in this baseline the Pooling Convolution (PoolConv).
More illustrations can be found in Figure 6. In general, PoolConv can produce the same accuracy (89.1%) as our method but it has much higher computation. We measure network complexity by the number of trainable parameters, floating point operations (FLOPs), and running time to analyze the network efficiency. With batch size 16, point cloud size 1024 from the ModelNet40 dataset, we report the statistics in Table 7. Given the minor performance difference but significantly more parameters and training time, PoolConv is not as efficient as our proposed method.

B. Repeatability
We further clarify the repeatability of the LRFs as it serves as the backbone for our feature learning. We follow Guo et al. [12] to conduct this experiment (see their section 3.3). Noted that there are also methods that solve LRFs for mesh such as MeshHog [45] and RoPS [12]. In this study we assume no normal vectors or triangle faces so we omit such methods in our comparison. We use six models from the Stanford 3D Scanning Repository [6] (Figure 7) scenes are created by resampling the models down to 1/2 of their original mesh resolution with Gaussian noise added (0.1 mesh resolution). From each model, 1000 points are randomly selected and their correspondences in the scene are obtained by searching the closest point in the Euclidean space. Let's denote the pair of points as (p si , p mi ) from scene and model respectively. The LRFs for these two points are computed as LRF si and LRF mi . To measure the similarity between LRF si and LRF mi , we use the error evaluation metric provided by Mian et al. [23]: Ideally, e i is zero when there is no error. We compare with four existing methods: EM [24], Mian [23], SHOT [35], and P [25]. The results are shown in Figure 8, where the horizontal axis indicates the angular error range and the vertical axis represents the percentage of points. The more points fall into left lower error range, the better of the methods. As can be seen, our proposed LRFs have much more low-range angular errors than other methods, but has significantly less high-range errors. This means that our LRFs varies more slowly, and thus allows more consistent predictions.

C. Per-Class Accuracies
To further demonstrate the advantages of our proposed convolution operator, we show the per-class accuracies for both classification and part segmentation tasks in this section.

C.1. Per-Class Accuracies for Object Classification on ModelNet40
The per-class accuracies for object classification on ModelNet40 under z/SO3 scenario is shown in Table 8. Our method outperforms previous methods significantly (ranking 1st in 32 out of 40 classes).

C.2. Per-Class Accuracies for Part Segmentation on ShapeNet
Here, we also show the per-class accuracies for part segmentation under the SO3/SO3 and z/SO3 scenarios in Table 9 and Table 10 respectively.     Table 10. Per-class accuracy of object part segmentation on the ShapeNet dataset in z/SO3 scenario. Our method significantly outperforms previous methods thanks to the rotation invariance features from our convolution operators.