Point Cloud Registration Based on Local Variation of Surface Keypoints

Abstract

Keypoint detection plays a pivotal role in three-dimensional computer vision, with widespread applications in improving registration precision and efficiency. However, current keypoint detection methods often suffer from poor robustness and low discriminability. In this study, a novel keypoint detection approach based on the local variation of surface (LVS) is proposed. The LVS keypoint detection method comprises three main steps. Firstly, the surface variation index for each point is calculated using the local coordinate system. Subsequently, points with a surface variation index lower than the local average are identified as initial keypoints. Lastly, the final keypoints are determined by selecting the minimum value within the neighborhood from the initial keypoints. Additionally, a sampling consensus correspondence estimation algorithm based on geometric constraints (SAC-GC) for efficient and robust estimation of optimal transformations in correspondences is proposed. By combining LVS and SAC-GC, we propose a coarse-to-fine point cloud registration algorithm. Experimental results on four public datasets demonstrate that the LVS keypoint detection algorithm offers improved repeatability and robustness, particularly when dealing with noisy, occluded, or cluttered point clouds. The proposed coarse-to-fine point cloud registration algorithm also exhibits enhanced robustness and computational efficiency.

1. Introduction

In the field of computer vision, 3D point cloud registration has garnered significant attention due to its widespread applications in various domains, including 3D reconstruction [1], object recognition [2], autonomous navigation [3], and cultural heritage preservation. The core objective of point cloud registration is to precisely align point clouds originating from distinct coordinate systems into a common reference frame. This process enables the calculation of rotation and translation transformation matrices between two target point clouds [4]. The advent of low-cost point cloud acquisition devices, such as Microsoft Kinect and Intel RealSense, has made point cloud data acquisition more accessible. Due to viewpoint limitations, it is often necessary to capture a complete 3D model from multiple different angles. As a result, point cloud registration techniques are employed to align point clouds obtained from various viewpoints in a pairwise manner.

Currently, existing methods for three-dimensional point cloud registration fall into four broad categories: direct georeferencing, target-based registration, surface-based registration, and feature-based registration [5]. The global feature descriptors encode the geometric information of the entire point cloud using a set of global features. However, global features ignore local shape information, making it challenging to register point clouds with occlusions and clutter. Specifically, on one hand, scenes with clutter and occlusions contain a significant number of outliers and missing scene information, which can lead to algorithms becoming stuck in local optima. On the other hand, large-scale point clouds have more points, and global descriptor algorithms need to process more data points, thus increasing computational complexity. In contrast, methods based on local feature descriptors encode the information from the local neighborhood of keypoint, requiring only a minimum of three corresponding point pairs to achieve registration. As a result, they significantly enhance the success rate of registration, especially in scenarios with occlusion and low overlap.

Keypoint detection serves as a crucial step in registration methods based on local feature descriptors. Over the past decade, numerous keypoint detection algorithms have been proposed for 3D reconstruction and point cloud simplification. Existing keypoint detection algorithms can be broadly classified into two categories: fixed-size and adaptive-size detection algorithms [6]. Fixed-size detection algorithms detect keypoints using a constant scale, which remains unchanged, regardless of variations in the feature scales of different regions within the point cloud. Examples of such algorithms include intrinsic shape signatures (ISS) [7], local surface patches (LSP), Harris 3D [8], and keypoint quality (KPQ) [9], among others. However, each of these methods has its limitations in practical applications. For instance, LSP detects keypoints uniformly but with relatively low repeatability [10], and KPQ tends to perform poorly in scenarios involving partial occlusion [6]. On the other hand, adaptive-size detection algorithms generate multiple scales for the input point cloud and detect keypoints at different scales, as observed in MeshDog and KPQ-AS [9]. Adaptive-size detection algorithms generally outperform fixed-size approaches [10], but they come with added complexity in scale computation, resulting in increased computational overhead. In contrast, fixed-size detection algorithms are computationally more efficient due to their simplicity. However, they tend to perform satisfactorily primarily when dealing with high-quality point clouds. In the presence of significant noise, occlusion, and low resolution in input point clouds, keypoints often exhibit low repeatability and tend to cluster in specific areas, significantly limiting their utility.

To address the aforementioned issues, this paper introduces a keypoint detection algorithm based on the local variation of the surface (LVS) and a point cloud registration method based on LVS. The core idea behind LVS is the uniform detection of keypoints displaying local surface variation within the point cloud. It initially establishes a local coordinate system for each point within the keypoint’s neighborhood to calculate the surface variation index. Subsequently, points with surface variation index values lower than the local average are designated as initial keypoints. Finally, the algorithm searches within the initial keypoint set for points in the neighborhood and selects those with the minimum surface variation index as keypoints.

The LVS-based registration algorithm encompasses keypoint detection, feature description, transformation estimation, and fine registration. LVS is utilized for keypoint detection, while SAC-GC is employed for transformation estimation. To assess the performance of LVS and the proposed registration method, comprehensive experiments and comparisons were conducted on four datasets. The results of these experiments indicate that the LVS keypoint detection algorithm introduced in this paper achieves higher repeatability and enhanced robustness in the presence of interference. Furthermore, registration experiments on the BMR dataset demonstrate that the LVS-based registration method outperforms state-of-the-art approaches.

This article makes the following contributions:

Firstly, it introduces a novel LVS keypoint detection algorithm that exhibits exceptional repeatability and robustness and is particularly well-suited for addressing issues like noise, occlusions, and clutter in point cloud data.

Secondly, it proposes a coarse-to-fine point cloud registration algorithm combining LVS and SAC-GC that seamlessly combines high accuracy and computational efficiency, showcasing outstanding performance in pairwise point cloud registration.

The remaining sections of the paper are organized as follows: Section 3 elaborates on the LVS keypoint detection method and technical details and introduces the LVS-based point cloud registration algorithm. Section 4 presents a comprehensive evaluation of the LVS keypoint and the proposed point cloud registration algorithm. Finally, Section 5 summarizes the findings and outlines future research directions.

2. Related Work

In the realm of point cloud registration, the current approach predominantly involves a combination of coarse registration and fine registration. Coarse registration quickly estimates the rigid transformation between two initial point clouds, offering an excellent initial position for fine registration. Fine registration, in turn, uses the initial pose from coarse registration to iteratively obtain the optimal transformation matrix [11]. The main challenge in this process lies in obtaining a robust initial pose during the coarse registration phase, with keypoint detection playing a crucial role. This study, therefore, places its focus on keypoint detection, and existing keypoint detectors are reviewed.

Sipiran et al. [8] introduced a three-dimensional version of the Harris operator (Harris 3D), inspired by its two-dimensional counterpart, using surface normals to compute the gradient of the covariance matrix. However, the performance of two-dimensional methods in a three-dimensional space is somewhat limited, particularly in terms of keypoint repeatability. To address the issue of a limited number of keypoints detected by Harris 3D, Wang et al. [12] proposed the nearest neighbor search (NNS) Harris 3D algorithm, which enhances the original Harris 3D keypoints by including multiple neighboring points as keypoints. Chen et al. [13] introduced the local surface patches (LSP) keypoint detection algorithm, which employs point shape indices to identify candidate keypoints and utilizes non-maximum suppression (NMS) to select the final keypoints. Despite achieving an even distribution of keypoints, LSP’s repeatability is relatively poor. Building upon LSP, Zeng et al. [14] presented the double Gaussian weighted dissimilarity measure (DGWDM) keypoint detection algorithm. DGWDM detects keypoints in two stages. Initially, it identifies initial keypoints based on local dissimilarity values and subsequently determines final keypoints using a multi-scale detection strategy. However, this method requires additional point cloud mesh information. Zhong et al. [7] introduced the intrinsic shape signatures (ISS) algorithm, which utilizes the ratio of eigenvalues of the covariance matrix and employs NMS to filter keypoints. The number of keypoints detected by this algorithm is roughly similar to the LSP method. Main et al. [9] proposed the keypoint quality (KPQ) keypoint detection method, which initially determines keypoints based on the ratio of local coordinate axes and subsequently selects the final keypoints by setting a keypoint quality parameter threshold. Compared to the ISS algorithm, KPQ uses fewer constraints in the non-maximum suppression step, to detect more keypoints, but increases computational complexity by using keypoint quality for final point selection [6]. Building upon LSP and KPQ, Lan et al. [15] introduced a keypoint detection algorithm based on the normalized shape index. This method initially detects keypoints using the coordinate axis ratios from KPQ and shape indices from LSP and subsequently determines final keypoints based on local dissimilarity measure values at different radii. Xiong et al. [16] presented a keypoint detection algorithm based on surface transformation and eigenvalue change indices, which combines the advantages of ISS and KPQ to improve repeatability. In the realm of keypoint detection based on normal vectors, Prakhya et al. [17] presented a keypoint detection algorithm based on surface transformation and eigenvalue change indices, which combines the advantages of ISS and KPQ to improve repeatability. Also in the realm of keypoint detection based on normal vectors, Muhammad et al. [10] introduced the fuzzy logic and normal orientation (Fuzzy-HoNo) algorithm, which enhances keypoint detection through soft decision boundaries and adaptive parameters. While it improves keypoint detection, this algorithm does entail higher computational complexity.

3. Method

3.1. Local Variation of Service Keypoint Detection

The LVS keypoint detection algorithm is primarily composed of three fundamental steps: the computation of the surface variation index, the detection of candidate keypoints, and the determination of the final keypoints. The purpose of the surface variation index is to represent local surface characteristics in a way that assigns higher values to regions with significant changes, while flat areas receive lower values. Candidate keypoint detection aims to identify points in local regions with noticeable changes, while excluding points in flat regions. The final keypoints are then derived through a simplification step aimed at reducing the number of points in changing regions, thus enhancing the quality of the final keypoints. Figure 1 illustrates the keypoint detection process, with Figure 1a originating from the B3R dataset bunny. Figure 1b displays the candidate keypoints, and Figure 1c showcases the ultimately determined keypoints.

3.1.1. Computation of Surface Variation Index

For any point $p$ in the point cloud, its neighborhood point set $Q=\{q_1,q_2,\cdots ,q_k\}$ is determined within a spherical neighborhood defined by the condition $‖p-q_i‖<R$, where the search radius R is manually set. To enhance robustness against noise, the entire neighborhood point set $Q$ is employed for the calculation of the covariance matrix. The covariance matrix $C$ based on $Q$ is constructed as follows:

$$C=\frac{1}{k}{\displaystyle \sum _{i=1}^k(q_i-\overline{q}){(q_i-\overline{q})}^T}$$

(1)

$$\overline{q}=\frac{1}{k}{\displaystyle \sum _{i=1}^k{q}_i}$$

(2)

where k represents the number of points in the set $Q$ and $\overline{q}$ represents the centroid of $Q$. To calculate the eigenvectors and eigenvalues of the covariance matrix $C$, Equation (3) is employed. The eigenvectors correspond to the coordinate axes of the local reference frame.

$$CV=DV$$

(3)

where $D=[{\lambda }_1,{\lambda }_2,{\lambda }_3]$ is a diagonal matrix containing the eigenvalues of $C$, and it satisfies ${\lambda }_1<{\lambda }_2<{\lambda }_3$. $V=[v_1,v_2,v_3]$ represents the matrix of eigenvectors corresponding to the eigenvalues.

Utilizing the Hotelling transformation [16] as per Equation (4), the points in $Q$ are transformed into a local reference frame formed by the three eigenvectors, as shown in Figure 2. The new neighborhood point set can be denoted as $Q\prime =\{q_1^{\prime },q_2^{\prime },\cdots ,q_k^{\prime }\}$.

$$q_1^{\prime }=V(q_i-\overline{q})$$

(4)

We define $Y$ and $Z$ to represent the components of the points in $Q$ along the $Y$ axis and $Z$ axis, respectively.

$$Y=\{y_1,y_2,\cdots ,y_k\}$$

(5)

$$Z=\{z_1,z_2,\cdots ,z_k\}$$

(6)

We selected the absolute value ratio of the point distribution distances along the $Y$ and $Z$ axes, which achieved the best results through the experimental comparison of three different surface variation indices $\left(\frac{\left|\overline{Y}\right|}{\left|\overline{Z}\right|},\frac{\left|\overline{X}\right|}{\left|\overline{Z}\right|},\frac{\left|\overline{X}\right|}{\left|\overline{Y}\right|}\right)$ to calculate the surface variation index $\rho$ for point $p$. $\rho$ is calculated as

$$\rho =\frac{\left|\overline{Y}\right|}{\left|\overline{Z}\right|}$$

(7)

3.1.2. Detection of Candidate Keypoints

As illustrated in Figure 3, the projection distribution of local neighborhood points on the $Y-Z$ plane reflects the local surface geometric changes of the point. $\rho$ denotes the extent of local surface geometric changes. In flat regions, the value of $\rho$ tends towards infinity, while in salient regions, it gradually approaches one. For feature-rich regions, the value of $\rho$ must be greater than one. It is important to note that setting the value of $\rho$ too small would result in an excessive concentration of keypoints in areas with drastic surface changes, whereas setting it too large would lead to the detection of an excessive number of keypoints. To effectively detect keypoints in different regions, the average surface variation index of point p serves as the threshold for keypoint detection. The average surface variation index is defined as follows:

$$\overline{\rho }=\frac{1}{k}{{\displaystyle \sum }}_{i=1}^k{\rho }_i$$

(8)

where ${\rho }_i$ represents the surface variation index of the neighborhood points of point $p$.

To select local surface salient areas as feature regions, the points for which the surface variation index at point p is less than the average surface variation index are defined as follows:

$$\rho <\overline{\rho }$$

(9)

Points that satisfy Equation (9) are called candidate keypoints.

3.1.3. Determination of Final Keypoint

As there may be an excessive number of candidate keypoints that meet the specified conditions, and as some of these points may not adequately represent the characteristics of the region, additional refinement of the candidate keypoints is necessary. Therefore, within the candidate keypoint set, for any point $p_m$, an approach is employed to select the final keypoint. Within a neighborhood of radius $R$ surrounding the candidate keypoint, the point with the minimum value of $\rho$ is considered as the final keypoint. It is worth noting that the method is similar to non-maximum suppression (NMS). However, in comparison to NMS, our criteria are more permissive. To be specific, while searching for local minima within each neighborhood, we retain non-minimum points within each neighborhood rather than discarding them. The conditions for determining keypoints can be expressed as follows:

$$\rho \left(p_{mi}\right)=min\left(\rho \left(p_{m1}\right),\rho \left(p_{m2}\right)\cdots \rho \left(p_{mn}\right)\right)$$

(10)

where $p_{mi}$ represents a keypoint, and $\rho (p_{m1}),\rho (p_{m2}),\cdots ,\rho (p_{mn})$ represents the surface variation indices of the candidate keypoints within a radius $R$. The pseudocode summarizing the detection steps of the proposed method is outlined in Algorithm 1.

Algorithm 1 LVS keypoint detection algorithm
	Input: Point Cloud $P$
	Output: Keypoints
1:	procedure surface variation Index Value Estimation
2:	for every point $p_i\in \begin{array}{cc}Input& Cloud\end{array}$ do
3:	Calculate Neigh Covariance Matrix $C_i$
4:	Convert neighborhood points to a new coordinate system
5:	Calculate Surface variation Index Value $\rho$
6:	return $\rho$
7:	procedure Candidate Keypoint Detection
8:	for every point $p_1\in P$ do
9:	Calculate Neigh mean surface variation Index Value $\overline{\rho }$
10:	if ${\rho }_{(p_i)}<\overline{\rho }$
11:	Candidate Keypoint $\leftarrow p_i$
12:	return Candidate Keypoint
13:	procedure Final Keypoint Determination
14:	for every point $q_i\in \begin{array}{cc}Candidate& Keypo\mathrm{int}\end{array}$ do
15:	get Nearest Neighbours $g_i$
16:	if ${\rho }_{(q_i)}<{\rho }_{(g_i)}$
17:	Keypoints $\leftarrow q_i$
18:	Return Keypoints

3.2. Coarse-to-Fine Point Cloud Registration

Based on the proposed LVS keypoint detection algorithm, a coarse-to-fine point cloud registration method has been developed. It mainly consists of three parts: LVS keypoint detection and description, efficient SAC-GC transformation estimation, and fine registration.

3.2.1. Local Variation of Service Keypoint Detection and Description

Using $P_s$ and $Q_t$ to represent the input source and target point clouds, first, the proposed LVS keypoint detection algorithm is used to detect keypoints, denoted as $\{p_1,p_2,\cdots ,p_k\}$ and $\{q_1,q_2,\cdots ,q_n\}$, respectively. Furthermore, it is essential to describe the neighborhood information of keypoints, since the keypoints detected may contain errors due to noise or originate from different source point clouds. Descriptors, on the other hand, represent abstract structural attributes of keypoints, encapsulating more information and being less susceptible to coordinate transformations. They play a crucial role in distinguishing between different keypoints and enhancing the accuracy of the registration process. For robustness, the SHOT descriptor is used to describe $\{p_1,p_2,\cdots ,p_k\}$ and $\{q_1,q_2,\cdots ,q_n\}$, resulting in the feature vectors $F_p=\{f_1^p,f_2^p,\cdots ,f_k^p\}$ and $F_q=\{f_1^q,f_2^q,\cdots ,f_n^q\}$.

3.2.2. Transformation Estimation via the Sampling Consensus Correspondence Estimation Algorithm (SAC-GC)

Once the SHOT features have been computed, the next step is to establish correspondences between the feature vectors. A common approach is to select the nearest point features as corresponding point pairs. However, it is important to note that source and target point clouds often have overlapping regions only in part, which implies that correspondences exist only for some features. It is necessary to filter out non-matching keypoint pairs as

$$‖f_i^p-f_j^q‖<{\epsilon }_1$$

(11)

Among these pairs $f_i^p\in F_p$, $f_j^q\in F_q$, those feature vectors $(f_i^p,f_j^q)$ that satisfy the threshold criteria are considered as corresponding point pairs $(p_i,q_j)$. All point pairs that satisfy the threshold are collectively referred to as the initial correspondence set $C_{init}$. Despite using a threshold for filtering, the initial set $C_{init}$ may still contain numerous incorrect correspondences. Therefore, it is necessary to estimate the best transformation to align point cloud $P$ with point cloud $Q$ from the set $C_{init}$ that includes erroneous correspondences. Common techniques include the RANSAC algorithm and its variants [4,18]. However, these methods often suffer from low computational efficiency. Hence, this paper introduces an efficient and robust transformation estimation method, known as the SAC-GC algorithm. The SAC-GC algorithm is designed to identify the best transformation within a specified number of iterations, denoted as $N$ from the initial correspondence set $C_{init}$. Because the algorithm has randomness, too few iterations may not find a sufficiently good model, while too many iterations can increase the algorithm’s runtime. Based on our experience, $N$ takes 1000. In each iteration, three corresponding point pairs are randomly selected from this set $C_{init}$. Since the keypoint pairs maintain Euclidean distance invariance before and after a rigid transformation, if three correctly corresponding point pairs form a triangle, the triangle $\Delta ABC$ in the source point cloud will be congruent to the triangle $\Delta A\prime B\prime C\prime$ in the target point cloud, as follows:

$$\Delta ABC=\Delta A^{\prime }{B}^{\prime }{C}^{\prime }$$

(12)

$$\frac{AB}{A^{\prime }{B}^{\prime }}=\frac{AC}{A^{\prime }{C}^{\prime }}=\frac{BC}{B^{\prime }{C}^{\prime }}$$

(13)

However, owing to the presence of interference, there may be real differences between the two point clouds and the two triangles. To account for these differences, a geometric similarity discriminant function [19] is employed, to assess the geometric similarity between $\Delta ABC$ and $\Delta A\prime B\prime C\prime$. The discriminant function is as follows:

$$\left|\frac{AB}{A^{\prime }{B}^{\prime }}-1\right|+\left|\frac{AC}{A^{\prime }{C}^{\prime }}-1\right|+\left|\frac{BC}{B^{\prime }{C}^{\prime }}-1\right|<{\mathsf{\epsilon }}_2$$

(14)

where ${\epsilon }_2$ represents the similarity threshold. If the corresponding point pairs satisfy the constraint in Equation (14), the transformation matrix $T_i$ (containing the rotation matrix $R_i$ and translation matrix $T_i$) is computed to align point cloud P with point cloud $Q$.

Subsequently, the traditional RANSAC method evaluates the quality of $T_i$ through statistics of inlier count or nearest neighbor count. However, the inlier count-based method may not accurately estimate the correct transformation, when $C_{init}$ contains a large number of erroneous information. On the other hand, the nearest neighbor count-based method requires the computation of the nearest neighbors in each iteration, which leads to higher computational complexity. In this study, we use the distance score between the corresponding points $c=\left\{\left(p^s,q^t\right),p^s\in P_s,q^t\in Q_t\right\}$ as the criteria for selecting inliers. This distance score is defined as:

$$S(c_j)=\left\{\begin{array}{c} \left|e\left(c_j\right)-{\mathsf{\epsilon }}_3\right|\hspace{1em}if\hspace{1em}e\left(c_j\right)<{\mathsf{\epsilon }}_3\\ 0\end{array}\right.$$

(15)

where $e(c_j)=‖R_i{p}_j^s+t_i-q_j^t‖$, ${\epsilon }_3$ is the distance threshold, which is set to 7.5 mr, by default. This choice is based on a local feature descriptor with a support radius of 15 mr [20]. Finally, considering the high outlier rate in point cloud registration, which can lead to the failure of non-randomness and maximal condition, the iteration count is chosen as the termination criterion for the algorithm. The above steps are repeated until the iteration count exceeds the threshold N, and the transformation matrix $T^{*}$ corresponding to the maximum distance score is selected as the final rotation matrix. Figure 4 illustrates the estimation process of SAC-GC.

3.2.3. Fine Registration

After applying the SAC-GC algorithm to accomplish coarse point cloud registration, the next step is to proceed with further fine registration. While coarse registration provides an initial alignment for point clouds $P_s$ and $Q_t$, a more precise registration is necessary. To achieve this, we utilize the classic iterative closest point (ICP) algorithm [21] to further refine the results. The primary concept behind the ICP algorithm is to achieve accurate registration by minimizing the distance between point clouds $P_s$ and $Q_t$. The ICP function is as follows:

$$R^{\ast },t^{\ast }={\arg min}_{R,t}\frac{1}{N}{\sum }_{i=1}^N{‖p_i-(R{q}_i+t)‖}^2$$

(16)

4. Experimental Results and Discussion

In this section, a series of experiments were conducted to evaluate the LVS keypoint detection algorithm, including assessing relative repeatability, absolute repeatability, and computational time. Four distinct datasets were utilized in these experiments to provide a comprehensive assessment of the algorithm’s performance. Furthermore, the point cloud registration method, based on LVS keypoints, was subjected to tests to evaluate its accuracy and robustness using the BMR dataset. It is important to note that all these experiments were carried out on a computer equipped with an Intel Core i5-13600kf 3.5 GHz processor and 32 GB of RAM, sourced from Lenovo, a Chinese brand based in Changchun.

4.1. Datasets

There were four datasets used to assess the performance of the proposed LVS keypoint detection method. These datasets are Stanford 3D, B3R, U3OR, and Queen. Figure 5 provides visual representations of the models and scenes within these four datasets.

The Stanford 3D dataset [22] consists of six models and their corresponding range data obtained through the Cyberware 3030 MS scanner. The point cloud data are noise-free, with a resolution of approximately 0.5 mm. The B3R dataset [23] includes six models and 18 scenes from the Stanford 3D Scanning Repository. These 18 scenes are generated by applying random transformations to the six models and adding Gaussian noise, with the values of 0.1, 0.3, and 0.5 milliradians. The data collection equipment is the same as the Stanford 3D dataset, and the data are primarily affected by rigid transformations and noise, with no occlusion. The U3OR dataset [24] comprises five models and 50 scenes. Each scene is composed of four or five models and captured using the Minolta Vivid 910 scanner with a resolution of around 0.6 mm. The data are free of noise but include occlusion and clutter. The Queen dataset [25] is composed of five models and 80 scenes, acquired using the Konica-Minolta Vivid 3D scanner. Compared to U3OR, the Queen dataset has more scene models and lower-quality data, including noise, occlusion, clutter, and resolution variations.

4.2. Parameter Analysis

The neighborhood radius $R$ is a crucial parameter in point cloud feature detection, and its value directly influences the recognition of point cloud features. If $R$ is set too large, it increases computational complexity and diminishes robustness against occlusions and point cloud boundaries. Conversely, when $R$ is set too small, it diminishes feature distinctiveness. To better analyze the impact of the neighborhood radius $R$ on keypoint detection, a methodology similar to that in reference [6] was employed. The Stanford point cloud data were used as test data, as discussed in detail in Section 4.1, and Gaussian noise, with values of 0.1 mr, 0.2 mr, and 0.3 mr, was introduced into the test point cloud. The neighborhood radius was set at 6 mr, 8 mr, 10 mr, 12 mr, 14 mr, 16 mr, and 18 mr where mr represents the point cloud resolution, which indicates the average distance between neighboring points in the point cloud. The relative repeatability and absolute repeatability of keypoint detection were assessed separately. Relative repeatability is defined by Formula (17), while absolute repeatability is defined by Formula (18). We also evaluated the computation time. The experimental results are presented in Figure 6.

As shown in Figure 6a, the relative repeatability of keypoints demonstrates an increase as the neighborhood radius R expands for different noise levels. When R is set at values less than 10 mr, the relative repeatability of keypoints experiences a significant uptick as the radius increases, particularly in the case of various noise point cloud data. Nevertheless, when R surpasses 10 mr, the relative repeatability of keypoints registers a more gradual increase with the expanding radius. In Figure 6b, the absolute repeatability of keypoints follows a consistent pattern, decreasing linearly as the neighborhood radius grows across different noise levels. This outcome is attributed to the increasing radius, leading to the detection of more stable features while filtering out lower-quality keypoints. In Figure 6c, it is shown that the growth is slow for R values less than 10 mr, and then it increases rapidly. Consequently, it is concluded that a neighborhood radius of 10 mr is well-suited for the keypoint detection method.

4.3. Evaluation Criteria for Keypoints

All keypoint methods employ keypoint repeatability as a widely accepted evaluation criterion. Evaluation methods for keypoint repeatability can be found in the following references [6,11,18]. Keypoint repeatability pertains to the capability of a keypoint detection algorithm to consistently locate the same keypoint in the same local region of the same model. High keypoint repeatability indicates that the detection algorithm demonstrates strong resistance to interference, such as noise, occlusion, and clutter.

Keypoint repeatability is typically divided into two categories: relative repeatability and absolute repeatability. The primary calculation steps are as follows: first, keypoint sets are independently detected from the source point cloud and the target point cloud, denoted as $K_{ss}$ and $K_{ts}$, respectively. Next, the keypoints detected from the source point cloud are aligned to the target point cloud using the true rotation and translation matrices, where the true rotation and translation matrix data are provided from datasets. If a keypoint $k_s$ in the source point cloud is at a distance less than the threshold ${\epsilon }_4$ from the nearest neighbor keypoint $k_t$ in the target point cloud, it is considered repeatable; that is:

$$‖R{k}_s+T-k_s‖<{\mathsf{\epsilon }}_4$$

(17)

Based on Equation (17), the total number of keypoints that meet the conditions detected from the source point cloud is denoted as $n_r$. The definitions of absolute repeatability and relative repeatability are as follows:

$$r=\frac{n_{\mathrm{r}}}{n_{\mathrm{s}}}$$

(18)

$$r_{\mathrm{abs}}=n_{\mathrm{r}}$$

(19)

where $n_s$ is the number of keypoints in the source point cloud.

4.4. Keypoint Repeatability Experiment

In this experiment, the LVS keypoint detection algorithm proposed in this paper was compared with six advanced methods (ISS, HoNo, Harris 3D, KPQ, LSP, NNS Harris 3D) using four public datasets. Due to errors or interference in point cloud devices, true corresponding points may exhibit a small offset. Therefore, a threshold that is too small might exclude correct corresponding points, while a threshold that is too large could result in the consideration of erroneous points. The distance threshold ${\epsilon }_4$ was set to 2 mr, where mr represented the average distance between points in the point cloud. The neighborhood radius was set to 6 mr, 8 mr, 10 mr, 12 mr, 14 mr, 16 mr, and 18 mr, respectively. The experiment calculated the relative repeatability and absolute repeatability of each algorithm under varying neighborhood radii. The results are displayed in Figure 7.

For the B3R dataset, the robustness of all methods in noisy environments was evaluated. The results of keypoint detection algorithms are presented in Figure 7a–f. Regarding keypoint repeatability (Figure 7a–c), LVS and KPQ performed exceptionally well, significantly surpassing other methods. The line graphs clearly illustrate that the LVS keypoint detection algorithm can maintain a repeatability rate of over 80% across different noise levels, and this rate increases with the radius. Harris 3D and NNS Harris 3D also demonstrated decent performance, with a repeatability rate fluctuating around 80%. However, HoNo, LSP, and ISS performed less satisfactorily, possibly due to the sensitivity of HoNo’s normal vectors, LSP’s curvature to noise, and ISS potentially containing planar points. Regarding keypoint absolute repeatability (Figure 7d–f), it is evident that, under varying noise conditions, KPQ and LVS consistently have the highest number of repeatable keypoints compared to the other methods. The number of keypoints they detect is less affected by noise. In contrast, ISS, HoNo, Harris 3D, LSP, and NNS Harris 3D detect fewer keypoints, which may be attributed to the impact of non-maximum suppression, implying that non-maximum suppression filtered out a significant portion of the keypoints.

Robustness experiments were conducted for all keypoint detection algorithms under occlusion, clutter, and border conditions, using the Stanford 3D and U3OR datasets. The results are presented in Figure 8, where (a, b) represent relative repeatability. It is evident from the graphs that LVS outperforms all other algorithms on both datasets. In Figure 8d,e depicting absolute repeatability, it can be observed that as the radius increases, the number of repeatable points gradually decreases for all algorithms. However, LVS consistently maintains 1000 or more repeatable points at various radii, while the other methods gradually tend to zero. This demonstrates the robustness of LVS against occlusion, clutter, and border conditions. The robustness of LVS can be attributed to two key factors: firstly, LVS detects keypoints based on the average surface change index, eliminating points in flat regions and enhancing the quality of keypoints by filtering out redundant points.

The Queen dataset, being of lower quality than the others, presents significant challenges due to its higher noise level, complex background, and sparse point distribution. The results of the seven methods are presented in Figure 8c,f. Regarding relative repeatability, KPQ and NNS Harris 3D exhibit the largest fluctuations, while LVS remains relatively stable. Furthermore, the absolute repeatability of LVS surpasses that of the other methods, providing a substantial number of keypoints for subsequent registration. This underscores the robustness of the LVS keypoint detection algorithm in handling various interferences.

4.5. Keypoint Computation Efficiency

In this section, the efficiency of all methods will be compared. Since the efficiency of the keypoint computation is related to the number of points in the original point cloud, this study selected the B3R dataset for testing. Radii are set from 6 mr to 18 mr, with a 2 mr interval, and then seven keypoint detection algorithms are used to detect keypoints at different radii. The results of time consumption are shown in Figure 9.

We can observe that ISS is the most efficient method, since it only requires the computation of eigenvalue ratios. Secondly, KPQ is the most time-consuming, as it needs to perform surface fitting to compute keypoint quality. It is worth noting that LVS employs a method similar to KPQ but is more efficient relative to KPQ and HoNo.

4.6. Registration Algorithm Comparison Experiment

In this section, the proposed registration algorithm based on LVS is evaluated. The evaluation experiments include qualitative and quantitative analyses, as well as comparisons with state-of-the-art algorithms. These experiments use the BMR dataset, which comprises point clouds obtained from various viewpoints using a Microsoft Kinect device. The point clouds in this dataset are challenging, and are characterized by noise, occlusions, missing data, and variations in resolution. Therefore, this dataset provides a comprehensive assessment of the registration algorithm’s performance. The registration parameters for the algorithm are set based on the analysis in Section 4.2, with $R$ = 10 mr, ${\epsilon }_1=0.8$, ${\epsilon }_2=0.5$, $N_{iter}=1000$.

4.7. Qualitative Results

Figure 10 displays the registration results of the proposed method for point clouds with varying angles and overlap ratios. The original point clouds pose challenges such as holes, missing data, and occlusions, which can make registration a challenging task.

However, our registration method can establish partially accurate correspondences and compute initial poses, providing a good starting point for fine registration. This reflects the ability of the proposed LVS keypoint detection method to identify a significant number of repeatable keypoints and underscores the robustness of LVS features to various interferences. It is worth noting that our algorithm is fully automatic and requires only the input of source and target point clouds to produce registration results. To validate the effectiveness of the algorithm, we also present 15 registration results in Figure 11.

4.8. Quantitative Results

In addition to the visual analysis, we conducted quantitative analyses of the registration results, including the time required for registration, rotation error, and translation error.

To measure the accuracy of registration, rotation error and translation error were used. Rotation error is between the estimated and the true rotation matrix, while translation error is between the estimated and the true translation vector. Specifically, they are defined as follows:

$${\epsilon }_r=\arccos \left(\frac{trace(R_{GT}{(R_E)}^{-1})-1}{2}\right)\frac{180}{\pi }$$

(20)

$${\mathsf{\epsilon }}_t=\frac{‖t_{GT}-t_E‖}{mr}$$

(21)

where $R_{GT}$ and $t_{GT}$ are the results obtained through manual initial alignment and refined using ICP registration.

To further validate the superiority of our proposed registration algorithm, we conducted a comparison of registration errors between our method and other methods. To ensure a fair comparison, we utilized the same registration pipeline, and the various methods only replaced the keypoint detection algorithms. We estimated the initial pose using SAC-GC and the final pose using ICP. Subsequently, we compared the performance of different methods at 80% and 50% overlap rates, with the calculation of overlap rates following the reference [4].

Table 1. Comparison of our LVS-based registration algorithm with six state-of-the-art methods (the top two results are in bold).

Overlap	Dataset	Error	ISS	HoNo	Harris 3D	KPQ	LSP	NNS Harris 3D	LVS
80%	Doll	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	0.51	0.45	10.66	\	0.75	0.57	0.46
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	3.80	2.79	110.88	\	5.20	4.12	2.83
	Duck	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	0.55	3.54	0.65	6.25	5.27	0.55	0.33
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	5.78	32.26	3.92	58.42	27.70	3.12	1.43
	Frog	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	0.40	0.41	178.32	\	0.38	0.41	0.37
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	3.15	3.63	1066.16	\	2.97	3.42	2.87
	Mario	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	24.97	0.47	12.95	\	12.95	0.50	0.50
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	242.64	4.00	127.27	\	127.27	4.46	4.40
	PeterRabbit	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	1.48	0.62	13.07	10.93	4.89	0.51	0.52
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	15.24	5.16	125.71	38.55	45.37	4.94	5.09
	Squirrel	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	1.85	1.29	1.04	10.79	1.25	1.09	1.05
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	16.85	12.89	9.79	110.24	12.29	10.77	10.03
	Average	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	4.96	1.13	36.12	4.66	4.25	0.61	0.54
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	47.91	10.12	240.62	34.54	36.80	5.14	4.44
50%	Doll	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	110.27	147.30	7.52	\	7.52	7.52	3.15
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	917.70	683.73	72.21	\	63.21	73.21	30.00
	Duck	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	9.20	171.59	43.27	43.27	87.89	147.83	0.00
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	47.79	605.18	444.55	444.55	831.01	1022.37	1.03
	Frog	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	0.51	69.55	49.23	45.92	17.40	50.69	0.23
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	6.19	580.65	385.92	434.57	175.56	430.44	3.73
	Mario	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	144.41	88.12	42.19	\	42.12	42.12	2.84
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	608.96	735.43	410.49	\	410.49	410.49	25.08
	PeterRabbit	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	22.92	143.72	22.92	177.51	174.05	135.61	3.36
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	217.10	388.72	217.10	1102.38	1038.71	592.93	15.59
	Squirrel	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	121.71	147.97	30.40	\	30.40	49.50	2.71
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	880.65	965.57	274.43	\	274.42	255.23	21.08
	Average	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	68.17	128.04	32.57	44.45	59.89	72.21	2.05
		${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	446.40	659.88	300.95	330.25	467.23	464.11	16.09

presents all the registration results.

As indicated in Table 1, all methods exhibit notable errors in the fine registration results, primarily due to the substantial interference in the BMR dataset, which poses challenges in initial pose estimation. Nevertheless, the LVS-based registration method consistently achieves the lowest rotation and translation errors across all datasets. The KPQ method, which detects fewer keypoints, performs the least effectively. At an 80% overlap rate, both LVS and the method based on NNS Harris 3D outperform the other methods in all datasets. The remaining methods exhibit optimal performance in only a few datasets. As the overlap rate decreases to 50%, registration becomes more challenging, leading to increased errors for all registration methods. The methods based on HoNo, Harris 3D, KPQ, LSP, and NNS Harris 3D display significant rotation and translation errors across all datasets as they struggle to detect repeatable keypoints. The ISS-based method performs reasonably well only on the Frog dataset.

To validate the improvement in SAC-GC over RANSAC, tests were conducted by replacing SAC-GC with RANSAC while maintaining the same number of iterations. The summarized experimental results are presented in the table below. It is evident from

Table 2. Performance of SAC-GC and RANSAC in terms of rotation and translation errors, and computational times.

Dataset	Error	ISS	HoNo	Harris 3D	KPQ	LSP	NNS Harris 3D	LVS
RANSAC	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	1.68	2.78	15.77	\	7.30	4.52	1.02
	${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	11.56	21.81	17.05	\	62.48	43.74	2.39
	time/ms	9.53	26.23	15.60	\	9.59	17.16	69.93
SAC-GC	${\mathsf{\epsilon }}_{\mathrm{r}}/°$	4.46	1.82	15.56	\	3.60	4.49	0.81
	${\mathsf{\epsilon }}_{\mathrm{t}}/\mathrm{m}\mathrm{r}$	29.78	20.08	16.57	\	20.92	39.40	5.32
	$\mathrm{t}\mathrm{i}\mathrm{m}\mathrm{e}/\mathrm{m}\mathrm{s}$	0.95	1.17	1.25	\	1.71	1.92	3.68

that each method has its strengths and weaknesses in terms of rotation and translation errors. Notably, SAC-GC offers a 14-fold speedup over RANSAC, due to the geometric similarity filtering, which eliminates a substantial number of incorrect point pairs.

5. Conclusions

This paper introduces a keypoint detection algorithm and a registration algorithm based on LVS. The LVS keypoint detection method begins by computing a local coordinate system for each point in the point cloud. In this local coordinate system, a surface variation index is calculated based on the coordinate axis ratios. Points with surface variation indices smaller than the local average value are identified as candidate keypoints. Subsequently, the point with the smallest surface variation index in the neighborhood of each candidate keypoint is selected as the final keypoint. Based on LVS keypoints, an efficient and accurate registration algorithm is proposed.

Extensive experimental evaluations were conducted to assess the performance of the proposed keypoint detector and registration algorithm. For keypoint evaluation, tests were conducted on four datasets, which contained noise, clutter, occlusion, and resolution variations. Compared to existing keypoint detectors, the LVS keypoint detector exhibited higher keypoint repeatability. The results also demonstrated the efficiency of the LVS detector. In the context of registration, experiments were carried out on low-quality point cloud datasets using the LVS and SAC-GC registration method. Qualitative and quantitative results demonstrated outstanding performance in terms of accuracy and efficiency. This was primarily attributed to the high repeatability of LVS keypoints and the efficient change estimation of the SAC-GC algorithm. Moreover, a comparison between SAC-GC and RANSAC under the same performance conditions revealed a 14-fold increase in efficiency for SAC-GC.