Fast Point Cloud Registration Algorithm Based on 3DNPFH Descriptor

Abstract

Although researchers have investigated a variety of approaches to the development of three-dimensional (3D) point cloud matching algorithms, the results have been limited by low accuracy and slow speed when registering large numbers of point cloud data. To address this problem, a new fast point cloud registration algorithm based on a 3D neighborhood point feature histogram (3DNPFH) descriptor is proposed for fast point cloud registration. With a 3DNPFH, the 3D key-point locations are first transformed into a new 3D coordinate system, and the key points generated from similar 3D surfaces are then close to each other in the newly generated space. Subsequently, a neighborhood point feature histogram (NPFH) was designed to encode neighborhood information by combining the normal vectors, curvature, and distance features of a point cloud, thus forming a 3DNPFH (3D + NPFH). The descriptor searches radially for 3D key point locations in the new 3D coordinate system, reducing the search coordinate system for the corresponding point pairs. The “NPFH” descriptor is then coarsely aligned using the random sample consensus (RANSAC) algorithm. Experiment results show that the algorithm is fast and maintains high alignment accuracy on several popular benchmark datasets, as well as our own data.

1. Introduction

There has been a recent and rapid development of three-dimensional (3D) laser scanning technology for use in reverse engineering, digital cities, deformation monitoring, and other applications [1]. Owing to limitations in the field of view of 3D laser scanning equipment, and the complex geometry of the scanned objects themselves, the point cloud data collected from each viewpoint only partially cover the geometric information of the scanned object surfaces. To obtain complete information regarding such surfaces, it is necessary to register the point clouds from individual scans into the same reference coordinate system.

To date, the classic iterative nearest point (ICP) [2] remains the most widely-used point cloud matching algorithm. Many researchers have made improvements to the ICP algorithm [3,4,5,6], which relies on a good initial alignment position. Without this, it quickly falls into the local optimum and cannot achieve a good registration effect. Therefore, as common practice, the initial alignment method is used to obtain a good initial alignment position and then the ICP algorithm is applied to achieve an accurate alignment. Due to the irregular nature of 3D point clouds, designing a local surface descriptor with high overall performance is a challenge. Three-dimensional point cloud descriptors fall into two main categories: handcrafted and deep learning based methods. The incredible power of deep learning techniques has resulted in a breakthrough in the obtainment of 3D point cloud descriptors. As an example, Deng et al. [7] proposed the Point Pair Feature NETwork, which uses a new N-tuple loss and an architecture that naturally injects global information into the local descriptors, achieving good results in terms of accuracy, speed, and other factors. In addition, Ao et al. [8] proposed Spinnet, which first introduces a spatial point transformer to map the input local surface into a well-designed cylindrical space and then applies a powerful point-based and 3D cylindrical convolutional neural layer feature extractor to derive compact and representative descriptors for matching. Spinnet has an excellent ability to generalize well under unseen scenarios. Finally, Fabio et al. [9] normalized their estimated local reference system by extracting point cloud patches and encoding rotationally invariant compact descriptors using a robust deep neural network based on PointNet. Although deep learning has made significant progress in the area of point cloud alignment, it inherently requires a large amount of training data, and a separate training process is needed to learn a separate feature extraction network, which is time-consuming and results in significant hardware requirements.

For handcrafted methods, such descriptors are divided into two categories depending on whether a local reference frame (LRF) is used. Although many efficient methods have been proposed for descriptors without an LRF, point pair feature (PPF) based descriptors are the most classical approaches for a 3D surface description. Johnson and Heber [10] proposed using spin image (SI) features, in which the normal vectors of the key points are first applied as reference axes and the local neighborhood points are then projected onto a 2D surface both horizontally and vertically. Although an SI is a frequently cited descriptor, it has limited descriptive power and is sensitive to changes in the data resolution. In addition, a point feature histogram (PFH) [11] has high discriminatory power but is extremely time-consuming. To address this problem, Rusu et al. [12] constructed a fast point feature histogram (FPFH) using a simplified point feature histogram (SPFH), which is characterized as fast and discriminative. Albarelli et al. [13] defined a descriptor for low-dimensional surface hashing and applied it to the surface matching problem in a game-theoretic framework, where the surface hash features are mainly computed based on multiscale statistical histograms of the local properties, including normal vector pinch angles, integral volumes, and their combination. Moreover, Zhao et al. [14] proposed a novel normal surface reorientation drawing upon a Poisson-disc sampling strategy to address the problem of data redundancy during data preprocessing. Subsequently, a new technique is used to divide the local point pairs for each key point into eight regions, where each local point pair distribution region is applied to construct the corresponding sub-features. Finally, an extracted histogram of the point pair features is generated by concatenating all the subfeatures into a single vector.

For LRF-based features, Stein and Medioni [15] designed the local characteristics of point clouds as a consequence of the offset angle, torsion angle, and curvature relationships between key points and those within the geodetic neighborhood. Frome et al. [16] also suggested using a 3D shape context (3DSC) by extending the 2D shape context (SC) [17] into the 3D domain. The proposed method first divides the local spherical domain into multiple subspaces and then computes the feature descriptors by calculating the percentage of points in each subspace. Zaharescu et al. [18] compute gradient vectors for each neighborhood point and project them onto three orthogonal planes of the LRF. Each plane is divided into four quadrants, and each quadrant corresponds to an 8-dimensional feature. In addition, Prakhya et al. [19] form a histogram by accumulating the points in each interval divided by a “3D” descriptor. As a concrete process, the local surface of the key points is aligned to the defined LRF by employing a “3D” descriptor, and the range between the minimum and maximum x-coordinate values of the points on the surface is then divided into D intervals along the x-axis. The same process is repeated along the y- and z-axes, and a 3D histogram of the point distribution (3DHoPD) is generated by concatenating these histograms. Although this method is fast, it is poorly descriptive. Guo et al. [20] first rotate the local surface in the LRF, project the surface after each rotation to calculate the projected point density statistics, and concatenate these statistics to obtain rotational projection statistics (RoPs). Although the use of RoPS has achieved the highest matching performance for several datasets, its shortcomings include a poor descriptiveness and time-consuming computations for data with uneven point distributions. Similar to the rotational projection mechanism of RoPS, Guo et al. [21] use the three orthogonal axes of the LRF to compute three spin map features and obtain triple spin images (TriSI) that are more resistant to occlusions than RoPS but are still more time-consuming.

In this paper, a point cloud alignment algorithm based on the 3D point neighborhood feature histogram (3DNPFH) descriptor is proposed to address the current problems inherent to an alignment algorithm. After uniform sampling using the voxel grid method, the algorithm transfers the key points to the new 3D coordinate system for the point cloud. The point pairs to be matched are obtained using the principle in which the key points are generated by similar numbers of 3D surfaces that are close to each other. We construct the neighborhood point feature histogram (NPFH) descriptor by calculating the normal vector, curvature, and distance features within the neighborhood of the key points, and finally apply the RANSAC algorithm to achieve a coarse alignment and obtain a good initial alignment position.

2. Proposed Methods

In general, in a 3D surface description, a unique high-dimensional feature vector is used to describe a local 3D surface at a 3D key point. In this study, a 3D neighborhood point feature histogram (3DNPFH) is proposed to represent a local 3D surface. Generating the 3DNPFH descriptor involves two main steps: encoding the 3D key point positions to form a pre-3D descriptor and obtain a list to be matched, and finding an exact match by computing the NPFH descriptor. Let us consider an input source point cloud $P_{source}$ upon which $I$ key points, $K_i$, where $i=\{1,2,\dots ,I\}$, are extracted using a uniform sampling. We then create a 3DNPFH descriptor from its radius neighborhood surface, $Surfac{e}_{ik}$, including K points, where $k=\{1,2,\dots ,K\}$. The neighborhood surface from which the descriptor is constructed is determined based on its support radius r. A key point $K_i$ has $Surfac{e}_{ik}$, where $i$ represents the index of the key points, and k represents the index of the points within the surface of the neighborhood of the key points.

2.1. Encoding 3D Key Point Locations

The uniformly-sampled key points are transformed into a new 3D coordinate system, and their 3D coordinates are recorded in the first three dimensions of the 3DNPFH descriptor. The extraction of feature descriptors around the key points and a comparison to find their correspondences are conducted to locate exact 3D key point correspondences generated from a similar 3D surface neighborhood. Therefore, the key points are transformed into a new 3D coordinate system in which the key points of similar surfaces are close to one another. We first calculate the centroid coordinates $mea{n}_{pt}$ in the neighborhood coordinate system $Surfac{e}_{ir}$ of surface radius r of key point $K_i$, and then subtract the centroid coordinates $mea{n}_{pt}$ from all point coordinates in $Surfac{e}_{ir}$, effectively generating a new surface $Surfac{e}_{ir-mea{n}_{pt}}$, and letting the key points $K_i$ subtract the centroid coordinate $mea{n}_{pt}$ to obtain $K_{i-mea{n}_{pt}}$. Finally, we have a new surface, $Surfac{e}_{ir-mea{n}_{pt}}$, used to calculate the local reference coordinate system {a}. The three axes of {a} form the rotation matrix ${\left[RF\right]}_{3\times 3}$, and the key point $K_{i-mea{n}_{pt}}$ is then transferred to a new 3D coordinate system, as shown in (1).

$${\left[K_{iRF}\right]}_{3\times 1}={\left[RF\right]}_{3\times 3}{\left[K_{i-mea{n}_{pt}}\right]}_{3\times 1}$$

(1)

where its new coordinates, $K_{iRF}$, constitute the first three dimensions of the descriptors proposed herein.

Local reference coordinate system: This algorithm establishes a local reference frame, such as SHOT [22], and the corrected covariance matrix of the point cloud is then calculated using the 3D surface $Surfac{e}_{ir-mea{n}_{pt}}$, as shown in (2). Within the radius neighborhood of the considered key points, weighting is conducted according to the distance $K_{i-mea{n}_{pt}}$ of the key points from the centroid. For better readability, we use $q_r$ to represent the point within the surface $Surfac{e}_{ir-mea{n}_{pt}}$ around the key points, and q to represent the distance between the key points and the centroid $K_{i-mea{n}_{pt}}$.

$$COV=\frac{1}{{\displaystyle \sum _{r:d_r\le r}\left(r-d_m\right)}}{\displaystyle \sum _{i:d_m\le r}\left(r-d_r\right)\left(q_r-q\right){\left(q_r-q\right)}^T}$$

(2)

Here,$d_r={\Vert q_r-q\Vert }_2$. To create a unique local reference coordinate system, it is necessary to disambiguate the direction of the normal. We use the orientation of the local x- and z-axes toward the principal directions of the vectors they represent, and finally obtain the local y-axis through the cross product of z and x, where y = z × x. By solving the covariance matrix COV, we can obtain the eigenvalues and the eigenvectors corresponding to the eigenvalues, which can be sorted in descending order to obtain ${\mu }_1>{\mu }_2>{\mu }_3$. The corresponding eigenvectors x, y, and z represent the three coordinate axes, and the rotation matrix is constructed as follows:

$${[RF]}_{3\times 3}={[x^T{y}^T{z}^T]}^T$$

(3)

However, because there may be various anomalies, we cannot state that the point closest to the key point in the new 3D coordinate system is the correct match; for example, noisy point cloud data may be acquired by the sensor or similar local reference coordinate systems. However, the correct match lies within the neighborhood of the key points, significantly reducing the search coordinate system for correctly matched points.

Figure 1 shows a schematic of the 3DNPFH descriptor. The key points of the source point cloud are shown in blue, and the key points of the target point cloud are shown in red. The blue and red spheres represent the LRF and the support size of the constructed descriptor, respectively. Then, for each model key point, the list of key points in the scene (shown as pink spheres in the new 3D coordinate system) is retrieved through a radial search of the threshold radius. From this retrieved list of possible key point matches of a scene, the one closest to the NPFH descriptor is considered an exact match.

2.2. Calculation of Neighborhood Point Feature Histogram (NPFH)

Geometric features such as the curvature, surface normals, and distances reflect the most basic geometry of a point cloud, which is the key to expressing the local features of the cloud. In this section, based on the radius neighborhood of the key point, the neighborhood curvature sum, normal vector angle sum, and distance sum corresponding to the key point are calculated. A 3D vector consists of the sum of the curvature of the neighborhood, the sum of the angle between the normal vectors, and the sum of the distance. This 3D vector is an NPFH descriptor.

2.2.1. Curvature

The normal and curvature information of a point cloud surface are important geometric features for 3D object recognition. The curvature is invariant to rotation, translation, and scaling and is therefore used as a feature element. The curvature value reflects the degree of concavity of the point-cloud surface. The sharp features of the point cloud have a more significant curvature. By contrast, the non-featured parts of the point cloud exhibit a relatively slight curvature.

In this study, the method described in [23] is used to estimate the norm and curvature of the data points by analyzing the covariance of k neighborhood points within radius r. We analyze the covariance of a given point of the neighborhood point covariance for point cloud datasets and solve the covariance matrix. The direction of the eigenvector corresponding to the smallest eigenvalue is defined as the normal value of the point. The curvature of the point is then estimated based on the surface variation of the point in the local area. The curvature $Cu{r}_i$ is calculated as follows:

First, the following is calculated:

$$C_i·v_j={\lambda }_j·v_j$$

(4)

This is transformed into solving the eigenvalues and eigenvectors of matrix $C_i$, where matrix $C_i$ is a covariance matrix of k points, and ($v_1$, $v_2$, $v_3$) are the eigenvectors of the matrix. Each data point $K_i$ in the point cloud corresponds to matrix $C_i$ as follows:

$$C_{\mathrm{i}}={\left[\begin{array}{l}{K}_{i1}-\overline{K_i}\\ K_{ik}-\overline{K_i}\end{array}\right]}^T\left[\begin{array}{l}{K}_{i1}-\overline{K_i}\\ K_{ik}-\overline{K_i}\end{array}\right]$$

(5)

where $C_i$ is a positive semi-definite third-order symmetric matrix, $\overline{K_i}$ is the centroid of the point within the neighborhood of the key points $K_i$, and $K_{ik}$ is the coordinate of the point in the radius neighborhood of $K_i$. The three eigenvalues ${\lambda }_1$, ${\lambda }_2$, and ${\lambda }_3$ of matrix $C_i$ and the corresponding unit eigenvectors $e_1$, $e_2, \mathrm{and} e_3 \mathrm{are} \mathrm{then} \mathrm{calculated}.$ Assuming that ${\lambda }_{1 }$≤${\lambda }_2$≤${\lambda }_3$, ${\lambda }_1$ describes the change in the surface in the normal direction and represents the distribution of data points on the tangent plane, the curvature can then be expressed as

$$Cu{r}_i=\frac{{\lambda }_1}{{\lambda }_1+{\lambda }_2+{\lambda }_3}$$

(6)

2.2.2. Deviation Angle between Normals

Previous studies have demonstrated that a representation based on the deviation angle between two normals has a high discriminative power [9]. The normal directions of $K_i$ and $K_{ik}$ are $n_{K_i}$ and $n_{K_{ik}}$, respectively. The cosine of the normal angle between $K_i$ and $K_{ik}$ can be expressed as

$$cos\hspace{0.17em}{\theta }_{K_{ik}}=\frac{n_{K_i}·n_{K_{ik}}}{\left|n_{K_i}\right|\left|n_{K_{ik}}\right|}$$

(7)

The sum of the angles normal to the key points and all points in the radius neighborhood is calculated as follows:

$${\omega }_a\left(K_i\right)={\displaystyle \sum _{K_{ir}\in Surfac{e}_{ir}}{\theta }_{K_{ik}\hspace{0.17em}}}$$

(8)

Figure 2 shows a schematic of the angle between the normal vector of the feature and non-feature regions. In Figure 2a, the normal angle in the neighborhood of the key point $K_i$ is larger, which generally forms the feature region of the point cloud. In Figure 2b, the normal angle within the neighborhood of key point $K_i$ is smaller, which generally forms the non-featured region of the point cloud. Therefore, the normal vector angle is also used as a parameter to calculate the feature description of the point cloud.

2.2.3. Sum of Distances between Neighborhood Points

For the radius neighborhood of a key point, the number of points within the neighborhood generally differs; therefore, the local 3D geometric features can be described by the distance sum of the neighborhood points.

The sum of the distances between the key points and the neighboring points reflects the characteristics of the point cloud. The point cloud feature is distinguished using the sum of the distances between the key points and neighboring points as the distance parameter.

The distance from a point in the neighborhood to a point in the radius neighborhood can be expressed using the following formula:

$${\omega }_d(K_i)={\displaystyle \sum _{K_{ir}\in Surfac{e}_{ir}}\left|K_{ik}-K_i\right|}$$

(9)

Figure 3 shows a diagram of the neighborhood point distances, where $K_i$ is the key point, and $K_{ik}$ is the point within the radius neighborhood of $K_i$.

After proposing three local geometric features, three sub-histograms are obtained: the sum of the distances between neighborhood points, the sum of the curvatures, and the sum of angles between the normal direction of the key point and the normal direction of the neighborhood points. Figure 4 shows a schematic of the NPFH feature-description mechanism. A 3DNPFH descriptor is created by combining the three sub-histograms above into a single histogram. The following are the three primary characteristics of the NPFH descriptor: The NPFH descriptor is computationally efficient, the three local geometric characteristics of the NPFH descriptor are low-dimensional and computationally efficient, and the computational cost of the NPFH descriptor is O(k), where k is the number of points within the radius neighborhood of key point $K_i$.

2.3. Matching

Taking advantage of the fact that key points generated by similar 3D surfaces are close to each other in the new 3D coordinate system, we apply the following matching of the 3DNPFH descriptors. First, the extracted key points are transformed into a new 3D coordinate system by constructing local reference coordinate systems for the key point neighborhood surfaces in the source and target point clouds. Then, for each source key point $K_{i-source}$ in the new 3D coordinate system, we find a list of the closest target key points $K_{i-target}$ in the new system that lie within the radius threshold $T_d$. Finally, we find the most accurate nearest neighbors in the 3DNPFH descriptor using a Euclidean distance search to form the corresponding point pairs in the to-be-matched list.

2.4. Mismatch Rejection of RANSAC

The corresponding point pairs are identified using the 3DNPFH feature-based descriptors. This study uses the RANSAC algorithm to eliminate mismatched pairs and improve the alignment accuracy of two-point clouds. Assuming that n matching pairs are obtained after the above feature matching, the RANSAC algorithm is used to reject false matches and obtain the transformation relationships between the point clouds as follows:

Step 1: Randomly select three non-collinear points from the source point cloud P, denoted as $\{p_1,p_2,p_3\}$, and search for their corresponding points from the target point cloud Q, which are denoted as $\{q_1,q_2,q_3\}$, $\{p_1,p_2,p_3\}$, and $\{q_1,q_2,q_3\}$, as samples.

Step 2: Use the samples to estimate the rigid body transformation matrix $H$.

Step 3: Using the model estimation matrix, transform the remaining points in the source point cloud $P$ and calculate the distance error between all points in the transformed source point cloud $P$ and the target point cloud $Q$ if the distance error of one point pair is below the set threshold. If there is an error, the point is added to the interior point set $U$; otherwise, it is an outlier.

Step 4: Repeat the above process until the number of points in the interior point set reaches the set threshold or the iteration number becomes greater than the maximum iteration number, and then stop the iterative calculations.

Step 5: Select the model parameter $H$ with the most significant number of interior points in the interior point set as the optimal model parameter and use the optimal model parameter $H$ to achieve a rough registration of the point cloud.

Because of the increased proportion of correct points in the set of correspondence points optimized using the RANSAC algorithm, the resulting rigid body transformation matrix is more accurate and effectively reduces the error in the point cloud alignment. However, RANSAC requires multiple iterations in the algorithm, and thus a lengthy time is required to obtain optimal results when the number of correspondence point pairs is large. Therefore, when using the RANSAC algorithm, care should be taken to set the threshold error and the number of iterations, as reasonable settings can help improve the rejection of erroneous point pairs.

3. Results

This section describes a performance test of our algorithm on four public datasets and on our own data, and compares the results with those of existing state-of-the-art descriptors. All experiments were conducted on a laptop with an Intel 2.40-GHz i5-10200H processor and 16 GB of memory, and the algorithms were implemented on Microsoft Visual Studio 2019 and the Point Cloud Library (PCL). To verify the effectiveness of the algorithm, in this study, the FPFH and 3DHoPD algorithms are compared under similar environments.

3.1. Experimental Data

This experiment first uses the open-source “Happy Buddha,” “Bunny,” “Armadillo” [24] and “Chicken” point cloud data [25], taken from the “Bologna” object recognition dataset, the “UWA” dataset, and the “random view” dataset. The numbers of points in the point cloud data in the experiment were as follows: Happy Buddha (32,316, 31,424), Bunny (34,834, 34,618), Armadillo (28,885, 32,385), and Chicken (135,142, 135,142). We then used a locally scanned mobile phone camera module point cloud for testing to further verify the effectiveness of the algorithm. The number of points in the point cloud of the “Camera Module” is (171,996, 171,979). The relevant information regarding the data used in this study is listed in

Table 1. Data used in the experiment.

No.	Model	Acquisition	Quality	Dimension	Data Set
1	Happy Buddha	Synthesis	High	3D	Bologna
2 3 4 5	Armadillo Bunny Chicken Camera Module	Minolta vivid Synthesis Synthesis SR7080	Medium High High High	2.5D 3D 3D 3D	Random View Bologna UWA Bologna Ours

, and the initial pose of the point cloud data is shown in Figure 5.

3.2. Selection of Main Parameters

The choice of relevant parameters directly affects the registration results. To measure the registration effect under different parameters, we use the most commonly applied root-mean-square error (RMSE) to measure the accuracy of the point cloud registration. This is defined as

$$RMSE=\sqrt{\frac{1}{N}{{\displaystyle {\sum }_{i=1}^N\Vert P_i-Q_i\Vert }}^2}$$

(10)

where $P_i$ and $Q_i$ are two corresponding points, and N is the number of matching point pairs. The smaller the RMSE is, the better the alignment of the two-point clouds.

In this study, uniform sampling is used to extract the key points.

Table 2. Number of key points under different voxel sizes.

Grid Size/m	0.01	0.013	0.015	0.017	0.02
Source points (P)	640	375	279	279	146
Target points (Q)	671	377	388	288	141

lists the number of sampling points for the “Happy Buddha” dataset for the different grid sizes. To reduce the running time of the algorithm, there are generally several hundred key points. Figure 6 shows the registration results for the different voxels. As shown in the figure, with an increase in the grid size, the registration time and number of feature points gradually decrease, and the RMSE is the lowest when the voxel size is 0.015 m. Therefore, we set the voxel size to 0.015 m.

Table 3. Registration errors under different values of ${\epsilon }_{ransac}$.

$${\mathit{\epsilon }}_{\mathit{r}\mathit{a}\mathit{n}\mathit{s}\mathit{a}\mathit{c}}/\mathbf{m}$$	0.002	0.003	0.004	0.005	0.01
RMSE/m	---	0.00632	0.00172	0.00172	0.00172
Time/s	3.081	3.002	2.902	2.632	2.552

shows the registration results of the Happy Buddha image dataset under different values of ${\epsilon }_{ransac}$. When the value of ${\epsilon }_{ransac}$ is too large, the distance threshold of the corresponding point pair increases, leading to an increase in the calculation error. When the value of ${\epsilon }_{ransac}$ is too small, the distance threshold of the corresponding point pair becomes smaller, leading to a decrease in the number of corresponding points; thus, the model parameters cannot be accurately estimated, and the registration fails. When ${\epsilon }_{ransac}$ is 0.01, the registration time of the algorithm is the shortest, and the root-mean-square error is the smallest.

3.3. Evaluation

To better test the effectiveness of the proposed descriptors, this section compares the algorithm with the well-performing FPFH and 3DHoPD algorithms. The registration results are first evaluated through a visualization and then by applying the well-known RMSE. The RMSE is defined through (5). Figure 7 shows the registration effect of the FPFH, 3DHoPD, and our proposed algorithms. The target point cloud is shown in red, and the registered point cloud is shown in blue.

Table 4. Registration errors of five models.

Model	FPFH	3DHoPD	Proposed
Happy Buddha	0.00544	0.00364	0.00172
Armadillo	0.00436	0.00410	0.00314
Bunny	0.00317	0.00331	0.00148
Chicken	0.00259	0.00302	0.00248
Camera Module	0.05895	0.05992	0.05739

lists the coarse registration RMSE values for each algorithm for the five models. The best results are highlighted in bold. From the experimental results, it can be seen that for all test point cloud data, our proposed algorithm achieves the smallest registration error for the five models, which further demonstrates the effectiveness of the proposed 3DNPFH descriptor. If a precise ICP registration is required in the future, our algorithm will provide a smaller pose registration, which requires fewer iterations to achieve better results.

Table 5. Comparison of the registration times of all algorithms for the five models.

Model	FPFH	3DHoPD	Proposed
Happy Buddha Armadillo Bunny Chicken Camera Module	3.693 3.286 3.076 63.781 14.432	2.620 2.507 2.415 7.611 5.875	1.828 1.514 1.217 6.262 4.232
Total	88.268	21.028	15.053

lists the registration times of the five models under the three different algorithms. The proposed method is the most effective. This is mainly due to the low number of dimensions of our proposed descriptor, i.e., only six. In addition, we significantly reduced the search space of the corresponding point pairs through “3D” descriptors, avoiding a complex corresponding point pair search. The total registration time of our method for the five models was only 1/6 that of the FPFH method and 7/10 that of the 3DHoPD approach. For the FPFH algorithm, which has 33 dimensions, its extraction time is significantly higher than that of the other descriptors because the supported radius size for the descriptor extraction doubles when calculating the SPFH. This was verified on the “Chicken” and “Camera Module” point clouds. Because of the higher density in these clouds, the number of points in the 3D sphere increases exponentially with the increase in the support radius size. Therefore, the computational cost of the FPFH is high in high-density point clouds or with larger support radius sizes [26]. For the 3DHoPD algorithm, which has 18 dimensions, the calculation of the histogram of point distributions (HoPD) descriptor considers the changes in the surface along the x-, y-, and z-directions, and then calculates the number of points by normalizing the histogram. However, this cannot explain the small surface changes (using a normal is helpful in this case).

The above experiments revealed that the FPFH algorithm, 3DHoPD algorithm, and our proposed method successfully registered five of the models, and the registration error of the proposed algorithm was the smallest. Additionally, our approach requires the shortest registration time and exhibits a higher efficiency. Therefore, the proposed algorithm achieves a significant improvement over other previous algorithms.

4. Conclusions

We propose a point cloud registration algorithm based on the 3DNPFH descriptor. The algorithm first uniformly samples the point cloud to extract the key points, transfers the key points to a new 3D coordinate system by constructing a local reference coordinate system of the point cloud, and significantly reduces the coordinate search system during feature matching based on key points of similar surfaces that are close to each other. Then, by combining the density, curvature, and normal vector information of the point cloud, a neighborhood point feature histogram is constructed to find exact matches. Comparing popular point cloud registration algorithms on different datasets, we deduce that this algorithm is faster and maintains a similar level of registration accuracy, making it more suitable for point cloud registration systems than existing algorithms.