LSPConv: local spatial projection convolution for point cloud analysis

Network architecture

We design the network architectures for point segmentation tasks and cloud classification using the proposed LSPConv layer.

Segmentation. We design two network architectures for part segmentation tasks and indoor segmentation using the proposed LSPConv layer. Both of them are encoder-decoder residual architecture, which is composed of a network for extracting point cloud information and a classification header for segmentation.

For part segmentation, the encoder is composed of four LSPConv layers with different point resolutions, and each residual layer is stacked by one residual block. The decoder utilizes the features from four different resolution point cloud layers and utilizes a shared-MLP for classification.

For indoor segmentation, the encoder is composed of four LSPConv layers with different point resolutions, and each residual layer is stacked with two residual blocks. The decoder is composed of four up-sampling layers with different resolutions and an embedding layer as a classification header. Each-up sampling layer integrates the semantic information from the residual blocks in the encoder with the same resolution, ensuring the effective transmission of fine-grained semantic information.

Classifacation. The classification network has the same encoder component as the segmentation model. We employ dynamic graph structures instead of downsampling and interpolation for sparser point clouds in the ModelNet40 and ScanObjectNN classification datasets. Specifically, rather than being fixed using geographical locations, the network structure is changed in each layer based on feature similarity across points.

The network architecture is shown in Fig. 2.

Feature weight assignment module

In the previous process of local information aggregation, the strength of the relationship between the feature vectors of different neighboring points and the feature vectors of the central query point is not considered. To address this issue, we propose a scheme of artificially setting a weight parameter to weigh the feature vectors of different neighbor points depending on the relative distance of the pair of points. For a set of local point clouds, its center query point is defined as point $i$ and one of the neighbor points is denoted as point $j$, $j\in \mathbf{N}(i)$. The feature of the $j$-th point after weighting can be represented in the following formula:

(1) $$f_j^{\mathrm{\prime }}=w_{ij}{f}_{j}j\in \mathbf{N}(i),$$where $f_j$ denotes the feature of the $j$-th neighbor point, $w_{ij}$ denotes the weight relative to the center point, and $f_j^{\mathrm{\prime }}$ denotes the output feature of it after the process of the Feature Weight Assignment Module. Here, $w_{ij}$ is a function of the distance between the $j$-th neighbor point and the center point $i$. The corresponding $j$-th points are multiplied by $w_{ij}$ to adjust the feature of each neighbor point.

We have introduced a set of three Feature Weight Assignment modules, each designed as a function of relative distance. This innovative approach allows for the effective assignment of distinct weights to points located at varying distances from the central point. This adaptability in weight assignment facilitates enhanced modeling of the point cloud’s spatial characteristics.

Linear function distance weighting module. The linear function distance weighting module utilizes the linear distance to weight the feature vector, which utilizes the $L_2$ norm of the relative coordinate position of each neighbor point as the weight of the feature vector of each neighbor point, as shown in the following formula:

(2) $$w_{ij}=\left||p_j-p_i\right||{}_{2}j\in \mathbf{N}(i),$$where $p_i$ and $p_j$ denote the coordinates of the center point and its $j$-th neighbor point, $\left||\cdot \right||{}_2$ denotes the $L_2$ norm of the vector. With this setting, points further away from the center have greater weight, which means that the weight is positively correlated with the relative distance, forcing the central point to collect information from distant points to enrich its own features.

Exponential function distance weighting module. The exponential function distance weighting module utilizes the exponential distance to weight the feature vector, which utilizes the exponential function of the $L_2$ norm of the relative coordinate position of each neighbor point as the weight of the feature vector of each neighbor point, as shown in the following formula:

(3) $$w_{ij}=e^{-\left||p_j-p_i\right||{}_2}j\in \mathbf{N}(i).$$

Radial basis function distance weighting module. The radial basis function distance weighting module utilizes the radial basis function to weight the feature vector and utilizes the radial basis function of the relative coordinate position of each neighbor point as the weight of the feature vector of each neighbor point. The radial basis function is a kind of scalar function that is symmetric in the radial direction, which is defined as a monotone function of Euclidean distance from any point in space to a center. In our method, the radial basis function is utilized as the weighting function, as shown in the following formula:

(4) $$w_{ij}=k\left(\left||p_j-p_i\right||\right)=e^{-\frac{{\left||p_j-p_i|\right|}_2^2}{2{\sigma }^2}}j\in \mathbf{N}(i),$$the variance of the radial basis function is determined by the parameter $\sigma$. The larger the value $\sigma$, the wider the frequency band of the radial basis function and the better the smoothness is. By adjusting the smoothness parameter $\sigma$, a compromise can be achieved between feature over-smoothing and under-smoothing. Due to the non-uniformity of the density of the point cloud, the distribution from the neighboring points to the center point is different for different center points, therefore different parameters should be selected for different center points to ensure that the Radial basis function will not produce over smooth and under smooth. To select the appropriate $\sigma$ for different center points, the learnable parameter $\sigma$ is designed according to the distribution from the neighbor point to the center point. The expression of $\sigma$ is as follows:

(5) $$\sigma =Linear\left(max\left(\left||p_j-p_i\right||{}_2\right)\right)j\in \mathbf{N}(i).$$

The design of the exponential function distance weighting module and the radial basis function distance weighting module is basically similar on a logical level, which means that the weight is negatively correlated with the relative distance. The central point is required to pay more attention to the features of its closer neighbors, for in common reality, the closer points tend to be of the same type, which emphasizes the consistency of a set of points. The weights of the above three methods as a function of distance are qualitatively depicted in Fig. 3.

Experiments show that the Feature Weight Assignment Module can significantly improve the accuracy of the model, which will be described in detail in the Evaluation section.

Anisotropic relative feature encoding module

The point cloud local feature aggregation module has the functions of information combing and information collection, whose performance directly affects the effectiveness of the network. Therefore, the construction of an effective point cloud local feature aggregation module is the most important issue in building the whole network. In our method, the proposed Anisotropic Relative Feature Encoding Module applies both relative spatial coordinates and relative feature information to encode the feature of the neighbor point, which significantly amplifies the heterogeneity of each neighboring point, effectively enhancing the model’s capacity to capture the diversity of information among adjacent points. The general formula of the local aggregation operator is:

(6) $$\widehat{f_i}=R\left(G\left\{\left(\mathrm{\Delta }{p}_{ij},\mathrm{\Delta }{f}_{ij},f_j\right)\mid j\in \mathbf{N}(i)\right\}\right),$$where $G(\cdot )$ represents the encoding function, which is used by the local aggregation layer to encode the relative coordinates of each point $i$ and the $j$-th point into a new feature vector. To fuse all the transformed neighborhood features to form the output features of point $i$, we use $R(\cdot )$ as the reduction function, which can use the maximum, mean, or sum. $f_j$ is defined as the feature of the $j$-th point, $\mathrm{\Delta }{p}_{ij}$ is defined as the coordinate of the $j$-th point relative to the $i$-th point, and $N(i)$ is defined as the neighborhood of the $i$-th point.

In order to calculate the aggregation weight of all adjacent points, a convolution filter is defined at any relative position based on the adaptive weight method, as shown in the following formula:

(7) $$G\left(\mathrm{\Delta }{p}_{ij},\mathrm{\Delta }{f}_{ij},f_j\right)=M\left(H\left(\mathrm{\Delta }{p}_{ij}\right)\odot (J\left(\mathrm{\Delta }{f}_{ij}\right)\odot I\left(f_j\right)\right).$$

Here, $H(\cdot )$ denotes a repetition function, which is introduced to repeat the coordinate information of three dimensions several times until its dimension is approximately equal to the feature dimension. $\odot$ denotes the Hadamard product, $I(\cdot )$, $M(\cdot )$ and $J(\cdot )$ were defined as the shared-MLP.

With the Feature Weight Assignment Module, the general formula of the local aggregation operator finally becomes:

(8) $$G\left(\mathrm{\Delta }{p}_{ij},\mathrm{\Delta }{f}_{ij},f_j\right)=M\left(H\left(\mathrm{\Delta }{p}_{ij}\right)\odot (J\left(\mathrm{\Delta }{f}_{ij}\right)\odot I\left(f_j^{\mathrm{\prime }}\right)\right).$$

It can be seen from Eq. (8) that $\mathrm{\Delta }{p}_{ij}$ and $\mathrm{\Delta }{f}_{ij}$ assign different relative feature information to different neighboring points, which distinct one certain neighbor point with others, exhibiting anisotropy. At the same time, employing only relative coordinates instead of absolute coordinates for encoding also ensures translation invariance, which is more suitable for point cloud scenes under different spatial locations.

Local spatial projection module

In our method, a point in space and its neighbors found by the K-nearest neighbor (KNN) algorithm is considered as a local point cloud block. Existing methods merely stack the features of neighboring points together as input features. We argue that this kind of approach is insufficient because it treats the local point cloud as a set of discrete points, lacking a comprehensive description of the overall geometric characteristics of the local point cloud. In order to analyze the integrity of local point cloud blocks, we designed a point cloud local information extraction module called the Local Spatial Projection Module, which models the geometric shape features of a point cloud through the utilization of vector projection and reassembly methods.

In the construction of the point cloud shape information extraction module, the center point of the local point cloud block is first used as the origin to build up a Cartesian coordinate system and regards the relative position of each point in the local point cloud block to the origin as the relative position vector of each point. Then, we divide the space Cartesian coordinate system into six axes: $x$ positive semi-axis, $x$ negative semi-axis, $y$ positive semi-axis, $y$ negative semi-axis, $z$ positive semi-axis, $z$ negative semi-axis. In order to obtain the complete representation of the local point cloud, the module projects the vector represented by the relative coordinate of each neighbor point to the six axes and sums the signals on each axis. The above process can be represented by the following formula:

(9) $$s_{i+}^l={\sum }_{j}max\left(0,\mathrm{\Delta }{p}_{ij}^l\right),j\in \mathbf{N}(i),l=x,y,z,$$

(10) $$s_{i-}^l={\sum }_{j}max\left(0,-\mathrm{\Delta }{p}_{ij}^l\right),j\in \mathbf{N}(i),l=x,y,z,$$where $p_i$ and $p_j$ denote the coordinates of the center point and its $j$-th neighbor point, $\mathrm{\Delta }{p}_{ij}^l$ denotes the components of the relative coordinate vector on the $l$-axis, $l=x,y,z$, and $s_{i+}^l$/ $s_{i-}^l$ denote the signal obtained by the summation operator on the $l$ positive/negative semi-axis.

After the projection operation, the original space shape is obtained. To reduce the sensitivity of the network to the change in point cloud density, the original space shape composition of signals projected on the six axes is normalized.

We proposed three normalization methods:

$L_2$ normalization The first method utilized $L_2$ normalization to normalize the original space shape, as shown below:

(11) $$s_{i\ast }^l=\frac{s_{i\ast }^l}{\sqrt{{\sum }_m{s}_{i+}^{m2}+{\sum }_m{s}_{i-}^{m2}}}m=x,y,z\ast =+/-,$$where $s_{i\ast }^l$ denotes the signal obtained by the summation operator on the $l$ positive/negative semi-axis and $s_{i\ast }^l$ is defined as the normalized signal on the $l$ positive/negative semi-axis.

Adaptive normalization. The second method utilized a multilayer perceptron to adaptively adjust the length of each axis of the original space shape to achieve a better spatial representation, as shown below:

(12) $$s_i=LeakReLu(BN(Linear(s_i))),$$

(13) $$s_i=ReLu(BN(Linear(s_i))),$$

$s_i$ is the initial input, $s_i$ is the middle represents and $s_i$ is the final result obtained. Here we employ the $ReLu$ activation function to ensure that the output signal of each axis is non-negative.

Sharp normalization. The third method is called sharp normalization. This method normalizes all the non-zero signals to 1 and remains the zero signal, which can be easily represented by the following formula:

(14) $$s_{i\ast }^l=\{\begin{array}{c}0,s_{i\ast }^l=0\hfill \\ 1,s_{i\ast }^l>0\hfill \end{array}.$$

By this design, the network is principally devoted to the distinction between points on the boundary and points in the interior. The sharp normalization method is proven to be efficient for indoor segmentation.

Different normalization methods are qualitatively depicted in Fig. 4. After the normalization, the normalized space shape, the relative position coordinate information, and color information are input into the neural network as the basic information of the point cloud for training. Note Local Spatial Projection Module exclusively captures the local shape of the original point cloud and is not applied to the downsampled point cloud. This design is because, while downsampling aggregates neighboring features and expands the receptive field, it also disrupts fine-grained geometric structures and appearances. Therefore, it is advisable to use this module exclusively at the highest resolution. In the Evaluation section, it is proved that adding space shape can effectively improve the network’s ability to capture the local information of the point cloud compared with simply inputting the relative position coordinate information.

Part segmentation

Data. In order to improve our model, we do more things. On the ShapeNetPart dataset (Yi et al., 2016), we further test our model for the part segmentation task. A total of 16,881 shapes totaling 16 categories make up this dataset, with 14,006 used for training and 2,874 for testing. Each point has a label assigned from a pool of 50 parts, and each point cloud has between two and six parts. We replicate Qi et al. (2017b)’s experimental setup and use their supplied data for benchmarking. Each form has 2,048 points sampled from it. In addition to the 3D coordinates, the input attributes also include the point normal.

Implementation. We select $L_2$ normalization for Local Spatial Projection Module to normalize the space shape and select radial basis function distance weighting module for Feature Weight Assignment Module to assign weights to different neighbor points for part segmentation task. Based on Pointnet (Qi et al., 2017a), a one-hot vector representing the different categories for each point is used to compute the segmentation results. Other training parameters are the same as for classification. All layers take 20 for the number $k$ of neighborhood size. To obtain the global feature, the max-pooling function is chosen. We select LeakyReLU for the activation function with a negative slope setting to 0.1 and batch normalization. We use SGD optimizer with momentum setting to 0.9 (Wang et al., 2019b). We apply a cosine annealing schedule to adjust the learning rate during the training. The initial learning rate is 0.1 and is decreased until 0.001 (Loshchilov & Hutter, 2016). The batch size for the training models is 32. We use PyTorch implementation and train the network on a Tesla A40 GPU.

Results. In Table 1, we present the mean instance IoU (mIoU) and mean class IoU (mcIoU). The IoU of a shape is calculated by averaging the IoU of each part, in accordance with the evaluation scheme of Qi et al. (2016). By averaging the IoUs overall testing instances, the mean IoU (mIoU) is calculated. The mean IoU across all form categories is known as the class IoU (mcIoU). The mean IoU of LSPconv on ShapeNetPart dataset reaches 86.6%, surpassing the previous competitive methods PointMLP (Ma et al., 2022) and Kpconv (Thomas et al., 2019) 0.2% and 0.3% respectively. We also exhibit the results of class-based segmentation. Comparing LSPconv to other approaches, it performs at the cutting edge.

Indoor segmentation

Data. We evaluate our model on Stanford Large-Scale 3D Indoor Spaces Dataset (Armeni et al., 2016) (S3DIS). This dataset consists of 271 rooms in total. Each room includes six 3D scan point clouds for indoor areas, belonging to 13 semantic categories. For a common evaluation protocol (Tchapmi et al., 2017; Qi et al., 2017a; Thomas et al., 2019), we select Area 5 to test our model because it is not in the same building as other areas.

Implementation. We select Sharp normalization for Local Spatial Projection Module to normalize the space shape and select radial basis function distance weighting module for Feature Weight Assignment Module to assign weights to different neighbor points for indoor segmentation task. The massive indoor scene datasets lead to further challenges, including the larger scale of the scene in a real environment with a lot of further noise and distinct outlines. Therefore, we follow the experimental settings of KPConv (Thomas et al., 2019), and train our network by applying randomly sample clouds in spheres. The subclouds consist of more points with various sizes and are stacked into batches for training our network much further. During the test phase, spheres are equably picked in the scenes. To ensure the accuracy of the test, we ensure that every point is examined several times by using a voting scheme. The input point attributes contain the RGB colors and the original heights. We use SGD optimizer with momentum set to 0.98 and an initial learning rate of 0.01. The learning rate decays by multiplying ${0.1}^{0.02}$ in each epoch. To prevent gradient explosion, the gradient clipping threshold value is set to 100. We use PyTorch implementation and train the network on a Tesla A40 GPU. Differing from the part segmentation setting, we omit the $J\left(\mathrm{\Delta }{f}_{ij}\right)$ in Anisotropic Relative Feature Encoding Module for such a setting that attains better performance in the experiment.

Results. In Table 2, we present the average classwise intersection over union (mIoU), average classwise accuracy (mAcc), and average classwise accuracy (OA). Each class’s IoU result is also supplied. LSPconv reaches 90.2%, 74.0%, and 68.2% under OA, mAcc, and mIoU metrics respectively. The performance exceeds that of previous classic models such as KPConv (Thomas et al., 2019), PAconv (Xu et al., 2021) and AGConv (Zhou et al., 2021). The remarkable performance on difficult large scene semantic segmentation datasets further demonstrates the effectiveness of the proposed local spatial projection module, anisotropic kernel, and weight assignment module.

Point cloud classification

Data. We test our model using two datasets: ModelNet40 (Wu et al., 2015) and ScanObjectNN (Uy et al., 2019) to Validate the classification ability of LSPConv.

ModelNet40 is subdivided into 40 categories and consists of 12,311 meshed CAD models. A total of 9,843 CAD models are intended to train our model, while 2,468 CAD models are intended to test it. We sample 2,024 points uniformly for each object and use the $(x,y,z)$ coordinates of them as input.

While ModelNet40 has long been considered the standard benchmark for point cloud analysis, the rapid evolution of point cloud analysis techniques may render it inadequate for assessing the capabilities of modern methods. In light of this, we have also undertaken experiments using the ScanObjectNN benchmark. ScanObjectNN comprises approximately 15,000 real-world scanned objects, meticulously classified into 15 distinct categories, with a total of 2,902 unique object instances. The presence of occlusions and noise in ScanObjectNN presents formidable challenges to existing point cloud analysis approaches. For our experiments, we have chosen to tackle the most challenging perturbed variant, denoted as PB_T50_RS.

Implementation. We select $L_2$ normalization for the Local Spatial Projection Module to normalize the space shape and select the radial basis function distance weighting module for the Feature Weight Assignment Module to assign weights to different neighbor points for the point cloud classification task. We recompute the graph in accordance with the network configurations (Wang et al., 2019b) based on the similarity of the feature sets in each layer. For all layers, the $k$ of neighborhood size is set to 20. The multiscale features are aggregated using shortcut connections and fed forward to a shared fully connected layer. Max-pooling is used to acquire the global feature. LeakyReLU and batch normalization are used on all levels. We utilize AdamW optimizer and apply a cosine annealing schedule to adjust the learning rate during the training. The initial learning rate is 0.001 and is decreased until 0.0001 (Loshchilov & Hutter, 2017). Each training model has a batch size of 32. We train the network on a Tesla A40 GPU using the PyTorch implementation. The data augmentation procedure includes point shifting, scaling, and perturbation.

Results The mean class accuracy (mAcc) and total accuracy (OA) are the evaluation metrics for both datasets. In Tables 3 and 4, we display the classification results on the ModelNet40 dataset and the ScanObjectNN dataset respectively. For the ModelNet40 dataset, we compare the input data types and the number of points connected to each method. With a limited input size of 2 k points, our model obtains a desirable outcome on the ModelNet40 dataset. The accuracy achieves 90.5% and 93.2% under mAcc and OA metrics respectively, almost on par with the advanced PointNeXt algorithm. For the ScanObjectNN dataset, accuracy has reached 76.7% and 80.0% in terms of mAcc and OA metrics respectively under a lightweight and simple model design. The experimental results conducted on these two datasets indicate that our algorithm has a satisfactory performance in classification tasks and exhibits a competitive edge.

Efficiency

We provide the parameter values and corresponding network performances in Table 5 to contrast the complexity of our model with previous influential methods. These models are for the classification task on ModelNet40. LSPconv has very few additional learnable parameters because the $L_2$ normalization in Local Spatial Projection Module does not introduce learnable parameters and the radial basis function Feature Weight Assignment Module just requires training an MLP to attain $\sigma$. From the table, it is evident that our model achieves a commendable performance, delivering an overall accuracy of 93.2% while utilizing only 1.8M parameters. This balance between accuracy and efficiency is comparable to leading-edge algorithms.

The effect of each proposed module

To verify the specific contribution of each module, we tested each module item by item. The results are summarized in Table 6. When introducing Feature Weight Assignment Module, $w_{ij}$ will be applied to $f_j$, $f_j^{\mathrm{\prime }}$ will be utilized instead of the original $f_j$. When introducing Anisotropic Relative Feature Encoding Module, $H\left(\mathrm{\Delta }{p}_{ij}\right)$ and $J\left(\mathrm{\Delta }{f}_{ij}\right)$ will be applied Hadamard product to $I(f_j^{\mathrm{\prime }})$. When introducing Local Spatial Projection Module, the $L_2$ normalized space shape will be modeled for the first layer instead of just utilizing $\mathrm{\Delta }{p}_{ij}$ for local geometric information description. The first line exhibits the experimental results of applying a symmetric kernel without introducing any of the proposed modules. The second row shows that equipped with the proposed Feature Weight Assignment (FWA) Module, the performance of the network has been boosted from 81.8% and 85.2% to 83.2% and 85.7% under mcIoU and mIoU on ShapeNet dataset. The third row demonstrates that including the proposed Anisotropic Relative Feature Encoding (ARFE) Module into the network improves the result to 83.8% and 86.4% in terms of mcIoU and mIoU, demonstrating its effectiveness of anisotropy kernel for enhancing the performance of the network. Finally, as shown in the fourth row, when applying Local Spatial Projection Module (LSP) for building a better representation of local spatial information, the results are improved to 84.2% and 86.6% in terms of mcIoU and mIoU.

Feature weight assignment module

We discuss the different designs of the Feature Weight Assignment Modules. Three different Feature Weight Assignment Modules are designed to assign weights to each neighbor point. We tested the performance of these modules separately. The introduction of exponential function can improve the segmentation accuracy by 0.2% under the mcIoU index, and the introduction of radial basis function can improve the segmentation accuracy by 0.5% and 0.2% under the mcIoU and mIoU indexes, respectively. This proves that the strategy of assigning different weights to the features of different neighbor points according to their distance is effective. Generally, the weight is negatively correlated with the distance. The learnable parameter $\sigma$ set by the radial basis function adaptively adjusts the smoothness of the weight distribution function, which can better find better weights for different neighbor points. As shown in Table 7, LSPConv can efficiently assign weights and obtain the best performance when the radial basis function distance weighting module is applied.

Relative information selection

In LSPConv, we imply relative information $\mathrm{\Delta }{p}_{ij}$ and $\mathrm{\Delta }{f}_{ij}$ for local feature modeling. As shown in Table 8, $\mathrm{\Delta }{p}_{ij}$ and $\mathrm{\Delta }{f}_{ij}$ are both utilized in order to enhance the difference between different neighbor points, which means the kernel could show anisotropy to model the local feature of the point cloud. We explore the performance of different inputs of relative information. When only $\mathrm{\Delta }{f}_{ij}$ is introduced, the accuracy is achieved 82.6% and 85.6% under mcIoU and mIoU indexes, respectively. Similarly, when only $\mathrm{\Delta }{p}_{ij}$ is introduced, the accuracy is achieved 84.0% and 86.3% under the mcIoU and mIoU indexes respectively. The experimental results exhibit that compared with utilizing $J\left(\mathrm{\Delta }{f}_{ij}\right)$ and $H\left(\mathrm{\Delta }{f}_{ij}\right)$ alone, simultaneously applying two relative information, $\mathrm{\Delta }{p}_{ij}$ and $\mathrm{\Delta }{f}_{ij}$, is the best way to encode the features of each point, with the mcIoU and mIoU indexes achieving 84.2% and 86.6% respectively.

Notice that the module exhibits the strongest anisotropy when all relative features are utilized and consequently the best results are obtained.

Local shape information representation

Furthermore, we discuss the different designs of the local shape information representation. There are three different Local Spatial Projection modules designed to model the local shape of the point cloud. We tested the performance of these three modules separately, as shown in Table 9. Experiments were carried out on different Local Spatial Projection modules. The adaptive normalization based Local Spatial Projection module is trained to adaptively scale the original space shape, compared to just using $\mathrm{\Delta }{p}_{ij}$, The performance of part segmentation is improved by 0.3% and 0.2% under mcIoU and mIoU indexes. $L_2$ regularization of original space shape based on the local spatial projection module of $L_2$ normalization, the performance of part segmentation is improved by 0.5% and 0.4% under mcIoU and mIoU indexes. The Sharp normalization method is more appropriate for scene semantic segmentation, but embedding it in part segmentation tasks still works, and the performance of part segmentation has improved by 0.2% and 0.1% under the mcIoU and mIoU metrics. The test results show that the proposed Local shape information representation module can better represent the local spatial information of the point cloud compared with simple $\mathrm{\Delta }{p}_{ij}$. The experimental results based on ShapeNet dataset show that all three proposed local spatial projection modules are effective, among which the $L_2$ normalization is the most effective. Notice that the $L_2$ normalization method performs better than the sharp normalization method on ShapeNet dataset, while The experiment shows the opposite results on S3DIS dataset. To this end, the $L_2$ normalization method is applied for part segmentation and classification while the sharp normalization method is selected for indoor segmentation.

Number of neighbor points

We conduct experiments to find out the influence of the number of nearest neighbors, as shown in Table 10. The result shows that the model achieving 84.2% and 86.6% under mcIoU and mIoU indexes, performs best when the number of neighbor points $k$ = 20. When the number of neighbors is too small, such as $k$ = 5 or $k$ = 10, the receptive field is insufficient and the local semantic information cannot be fully mined. We find that when $k$ is too large ( $k$ = 40), the performance of the model deteriorates to 84.0% and 86.4% under mcIoU and mIoU indexes. It is mainly because a large receptive field introduces noise from other parts, resulting in ambiguous local information and a lack of consistency in the point cloud. This result confirms that appropriately increasing the number of neighbor points can expand the receptive field, which improves the ability of the operator to capture the geometric structure and represent local information.