{'fraction_non_alphanumeric': 0.023833603020496225, 'fraction_numerical': 0.008461434735706581, 'mean_word_length': 4.9592205705102455, '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': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Learning Graph-Convolutional Representations for Point Cloud Denoising

Point clouds are an increasingly relevant data type but they are often corrupted by noise. We propose a deep neural network based on graph-convolutional layers that can elegantly deal with the permutation-invariance problem encountered by learning-based point cloud processing methods. The network is fully-convolutional and can build complex hierarchies of features by dynamically constructing neighborhood graphs from similarity among the high-dimensional feature representations of the points. When coupled with a loss promoting proximity to the ideal surface, the proposed approach significantly outperforms state-of-the-art methods on a variety of metrics. In particular, it is able to improve in terms of Chamfer measure and of quality of the surface normals that can be estimated from the denoised data. We also show that it is especially robust both at high noise levels and in presence of structured noise such as the one encountered in real LiDAR scans.


Introduction
A point cloud is a geometric data type consisting in an unordered collection of 3D points representing samples of 2D surfaces of physical objects or entire scenes. Point clouds are becoming increasingly popular due to the availability of instruments such as LiDARs and the interest in exploiting the richness of the geometric representation in challenging applications such as autonomous driving. However, the acquisition process is imperfect and a significant amount of noise typically affects the raw point clouds. Therefore, point cloud denoising methods are of paramount importance to improve the performance of various downstream tasks such as shape matching, surface reconstruction, object segmentation and more.
Traditional model-based techniques [1,2,3,4,5,6] have typically focused on fitting a surface to the noisy data. Such techniques work well in low-noise settings but they usually suffer from oversmoothing, especially in presence of high amounts of noise or geometries with sharp edges. Given the success of learningbased methods, in particular those exploiting deep neural networks, in a wide variety of tasks, including image denoising and restoration problems [7,8], a few works have recently started exploring point cloud denoising with deep neural networks. The most challenging problems in processing point clouds are the lack of a regular domain, such as a grid, and the fact that a point cloud is just a set of points and any permutation of them still represents the same data. Any learning-based method must therefore learn a permutation-invariant function that can deal with data defined on an irregular domain. This is a significant challenge that point cloud processing algorithms tackled by either approximating the irregular domain with a grid, e.g. by building voxels, or building a permutationinvariant function as a composition of operations acting on single points (e.g., size-1 convolution) and a globally symmetric function (e.g., a max pool) as done by PointNet [9]. Neither of these solutions is completely satisfactory. The former introduces an undesirable approximation, while the latter lacks the expressiveness of convolutional neural networks (CNN) where the convolution operation extracts features that are localized as functions of the neighborhood of a pixel and features of features are assembled in a hierarchical manner by means of multiple layers, progressively expanding the receptive field. Recently, graph convolution [10] has emerged as an elegant way to build operators that are intrinsically permutation-invariant and defined on irregular domains, while also exploiting some of the useful properties of traditional convolution, such as localization and compositionality of the features as well as efficient weight reuse. In particular, spatial-domain definitions of graph convolution have been recently applied in several problems involving point clouds such as classification [11], segmentation [12], shape completion [13] and generation [14]. Notably, the point cloud denoising problem has yet to be addressed with graph-convolutional neural networks.
In this paper, we propose a deep graph-convolutional neural network for denoising of point cloud geometry. The proposed architecture has an elegant fullyconvolutional behavior that, by design, can build hierarchies of local or non-local features to effectively regularize the denoising problem. This is in contrast with other methods in the literature that typically work on fixed-size patches or apply global operations [15,16]. Moreover, dynamic computation of the graph from similarities among the high-dimensional feature-space representations of the points allows to uncover more complex latent correlations than defining neighborhoods in the noisy 3D space. Extensive experimental results show a significant improvement over state-of-the-art methods, especially in the challenging conditions of high noise levels. The proposed approach is also robust to structured noise distributions such as the ones encountered in real LiDAR acquisitions.

Related work
The literature on 3D point cloud denoising is vast and it can be subdivided into four categories: local surface fitting methods [1,2,3,4,5,6], sparsity-based methods [17,18,19], graph-based methods [20,21,22], and learning-based methods [15,23,16,24]. Among the methods belonging to the first category, the moving least squares (MLS) approach [1] and its robust extensions [2,3] are the most widely used. Other surface fitting methods have also been proposed for point cloud denoising, such as jet fitting [6] or parameterization-free local projector operator (LOP) [4,5]. These methods achieve remarkable performance at low levels of noise, but they suffer from over-smoothing when the noise level is high [25].
A second class of point cloud denoising methods [17,18,19] is based on sparse representations. In this case, the denoising procedure is composed of two minimization problems with sparsity constraints, where the first one estimates the surface normals and then the second one uses them in order to update the point positions. However, at high levels of noise the normal estimation can be very poor, leading to over-smoothing or over-sharpening [18].
Another approach for point cloud denoising is derived from the theory of graph signal processing [26]. These methods [20,21,22] first define a graph whose nodes are the points of the point cloud. Then, graph total variation (GTV)-based regularization methods are applied for denoising. These techniques have proved to achieve very strong performance when the noise level is low. Instead, at high noise levels, the graph construction can become unstable, negatively affecting the denoising performance.
In the last years, learning-based methods [15,23,16,24], especially the ones based on deep learning, have been gaining attention. Extending convolutional neural networks to point cloud data is not straightforward, due to the irregular positioning of the points in the space. However, in the context of shape classification and segmentation, many methods have recently been proposed specifically to handle point cloud data. PointNet [9] is one of the most relevant works in this field, where each point is processed independently before applying a global aggregation. Recently, a few methods proposed to extend the approach of PointNet to point cloud denoising. PointCleanNet [15] uses an approach similar to PointNet in order to estimate correction vectors for the points in the noisy point cloud. Instead, in [16] the authors use a neural network similar to PointNet to estimate a reference plane for each noisy point and then they obtain the denoised point cloud by projecting the noisy point onto the corresponding reference plane. Also PointProNet [24] performs point cloud denoising by employing an architecture similar to PointNet in order to estimate the local directions of the surface. However, the main drawback of these techniques based on PointNet is that they work on individual points and then apply a global symmetric aggregation function, but they do not exploit the local structure of the neighborhood. PointCleanNet addresses this issue by taking as input local patches instead of the entire point cloud. However, this solution is still limited by the fact that the network cannot learn hierarchical feature representations, like standard CNNs.
Graph-convolutional networks have shown promising performance on tasks such as segmentation and classification. In particular, DGCNN [12] first introduced the idea of a dynamic graph update in the hidden layers of a graphconvolutional network. However, the denoising problem is significantly different from the classification and segmentation tasks addressed in [12], that rely more on global features instead of localized representations. In particular, there are several design choices that make DGCNN unsuitable for point cloud denoising: the spatial transformer block is not useful for denoising since it seeks a canonical global representation, whereas denoising is mostly concerned with local representations of point neighborhoods and also significantly increases the computational complexity for large point clouds; the graph convolution operation uses a max operator in the aggregation, which is unstable in presence of noise; the specific graph convolution definition is also less general than the one presented in this paper, which allows to implement adaptive filters where the aggregation weights are dependent on the feature vectors instead of being fixed as in [12], as well as incorporating an edge attention term which is especially important in presence of noise because it promotes a lowpass behavior by penalizing edges with large feature variations.

Proposed method
In this section we present the proposed Graph-convolutional Point Denoising Network (GPDNet), i.e., a deep neural network architecture to denoise the geometry of point clouds based on graph-convolutional layers. The focus of the paper is to investigate the potential of graph convolution as a simple and elegant way of dealing with the permutation invariance problem encountered when processing point clouds. For this reason, we focus on analyzing the network in a discriminative learning setting where a clean reference is available and it is perturbed with white Gaussian noise. We refer the reader to [23] for a technique to train any point cloud denoising network in an unsupervised fashion only using noisy data. An overview of the architecture of GPDNet is shown in Fig. 1. At a high level, it is a residual network that estimates the noise component of the input point cloud, which has been shown [7] to be easier than directly cleaning the data. A first block is composed of three single-point convolutions that gradually transform the 3D space into an F -dimensional feature space. Then a cascade of two residual blocks is used, having an input-output skip connection to reduce vanishing gradient issues. Each residual block is composed of three graphconvolutional layers. The graph is computed by selecting the k nearest neighbors to each point in terms of Euclidean distances in the feature space. Notice that the graph construction is dynamic, i.e., it is updated after every residual block but shared among the graph convolutional layers inside the block to limit computational complexity. Dynamic construction of a similarity graph has been shown to induce more powerful feature representations [12,14] and, in the context of a residual denoising network, it progressively uncovers the latent correlations that have not yet been eliminated. Intuitively, dynamic graph construction is preferable over building the graph in the noisy 3D space as neighborhoods might be strongly perturbed at high noise variances, leading to unstable or sub-optimal neighbor assignments. All layers are interleaved with batch normalization which stabilizes training, especially in presence of Gaussian noise. Finally, the last graph-convolutional layer projects the features back to the 3D space.

Graph-convolutional layer
The core of the proposed architecture is the graph-convolutional layer. Graph convolution is a generalization of convolution to data that are defined over the nodes of a general graph rather than a grid. Multiple definitions of graph convolution have been proposed to capture salient properties of classical convolution, notably localization and weight reuse. In this paper, we use a modified version of the Edge-Conditioned Convolution (ECC) [11] to address vanishing gradient and over-parameterization. In particular, we use some of the approximations introduced in [27] in the context of image denoising.
The graph-convolutional layer has two inputs: a tensor representing a feature vector for each point, and a graph where nodes are points and edges represent similarities between points. The output feature vector h l+1 i ∈ R F l of point i at layer l is computed by performing a weighted aggregation over its neighborhood N l i as defined by the graph: The weights include a self-loop matrix W l ∈ R F l+1 ×F l which is shared among all points. The other weights in the aggregation, i.e., vectors φ j→i t ∈ R F l+1 , ψ j→i t ∈ R F l and scalar ω j→i t are computed as functions of the difference between the feature vector of point i and point j, This function is implemented as a multilayer perceptron (MLP) with two layers, where the final fully-connected layer can be approximated by means of a stack of circulant matrices since the number of free parameters would otherwise be very large. The value r is a hyperparameter setting the maximum rank of the aggregation weight matrix obtained by explicitly computing again to reduce the number of parameters and memory requirements of the aggregation operation. The parameter γ l,j→i is a scalar edge attention term which exponentially depends on the Euclidean distance between feature vectors across an edge: being δ a decay hyperparameter. This definition of graph convolution has some advantages over alternative definitions such as GraphSAGE [28], FeastNet [29] or DGCNN [12]. In particular, the aggregation weights are functions of feature differences making the filtering operation performed by the graph-convolutional layer adaptive. Moreover, since the function is implemented as an MLP, it can be more general than a fixed function with some learnable parameters.
The graph is constructed by searching for the k-nearest neighbors of each point in terms of Euclidean distance between their feature vectors. To limit complexity, a search area of predefined size, centered around the point, is defined, e.g., as a fixed number of neighbors in the noisy 3D space (see Fig. 4 for a visual representation of the search area and feature space neighborhoods).
We remark that GPDNet is fully-convolutional thanks to the graph convolution operation. By fully-convolutional we mean that the output feature vector of each point at a given layer is obtained as a multi-point aggregation of the feature vectors of neighboring points in the previous layer, thus building complex hierarchies of aggregations. This is in contrast with PointCleanNet [15] which works by processing each patch independently to estimate the denoised version of the central point. That approach does not create hierarchies of features obtained by successive multi-point aggregations, as in a classical CNN. The graph-convolutional structure recovers this behavior and can learn more powerful feature spaces.

Loss functions
We consider two loss functions to train the proposed method in a supervised setting. The first one is the mean squared error (MSE) between the denoised point cloudx and its noiseless ground truth x, i.e.: being N the number of points in the point cloud. This is the most natural choice in presence of Gaussian noise. However, it does not exploit prior knowledge about the distribution of points. In fact, it does not use the fact that the points may lie on a surface and therefore the tangential component of the noise is not as relevant as the normal component. This property can be incorporated by regularizing the MSE loss with a term measuring the distance of the denoised point from the ground truth surface. Such measure can be approximated by the proximity to surface metric which computes the distance between the denoised point and the closest ground truth point. The loss function (MSE-SP) then becomes: for a regularization hyperparameter λ. Other works also considered proximity to surface in the loss function. Notably, PointCleanNet [15] uses a loss that combines the proximity to surface with a dual term measuring the distance between a ground truth point and the closest denoised point. This is done to ensure that the denoised points do not collapse into filament structures. We found that using the MSE to enforce this property provides better results.

Experimental results
In this section an experimental evaluation against state-of-the-art approaches as well as an analysis of the proposed technique is performed. Code is available online 1 .

Experimental setting
The training and test set are created selecting post-processed subsets of ShapeNet [30] repository. This database is composed by 3D models of 55 object categories, each one described by a collection of meshes. Before utilization, the data has to be sampled and normalized. First we sample 30720 uniformly distributed points for each model, then we rescale the obtained point clouds normalizing their diameter in order to ensure that data are at the same scale. More than 100000 patches of 1024 points each are randomly selected from the point clouds to create the training set, taking point clouds from all the categories except 10 reserved for the test set. Each patch is created by randomly selecting a point from a point cloud and collecting its 1023 closest points. The test set is constituted by 100 point clouds taken from ten different categories: airplane, bench, car, chair, lamp, pillow, rifle, sofa, speaker, table. We randomly select ten models from each category and sample 30720 uniformly distributed points from each model. GPDNet is trained for a fixed noise variance for approximately 700000 iterations, each one characterized by a batch size of 16. The number of features used for all the layers is 99, except for the first three single-point convolutional layers where the number of features is gradually increased from 33 to 66 and finally to 99. The Adam optimizer has been employed with a fixed learning rate equal to 10 −4 . Concerning the graph-convolutional implementation, the rank r for the low-rank approximation is set to 11, 3 circulant rows are considered for the construction of the circulant matrix, and δ = 10. During testing, GPDNet takes as input the whole point cloud and a search area is associated to each point of the point cloud, wherein the neighbors are searched and identified. Unless otherwise stated, 16 nearest neighbors in terms of Euclidean distances are used for graph construction. In this section the proposed method is compared with state-of-the-art methods for point cloud denoising. As described in Section 2, different categories of point cloud denoising methods are present in the literature. In the experiments, we take into account at least one algorithm from each category. APSS [3] and RIMLS [2] are well-known MLS-based surface fitting methods and they were tested using the MeshLab software [31]. AWLOP [5] is another surface fitting method and it was implemented using the software released by the authors. MRPCA [19] is a sparsity-based method and it was implemented using the code provided by the authors. GLR [20] is one of the most promising works belonging to the graph-based category and it was implemented using the code provided by the authors. PointCleanNet (PCN) [15] is one of the most recent learning-based methods and its code is publicly available. In order to ensure a fair comparison, PointCleanNet was retrained with additive Gaussian noise at a specific standard deviation, instead of using the blind model released by the authors. We also include a modified version of DGCNN [12] as an additional baseline. This modified version replaces the segmentation head with a single-point convolution to regress the point displacement. As metric to evaluate the performance of the proposed method, we compute the Chamfer measure, also called Cloud-to-Cloud (C2C) distance. This metric is widely utilized in point cloud denoising, because it computes an average distance of the denoised points from the original surface. First, the mean distance between each denoised point and its closest ground truth point is computed, then the one between each ground truth point and its closest denoised point. The Chamfer measure is then their average:

Comparisons with state-of-the-art
The results of the experiments at different noise levels are reported in Table 1 Table 2 with σ = 0.015 and Table  3 with σ = 0.02. Instead, at low noise level the other algorithms become more competitive and the performance gap decreases, but the proposed method still obtains the best results in the majority of the categories, as reported in Table 1. This can be explained by the fact that most of the other methods involves surface reconstruction or normal estimation, operations that cannot be computed with sufficient accuracy at high levels of noise. Instead, the proposed method directly estimates the denoised point cloud. In addition, it can be observed from Table 3 that the GPDNet MSE-SP version is particularly effective at high levels of noise, outperforming GPDNet MSE in almost all the categories. This behavior can be explained by the regularizing effect of the surface distance component of the loss, which is especially useful at high noise variance due to the fact that it can incorporate more prior knowledge about the data. The performance difference between the two variants decreases at low noise levels, as shown in Table 1. It is worth noting that DGCNN shows poor performance for the reasons explained in Sec. 2, being originally designed for classification or segmentation. This is in line with the results presented in the PointCleanNet paper [15] where the au- thors also show the poor denoising performance of DGCNN, and highlights the importance of the design in this paper, which is tailored to the denosing task. We also consider another metric for a quantitative assessment of the denoised point clouds. In particular, we assess whether an off-the-shelf algorithm for surface normal estimation can produce more accurate normals when provided with point clouds denoised by the proposed method. Since surface normals are widely used in many applications, we believe that measuring their quality when extracted from the denoised data is a relevant metric for the characterization of a denoiser. In this experiment we consider a different test set, composed of 5 well-known point clouds: Armadillo, Bunny, Column, Galera and Tortuga. The change of dataset is motivated by the availability of ground truth normals for these point clouds. For every denoising method considered in the comparison, we compute the unoriented normal vector of each point in the denoised point cloud. The standard algorithm employed for the normal estimation is the built-in MAT-LAB function, which is based on principal component analysis. We compute the unoriented normal angle error (UNAE) as where n i is the groud-truth normal vector at x i andn i * is the estimated normal vector at the denoised point closest to x i . Table 4 reports the average error across the five test point clouds. A minimum error of about six degrees is reported since the MATLAB algorithm introduces a non-zero estimation error in the computation of the normals, as can be seen from the first column of Table  4. It can be observed that the proposed denoising method, in particular the version with only MSE as loss function, increases the accuracy of the normal estimation, outperforming the state-of-the-art at each noise level considered. It is also interesting to notice that learning-based methods are more stable to noise than model-based methods as their performance degrades more gracefully for increasing noise variance. Fig. 2 shows qualitative results at a medium noise level by presenting the denoised point cloud for each method. The surface distance of each point is visualized in the figure to understand the position of the denoised points with respect to the ground truth. The root mean square value of the surface distance (RMSD) can be computed as:  It can be seen that on average both versions of our method provide lower pointssurface distance and that the shape of the reconstructed point cloud is more similar to the original one. Fig. 3 shows another qualitative comparison, displaying the unoriented normal estimation error for each denoised point. It can be seen that the proposed method, especially the version with only MSE, provides lower normal estimation errors, highlighting the higher quality of the denoised point cloud.

Ablation studies
We study the behavior of GPDNet in terms of a few design choices. In particular, we first investigate the impact of dynamic graph computation, i.e., updating the graph from the hidden feature space as in Fig. 1, as opposed to a fixed graph construction where neighbors are identified in the noisy 3D space and used for all graph-convolutional layers. Table 5 shows that dynamic graph update provides improved performance thanks to refined neighbor selection. We also study the impact of neighborhood size on the overall performance. Selecting a larger number of neighbors for graph convolution increases the size of the receptive field and can help denoise smooth areas in the point cloud by capturing more context, at the price of losing some localization and increased computational complexity. This is related to results on image denoising [32], where it is known that the optimal size of the receptive field depends on the noise variance. Tables 6 and 7 show that increasing the number of neighbors is beneficial, up to a saturation point. We also see that the impact of a larger receptive field is more significant for the GPDNet MSE-SP variant.

Feature analysis
We analyze the characteristics of the receptive field, i.e., the set of points whose feature vectors influence the features of a specific point, induced by the graph convolutional layers. In Fig. 4 we show an example of the receptive field of a single point for the output of the graph convolutional layers of a residual block with respect to the input of the residual block. The visualization is on the denoised point cloud. We observe that the receptive field is quite localized in the 3D space and its size increases as the number of layers increases. It is interesting to note that, since the graph is dynamically constructed in the feature space, the points of the receptive field are not just the spatially closest ones but they are also among the ones with similar shape characteristics. For example, in Fig. 4 the considered point is on the lower side of the chair stretcher and all the points of the receptive field belong to the same part of the surface. In order to better analyze this non-local property of the receptive field we measure its radius in the 3D space and compare it to a fixed graph construction where the neighbors are determined by proximity in the noisy 3D space. Fig. 5 shows the radius of the receptive field of each point at the output of a residual block with respect to the input of the residual block. The radius is evaluated as the 90 percentile Euclidean distance in the 3D space on the clean point cloud (90 percentile is used since the maximum might be an unstable metric). It can be noticed that when using the dynamic graph construction the radius is only slightly larger in the first residual block but can be significantly larger in the second one. This can be interpreted as the feature space building and exploiting more and more non-local features with patterns similar to those in Fig. 4. In order to check if the proposed architecture can generalize beyond white Gaussian noise, we train it on a simulated LiDAR dataset. We simulate scanning the Shapenet objects with a Velodyne HDL-64E scanner using the Blensor software [33]. Two sources of noise are considered for the acquisition process: a laser distance bias with Gaussian distribution and a per-ray Gaussian noise. We set both distributions to be zero-mean and with a standard deviation equal to 1% of the longest side of the object bounding box. We also retrained PointCleanNet on the simulated data for comparison with a state-of-the-art model. Table 8 shows that the results follow those on white Gaussian noise, with the proposed method improving over PointCleanNet. Note that RMSD is used as metric in place of the Chamfer measure since it is better suited to the case when points are not uniformly distributed.

Conclusions
In this paper, we have presented a new graph-convolutional neural network targeted for point cloud denoising. Thanks to the graph-convolutional layers, the proposed architecture is fully convolutional and can learn hierarchies of features, showing a behaviour similar to standard CNNs. The experimental results show that the proposed method provides a significant improvement over state-of-theart techniques. In particular, the proposed method is robust to high level of noise and structured noise distributions, such as those observed in real LiDAR scans.