Point cloud denoising based on tensor Tucker decomposition

TL;DR

This paper introduces a novel point cloud denoising method using tensor Tucker decomposition, which effectively reduces noise in high Gaussian noise scenarios by leveraging local surface patch representations and frequency domain manipulation.

Contribution

The paper presents a new tensor Tucker decomposition-based algorithm for point cloud denoising that outperforms existing methods in high noise conditions.

Findings

Outperforms state-of-the-art in high Gaussian noise ($\sigma=0.1$)

Effective noise removal through frequency domain manipulation

Competitive with existing methods in lower noise scenarios

Abstract

In this paper, we propose a new algorithm for point cloud denoising based on the tensor Tucker decomposition. We first represent the local surface patches of a noisy point cloud to be matrices by their distances to a reference point, and stack the similar patch matrices to be a 3rd order tensor. Then we use the Tucker decomposition to compress this patch tensor to be a core tensor of smaller size. We consider this core tensor as the frequency domain and remove the noise by manipulating the hard thresholding. Finally, all the fibers of the denoised patch tensor are placed back, and the average is taken if there are more than one estimators overlapped. The experimental evaluation shows that the proposed algorithm outperforms the state-of-the-art graph Laplacian regularized (GLR) algorithm when the Gaussian noise is high ($\sigma=0.1$), and the GLR algorithm is better in lower noise cases ($\sigma=0.04, 0.05, 0.08$).

Figures

Tables

Table 1. Table 1 : MSE for different models ( σ = 0.04 𝜎 0.04 \sigma=0.04 ).

Model	Noisy	APSS	RIMLS	GLR	TUDE
Gargoyle	0.367	0.258	0.275	0.251	0.283
DC	0.338	0.227	0.245	0.217	0.248
Daratech	0.348	0.264	0.284	0.269	0.301

Table 2. Table 2 : MSE for different models ( σ = 0.05 𝜎 0.05 \sigma=0.05 ).

Model	Noisy	APSS	RIMLS	GLR	TUDE
Gargoyle	0.413	0.281	0.298	0.269	0.301
DC	0.381	0.248	0.266	0.231	0.265
Daratech	0.387	0.328	0.363	0.308	0.331

Table 3. Table 3 : MSE for different models ( σ = 0.08 𝜎 0.08 \sigma=0.08 ).

Model	Noisy	APSS	RIMLS	GLR	TUDE
Gargoyle	0.539	0.393	0.432	0.348	0.367
DC	0.503	0.377	0.409	0.317	0.341
Daratech	0.482	0.458	—-	0.384	0.388

Table 4. Table 4 : MSE for different models ( σ = 0.1 𝜎 0.1 \sigma=0.1 ).

Model	Noisy	APSS	RIMLS	GLR	TUDE
Gargoyle	0.619	0.531	0.583	0.436	0.416
DC	0.577	0.514	0.556	0.400	0.392
Daratech	0.531	—-	—-	0.437	0.418

Equations

$$(\mathcal{A}{\times }_1\mathbf{X}{)}_{ijk}\stackrel{\mathsf{def}}{=}\sum _{l=1}^m{\mathcal{A}}_{ljk}{X}_{il}.$$

$$\mathbf{V}=\mathbf{W}+\mathbf{E},$$

$$\min \frac{1}{2}\Vert \mathcal{A}-\mathcal{C}{\times }_1\mathbf{P}{\times }_1\mathbf{Q}{\times }_1\mathbf{R}{\Vert }^2,$$

Full text

**Index Terms— ** Point cloud denoising, Tucker decomposition, Hard thresholding, HOOI algorithm

1 Introduction

In recent years, the low-cost and high-resolution scanners of point cloud are becoming available, and have been promoting the wide applications of point cloud processing in various areas, e.g., remote sensing [1], cultural heritage [2] and geographic information system [3]. However, because of the physical constraints, the raw point cloud data is always corrupted with noises, which has made the denoising an important step for further processing in point cloud. In fact, the denoising problem is also a popular topic in signal processing field [4, 5, 6, 7, 8, 9].

Up to now, many different types of algorithms have been developed for point cloud denoising [10], which can be classified as four categories [11]: Moving least squares (MLS)-based, Locally optimal projection (LOP)-based, Sparsity-based and Non-local algorithms. Now we briefly introduce the algebraic point set surfaces (APSS) [12] and robust implicit MLS (RIMLS) [13] algorithms in MLS-based category, and the graph Laplacian regularized (GLR) [11] algorithm in Non-local category. In fact, the APSS and RIMLS algorithms are to approximate the smooth surface based on the local reference domains of the noisy points, and then determine the true positions by the resulting surface. The GLR algorithm is based on the assumption that the surface patches in a point cloud lie on a manifold of low dimension, which was earlier studied in the low-dimensional manifold model (LDMM) [14] algorithm for image processing.

As more and more real world data can be represented as the tensor form, e.g., video [15], hyperspectral image [1], tensor decomposition has become a popular tool to solve many signal processing problems [16, 17], e.g., image denoising [18], graph signal processing (GSP) [19, 20]. As one of the most important transformations in the tensor field, Tucker decomposition [16, 21] is to transform a tensor into a core tensor of smaller size by a set of column orthogonal matrices. In fact, it can be understood as a higher order version of the principal component analysis (PCA).

In this paper, we try to solve the point cloud denoising problem by a tensor approach. We first construct a 3rd order tensor based on the similarity between different local surface patches in a point cloud. Then we use the Tucker decomposition to compress the patch tensor, and take the core tensor as the frequency domain. In fact, this process has removed some noise, similar to the PCA case. For better denoising performance, we continue to use the hard thresholding on the core tensor to remove more noise. Finally, we place back the fibers111the fiber of a tensor is defined by fixing every index but one., and take the average if there are more than one estimators overlapped. This algorithm belongs to Non-local category, as it is based on the similarity between local surface patches.

The main contribution of this paper is the formulation of the point cloud denoising problem from a tensor point of view, and combining the Tucker decomposition and hard thresholding to solve it. It is shown by the experiments that the proposed algorithm outperforms the state-of-the-art GLR algorithm when the Gaussian noise is high ($\sigma=$0.1). To the best of our knowledge, this is the first time applying Tucker decomposition to the point cloud denoising problem.

This paper is organized as follows. In Section 2, we formulate the point cloud denoising problem, and propose a Tucker decomposition based algorithm to solve it. In Section 3, we conduct some experiments to evaluate the performance of the proposed algorithm, and discuss the results. Section 4 includes the conclusion and future work.

Now we give some notations before further discussion. In this paper, we denote $\mathbb{R}^{m\times n\times p}\stackrel{{\scriptstyle\sf def}}{{=}}\mathbb{R}^{m}\otimes\mathbb{R}^{n}\otimes\mathbb{R}^{p}$ to be the linear space of 3rd order real tensors. We denote by $\|\cdot\|$ the Frobenius norm of a tensor or a matrix, or the Euclidean norm of a vector. Tensors, matrices, and vectors, will be respectively denoted with bold calligraphic letters, e.g. $\boldsymbol{\mathcal{A}}$, with bold uppercase letters, e.g. $\boldsymbol{X}$, and with bold lowercase letters, e.g. $\boldsymbol{v}$; corresponding entries will be denoted by $\mathcal{A}_{ijk}$, $X_{ij}$, and $v_{i}$. Let $\boldsymbol{\mathcal{A}}\in\mathbb{R}^{m\times n\times p}$ be a 3rd order tensor, and $\boldsymbol{X}\in\mathbb{R}^{q\times m}$ be a matrix. We follow the definitions and notations in [16], e.g., the 1-mode product is

[TABLE]

2 Point cloud denoising based on Tucker decomposition

2.1 Problem formulation

Assume that $\mathscr{V}=\{\boldsymbol{v}_{i}\}_{i=1}^{\rm N}$ is a noisy point cloud, i.e., a set of unstructured spatial points, and $\boldsymbol{V}=[\boldsymbol{v}_{1},\cdots,\boldsymbol{v}_{N}]^{{\sf T}}\in\mathbb{R}^{N\times 3}$ is the corresponding position matrix satisfying

[TABLE]

where $\boldsymbol{W}$ is the true position matrix and $\boldsymbol{E}$ is a Gaussian noise with zero mean and standard deviation $\sigma$. In this paper, we study the point cloud denoising problem to find $\boldsymbol{W}$.

To solve this problem, we first represent the surface patches of a point cloud as matrices of the same size, and stack the similar patch matrices to a 3rd order patch tensor $\boldsymbol{\mathcal{A}}\in\mathbb{R}^{m\times n\times p}$, based on the similarity between different local surface patches. Suppose that $r_{1}<m,r_{2}<n,r_{3}<p$. Then, we formulate problem (1) to be the following Tucker decomposition [16, 21] problem

[TABLE]

where $\boldsymbol{\mathcal{C}}\in\mathbb{R}^{r_{1}\times r_{2}\times r_{3}}$ is the core tensor, and $\boldsymbol{P},\boldsymbol{Q},\boldsymbol{R}$ are the factor matrices. This is in fact the higher order PCA to compress $\boldsymbol{\mathcal{A}}$ to be of smaller size. This problem can be solved efficiently by the higher order orthogonal iterations (HOOI) [22] method. In this paper, we use the HOOI algorithm to solve problem (2), and understand the core tensor as the frequency domain similar to the PCA case. Then by the hard thresholding on the core tensor, we remove the noise of the point cloud.

2.2 Tucker decomposition based algorithm

In this subsection, we mainly develop the Tucker decomposition based point cloud denoising (TUDE) algorithm. All the details of this algorithm are summarized in Algorithm 1.

2.2.1 Determining the patch matrices

We first choose a subset $\mathscr{S}\subseteq\mathscr{V}$ as the set of seed points by the downsampling method, which can make the seed points sampled uniformly. For each seed point $\boldsymbol{s}\in\mathscr{S}$, we choose the $K$ nearest points in $\mathscr{V}$, and sort them to be a patch matrix in $\mathbb{R}^{K\times 3}$ based on their Euclidean distances to $\boldsymbol{s}$. The $\mathscr{S}$ should be large enough to guarantee that the union of all the points in patch matrices can cover $\mathscr{V}$.

2.2.2 Determining the groups of similar patch matrices

To make the similarity between patch matrices be rotation invariant, we use the distance $d(\boldsymbol{X},\boldsymbol{Y})$ based on the iterative closest point (ICP) cost function, as in [23].

Given a thresholding value $\delta_{\rm sim}>0$, for each patch matrix $\boldsymbol{X}\in\mathbb{R}^{K\times 3}$, we find all the patch matrices $\boldsymbol{Y}$ satisfying that the average distance $d(\boldsymbol{X},\boldsymbol{Y})/3K$ is smaller than $\delta_{\rm sim}$. In the process of solving the ICP problem, we find a transformation on $\boldsymbol{Y}$. Then we put all of such transformed patch matrices in a group. In other words, the average distance between each patch matrice and the reference one in the same group will be always smaller than $\delta_{\rm sim}$. To guarantee the speed, we set a search region Nreg for this searching process.

2.2.3 Patch tensor denoising

For each group of similar patch matrices $\{\boldsymbol{X}_{p}\}_{p=1}^{M}\subseteq\mathbb{R}^{K\times 3}$, we stack them together to be a 3rd order patch tensor $\boldsymbol{\mathcal{A}}\in\mathbb{R}^{K\times 3\times M}$. Then we calculate the Tucker decomposition (2) of $\boldsymbol{\mathcal{A}}$ by the HOOI algorithm, and manipulate the hard thresholding on the core tensor. We keep the entries with absolute value larger than the largest absolute value multiplied by $\delta_{\rm thre}$, and eliminate other entries. Then, by the inverse transformation, we get the denoised tensor $\boldsymbol{\mathcal{A}}_{\ast}\in\mathbb{R}^{K\times 3\times M}$.

2.2.4 Aggregation

This step is to place all the fibers of denoised tensors $\boldsymbol{\mathcal{A}}_{\ast}$ back to the original positions. On each patch matrix of the denoised tensors, we first make the inverse transformations of that determined in the process of solving the ICP problem. Then we place back all the patch matrices. It is highly possible that we get more than one estimators for one original patch matrix. In this case, we take the average of these overlapped ones. Finally, we place back all the row vectors of patch matrices. It is also possible that there are several estimators for one point position, when a point appears simultaneously in many patch matrices, and we take the average similarly.

3 Experimental evaluation

In this section, we compare the proposed TUDE algorithm with some existing algorithms: the APSS [12], RIMLS [13], and GLR [11] algorithms. The APSS and RIMLS algorithms are implemented with MeshLab software [24]. The GLR algorithm is implemented with Matlab. The TUDE algorithm is implemented with Python.

3.1 Experimental setup

We use the Gargoyle, DC and Daratech point cloud models from [23, 25, 11] to conduct experiments. The numbers of points and the numbers of seed points after the downsampling process for these three models are 58611, 56645, 32003 and 28361, 27496, 15475, respectively. These models are added the Gaussian noises with $\sigma={\rm 0.04,0.05,0.08,0.1}$, respectively. We use the mean square error (MSE) in [11] to evaluate the denoising performance.

In the proposed TUDE algorithm, we always set $\delta_{\rm sim}=1$, N${}_{\rm reg}=20$, $(r_{1},r_{2},r_{3})=(3,3,3)$ and $\delta_{\rm thre}=0.1$. We set $K=19,21,26,35$ for $\sigma={\rm 0.04,0.05,0.08,0.1}$, respectively. In the GLR algorithm, we set $r=12$ for $\sigma={\rm 0.04,0.05}$, $r=13$ for $\sigma={\rm 0.08}$, and $r=14$ for $\sigma={\rm 0.1}$, as we find this setting can generally get the best results. In APSS and RIMLS algorithms, we set the MSL filter scale to be $4,5,6$, and choose the best result.

3.2 Experimental results

The experimental results are shown in Tables 1, 2, 3 and 4, where “—” means that the MSE does not decrease after the algorithm. A visualization of the TUDE algorithm denoising result on the Gargoyle model ($\sigma=0.1$) is shown in Figure 1, where we can see that the denoised model is more compact and regular than the noisy one.

3.3 Discussions

We first make some comparisons based on Tables 1, 2, 3 and 4. (1) Compared with the APSS algorithm, TUDE algorithm has better results when $\sigma=0,08,0.1$, and APSS is better when $\sigma=0.04,0.05$. (2) Compared with the RIMLS algorithm, TUDE algorithm has better results when $\sigma=0.08,0.1$, close results when $\sigma=0.05$ and RIMLS is better when $\sigma=0.04$. (3) Compared with the state-of-the-art GLR algorithm, TUDE algorithm has better results when $\sigma=0.1$, and GLR is better when $\sigma=0.04,0.05,0.08$. Then we can summarize that the proposed TUDE algorithm has better results when tackling the point cloud denoisng problem with high noise.

This is because of the following facts: (1) The APSS and RIMLS algorithms are both based on the local reference domains of the noisy points, which are influenced more heavily by the high noise. However, the GLR and TUDE algorithms belong to Non-local category, and thus still work well with high noise. (2) The GLR algorithm uses projection on the reference plane to find the correspondence [11], which may make it more sensitive to the high noise than the TUDE algorithm. (3) In the TUDE algorithm, after the denoising process by the compression of Tucker decomposition (i.e., higher order PCA), we continue to manipulate the hard thresholding on the core tensor. In the experiments, we find that the denoising result is much better than just using the Tucker decomposition. The combination of these two processes may be also an important reason why it works better in high noise case.

The proposed TUDE algorithm is also competitive in the speed. In fact, the running time of each experiment is $4\sim 6$ minutes on the Daratech model, and $8\sim 10$ minutes on the Gargoyle and DC models. This is because of that (1) TUDE algorithm is not an iterative algorithm, and (2) the main procedure in TUDE algorithm is the HOOI algorithm, which is of high efficiency [26].

Now we make some discussions about the parameters of the proposed TUDE algorithm. (1) There is a strong positive correlation between the patch matrix size K and the Gaussian noise level. This is reasonable as we need larger surface patches when the noise is higher. (2) We always set N${}_{\rm reg}=$ 20 in the experiments. In fact, the final MSE value will be better if we increase the Nreg value. However, this would make the algorithm slower. In these three models, the speed would be too slow (more than one hour) if Nreg is more than 200. (3) We always set $\delta_{\rm thre}=0.1$ in the experiments. In fact, on the Daratech model, we find that the result will be better, if $\delta_{\rm thre}$ is set to be smaller. One possible reason is that the Daratech model has more flat surfaces, while other two models have more round surfaces.

In the experiments, we find that the hard thresholding process sometimes keeps only one entry (with the largest absolute value), and eliminates all other entries. In this case, it is natural to ask whether we could get the same result if we take $(r_{1},r_{2},r_{3})=(1,1,1)$ directly, which is corresponding to the best rank-1 approximation [22]. In fact, by the experiments, we find that this is not the case. Taking $(r_{1},r_{2},r_{3})=(1,1,1)$ directly generally gets worse results than the approach of this paper. In other words, combining the Tucker decomposition and hard thresholding is better.

4 Conclusion

In this paper, we propose a new point cloud denoising algorithm by using the tensor Tucker decomposition to exploit the self-similarities between local surface patches in a point cloud. After calculating the Tucker decomposition by the HOOI algorithm, we manipulate the hard thresholding on the compressed tensor to remove the noise. Finally all the points are placed back, and the average is taken if there are more than one estimators overlapped. From the experiments, we show that this new algorithm is competitive in the speed, and outperforms the state-of-the-art GLR algorithm when the additive Gaussian noise is high ($\sigma=$ 0.1), while the GLR algorithm is better in lower noise cases ($\sigma=0.04,0.05,0.08$). In the future work, based on the TUDE algorithm, we will try to construct a nonlinear model to get better denoising results.

5 Acknowledgement

The authors would like to thank Gene Cheung for providing the point cloud models and Matlab codes of GLR algorithm, and Hei Victor Cheng for valuable discussions about the algorithm setting.