L EARNING TO R EGISTER U NBALANCED P OINT P AIRS
Anonymous authors
Paper under double-blind review
A BSTRACT
Point cloud registration methods can effectively handle large-scale, partially overlapping point cloud pairs.
Despite its practicality, matching the unbalanced pairs in terms of spatial extent and density has been overlooked and rarely studied.
We present a novel method, dubbed UPPNet, for U nbalanced P oint cloud P air registration.
We propose to incorporate a hierarchical framework that effectively finds inlier correspondences by gradually reducing search space.
The proposed method first predicts subregions within target point cloud that are likely to be overlapped with query.
Then following super-point matching and fine-grained refinement modules predict accurate inlier correspondences between the target and query.
Additional geometric constraints are applied to refine the correspondences that satisfy spatial compatibility.
The proposed network can be trained in an end-to-end manner, predicting the accurate rigid transformation with a single forward pass.
To validate the efficacy of the proposed method, we create a carefully designed benchmark, named KITTI-UPP dataset, by augmenting the KITTI odometry dataset.
Extensive experiments reveal that the proposed method not only outperforms state-of-the-art point cloud registration methods by large margins on KITTI-UPP benchmark, but also achieves competitive results on the standard pairwise registration benchmark including 3DMatch, 3DLoMatch, ScanNet, and KITTI, thus showing the applicability of our method on various datasets.
The source code and dataset will be publicly released.
I NTRODUCTION
Point cloud registration is a task that aims to recover 3D rigid transformation between two possibly overlapping point cloud fragments.
The rapid advance of commodity 3D sensors gives rise to the necessity of efficient point cloud registration algorithms for numerous real-world applications, including 3D reconstruction for virtual-, augmented-, and mixed reality applications, and the navigation systems of autonomous vehicles or robotic agents.
Recent work has made remarkable progress in developing learning-based point cloud registration algorithms for tackling real-world 3D scans (Geiger et al., 2012; Zeng et al., 2017) with high-resolution feature extraction (Choy et al., 2019b; Bai et al., 2020)
under presence of low ratio of the inlier correspondences (Choy et al., 2020b; Bai et al., 2021; Lee et al., 2021) or small overlap region between point pairs (Huang et al., 2021).
However, the imbalance issue in terms of spatial extent and point density between the input point clouds is often overlooked, despite its practical utility in the problems such as incremental mapping, or the registration of partial observations and the holistic environment.
For instance, there are sensible solutions for registering a pair of 3D LiDAR scans, but registering a single LiDAR scan and a large-scale 3D map still remains challenging.
A viable solution is to apply a global localization approach (Uy & Lee, 2018; Komorowski, 2021; Du et al., 2020; Zhang & Xiao, 2019; Liu et al., 2019), but the existing methods cast the problem as a retrieval task and assume that the 3D map is given as a set of overlapping 3D scans rather than a holistic map, which is not generally applicable to the unbalanced point pairs.
Recent feature-based pairwise point cloud registration methods are equipped with matchability detection (Bai et al., 2020), overlap detection (Huang et al., 2021), or hierarchical correspondence prediction (Yu et al., 2021), which are possibly advantageous in registering unbalanced point clouds.
However, we empirically found that they collapse in registering unbalanced point clouds.
Point cloud description and matching in the modern feature-based registration methods tend to be distracted by similar geometric structures that often appear in the larger point cloud.
To this end, we propose UPPNet , the first neural architecture which is designed to be efficient for large-scale U nbalanced P oint cloud P air registration.
UPPNet is a hierarchical framework that effectively finds inlier correspondences by gradually reducing search space.
In the coarsest level, a submap proposal module proposes the subregions that are likely to be overlapped with the query by utilizing a global geometric context.
Then, the coarse-to-fine matching module predicts accurate point-level correspondences by utilizing attention-based context aggregation and solving optimal transport problems.
The subsequent structured matching module filters out outlier correspondences that violate spatial compatibility.
To evaluate our method, we create a carefully designed benchmark, namely KITTI-UPP dataset, for matching point cloud pairs under the diverse spatial extent and point density imbalance by augmenting the KITTI odometry dataset (Geiger et al., 2012).
The experiment shows that our method improves the Registration Recall on the KITTI-UPP dataset by over 19.6% than state-of-the-art registration pipelines when the target point cloud is 11.1 times spatially larger and 11.7 times denser than the query point cloud.
Furthermore, we evaluate the proposed method under the unbalanced indoor environments using ScanNet (Dai et al., 2017) dataset and show that the proposed method can be generalized for indoor RGB-D scans.
Finally, to demonstrate the applicability of the proposed method for partially overlapped point cloud pairs, we evaluate our method on the standard pairwise registration benchmarks, 3DMatch, 3DLoMatch (Zeng et al., 2017; Huang et al., 2021), and KITTI odometry (Geiger et al., 2012) datasets.
The proposed method achieves competitive registration accuracy with the modern pairwise registration methods (Bai et al., 2020; Huang et al., 2021; Yu et al., 2021).
An overview of our method can be found in Figure 1.
Our main contributions are summarized as follows:
• We propose a novel hierarchical framework that gradually reduces the search space via submap proposal module and coarse-to-fine matching modules, which can effectively handle unbalanced point cloud registration tasks.
• We introduce a new benchmark, namely KITTI-UPP dataset, by carefully augmenting the large-scale outdoor LiDAR dataset (Geiger et al., 2012).
• Our method can be trained in an end-to-end manner and demonstrates strong generalization ability on a wide range of spatial and point density.
It outperforms the previous state-of-theart methods by 19.6% Registration Recall on a challenging benchmark.
• Our method achieves competitive registration accuracy in both unbalanced indoor RGB-D registration (Dai et al., 2017) and the standard pairwise registration benchmarks (Zeng et al., 2017; Huang et al., 2021; Geiger et al., 2012), showing the applicability of the method.
R ELATED W ORK
Point cloud registration.
Given partially overlapping point cloud pairs, point cloud registration aims to estimate the rigid transformation parameters that align the input point clouds.
Typical pipelines start with the feature extraction and matching stage to produce a set of putative correspondences, followed by a robust model fitting algorithm to estimate the pose parameters from given correspondences.
Traditional local descriptors for point clouds (Johnson & Hebert, 1999; Rusu et al., 2008; 2009;
Tombari et al., 2010; Salti et al., 2014) encode local geometry using hand-crafted features such as surface normal or curvature.
Recent learnable feature descriptors train a network to extract geometric features in a data-driven manner.
Qi et al.
(2017) incorporate shared MLP and permutation-invariant aggregation operations to process unordered and irregular point cloud data.
Deng et al.
(2018a;b) extended Qi et al.
(2017) by combining point pair feature to extract global context-aware feature descriptors.
Choy et al.
(2019b) adopted the fully convolutional networks to process point cloud data by utilizing sparse convolution (Choy et al., 2019a) and achieved state-of-the-art feature matching accuracy in large-scale real-world datasets.
Bai et al.
and Huang et al.
(2021) incorporate keypoint and overlap confidence prediction for robust feature matching between low overlapping point pairs.
The set of putative correspondences that is built by matching local feature descriptors tends to contain a high portion of outliers.
Hence, the pose estimation algorithm should be robust against the existence of outliers.
RANdom
SAmple Consensus (RANSAC) (Fischler & Bolles, 1981) and its variants (Fitzgibbon, 2003; Raguram et al., 2012; Hoseinnezhad & Bab-Hadiashar, 2011; Chum & Matas, 2005) are one of the most popular methods.
Recent studies of learning-based outlier rejection methods apply for the problem of two-view correspondences (Moo Yi et al., 2018;
Zhang et al., 2019; Brachmann et al., 2017) and 3D correspondences (Choy et al.
, 2020b;a).
Lee et al.
(2021) utilizes Hough voting in 6D parameter space and learnable refinement module, resulting in a robust and efficient registration pipeline for the large-scale point cloud.
Bai et al.
(2021) incorporate the spatial compatibility to filter out noisy correspondences.
Yu et al.
(2021) proposed to avoid keypoint detection by incorporating hierarchical correspondence extraction modules and Lu et al.
(2021) present specialized pipeline for large-scale LiDAR scans.
However, none of those methods are explicitly designed for the unbalanced point cloud registration and we empirically found that those methods collapse under the extreme imbalance in terms of spatial extent and point density.
Global localization.
The early global localization algorithms are based on the 2D images (Chen et al., 2017;
Sarlin et al., 2019; Sattler et al., 2017), where input images are matched against the 3D map reconstructed with Structure from Motion (SfM).
They often cast a visual localization task as a retrieval problem, where the query images are described with global descriptors, and the most similar point features are retrieved from the database.
Vector of Locally Aggregated Descriptors (VLAD) (J´egou et al., 2010; Arandjelovic & Zisserman, 2013) is one of the most widely used approaches.
It aggregates the local descriptors into a single global descriptor via clustering and is designed to be very low dimensional.
NetVLAD
(Arandjelovic et al., 2016) has extended it to learnable method.
Recently, 3D point cloud-based global localization methods are developed.
Yin et al.
(2017; 2018) projects a point cloud onto a spherical image and then extracts a global feature descriptor via 2D
CNN.
In Yin et al.
(2019), it is combined with a localization module, which utilizes particle filter and
ICP for 3D pose estimation.
Uy & Lee (2018) apply NetVLAD to point cloud data using PointNet Qi et al.
(2017) as backbone network.
Based on this, Zhang & Xiao (2019) employs per-point attention to enhance the global descriptor.
Liu et al.
(2019) applies a graph neural network on hand-crafted point features to encode local context and aggregate it into global descriptors using the NetVLAD layer.
Du et al.
(2020) jointly optimizes both local and global feature extractors and solves both global retrieval and local registration in a single forward pass.
Komorowski (2021) utilizes sparse convolutional networks to overcome the limitation of the local context of PointNet.
One feasible solution to tackle the unbalanced point cloud registration is to device the task into two separate sub-tasks; 1) the nearest frame retrieval and 2) local registration.
After the target frame is retrieved, the relative pose between the query and the target frame is predicted by applying the conventional pairwise registration methods.
These methods, however, suffer from several drawbacks.
First, there are significant overheads in both the computational cost and the memory footprint to represent a scene with a set of multiple overlapping local frames.
Second, they are likely not to generalize when point cloud pairs have a domain difference.
For instance, considering the registration between the reconstructed point cloud of a large-scale scene and a local scan, the global localization methods fail to be directly adopted due to the severe density difference.
Finally, the success of the registration strongly depends on the localization results.
They can not recover when the coarse alignment via localization fails.
M ETHOD
This section describes the proposed UPPNet, designed for registering unbalanced point cloud pairs.
To handle spatial and density imbalance, we introduce a hierarchical framework consisting of three levels of matching stages, submap matching (Section 3.3), super point matching (Section 3.4), and point matching (Section 3.5).
The overview of the proposed pipeline is illustrated in Figure 1.
3. P ROBLEM D EFINITION
Given a pair of possibly overlapping point clouds, X ∈ R n × 3 , Y ∈ R m × 3 , our goal is to estimate the optimal rigid transformation R ∗ , t ∗ that minimizes the geometric error defined as follows:
[Equation]
where R ∈ SO (3) , t ∈ R 3 are rotational matrix and translation vector, C is a set of true correspondences between X and Y .
In this paper, we are interested in the case where V ( X ) ≫ V ( Y ) , and
[Figure]
e l f
[Figure]
a tt e n
[Figure]
c r
[Figure]
ss
[Figure]
a tt e n
[Figure]
Modules in UPPNet, including feature extraction and correspondence estimation, can be trained in an end-to-end manner with the three losses L s , L g , and L p .
n ≫ m , where V ( · ) denotes the spatial volume of the bounding box that tightly covers the input point cloud.
In other words, there is spatial and density imbalance between X and Y .
From here on, we will refer to the reference point cloud that spans a larger spatial extent with higher density ( X ) as a map , and a query point cloud with a small and sparse point cloud ( Y ) as a query .
Furthermore, we use the terms spatial imbalance factor , ρ s = V ( X ) V ( Y ) , and point imbalance factor , ρ p = nm , to denote the relative imbalances between two point clouds in terms of spatial extent and number of points.
Note that we can also calculate the density imbalance factor by ρ d = ρ p ρ s .
3. F EATURE E XTRACTION
The proposed UPPNet begins with the feature extraction to encode the geometric context of map and query point clouds.
To achieve this goal, we adopt a shared U-shaped network implemented with KPConv (Thomas et al., 2019) to extract the multi-level features.
Given an input point cloud
X ∈ R n × 3 with initial feature F in X ∈ R n × d in , the feature extractor f θ ( · ) outputs the pointwise feature
F X ∈ R n × d that encode local geometric context, denoted as ( X , F X )
=
f θ ( X , F in X ) .
At the most coarse resolution, i.e., at the end of the encoder, we obtain downsampled points with corresponding feature vectors, and we call the downsampled points as super points and denotes the point coordinates and the features with X ′ ∈ R n ′ × 3 and F X ′ .
For each super point x ′ i , the input point cloud X can be partitioned into groups by assigning each point to its closest super point as in Yu et al.
[Equation]
where we denote the corresponding super point feature map as F ′ G i .
3. S UBMAP M ATCHING
Building submaps.
The first stage of our hierarchical registration pipeline is the submap proposal that builds the submap candidates that are likely to be overlapped with the query point cloud.
To do so, we divide the map into L overlapping submaps.
A submap S i is a subset of superpoints of the map, i.e., S i ⊂ X ′ , that lie in i -th submap region S i : S i = { x ′ ∈ X ′ : x ′ ∈ S i } .
Each (cubic-shaped) submap region S i with its center c i ∈ R 3 (which we call center point) and edge length of v ∈ R + is formally defined as S i = { s ∈ R 3 : max | s − c i | ≤ v/ 2 } .
In this work, we evenly place L overlapping submap regions {S i } Li =1 to cover all the superpoints of the map X ′ with carefully chosen overlapping ratio µ , satisfying |S i ∩ S j | / |S i | = µ and || c i − c j || = v · µ for any adjacent, overlapping submap regions
S i and S j . We set µ = 0 . 5 in our experiments. The edge length of the submap regions, v ∈ R + , is defined by the spatial size of the query Y :
Specifically, we first compute the furthest distance between two points in Y along i -th axis as s i = | max a y a,i − min b y b,i | ∈ R + , thus giving { s i } 3 i =1 of which respective elements represent width ( s 1 ), height ( s 2 ), and length ( s 3 ) of Y . The edge length of submap regions is defined as the largest edge length of Y : v = max i s i .
The overview of the submap proposal and grouping is shown in Figure 1 (b).
Attention-based context aggregation.
The super point feature maps of query and submaps are then strengthened via attention-based context aggregation module (Yu et al., 2021;
Huang et al., 2021;
Sarlin et al., 2020) to incorporate the global geometric context.
As in Huang et al.
(2021), we construct a bipartite graph between query and map point cloud regarding the super points as nodes, and we apply a sequence of self-, cross-, and self-attention layers to fuse the global context between two point clouds and augment each super point feature.
Given super point feature maps ( F ′ X , F ′ Y ) , we linearly project the source feature F ′ X to query , Q = W Q F ′ X and target feature F ′ Y to key and value as K = W K F ′ Y , V = W V F ′ Y , respectively, where W Q , W K , and W V are the learnable parameters.
To calculate the message M that flows in the graph, we use attention-based aggregation as follows: M = QK T √ b · V , where b is the channel dimension of super point features.
When calculating self-attention messages, we take ( F ′ X , F ′ X ) and ( F ′ Y , F ′ Y ) as input and flow messages to corresponding subgraphs.
Global feature aggregation.
After we augment super point features, we aggregate super point features into a global descriptor for each submap.
The super point features are lifted into a higher dimension by a linear layer and then aggregated into a global descriptor via Generalized Mean
Pooling (GeM) (Radenovi´c et al., 2018).
GeM has shown its strength in localization tasks for various modality (Tolias et al., 2015; Komorowski, 2021).
Concisely, GeM aggregates the super point features
F ′ S
i for submap S i and builds the global descriptor F GD S i as F GD S i ( k ) =
(cid:0) 1 | S i | (cid:80) x ′ j ∈ S
i ( F ′ x ′ j ( k ))
α (cid:1) 1 /α , where F GD S i ( k ) is k -th element of the global descriptor, and α is a learnable parameter.
Global feature matching.
With the aggregated global descriptors for each submap { F GD S i } and query
F GD Y , we calculate the similarity matrix using L2 distance between two global descriptors:
[Equation]
where d GD is a one dimensional vector because the query point cloud Y is described with a single global descriptor F GD Y , whereas the map X is described with m global descriptors F GD S i for each submap S i .
On train time, we apply a loss function on d GD with groundtruth supervision.
On inference time, we pick k submaps with the top- k similarity values, where k is a hyperparameter.
3. S UPER P OINT M ATCHING
After the candidate submaps are proposed with the consideration of the global geometric context, we perform the super point matching.
For each proposed submap, the super points belonging to the submap S
i are retrieved with corresponding super point features, F ′ S i ∈ R | S i |× d ′ .
Then we leverage super point features F ′ S
i , F ′ Y of submap and query to calculate the similarity matrix S S
i using inner product:
[Equation]
Neighborhood constraint.
The similarity matrix S S i effectively convey the geometric information with moderate receptive field size.
Following Lu et al.
(2021), we incorporate additional geometric context, called neighborhood constraint, to handle challenging cases.
As described in Eq. 2, each point x ∈ X are assigned to the closest super point.
For each super point x ′ i ∈
X ′ , we aggregate the neighbor features of points within the partition G i using max pooling and denote the aggregated features as neighbor feature , ¯F G i .
Now we calculate another similarity matrix N S i = ¯F T S i ¯F Y , called neighbor similarity matrix .
The final similarity matrix is defined as addition of two similarity matrices augmented with additional row and column for slack entries to handle unmatched super points as suggested in Yu et al.
; Sarlin et al.
[Equation]
We then utilize Sinkhorn algorithm (Sinkhorn & Knopp, 1967) to solve optimal transport problem on Z S i and obtain ¯ Z S i .
Each entry ( i, j ) in ¯ Z S i indicates normalized probability whether ( i, j ) correspondence is a true correspondence.
By thresholding ¯ Z S i by predefined value τ Z , we obtain the set of predicted super point correspondences, C ′ , and they passed to the final point matching module to point correspondences, C .
Structured matching.
We use spatial compatibility (Bai et al., 2021; Lee et al., 2021) to further reject the outlier correspondences.
It considers two correspondences ( p i , q i ) and ( p j , q j ) are likely to be inliers if their spatial distance | d ( p i , p j ) − d ( q i , q j ) | is smaller than predefined threshold.
Extending this concept, for each correspondence, we compute the compatibility score with respect to the number of their compatible correspondences in the whole correspondence set.
For example, whole correspondences set is { c 1 , c 2 , c 3 } and compatibility score of c 1 will be 2 when c 2 and csatisfy spatial compatibility with c 1 .
With the compatibility score, we consider correspondences with a low score as outliers and filter out them.
In our hierarchical framework, we apply this strategy to our super point matching module and point matching module to extract only reliable correspondence pairs.
Furthermore, KNN search is used to guarantee as many inliers as possible for the initial correspondence set.
For more details about the structured matching, please refer to Appendix.
3. P OINT M ATCHING
Given predicted super point correspondence, we refine it to point-level correspondences for the final rigid transformation parameter estimation.
We expand a single super point correspondence to a pair of point patches with neighboring points around the super points in each point cloud.
We use the point-to-super point grouping as described in Eq. 2 and pass the selected point groups to the matching module as in Section 3.4.
After applying the threshold to the similarity matrix and structured matching, we get the final set of point-level correspondences between two input point clouds.
We then run RANSAC on the correspondence set to estimate the rigid transformation parameter.
Note that there are multiple sets of correspondences since we perform the matching module for each proposed submap in parallel.
We select the one with the highest inlier ratio among the multiple transformation candidates as our final prediction.
3. L OSS
We train our network using the loss function defined as L =
L s + λ g L g + λ p L p , where the total loss is the weighted sum of submap matching loss L s , super point matching loss L g , and point matching loss L p .
Specifically, we define point matching loss L p as:
[Equation]
(6) where ¯ Z is the predicted similarity matrix after solving optimal transport using Sinkhorn algorithm, ˆ
Z is the binary matrix that indicates groundtruth.
If ( i, j ) correspondence is a true correspondence then ˆ Z
( i, j )
= 1 , and ˆ Z
( i, j ) = 0 otherwise.
For L g and L s , we apply the same formulation, but we calculate the overlap ratio between two patches around the super points as ground-truth soft label values.
This fact indicates that we only provide a point-wise binary matrix for the supervision , and the similarity matrix for super point matching and submap matching are calculated with ˆ Z .
Additional supervision rather than the rigid transformation matrix between query and map point clouds is not required.
More details on calculating ground-truth similarity matrices are provided in Appendix.
[Figure]
E XPERIMENT 4. E XPERIMENTAL SETTINGS
KITTI-UPP dataset.
To the best of our knowledge, there are no available benchmarks and public datasets targeting the large-scale unbalanced point cloud registration task.
To validate the effectiveness of our approach, we introduce KITTI-UPP, a carefully designed dataset for large-scale unbalanced point cloud registration tasks.
We build KITTI-UPP by aggregating sequential LiDAR frames for each scene provided by the KITTI Odometry benchmark (Geiger et al., 2012).
To control spatial and density imbalance factor between map and the query as defined in Section 3.1, we tune two parameters when selecting KITTI frames for aggregation: range and hop .
The range determines how many frames we use to construct a map, indicating the map size.
If the range value is set to 500, we aggregate 500 consecutive LiDAR frames to build a single map.
The hop indicates the frame jump for the LiDAR frame aggregation.
If we set the hop value as 10, every 10 th frame is used for the aggregation.
In this manner, the hop controls the density of the aggregated point cloud.
In our experiment, we set 300 and 10 as the default values for range and hop, respectively, to train
UPPNet and baseline approaches.
We then utilize KITTI-UPP scenes made with other hops and ranges that are unseen during the training to analyze the registration performance on the various spatial and density imbalance factors.
Note that we ensure that any query is not included in the map.
When we aggregate every 10th frames to construct a map, i.e., { 10 · i | 0 ≤ i ≤ ⌈ range10 ⌉} , then we select the query frames from a index set { 10 · i + 5 | 0 ≤ i ≤ ⌈ range10 ⌉} to ensure that the same frame is not used in both a query and a map.
ScanNet benchmark.
To validate the robustness of our proposed method in large-scale indoor environments, we use ScanNet (Dai et al., 2017) benchmark which contains 2M RGB-D scans of over 707 unique indoor scenes.
To evaluate the methods under an unbalanced environment, we use the provided reconstructed mesh of ScanNet as a map and register a single RGB-D frame with the map, thus being able to omit the labor-heavy process for generating maps as in KITTIUPP dataset construction.
For the unbalanced point cloud registration task.
An example pair is illustrated in Figure 2.
Specifically, we use a subset of ScanNet which consists of 12/2/5 scenes for training/validation/testing splits respectively where each scene contains a varying number of scans ranging from 8 to 113.
Evaluation metric.
We use the standard metric to assess the pairwise registration accuracy using
Rotational Error (RE): arccos
Tr( R T ˆR ) − 1and relative Translational Error (TE): ∥ t − ˆt ∥ 2 , where
R , t are the predicted rotation matrix and a translation vector, ˆR , ˆt are the ground-truth.
We also use relative Inlier Ratio (IR) and Registration Recall (RR) for the evaluation.
IR is defined as the ratio of correspondences whose geometric distances are below the predefined threshold ( τ I ) when transformed with the ground-truth transformation.
For a registered pair having RE and TE less than the predefined thresholds ( τ R , τ t ), we regard it as a successful registration and calculate the RR of successful registration over the entire dataset.
For indoor datasets, we report three standard metrics,
KITTI
KITTI-UPP
KITTI
KITTI-UPP 99.
11* +19.
[Table]
namely Registration Recall (RR), Inlier ratio (IR) and Feature Matching Recall (FMR) following the literature.
The precise definition of evaluation metrics can be found in the Appendix.
4. C OMPARISON
Outdoor Experiment.
We compare our UPPNet with the state-of-the-art pairwise registration methods (Bai et al., 2020; Huang et al., 2021; Yu et al., 2021) in Figure 3.
We select those methods as baselines since they are equipped with keypoint detector (Bai et al., 2020), overlap prediction module (Huang et al., 2021), or coarse-to-fine registration module (Yu et al., 2021), which are likely to be favorable for the unbalanced point cloud registration.
For a fair comparison, we finetune all baseline methods on our KITTI-UPP dataset , where the baselines were pretrained with KITTI odometry dataset (Geiger et al., 2012).
All details of the training and evaluation setup for the baseline models can be found in Appendix.
As shown in Figure 3, our method achieves the best results in all metrics.
Moreover, our method achieves the best generalization ability w.r.t the various spatial extent and density imbalances as shown in Figure 3, indicating the advantages of our method.
To verify the effectiveness of UPPNet, we conduct additional experiments; incorporating retrieval method with baseline models.
In this experiment, we combine pairwise registration methods with MinkLoc3Dv2 (Komorowski, 2022) that shows best performance on 3D retrieval task.
For fair comparison, We train the MinkLoc3Dv2 (Komorowski, 2022) on our KITTI-UPP dataset for 200 epochs.
Even though pairwise registration methods benefit from MinkLoc3Dv2 (Komorowski, 2022), UPPNet still outperforms baseline models by large margins.
We conclude that the method of generating global descriptor in MinkLoc3Dv2 (Komorowski, 2022) is not suitable for our challenging scenario which is under extreme imbalance in terms of spatial extent and point density; aggregating the features of all points rather than reliable points in contrast to UPPNet.
Indoor Experiment.
We report unbalanced point cloud registration results on large-scale indoor environments, e.g., ScanNet (Dai et al., 2017).
In this experiment, we compare our UPPNet with
CoFiNet (Yu et al., 2021).
We take two methods of ours and CoFiNet pretrained on 3DMatch (Zeng et al., 2017) and finetune on ScanNet.
Registration results are summarized in Table 1; our method
[Table]
achieves 21.1% Registration Recall improvements over CoFiNet, which reveals the robustness of our method for indoor unbalanced point cloud registration as well.
4. A NALYSIS
To study the effectiveness of the proposed UPPNet
[Table]
we conduct extensive ablation experiments and report the results in Table 2.
In Table
[Table]
we conduct an ablation study on the core design choices of our method: k-nearest-neighbor values and usage of submap proposal and structured matching modules.
As shown in Table
[Table]
k = 16 is the optimal configuration for considering all metrics.
In addition, we found that both submap proposal and structured matching modules bring significant improvement in registration recall, where the best performance is achieved when all modules are enabled.
[Table]
Moreover, we evaluate our method on three popular benchmarks, namely 3DMatch (Zeng et al., 2017), 3DLoMatch (Huang et al., 2021), and KITTI (Geiger et al., 2012), to demonstrate the applicability of the proposed method in the balanced but partially overlapping setup.
We compare our method with the state-of-theart feature-matching based registration methods (Bai et al., 2020; Choy et al., 2019b; Yu et al., 2021; Huang et al., 2021) on 3DMatch and 3DLoMatch benchmarks.
For the KITTI odometry benchmark, we select HRegNet (Lu et al., 2021) and CoFiNet (Yu et al., 2021) as baselines since they exhibit strong performance on KITTI benchmark (Geiger et al., 2012). For these experiments, we follow the training and evaluation settings of Yu et al.
As reported in Tableand Figure 3, our method exhibits competitive results from the previous state-of-the-art registration methods on both indoor and outdoor datasets, even with the extremely low overlap scenario.
This result suggests that our method is not specialized for the KITTI-UPP benchmark but also applies to the indoor and low overlap environment.
For more details on training and evaluation for the 3DMatch dataset, please refer to the Appendix.
Finally, we measure the latency of our method and report the breakdown of elapsed times for each module on the KITTI-UPP benchmark in comparison with CoFiNet (Yu et al., 2021).
As reported in
Table 3, our method takes 0.4 seconds more than CoFiNet but improves registration recall by 15.6%.
C ONCLUSION
In this paper, we presented a neural architecture for unbalanced point cloud registration with extreme spatial scale and point density discrepancy.
We proposed a hierarchical framework that finds inlier correspondences effectively by gradually reducing search space to tackle this problem.
Our proposed method can handle scale differences by finding subregions that are likely to be overlapped with the query point cloud and estimating the correspondences via a coarse-to-fine matching module to the selected subregions.
Finally, structured matching is applied to prune the noisy correspondences further.
Our method outperforms the state-of-the-art methods by a large margin in extensive experiments on the challenging dataset.
Limitations.
We use RANSAC to get the final rigid transformation parameter with the estimated correspondences.
Leveraging a differentiable model estimator, e.g., weighted Procrustes method (Choy et al., 2020a), would be an interesting future research direction.
A A PPENDIX
In this supplementary material, we provide the detailed algorithm of the structured matching procedure in Section A.1, the description of how we form the data splits of our KITTI-UPP dataset for training and evaluation in Section A.2, additional details on the experiments in Section A.3, the additional quantitative results in Section A.4 with the implementation details of baseline methods, equations for the loss terms in Section A.5, details of architectural configuration in Section A.6, and finally qualitative results in Section A.7.
A. S TRUCTURED M ATCHING
We provide additional information on our structured matching.
As in Section3.4, the initial correspondence set is extracted from similarity matrix ¯ Z .
Simple strategy is to consider an entry ( i, j ) with high confidence score in ¯ Z as a valid correspondence as in (Yu et al., 2021):
[Equation]
However, this strategy is prone to missing inlier correspondences in our unbalanced setting; that is difficult to extract consistent features from the same region of the map and query as the inlier correspondences often have low confidence scores.
An alternative solution is to select confident correspondences relatively for each point rather than using an absolute threshold value.
We utilize
K-nearest-neighbor (KNN) search in feature space and retrieve the top-k candidate correspondences for each point having the highest inlier confidence values:
[Equation]
This approach can guarantee to select k candidates for each point even if their confidence scores are low.
Although more inlier correspondences can be obtained by KNN search, selecting extra correspondences leads to a high number of outliers.
To cope with these challenges, we combine spatial compatibility with KNN search for outlier rejection.
We first check whether each correspondence satisfies spatial compatibility with others, as illustrated in Figure 4(b).
Assume that we have N correspondences { ( x n , y n ) }
Nn =1 where x n , y n ∈ R 3 is a pair of 3D points, i.e., n -th correspondence. The spatial compatibility matrix S ∈ R N × N encodes relative distances of the correspondences such that S i,j = 1 [ | d ( x i , x j ) − d ( y i , y j ) | < θ ] where θ is distance threshold; score of 1 is assigned to S i,j if a pair of correspondences i, j are spatially consistent and scores of 0 is given otherwise.
In this toy example, { c 1 , c 3 , c 5 , c 7 } are inlier correspondences and { c 2 , c
4 , c 6 , c 8 } are outlier correspondences.
Although we can reject c 6 by sampling the correspondences with at least one compatible correspondence, we still suffer from the outliers { c 2 , c 4 , c 8 } .
Notably, a large-scale map would have numerous repetitive structures, making it challenging to distinguish hard negative correspondences { c 2 , c 4 , c 8 } using only their associated features, i.e., through first order matching.
Instead, we can select correspondences with high compatibility scores, as described in Section 3.4, by counting the number of compatible correspondences for each correspondence.
Furthermore, we can calculate compatibility coherence between two correspondences by calculating how many correspondences are compatible with both of them.
The calculation of compatibility coherence scores of some correspondence i is formulated as similarities (dot-product) between spatial consistency of correspondence i and those of other correspondences: C i = SS Ti, :
∈ R N which counts the number of spatially-consistent matches that correspondence i has in common with others.
In other words, compatibility coherence score of correspondences i and j amounts to the number of spatially-consistent correspondences they have in common .
As an specific example, correspondences c 1 and c 3 in Figure 4(a) have two common spatially-consistent correspondences of c 5 and c 7 which makes C 1 , 3 = C 3 , 1 = 2 while correspondences c 6 and c 8 do not have any common spatially-consistent correspondences
so C 6 , 8 = C 8 , 6 = 0 . In our experiments, we use the compatibility coherence because it shows better performance in Table 4.
We can get compatibility coherence by simply multiplying the compatibility matrix in Figure 4(b).
Then, we compute the average coherence value per correspondence.
Finally, thresholding these values with t indicates which correspondences to keep for the final correspondence set { c 1 , c 3 , c 5 , c 7 } .
In our case, we set this threshold as the mean value of the average coherence values, as shown in Figure 4(c).
As a result, by combining this strategy with KNN search, we firstly can obtain as many inliers as possible and efficiently filter out the outliers through structured matching.
Experimentally, combining these two approaches is the key to solving the noisy correspondence problem caused by feature ambiguity common in unbalanced point pairs.
𝐴𝑣𝑔
C C
C C
C C
C
C  1 0 0 0 0 0 10 0 1 0010 1 10 0 00 1 00 0
C
C C
C C
C C
C
C1 C2 C3 C4 C5 C6 C7 C (b) 2 0 0 0 0 0 20 0 2 0010 2 10 0 00 2 00 0
C
C C
C C
C C
C
C1 C2 C3 C4 C5 C6 C7 C (c) 0.
𝐴𝑣𝑔 0.46 ≥ (a) ⋮ [Table] TE [Table]
IR
[Table]
[Table]
p
[Table]
[Table]
A. D ATASET
We follow the same data split strategy that FCGF (Choy et al., 2019b) uses for KITTI odometry dataset (Geiger et al., 2012) for our KITTI-UPP dataset.
We use sequences 0-5 for training, 6-7 for validation, and 8-10 for testing.
For building the input point cloud pair, the query point clouds are sampled from the original frames of the KITTI odometry dataset, and the map point clouds are created by aggregating the LiDAR frames while managing two parameters: range and hop as described in
Section 4.1.
During training, we set the range and hop value to 300 and 10 to build maps.
The query frames are at least 10m apart from each other, and we pick the map which is the closest one to each query among the generated map point clouds.
For evaluation, we use varying range and hop values to evaluate the generalization ability of the methods.
Especially for the test split, we carefully designed the input point cloud pairs so that the query would not be included in the frames that are used to generate the map.
Through this procedure, we yield 1,358 pairs for training, 180 for validation, and 275 for testing.
A. A DDITIONAL D ETAILS ON THE E XPERIMENTS
Evaluation metric.
We use the standard metric to assess the pairwise registration accuracy using
Rotational Error (RE): arccos
Tr( R T ˆR ) − 1and relative Translational Error (TE): ∥ t − ˆt ∥ 2 , where
R , t are the predicted rotation matrix and a translation vector, ˆR , ˆt are the ground-truth.
We also use relative Inlier Ratio (IR) and Registration Recall (RR) for the evaluation.
IR is defined as the ratio of correspondences whose geometric distances are below the predefined threshold ( τ I ) when transformed with the ground-truth transformation.
For a registered pair having RE and TE less than the predefined thresholds ( τ R , τ t ), we regard it as a successful registration and calculate the RR of successful registration over the entire dataset.
Implementation details.
We implement our method with PyTorch (Paszke et al., 2019) and KPConv (Thomas et al., 2019) for efficient 3D kernel-point convolution.
We use a U-shaped network equipped with an encoder and decoder, with three layers of KPConv and KPConv transposed layers.
The feature dimensions of the point feature and super point feature are 32 and 256, respectively.
Input point clouds are downsampled with a 1m voxel size on KITTI-UPP, 30cm on KITTI (Geiger et al., 2012), and 2.5cm on 3DMatch (Zeng et al., 2017) and 3DLoMatch (Huang et al., 2021).
We set λ g = λ p = 1 , and train the network for 200 epochs with Adam optimizer and initial learning rate of 1e-4.
On inference time, k is set to 16 for KNN search.
The detailed architectural configuration can be found in Figure 7.
All experiments are performed on a single Nvidia Tesla V100 GPU and Intel Xeon Gold 6230R CPU @ 2.10GHz.
Pairwise registration on 3DMatch and 3DLoMatch.
To evaluate our method on 3DMatch and 3DLoMatch dataset, we use the checkpoint of CoFiNet Yu et al., 2021) pretrained on the 3DMatch dataset since the network architecture of our approach for the super point and point description is compatible with CoFiNet.
Following the recent literature (Choy et al., 2019b; Bai et al., 2020; Huang et al., 2021; Yu et al., 2021), we use three metrics to assess the registration performance of the methods:
• Registration Recall (RR) :
The ratio of successful registration over the entire dataset.
We consider the registration with RMSE ¡ 0.2 (m) as successful for 3DMatch and 3DLoMatch datasets.
• Inlier Ratio (IR) :
The fraction of correct correspondences among the estimated correspondence set.
We consider correspondences matched with smaller than 10cm residual as correct ones.
• Feature Matching Recall (FMR) :
The fraction of point pairs with an inlier ratio higher than the predefined value over the entire dataset.
We use 5% as the threshold for 3DMatch and 3DLoMatch datasets.
A. A DDITIONAL Q UANTITATIVE R ESULTS
More baselines.
We provide the additional comparison of our UPPNet with the state-of-theart pairwise registration methods (Bai et al., 2020;
Huang et al., 2021; Yu et al., 2021; Lu et al., 2021) and classical methods (Zhou et al., 2016; Fischler & Bolles, 1981) in Table 5 and Tablewith varying spatial and point imbalance factors.
To compare with classical methods, we evaluate
RANSAC (Fischler & Bolles, 1981) and FGR (Zhou et al., 2016) equipped with classical descriptor
FPFH (Rusu et al., 2009) on our KITTI-UPP dataset.
For RANSAC, we report the results with 4M iterations.
They mostly fail on our challenging dataset.
We further refine the registration results of both methods by applying post-processing with ICP (Besl & McKay, 1992).
For state-of-the-art methods, we select Predator (Huang et al., 2021), CoFiNet (Yu et al., 2021), D3Feat (Bai et al., 2020), HRegNet (Lu et al., 2021) for the baseline methods as they are likely to be favorable for the unbalanced point cloud registration.
For a fair comparison, we train the Predator, CoFiNet and ours for 200 epochs on our KITTI-UPP dataset.
For D3Feat and HRegNet, the pretrained model trained on the KITTI Odometry dataset with 200 epochs is finetuned on our KITTI-UPP dataset with additional 50 epochs. [Table]
More results with varying imbalance factors.
To evaluate the generalizability, we compare our
UPPNet with the baseline methods under various scales and densities in Table 5 and Table 6.
In Table 5a, we report the results with the fixed range value 100 under different hop value 25 ( ρ p = 2 . 3 ), 10 ( ρ p = 3 . 7 ), 5 ( ρ p = 4 . 8 ), and 1 ( ρ p = 6 . 9 ).
Note that the range value 100 with hop value 25 is the least challenging data which is most similar to a balanced dataset e.g., KITTI odometry dataset.
Likewise, the results in Table 5b, 6a, 6b are reported under various hop value 25, 10, 5, andwith fixed range value 200, 300, and 400, respectively.
As shown in Table 5a-6b, performance of D3Feat (Bai et al., 2020) and CoFiNet (Yu et al., 2021) drops dramatically as the spatial extent and density of map become larger.
On the other hand, our UPPNet can maintain the high performance at all evaluation metrics and outperform the baseline methods by a large margin, with robust structured matching and our hierarchical framework.
Registration results with different overlap ratios.
To verify the robustness of our method with respect to the overlap ratio between query and map, we conduct experiments under varying overlap ratios as well as in presence of spatial and density imbalance.
In this experiment, we set the range and hop values to 100 and 25 respectively.
Following FCGF (Choy et al., 2019b), each pair is at least 10m apart.
We compute overlap ratio for each pair and assign each pairs to three different groups; pairs with < 70% , 70-85%, and > 85% overlap, and denote each group as low, mid, and high overlaps respectively.
The results are shown in Figure 5 as well as the results of two baselines methods,
CoFiNet (Yu et al., 2021) and Predator (Huang et al., 2021)
As shown in the figure, our method consistently outperforms other baselines by large margin for all overlap ratios of low, mid, and high, gaining notable registration recall improvement of 26% over CoFiNet.
We note that our method is not only effective in presence of spatial density imbalance but it is also robust under different overlap ratios. [Table] [Figure]
Registration results with ground-truth submap.
To validate the effectiveness of our proposed submap matching and structured matching modules, we analyze the registration performance of all methods when the ground-truth submap is provided.
Note that this setting is advantageous for the baseline methods since they are optimized for balanced point pairs, and we refer to these results as the theoretical upperbounds of the baselines methods since we can assume the combination of a highly accurate localization algorithm with the baseline methods.
As shown in Figure 6, thanks to the robustness of the submap matching module in establishing reliable submap correspondences, our model without gt submaps achieves relatively small performance drops compared to others (Yu et al., 2021;
Huang et al., 2021).
Moreover, we highlight that the proposed structured matching effectively helps our method achieve the best results, outperforming the upper bounds of other baselines by large margins even without ground truth submaps.
A. L OSS
In this section, we provide concise equations to calculate the loss terms, L s , L g , and L p .
As we described in Section 3.6 in our main manuscript, the point matching loss L p is defined as:
[Equation]
where ¯ Z is the predicted similarity matrix after solving optimal transport using the Sinkhorn algorithm, ˆ
Z is the binary matrix that indicates ground-truth.
For coarse scale super point and submap level matching, we follow (Yu et al., 2021) and calculate the overlap ratio between two super points, or submaps, to calculate soft-labeled supervision.
For super point matching, we calculate the overlap ratio between two super points as:
[Equation]
where ˆR , ˆt is the groundtruth rotation and translation and τ g is the predefined distance threshold.
If the superpoint ( i ′ , j ′ ) is not an inlier correspondence, we assign it to the slack entry in the similarity matrix.
For this, we calculate the ratio of points in G i ′ which are overlapped with point cloud Y : [Equation] x
[Equation]
and finally build the groundtruth similarity matrix ˆ Z g ∈ R n ′ +
× m ′
+1 as:
[Equation]
Then we calculate the loss similar with point matching loss.
[Equation]
Note that unlike the point matching loss L p , super point matching loss is supervised with the continuous soft labeled supervision ˆ Z g .
Similarly, we can calculate the submap matching loss L s :
[Equation]
where ˆ Z s is the ground-truth similarity matrix at submap level, and it can be calculated in a similar way.
A. N ETWORK A RCHITECTURE
UPPNet adopt a shared U-shaped network based on KPConv (Thomas et al., 2019) to extract multilevel features.
Detailed architecture is demonstrated in Figure 7.
Compared to CoFiNet (Yu et al., 2021), additional layers for the submap matching module are added to our network.
We generate a global descriptor through Generalized Mean Pooling (GeM).
As the global descriptor of the query is a single vector, the self-attention module is applied only for global descriptors of the map, such as in
Figure 7.
[Figure] [Figure]
Attention, N
F ’ X Ⓒ C o n v 1 D ( N , N ) Ⓐ C o n v 1 D (
N , N ) F ’ X ⊕
C o n v 1 D (
N , N )
C o n v 1 D ( N , N ) C o n v 1 D ( N , N ) Cross Attention, N F ’ Y Ⓒ
C o n v 1 D (
N , N ) Ⓐ C o n v 1 D (
N , N ) F ’ X ⊕ C o n v 1 D (
N , N )
C o n v 1 D (
N , N ) C o n v 1 D ( N , N )
F ’ X
S e l f A tt e n t i o n , S e l f A tt e n t i o n , S e l f A tt e n t i o n ,
S e l f A tt e n t i o n ,
C r o ss A tt e n t i o n , Ⓒ Ⓒ Ⓒ
C o n v 1 D , ( 256 , 256 )
N e a r e a s t
U p s a m p l e
C o n v 1 D , ( 768 , 128 )
N e a r e a s t
U p s a m p l e
C o n v 1 D , ( 364 , 64 )
N o d e G r o up i n g
N e a r e a s t
U p s a m p l e
C o n v 1 D , ( 192 , 32 )
C o n v 1 D , ( 32 , 32 )
C o n v 1 D , ( 32 , 32 ) same encoder
S e l f A tt e n t i o n ,
S e l f A tt e n t i o n , S e l f A tt e n t i o n ,
S e l f A tt e n t i o n ,
C r o ss A tt e n t i o n , same encoder
C o n v 1 D , ( 256 , 512 )
G e M
C o n v 1 D , ( 256 , 51 2 )
G e M
S ub r e
g
i o n
G r o up i n g
S e l f A tt e n t i o n ,
C r o s s A tt e n t i o n , 512 S e l f A tt e n t i o n ,
A. A DDITIONAL Q UALITATIVE R ESULTS
In Figure 8, we provide additional qualitative results of our method along with the baseline methods on the KITTI-UPP test dataset.
[Figure]