Preamble

Vol. 39 No. 10
Application Research of Computers
Accepted Paper

Point Cloud Registration Algorithm Based on Mixed-Features Sampling for Overlapping Domain

Hu Jianghao, Wang Feng†
(School of Information Engineering, Guangdong University of Technology, Guangzhou 510006, China)

Abstract: This paper proposes a point cloud registration algorithm based on mixed-features sampling for overlapping domain to address the low efficiency and large errors in registering two partially overlapped point clouds. First, the algorithm predicts the overlap score of each point through encoding and feature interaction to obtain richer point cloud features. Second, it extracts local geometric features of overlapping points and retains overlapping keypoints based on overlap scores and the significance of point features. Finally, it constructs a hybrid feature matrix using the geometric and spatial information of overlapping keypoints, calculates the matching similarity of the matrix, and obtains registration results through weighted singular value decomposition. Experimental results demonstrate that the proposed method possesses strong generalization ability and can significantly improve point cloud registration accuracy while ensuring registration efficiency.

Keywords: machine vision; point cloud registration; overlapping areas; hybrid feature

0 Introduction

Point cloud registration is a critical task in computer vision that aims to find a rigid transformation aligning one 3D source point cloud with another 3D target point cloud \cite{1}. It finds extensive applications in pose estimation \cite{2}, 3D reconstruction \cite{3}, object localization \cite{4}, and has attracted widespread attention from scholars domestically and internationally. The registration problem can be described as follows: given source point cloud $X = {x_i}{i=1}^N \in \mathbb{R}^{3 \times N}$ and target point cloud $Y = {y_j}^3$ is the translation vector.}^M \in \mathbb{R}^{3 \times N}$, the goal is to find a rigid transformation ${R, t}$ that aligns the two point clouds, where $R \in SO(3)$ is the rotation matrix and $t \in \mathbb{R

In practical applications, camera motion between consecutive frames typically produces partially overlapped 3D point clouds \cite{5}. Partial point cloud registration is a common real-world scenario. Due to inconsistent data scales and low feature density in partially overlapped point clouds, they face challenges such as low registration efficiency and large errors. Among traditional registration methods, the Iterative Closest Point (ICP) algorithm \cite{6} is most commonly used, but it is sensitive to initial positions and prone to local optima. The Fast Global Registration (FGR) algorithm \cite{7} accelerates global registration through Fast Point Feature Histograms \cite{8} and alternating optimization techniques, yet it remains sensitive to noise. The Globally Optimal ICP (Go-ICP) algorithm \cite{9} solves the local minima problem through branch-and-bound methods, but it remains sensitive to initial positions.

With the dramatic increase in point cloud data scale, traditional registration methods can no longer meet practical demands in terms of efficiency and accuracy. In recent years, deep learning-based point cloud registration algorithms and scheme designs have become research hotspots. Compared with traditional methods, deep learning approaches offer higher precision and stronger robustness. Aoki et al. \cite{10} proposed a robust and efficient point cloud registration algorithm, PointNetLK, which combines the PointNet deep learning network \cite{11} with an improved Lucas-Kanade algorithm \cite{12}, improving registration accuracy under moderate-scale transformations and noise conditions. Wang et al. \cite{13} proposed the Deep Closest Point (DCP) network, which uses dynamic graph convolutional neural networks \cite{14} to extract point cloud features and employs attention mechanisms to compute point correlations. Wang et al. \cite{15} proposed the Partial-to-Partial Registration (PRNet) deep learning network using self-supervised learning, which uses Gumbel-Softmax \cite{16} and a direct gradient estimator to sample keypoint correspondences. Li et al. \cite{1} proposed the Iterative Distance-Aware Similarity Matrix Convolution (IDAM) network, which fuses local geometric features and distance features of point clouds while using mutually supervised hybrid elimination to improve registration accuracy. Yew et al. \cite{17} combined hybrid features with annealing algorithms to reduce the influence of initial position on final registration results and enhance network generalization, though at slower computational speeds.

However, the aforementioned methods do not explicitly handle non-overlapping points. Compared with overlapping points, non-overlapping points offer limited extractable features, while registration accuracy heavily depends on feature extraction quality. Non-overlapping points have minimal impact on the effective receptive field of fully convolutional point feature descriptors \cite{18,19}. Therefore, changing feature extraction methods yields limited improvement for partially overlapped point cloud registration performance. For partially overlapped point clouds, learning where to sample feature points can effectively enhance registration performance. Xiong et al. \cite{20} proposed a keypoint extraction method based on normal vector projection covariance analysis. Huang et al. \cite{21} supplemented previous keypoint extraction methods and extended them to low-overlap scenarios \cite{22}. Zhang et al. \cite{23} combined clustered region segmentation with convex optimization to improve registration performance for point clouds with low overlap. Li et al. \cite{24} retained point pairs with greater contribution through downsampling and threshold separation. Xu et al. \cite{25} learned an overlapping mask to reject non-overlapping regions, converting partial-to-partial registration into same-shape point cloud registration and achieving excellent performance. However, due to noise points and non-overlapping points, sampling overlapping points may remove correct correspondents in the target point cloud, leading to degraded registration performance.

To address this, we propose a point cloud registration algorithm based on mixed-features sampling for overlapping domain. Our approach effectively extracts overlapping points while reducing the probability of removing correct correspondents in the target point cloud. First, we extract interactive features within each point cloud through encoding and feature interaction, enhancing the network's ability to describe local geometric structures, extracting overlapping keypoints with rich features, and improving registration efficiency. Second, we combine local geometric features and distance features of point clouds, leveraging interactions between different point pair features to reduce the influence of initial position on registration performance and improve accuracy. Finally, to balance performance and efficiency, we propose a validity score computation network that reduces the impact of incorrectly removing corresponding point pairs in the target point cloud during keypoint sampling, thereby improving the precision and robustness of point cloud registration, especially for partially overlapped cases.

1 Point Cloud Registration Framework and Algorithm Design

We propose a deep learning-based point cloud registration algorithm whose structure is illustrated in Figure 1, consisting of four main components: (1) overlap score prediction, (2) salient feature sampling, (3) mixed feature extraction, and (4) similarity and validity score computation. First, we use PointNet to encode point clouds, feed the encoded features into a feature interaction module, and decode the overlap scores using PointNet. We sample K overlapping points with high overlap scores. Second, we extract local geometric features of overlapping points, retain L salient feature points, compute distance features for these salient points, and combine local geometric and distance features to construct a mixed feature matrix. We then compute similarity and validity scores, assign different weights to each point based on validity scores, and solve for the rigid transformation using weighted singular value decomposition.

1.1 Overlap Score Prediction

Notably, non-overlapping portions have minimal impact on fully convolutional feature point descriptors, while overlapping portions contain more data and richer features \cite{18,19}. Therefore, points in overlapping regions can effectively improve registration performance. We treat the overlap problem as a binary classification task \cite{5} and propose a feature interaction module, shown in Figure 2, to compute overlap scores for points in source and target point clouds and sample K points with high overlap scores.

We use a modified PointNet to extract global features $F_X$ and $F_Y$ from source and target point clouds, respectively. We apply max pooling to $F_X$ and $F_Y$ to obtain pooled features $F_X^p$ and $F_Y^p$. Next, we stack and expand $F_X^p$ and $F_Y^p$ to match the dimensions of $F_X$ and $F_Y$, as shown in Figure 2. Overlap score prediction can be viewed as a binary classification problem. Therefore, we concatenate global features, expanded pooled features, and their differences, then decode them using a modified PointNet to obtain overlap scores $O_X$ and $O_Y$ for source and target point clouds:

$$
O_X = d(F_X, \text{cat}(F_X^p, F_X - F_Y^p)), \quad O_Y = d(F_Y, \text{cat}(F_Y^p, F_Y - F_X^p))
$$

where $d(\cdot)$ denotes the decoding PointNet, $\text{cat}(\cdot)$ represents concatenation, and $e(\cdot)$ denotes the stacking expansion operation. After obtaining overlap scores, we sample K points based on these scores to obtain sampled source point cloud $X' = {x_i}{i=1}^K \in \mathbb{R}^{3 \times K}$ and sampled target point cloud $Y' = {y_j}$.}^K \in \mathbb{R}^{3 \times K

1.2 Salient Feature Sampling

Using all point features for correspondence search requires substantial memory and time. Non-salient features degrade registration performance, whereas salient features contain richer information and stronger discriminability. Therefore, we propose a salient feature sampling module, shown in Figure 3. First, we use Graph Neural Networks (GNN) \cite{26} to extract local geometric features $f(x_i)$ and $f(y_j)$ for points $x_i$ in source point cloud and $y_j$ in target point cloud. Second, we apply multi-layer perceptrons to feature vectors to obtain saliency scores $s_i$ and $s_j$ for source and target point cloud features. Finally, we retain the L data points with highest saliency scores and remove those with low scores. The sampled source point cloud is denoted as $X'' = {x_i}{i=1}^L \in \mathbb{R}^{3 \times L}$ and the sampled target point cloud as $Y'' = {y_j}$.}^L \in \mathbb{R}^{3 \times L

1.3 Mixed Feature Extraction

Most existing learning-based methods use only local geometric features for correspondence matching. Since the matching approach between different point pairs is identical, using only local geometric features has limited ability to identify similarity between two points. ICP uses distance features for correspondence matching, which is sensitive to initial point cloud positions. Combining local and distance features to fully utilize geometric and spatial information of point clouds can achieve higher registration accuracy and reduce the influence of initial position on performance. We compute distance features for points in sampled point clouds and concatenate them with local geometric features obtained in Section 1.2 to obtain mixed features:

$$
H_{ij}^{(n)}(x_i', y_j') = \text{cat}\left(f(x_i'), f(y_j'), |x_i' - y_j'|_2, |x_i' - x_i^0|_2, |y_j' - y_j^0|_2\right)
$$

where $\text{cat}(\cdot)$ denotes concatenation and $n$ represents the number of iterations for updating distance features within mixed features.

We define the loss function for mixed feature matching supervision as follows:

$$
L_H = \frac{1}{L}\sum_{i=1}^L \sum_{j=1}^L \log\left(s_i \cdot H_{ij}^{(n)}\right)
$$

where $s_i$ is the saliency score of the $i$-th point in source point cloud. Local geometric features are more important than distance features in early registration stages. Therefore, we only use the keypoint sampling loss function in the first iteration.

2.2 Validity Score Computation

Sampling salient data points from source and target point clouds can significantly improve registration efficiency but may also eliminate correct correspondents for some source points in the target point cloud. Therefore, we propose a validity score computation network to calculate the credibility of matching results, as shown in Figure 4.

First, we compute a validity score for each point in the source point cloud by applying 1D convolution to the mixed feature matrix, taking the maximum value, and passing it through a fully connected layer:

$$
v_i = \text{sigmoid}\left(\text{MLP}\left(\max_j H_{ij}^{(n)}\right)\right)
$$

Validity scores can be viewed as the probability of correct matching between points in source and target point clouds. Based on validity scores, we compute weights for each point:

$$
m_i = \mathbb{I}\left(v_i \geq \text{median}(v)\right) \cdot v_i
$$

where $\mathbb{I}(\cdot)$ is an indicator function that assigns 1 if the condition is satisfied and 0 otherwise. After obtaining weights for each point, we use weighted Singular Value Decomposition (SVD) to compute the rotation matrix $R$ and translation vector $t$:

$$
R, t = \arg\min_{R,t} \sum_i m_i \cdot |R x_i' + t - x_i^*|_2
$$

where $x_i^*$ is the point in target point cloud $Y''$ with maximum correspondence probability to $x_i'$.

2.3 Loss Function

The network loss function consists of four components using multi-supervision. The overlap score prediction loss is $L_O$. Since overlap prediction only has two cases (overlap or non-overlap), we treat it as a binary classification task supervised by cross-entropy loss:

$$
L_O = \frac{1}{N}\sum_{i,j} \left(O_{ij}^X \log \hat{O}{ij}^X + O^Y\right)}^Y \log \hat{O}_{ij
$$

where $O_{ij}^X$ and $O_{ij}^Y$ are ground truth overlap scores for source and target point clouds. The keypoint sampling loss is defined as:

$$
L_k = \frac{1}{L}\sum_{i=1}^L \log\left(s_i \cdot H_{ij}^*\right)
$$

where $j^$ is the index of the point in $Y''$ closest to the ground truth correspondence of $x_i'$, and $g_{ij}^$ is an indicator function for whether the distance between two points satisfies correspondence criteria:

$$
g_{ij}^* = \begin{cases}
1 & \text{if } |R x_i' + t - y_j'|_2 \leq r \
0 & \text{otherwise}
\end{cases}
$$

The credibility supervision loss is defined as:

$$
L_c = \frac{1}{L}\sum_{i=1}^L \left(-\log v_i \cdot g_i^ - \log(1 - v_i) \cdot (1 - g_i^)\right)
$$

where $g_i^*$ is the ground truth indicator function under true transformation. The total supervised loss function uses multi-supervision and is defined as the weighted sum of four loss functions:

$$
L = \alpha L_O + \beta L_k + L_H + L_c
$$

where $\alpha$ and $\beta$ are adjustable hyperparameters, with $\beta = 1$ during the first iteration and $\beta = 0$ otherwise.

3.1 Experimental Environment and Design

Our experiments use Python with the PyTorch deep learning framework. The hardware environment consists of an Intel(R) Core(TM) i9-12900KF 3.19GHz CPU and an RTX3080 GPU. We evaluate the proposed algorithm on the synthetic ModelNet40 dataset and the real Stanford 3D scanning dataset, both widely used for point cloud registration. ModelNet40 contains 12,311 CAD models across 40 categories, divided into training (9,843 objects) and test (2,468 objects) sets. For each object, we randomly sample 1,024 points to generate object point clouds. Each point cloud is randomly rotated within [0°, 45°] and translated within [-0.5, 0.5] along each axis. The initial point cloud serves as the source, and the transformed version as the target. To generate partially overlapped point clouds, we randomly fix a point far from both point clouds and retain the nearest 768 points for each point cloud.

3.2 Experimental Parameter Settings

In implementation, we sample the top 717 points by overlap score, set mixed feature iteration count to 3, retain 128 salient feature points, and set hyperparameter $\alpha$ for overlap score prediction loss to 0.6. We train the model using the Adam optimizer for 40 epochs with an initial learning rate of 0.0001, weight decay of 0.001, and multiply the learning rate by 0.1 every 30 epochs.

3.3 Experimental Evaluation

We compare our method with traditional algorithms (ICP \cite{6}, FGR \cite{7}, Go-ICP \cite{9}) and deep learning-based methods (PointNetLK \cite{10}, DCP \cite{13}, PRNet \cite{15}, IDAM \cite{1}). All deep learning methods are trained on the same training set. Evaluation metrics include Root Mean Square Error (RMSE) and Mean Absolute Error (MAE) for rotation matrix and translation vector. For rotation, RMSE(r) and MAE(r) are measured in degrees; for translation, RMSE(t) and MAE(t) are used.

3.4 Unseen Shape Point Cloud Registration

For unseen shape experiments, we train and test our algorithm on the ModelNet40 dataset. ModelNet40 contains 9,843 training objects and 2,468 test objects across 40 categories. Figure 5 compares registration performance between our method and IDAM on the test set. IDAM reaches optimal performance at 11 iterations with RMSE(r) = 1.52°, while our method achieves optimal performance at 13 iterations with RMSE(r) = 0.87°. Final results are shown in Table 1.

Due to poor initial position, ICP exhibits inferior registration performance. Go-ICP solves local minima through branch-and-bound but remains sensitive to initial position. FGR utilizes geometric shape features for registration, yielding more accurate results but still with higher errors compared to deep learning methods. Deep learning methods DCP and PRNet use geometric features, while IDAM uses mixed features, achieving better performance than other deep learning methods. However, IDAM does not handle non-overlapping points, resulting in extracted features containing less informative data. Our algorithm combines geometric and distance features while considering overlapping regions, sampling overlapping keypoints with richer features than non-overlapping points, and removing non-overlapping points to eliminate redundant information. This converts partial-to-partial registration into same-shape registration, assigning higher weights to overlapping points with rich feature information during registration. Compared with IDAM and other deep learning methods, our approach demonstrates stronger descriptive capability for local geometric structures.

Experimental results show our method outperforms compared traditional and deep learning methods across all four metrics, achieving RMSE(r) = 0.87° and RMSE(t) = 0.004, significantly improving point cloud registration accuracy. Figure 6 visualizes our registration results, where the green point cloud is the source, and the red point cloud is the target obtained by randomly rotating [0°, 45°] and translating [-0.5, 0.5] along each axis. Figure 6(b) shows our method achieves precise registration for unseen shapes.

3.5 Unseen Category Point Cloud Registration

For generalization experiments on unseen categories, we train on the first 20 categories and test on the remaining 20. Figure 7 compares registration performance. IDAM reaches optimal performance at 24 iterations with RMSE(r) = 1.59°, while our method achieves optimal performance at 26 iterations with RMSE(r) = 0.95°. Final results are shown in Table 2. Traditional algorithms (ICP, Go-ICP, FGR) do not require training, thus are less affected by category differences. Deep learning methods experience performance degradation when training and testing on different categories. However, our algorithm outperforms all comparison methods across all metrics, demonstrating good generalization capability for unseen category point cloud data.

Figure 8 visualizes registration results for unseen categories. Our method achieves precise registration for unseen categories, as clearly shown in Figure 8(b).

3.6 Noisy Unseen Shape Point Cloud Registration

Real-world scanned models often contain noise due to camera motion between consecutive frames. We add random Gaussian noise with standard deviation 0.01 to all shapes, clipping the noise to [-0.05, 0.05], while keeping other settings consistent with Section 3.4. Table 3 shows the results. Gaussian noise significantly affects FGR's performance due to its impact on shape features. ICP and Go-ICP demonstrate certain robustness to noise. Deep learning methods (DCP, PRNet, IDAM, and ours) show less performance degradation than noise-free cases because noise augmentation during training improves local feature descriptor robustness. Our method uses feature interaction to filter noise and non-overlapping points, assigning lower weights to mismatched noise points during registration, thereby enhancing robustness. Our method outperforms comparison methods on RMSE(r), MAE(r), and MAE(t), and is slightly inferior to PRNet on RMSE(t), demonstrating good noise-resistant generalization.

3.7 Algorithm Time Complexity

We evaluate computational performance on the ModelNet40 test set, comparing average runtime for processing a point cloud. We sample 512, 1,024, and 2,048 points, with results shown in Table 4. Deep learning methods are generally faster than traditional methods. Feature extraction-based deep learning algorithms inevitably extract geometric features from non-overlapping and non-salient points, resulting in low efficiency. Our method filters non-overlapping and non-salient points through double-layer sampling, significantly reducing computational load and improving runtime efficiency. Table 4 shows our method is second only to DCP in speed, 4-5 times faster than FGR, 2-3 times faster than PRNet and PointNetLK, and significantly superior to ICP and IDAM.

3.8 Stanford Dataset Registration Experiments

We conduct experiments on the Stanford 3D scanning dataset to further validate our algorithm's generalization capability. Compared with ModelNet40, Stanford dataset point clouds have non-uniform distribution, making registration more challenging. We select bunny and hand models, downsampled to 2,048 points. Each point cloud is randomly rotated [0°, 45°] and translated [-0.05, 0.05] along each axis to generate target point clouds. We create partially overlapped point clouds using a similar approach to ModelNet40. We compare with DCP, PRNet, and IDAM, which perform well on ModelNet40. Final results are shown in Table 5.

Figure 9 visualizes the results, with red as source and blue as target. For non-uniformly distributed point clouds, our method eliminates redundant information by predicting overlap and saliency scores, retains more feature information, and assigns higher weights to overlapping points with rich features. Experimental results show our method achieves lower registration errors than comparison methods, demonstrating good generalization for non-uniformly distributed point clouds.

3.9 Noisy Stanford Dataset Registration Experiments

We add random Gaussian noise with standard deviation 0.01 to real data models, clipping to [-0.05, 0.05], while keeping other settings consistent with Section 3.8. Table 6 shows the results. Due to noise impact on shape features, all models experience performance degradation. Our method uses feature interaction to filter noise and non-overlapping points, assigning lower weights to mismatched noise points. Consequently, our method outperforms comparison methods on RMSE(r), MAE(r), and MAE(t), demonstrating robustness to noisy point clouds.

3.10 Visualization Analysis

For partially overlapped point clouds, we address issues such as inconsistent data scale and low feature density by sampling equal numbers of overlapping keypoints and extracting their mixed features. Figure 10 visualizes the results, with green as source, red as target, and blue as extracted overlapping keypoints. Using only overlapping keypoints for registration allows us to fully utilize rich feature information from overlapped regions, reduce computational load, and improve registration efficiency.

Figure 11 compares registration results of our method with ICP and FGR, with green as source and red as target. For partially overlapped point clouds with inconsistent data scale and low feature density, ICP easily falls into local optima, while FGR fails to efficiently identify similarity between points. Our method achieves higher registration accuracy for partially overlapped point clouds, outperforming comparison methods both quantitatively and visually.

4 Conclusion

This paper proposes a point cloud registration algorithm based on mixed-features sampling for overlapping domain. The method effectively extracts overlapping points while reducing the probability of removing correct correspondents in the target point cloud. First, feature interaction and salient feature sampling obtain richer point cloud features, enhancing the algorithm's ability to learn feature information and reducing computational load. Second, combining geometric and spatial information constructs a mixed feature matrix that leverages interactions between different point pair features, reducing the influence of initial position on registration performance. Finally, a validity score computation network assigns appropriate weights to each point, enhancing the network's ability to identify important information. Experimental results on synthetic ModelNet40 and real point cloud datasets demonstrate that our method achieves higher registration accuracy for partially overlapped point clouds while maintaining efficiency, with improved robustness and generalization capability.

References

[1] Li J, Zhang C, Xu Z, et al. Iterative distance-aware similarity matrix convolution with mutual-supervised point elimination for efficient point cloud registration [C]// Proc of European Conference on Computer Vision. Springer, Cham, 2020: 378-394.
[2] Wong J M, Kee V, Le T, et al. Segicp: Integrated deep semantic segmentation and pose estimation [C]// Proc of IEEE/RSJ International Conference on Intelligent Robots and Systems. 2017: 5784-5789.
[3] Blais G, Levine M D. Registering multiview range data to create 3D computer objects [J]. IEEE Trans on Pattern Analysis and Machine Intelligence, 1995, 17 (8): 820-824.
[4] Lu W, Zhou Y, Wan G, et al. L3-net: Towards learning based lidar localization for autonomous driving [C]// Proc of IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2019: 6389-6398.
[5] Zhu L, Liu D, Lin C, et al. Point cloud registration using representative overlapping points [EB/OL]. (2021). https://arxiv.org/abs/2107.02583.
[6] Besl P J, McKay N D. A method for registration of 3-D shapes [J]. IEEE Trans on Pattern Analysis and Machine Intelligence, 1992, 14 (2): 239-256.
[7] Zhou Q Y, Park J, Koltun V. Fast global registration [C]// Proc of European Conference on Computer Vision. Springer, Cham, 2016: 766-782.
[8] Rusu R B, Blodow N, Beetz M. Fast point feature histograms (FPFH) for 3D registration [C]// Proc of IEEE International Conference on Robotics and Automation. IEEE, 2009: 3212-3217.
[9] Yang J, Li H, Campbell D, et al. Go-ICP: A globally optimal solution to 3D ICP point-set registration [J]. IEEE Trans on Pattern Analysis and Machine Intelligence, 2015, 38 (11): 2241-2254.
[10] Aoki Y, Goforth H, Srivatsan R A, et al. Pointnetlk: Robust & efficient point cloud registration using pointnet [C]// Proc of IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2019: 7163-7172.
[11] Qi C R, Su H, Mo K, et al. Pointnet: Deep learning on point sets for 3d classification and segmentation [C]// Proc of IEEE Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2017: 652-660.
[12] Lucas B D, Kanade T. An iterative image registration technique with an application to stereo vision [C]// Proc of the 7th International Joint Conference on Artificial Intelligence. Morgan Kaufmann Publishers Inc, 1981: 674-679.
[13] Wang Y, Solomon J M. Deep closest point: Learning representations for point cloud registration [C]// Proc of IEEE/CVF International Conference on Computer Vision. Piscataway, NJ: IEEE Press, 2019: 3321-3330.
[14] Wang Y, Sun Y, Liu Z, et al. Dynamic graph cnn for learning on point clouds [J]. ACM Trans On Graphics, 2019, 38 (5): 1-12.
[15] Wang Y, Solomon J M. Prnet: Self-supervised learning for partial-to-partial registration [J]. Advances in Neural Information Processing Systems, 2019, 32.
[16] Jang E, Gu S, Poole B. Categorical reparameterization with gumbel-softmax [EB/OL]. (2016). https://arxiv.org/abs/1611.01144
[17] Yew Z J, Lee G H. Rpm-net: Robust point matching using learned features [C]// Proc of IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2020: 11824-11833.
[18] Choy C, Park J, Koltun V. Fully convolutional geometric features [C]// Proc of IEEE/CVF International Conference on Computer Vision. Piscataway, NJ: IEEE Press, 2019: 8958-8966.
[19] Bai X, Luo Z, Zhou L, et al. D3feat: Joint learning of dense detection and description of 3d local features [C]// Proc of IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2020: 6359-6367.
[20] Xiong Fengwei, Zhuang Jian, Shen Ren. A low feature recognition degree point cloud registration method based on neighborhood curvature [J]. Computer Application Research, 2022, 39 (1): 6.
[21] Huang S, Gojcic Z, Usvyatsov M, et al. Predator: Registration of 3d point clouds with low overlap [C]// Proc of IEEE/CVF Conference on Computer Vision and Pattern Recognition. Piscataway, NJ: IEEE Press, 2021: 4267-4276.
[22] Qin Hongxing, Liu Zhentao, Tan Boyuan. Advances in rigid point cloud registration for deep learning [J]. Chinese Journal of Image and Graphics, 2022, 27 (2): 329-348.
[23] Zhang Yuan, Li Xiaoyan, Han Xie. A 3D point cloud registration method with low overlap rate [J]. Progress in Laser and Optoelectronics, 2021, 58 (8): 0810014.
[24] Li Xin, Mo Site, Huang Hua, et al. Multi source point cloud registration method for automatic calculation of overlap [J]. Infrared and Laser Engineering, 2021, 50 (12): 270-278.
[25] Xu H, Liu S, Wang G, et al. Omnet: Learning overlapping mask for partial-to-partial point cloud registration [C]// Proc of the IEEE/CVF International Conference on Computer Vision. 2021: 3132-3141.
[26] Wyu Z, Pan S, Chen F, et al. A comprehensive survey on graph neural networks [J]. IEEE Trans on Neural Networks and Learning Systems, 2020, 32 (1): 4-24.