GeoLCR: Attention-based Geometric Loop Closure and Registration

TL;DR

GeoLCR introduces an attention-based geometric loop closure and registration algorithm utilizing lidar data, achieving high precision and perfect loop detection success across multiple datasets, advancing autonomous vehicle perception capabilities.

Contribution

The paper presents a novel lidar-based loop detection and registration method with an innovative point-level registration model and attention mechanism, outperforming existing approaches in accuracy and success rate.

Findings

Up to twofold increase in translation and rotation accuracy.

Achieved 100% success rate in loop detection on challenging sequences.

Validated across multiple datasets including KITTI and Nuscenes.

Abstract

We present a novel algorithm specially designed for loop detection and registration that utilizes Lidar-based perception. Our approach to loop detection involves voxelizing point clouds, followed by an overlap calculation to confirm whether a vehicle has completed a loop. We further enhance the current pose's accuracy via an innovative point-level registration model. The efficacy of our algorithm has been assessed across a range of well-known datasets, including KITTI, KITTI-360, Nuscenes, Complex Urban, NCLT, and MulRan. In comparative terms, our method exhibits up to a twofold increase in the precision of both translation and rotation estimations. Particularly noteworthy is our method's performance on challenging sequences where it outperforms others, being the first to achieve a perfect 100% success rate in loop detection.

Tables

Table 1. TABLE I : Our method is faster than most of the learning-based approaches in each processing.

Running Time of Learning-based Approaches (ms)
RPMNet	DCP	LCDNet	Ours	Ours(CUDA)
854.79	456.18	1324.2	597	297

Table 2. TABLE II : The false positive and false negative of the loop closure detection models. After the registration we can get very accurate loops.

Data	False Postive	False Positive After Registration
KITTI 00	0.26	0.00
KITI-360 09	0.22	0.01

Table 3. TABLE III: Pose estimation error for positive pairs in the KITTI dataset . TE and RE are Translation and Rotation Errors. In both 0 and 8 sequences, our approach achieves better performance in translation accuracy and comparable rotation accuracy. In both cases, our method succeeded in detecting all the loop closure frames. (succ./all) means the errors for the frame pairs in successfully detected loops and in all loops in the database.

	Seq. 00			Seq. 08
	Success	TE (m)	RE (deg)	Success	TE (m)	RE (deg)
		(succ. / all)	(succ. / all)		(succ. / all)	(succ. / all)
GICP [gicp]	-	- / 1.38	- / 6.22	-	- / 3.71	- / 153.7
TEASER [teaser]	34.06%	0.98 / 2.72	1.33 / 15.85	17.13%	1.34 / 3.83	1.93 / 29.19
OverlapNet [overlapnet]	83.86%	- / -	1.28 / 3.89	0.10%	- / -	2.03 / 65.45
DCP [wang2019deep]	50.71%	0.98 / 1.83	1.14 / 6.61	0%	- / 4.01	- / 161.24
LCDNet [lcdnet]	100%	0.11 / 0.11	0.12 / 0.12	100%	0.15 / 0.15	0.34 / 0.34
Geometric Transformer [geometric]	-	- / 0.08	- / 0.32	-	- / 0.13	- / 0.67
Ours (GeoLCR: wo Coarse ft)	100%	0.07 / 0.07	0.43 / 0.43	100%	0.12 / 0.12	0.51 / 0.51
Ours (GeoLCR: w Coarse ft)	100%	0.06 / 0.06	0.33 / 0.33	100%	0.11 / 0.11	0.47 / 0.47

Table 4. TABLE IV: Pose estimation error for positive pairs in the KITTI-360 dataset . For both of the two sequences in the KITTI-360, our method achieved far better results in estimating translation(TE: Translation Error). On both Sequence 02 and 09, our method estimates poses up to two times better than other algorithms in translation and shows comparable results in rotation(RE: Rotation Error). Also, our method succeeded in detecting loop closures for both the sequences (i.e. 100% success rate), while every other method failed on Sequence 02.

	Seq. 02			Seq. 09
	Success	TE (m)	RE (deg)	Success	TE (m)	RE (deg)
		(succ. / all)	(succ. / all)		(succ. / all)	(succ. / all)
GICP [gicp]	-	- / 3.51	- / 138.61	-	- / 2.39	- / 79.72
TEASER [teaser]	27.02%	1.25 / 3.16	1.83 / 19.16	30.32%	1.14 / 2.91	1.46 / 19.22
OverlapNet	11.42%	- / -	1.79 / 76.74	54.33%	- / -	1.38 / 33.62
DCP	5.62%	1.09 / 3.14	1.36 / 149.27	30.10%	1.04 / 2.30	1.06 / 64.86
LCDNet	98.55%	0.27 / 0.32	0.32 / 0.34	100%	0.20 / 0.20	0.22 / 0.22
Geometric Transformer	-	- / 0.27	- / 1.46	-	- / 0.12	- / 0.41
Ours (GeoLCR: wo Voxel ft)	100%	0.14 / 0.14	0.42 / 0.42	100%	0.10 / 0.10	0.32 / 0.32
Ours (GeoLCR: w Voxel ft)	100%	0.08 / 0.08	0.35 / 0.35	100%	0.08 / 0.08	0.26 / 0.26

Table 5. TABLE V: Pose estimation error in the Mulran dataset  [ mulran ] .

Mulran [mulran]	Sejong01		Sejong02		Sejong03
	TE (m)	RE (deg)	TE (m)	RE (deg)	TE (m)	RE (deg)
Ours (GeoLCR)	0.47	0.78	0.44	0.73	0.74	1.12
LCDNet [lcdnet]	5.44	20.81	4.42	16.57	5.26	19.59
Geometric Transformer [geometric]	0.14	0.38	0.15	0.42	0.41	0.30
GICP [gicp]	0.89	0.86	1.02	0.33	1.64	1.07

Table 6. TABLE VI: Pose estimation error in the Complex Urban dataset .

Complex Urban [urban]	Urban07		Urban08
	TE (m)	RE (deg)	TE (m)	RE (deg)
Ours (GeoLCR)	0.71	3.12	0.65	2.50
LCDNet [lcdnet]	4.18	54.92	3.64	37.84
Geometric Transformer [geometric]	0.87	6.61	1.28	8.97
GICP [gicp]	2.13	83.23	1.44	29.00

Table 7. TABLE VII: Pose estimation error in the NCLT dataset . Because the dataset is very sparse and there are not many points(16-channel Lidar), the LCD-Net failed in the dataset. For other methods, because there are some places in open space, there are not many features around the robot, all the algorithms perform bad in the situation, thus the average performance in NCLT dataset is generally worse than other datasets.

NCLT [nclt]	2012-08-20		2012-10-28		2012-11-16
	TE (m)	RE (deg)	TE (m)	RE (deg)	TE (m)	RE (deg)
Ours (GeoLCR)	1.24	10.1	1.63	15.1	1.64	13.9
LCDNet [lcdnet]	-	-	-	-	-	-
Geometric Transformer [geometric]	1.39	10.23	2.42	17.00	2.29	17.12
GICP [gicp]	4.17	128.98	4.05	107.83	3.37	86.69

Table 8. TABLE VIII: Pose estimation error for positive pairs in the KITTI dataset . Our method achieved a comparable result for translation and better performance for rotation.

	Ours (GeoLCR)			LCDNet [lcdnet]
	Success	TE (m)	RE (deg)	Success	TE (m)	RE (deg)
		(succ. / all)	(succ. / all)		(succ. / all)	(succ. / all)
KITTI Seq 00	100%	0.11 / 0.11	0.12 / 0.12	100%	0.14 / 0.14	0.13 / 0.13
KITTI Seq 08	100%	0.15 / 0.15	0.34 / 0.34	100%	0.19 / 0.19	0.24 / 0.24

Table 9. TABLE IX: Pose estimation error for positive pairs in the KITTI-360 dataset . Our approach achieves higher accuracy in rotation and translation estimations and more robust accuracy in nearby-frame detection.

	Ours (GeoLCR)			LCDNet [lcdnet]
	Success	TE (m)	RE (deg)	Success	TE (m)	RE (deg)
		(succ. / all)	(succ. / all)		(succ. / all)	(succ. / all)
KITTI-360 Seq 0	100%	0.14 / 0.14	0.13 / 0.13	44%	0.97 /2.0	1.12 /27.75
KITTI-360 Seq 2	100%	0.17 / 0.17	0.18 / 0.18	49.8%	1.00 / 1.93	1.37 / 14.98
KITTI-360 Seq 4	100%	0.16 / 0.16	0.15 / 0.15	44%	1.00 / 2.05	1.19 / 20.01
KITTI-360 Seq 5	100%	0.16 / 0.16	0.15 / 0.15	47%	0.97 / 2.03	1.39 / 22.1
KITTI-360 Seq 6	100%	0.17 / 0.17	0.15 / 0.15	57%	0.95 /1.68	1.21 /14.70
KITTI-360 Seq 9	100%	0.14 / 0.14	0.12 / 0.12	57%	0.92 / 1.54	1.13 / 9.82

Table 10. TABLE X: Pose estimation error for positive pairs in the Nuscenes dataset . The Nuscenes dataset, with more dynamic obstacles, is more complex than the KITTI or the KITTI-360. Our method achieved a comparable result for translation and better performance for rotation.

Nuscenes	Success	TE (m) (succ. / all)	RE (deg) (succ. / all)
Ours (GeoLCR)	100%	0.15 / 0.15	0.12 / 0.12
LCDNet [lcdnet]	21%	0.57 /11.59	1.91 /20.95

Equations

$${\mathbf{v}}_{s,i}=\frac{1}{|{\mathcal{C}}_i|}\sum _{{\mathbf{p}}_m\in {\mathcal{C}}_i}{\mathbf{p}}_m,$$

$$O({\mathcal{Q}}_s,{\mathcal{Q}}_k)$$

$${\mathcal{I}}_{i,j}$$

$$o_{i,j}=\exp \frac{-{\sum }_{{\mathbf{p}}_m\in {\mathcal{C}}_j}{\Vert {\mathbf{p}}_m-{\mathbf{p}}_n\Vert }_2}{|{\mathcal{C}}_j|},$$

$$\hat{d}({\mathbf{f}}_i^s,{\mathbf{f}}_j^k)$$

$$\hat{o}({\mathbf{f}}_i^s,{\mathbf{f}}_j^k)$$

$${\mathcal{L}}_i$$

$${\mathcal{L}}_l^p$$

$${\mathcal{L}}_l^n$$

$${\mathcal{L}}_o$$

$$\widehat{{\mathcal{F}}^p}=k_{self}({\mathcal{F}}^v,{\mathcal{F}}^p)$$

$${\tilde{\mathcal{F}}}_k^p=k_{cross}({\hat{\mathcal{F}}}_s^p,{\hat{\mathcal{F}}}_k^p),{\tilde{\mathcal{F}}}_s^p=k_{cross}({\hat{\mathcal{F}}}_k^p,{\hat{\mathcal{F}}}_s^p)$$

$$s[a,m,n]=\sum _{k\in \{0,...,d\}}\widetilde{{\mathcal{F}}_k^p}[a,m,k]\times \widetilde{{\mathcal{F}}_s^p}[a,n,k]$$

$${\mathcal{L}}_{\text{matrix}}={\Vert {\hat{R}}^T{R}_g-I\Vert }_2^2+{\Vert \hat{t}-t_g\Vert }_2^2$$

$${\mathcal{L}}_{\text{distance}}=\text{MSE}(\hat{T}{\mathbf{p}}_s-T_g{\mathbf{p}}_s),$$

$${\mathcal{L}}_r=\gamma {\mathcal{L}}_{\text{matrix}}+\eta {\mathcal{L}}_{\text{distance}},$$

$${\mathbf{fr}}_k\notin {\mathcal{H}}_c\text{and}{\Vert {\mathbf{fr}}_k-{\mathbf{fr}}_c\Vert }_2<d_f$$

$$RE=\arccos \frac{trace({\hat{R}}^T{R}_{\text{g}})-1.0}{2}$$

Full text

I Introduction

Simultaneous Localization and Mapping (SLAM) algorithms are integral components in robotics and autonomous navigation applications [fastlio, lego, overlapnet, lcdnet]. These algorithms strive to simultaneously estimate the position of a vehicle navigating within an unknown environment and construct a map of the environment. SLAM computation generally encompasses two primary steps [tsintotas2022revisiting, lowry2015visual]: The first is local odometry [gicp, lego, fastlio], which aims to construct a consistent map within a short range. However, this approach tends to accumulate drift over time. To counteract this, the second stage, loop closure [elastic, lcdnet, overlapnet], comes into play when the robot encounters a closed loop, enabling the rectification of the constructed map and addressing drift accumulation issues. Our focus in this paper is only on loop closure, specifically on loop detection and pose computation.

A wide variety of sensors are used in different vehicles, such as mono-cameras, RGBD cameras, Lidars, and IMUs. Different perception algorithms are also developed that are tailored for each sensor. Monocular cameras, for instance, are commonly employed in SLAM tasks [orbslam], and the efficacy of visual SLAM can be further optimized with an IMU sensor. The advent of RGBD cameras has enabled these algorithms to compute precise depth data, thereby enhancing the map-building accuracy. Among the sensors, Lidars are often considered the most accurate for long-range depth information. Several approaches [lego, liosam, lcdnet, overlapnet] exploit Lidars for mapping and localization as they typically provide higher quality depth information compared to RGBD sensors. In this paper, we confine our attention to Lidar as the perceptual sensor for the loop closure tasks.

Loop closure in SLAM computation consists of two subtasks, as depicted in Figure 1. The first task involves detecting the closed-loop scenario where the robot needs to discern if the current environment resembles any previously encountered scenarios. The second task involves recalculating the current position based on detected similar frames for low-level map rectification. Traditional approaches [lego, liosam] often use ICP-based methods, yet these optimization-based algorithms often suffer from local minimum issues. Some learning-based approaches [overlapnet, arshad2021role] target autonomous cars, focusing on yaw angle registration and long-range Lidar points. However, these approaches do not offer distance-related information and cannot be directly implemented by small robots that require 3D rotation and translation with short-range Lidar sensors.

**Main Contributions: ** We present GeoLCR, a learning-based approach for geometric loop closure and point-level registration. The framework involves a unique amalgamation of overlap estimation and registration, incorporating innovative techniques for voxel matching and pose calculations to bolster accuracy. The unique aspects of our work encompass:

We propose an overlap detection metric for 3D loop closure detection. Based on the Superpoint Matching Module [geometric], we develop an overlap estimator to estimate the overlap values. We demonstrate that the overlap estimation is consistent with the distances between two point clouds and is easy to use for loop closure detection. 2. 2.

We propose a novel transformer-based registration model that is specific to our overlap estimator. We exploit the fact that the distance between coarse features corresponds to the overlap between a pair of voxels and take these features into account to improve the accuracy of point matching. We also show that our registration transformer generates better results (Section IV and Appendix [appendix]). 3. 3.

We validate the efficacy of our approach using different datasets, including those based on cars and small robots, specifically KITTI [kitti], KITTI-360 [kitti360], Nuscenes [nuscenes], Complex Urban [urban], NCLT [nclt] and MulRan [mulran]. We show that our approach is up to two times more accurate in registration and also more accurate in overlap detection than the other state-of-the-art methods [appendix].

II Background

Different techniques have been proposed for loop closure based on the underlying sensors. In terms of camera-based and Lidar-based approaches, there are many traditional approaches as well as learning-based approaches [zhang2021visual, overlapnet, lcdnet]. In this section, we mainly limit ourselves to techniques proposed for Lidar sensors.

II-A Loop Closure Detection

The traditional loop closure algorithms using Lidar data are mostly based on optimization approaches [lego, fastlio], where the Levenberg-Marquardt algorithm is used to find the minimum distance between the point clouds directly  [fastlio, dellenbach2022ct]. The Lio-sam [liosam] algorithm uses an extra GPS sensor and introduces the GPS graph factor to help with the detection of loop closure. LLoam [ji2019lloam] segments the Lidar data and builds a factor graph to perform graph optimization for loop closure detection. LDSO [gao2018ldso] uses the image features to build a similar bag-of-words (BoW) approach and uses a sliding window to perform optimization. However, those approaches suffer from local minimum problems, where the current pose estimation may not be accurate.

With the development of learning-based approaches, researchers are able to extract the semantic information from point clouds and compare the semantic features from different frames for loop closure. The learning-based methods implicitly trained the models to detect the loops comparably accurately or even more accurately than classical methods [lin2021topology, li2021sa, zhou2022loop]. Lin et al. [lin2021topology] use the semantic information to build a topology graph and compare the objects’ relative positions within two frames; SA-LOAM [li2021sa] extracts the semantic information of each sub-graph (i.e. the local map) and then compares the similarity of the sub-graphs for loop closure. [zhou2022loop] uses a similar approach to generate local map descriptors and compare the likelihood of the descriptors. Although these semantic approaches can compute the similarities of different local frames, they cannot predict the overlap or matching of different local frames. Recently, several approaches have been proposed that can directly predict the overlap between the local frames [zhou2021ndt, ma2022overlaptransformer, overlapnet]. However, their predictions are based on the 2D birds-eye-view graph, and they directly use the overall point cloud for registration, which can be computationally expensive and requires a lot of storage. In this paper, we present a new method based on a Superpoint Matching Module [geometric] to predict the overlap and use the points in matched voxels to perform point registration and predict the current position.

II-B Point Registration

After detecting the loop closure, a new estimate of the current position needs to be predicted with the matched frame. There are many known approaches that can be used for point registration. Traditionally, researchers have used ICP/GICP [gicp] for registration with the help of RANdom SAmple Consensus (RANSAC). For learning-based approaches, the Sinkhorn algorithm and differentiable Singular Value Decomposition (SVD) approaches have been combined for the registration task [geometric, lcdnet]. These approaches take into account all the points for calculation, which can be computationally costly and subject to local minima issues. We present a novel approach using a point transformer that takes the features of matched voxels for registration and estimates the transformation matrix between the points in matched pairs to reduce the computation.

III Approach

In this section, we give the definition of the overlap and describe the details of the overlap and registration models, and finally we also provide the complete loop closure detection strategy.

In this work, the low-level odometry is achieved by Lio-sam [liosam], which is based on GTSAM [dellaert2012factor], where the map modification is done by the factor graph [dellaert2012factor] method. we assume the map rectification is well handled by Lio-sam and we only focus on the loop detection and registration.

The observation input of our model is 3D Lidar point cloud, points $\mathbf{p}\in\mathbb{R}^{3}$. The loop closure task includes: First, estimate the overlaps between the current keyframe $s$ and the selected previous keyframes, then select the potential matched historic frames; Second, predict the transformation matrix $T\in SE(3)$ between the current keyframe $s$ and the selected historic keyframe $k$. Then extract the best matches as closed loops and provide the transformation matrix as constraints for local odometry.

In this section, we give an overlap definition in III-A, describe Overlap Estimator in III-B and Registration in III-C. Finally introduce the whole pipeline of the loop detection in III-D

III-A Overlap Definition

For overlap detection, a sequence of keyframes $k$ with points set $\mathcal{P}_{k}$ is compared with the current frame $s$ of observation with points set $\mathcal{P}_{s}$. For each frame, we use a voxelization method [zhou2020end] to down-sample the point clouds corresponding to this frame. The position of each voxel is calculated by the mean value of all the points in the voxel using Equation 1:

[TABLE]

where position $\mathbf{v}_{s,i}\in\mathcal{Q}_{s}$ is the position of voxel $i$ in the current keyframe $s$, then we can also have $\mathbf{v}_{k,j}\in\mathcal{Q}_{k}$ as the position of voxel $j$ in one of the previous keyframes $k$. $\mathcal{Q}_{s}$ and $\mathcal{Q}_{k}$ represent the voxel clouds generated from point clouds $\mathcal{P}_{s}$ and $\mathcal{P}_{k}$ frame $s$ and $k$, respectively. All the points in the voxel space of voxel $i$ compose the point set $\mathcal{C}_{i}$, so $\mathbf{p}_{m}\in\mathbb{R}^{3}$ represents the $m_{\text{th}}$ point in $\mathcal{C}_{i}$. The overlap between the two voxel clouds of the current keyframe and a historic keyframe is given as

[TABLE]

$\mathcal{I}_{i,j}\in\{0,1\}$ represents the indicator function that gives 1 when two voxels $i$ and $j$ overlap, where $th$ is the threshold for the overlap score. In this project, we set $th=0.1$. Notice that $O(\mathcal{Q}_{s},\mathcal{Q}_{k})$ is not in $[0,1]$ because the denominator is the minimum number of two groups of voxels and one voxel can match several voxels from the other cloud. The $o_{i,j}$ represents the overlap score of one pair of voxels, $i,j$, and this is estimated by the Overlap Estimator in in Figure 2. Each voxel is a small point cloud, so the ground truth overlap score of each pair of voxels is calculated in a similar way to how we match two point clouds: we calculate the average Euclidean distance $\left\|{\cdot}\right\|_{2}$ between two points clouds and then take the negative exponential value as the overlap score of the two voxels to ensure the values are [0-1] for easier training, as the follows:

[TABLE]

where $\mathbf{p}_{m}\in\mathcal{C}_{j}$ and $\mathbf{p}_{n}\in{\mathcal{C}_{T}}_{i}$, $\mathcal{C}_{i}$ and $\mathcal{C}_{j}$ are point sets of voxels $i$ and $j$ in frames $s$ and $k$, and $|\mathcal{C}_{j}|$ is the points number in set $\mathcal{C}_{j}$. ${\mathcal{C}_{T}}_{i}$ is the transformed point set of ${\mathcal{C}_{T}}_{i}$ by the ground-truth transformation matrix $T$ (Figure 2), and $\mathbf{p}_{n}$ is the nearest point in ${\mathcal{C}_{T}}_{i}$ to $\mathbf{p}_{m}$. In our implementation, when the overlap score $O(\mathcal{Q}_{s},\mathcal{Q}_{k})>0.5$, we consider the two keyframes overlapped.

III-B Overlap Estimation

Overlap detection detects overlapped point clouds. Because this step compares the current point cloud with multiple clouds in database, the computational cost is critical. Geometric Transformer’s [geometric] pipeline is very computationally costly, but its Superpoint Matching Module encodes voxel’s geometric information itself and also geometric relationship between two voxels in the voxel’s features. Taking advantage of the geometric information, we design an Overlap Estimator to estimate the matched pairs, as Figure 2. To reduce the computation, we only use the voxels’ features extracted by the encoder of the KPConv for the overlap estimation. The voxel features are put into the Superpoint Matching Module as Figure 2 and then we can get processed voxel features (normalized), $\mathbf{f}^{s}$ and $\mathbf{f}^{k}$ for the current keyframe $s$ and one historic keyframe $k$. The feature similarity $\hat{d}()$ and overlap score $\hat{o}$ are:

[TABLE]

where $a(\cdot)$ is the Sigmoid activation function. $g(\cdot)$, $h_{s}(\cdot)$, $h_{c}(\cdot)$, and $h_{k}(\cdot)$ all contain a sequence of linear layers with ReLU activation function. The details of the networks and feature dimensions are in Supplement Section A.  [appendix]. In the following equations, we use $o_{i,j}$ for the ground truth of the overlap score between the two voxels $i$ and $j$, $\hat{o}_{i,j}$ for $\hat{o}(\mathbf{f}_{i}^{s},\mathbf{f}_{j}^{k})$, and $\hat{d}_{i,j}$ for $\hat{d}(\mathbf{f}_{i}^{s},\mathbf{f}_{j}^{k})$.

The loss function of the whole overlap estimation model has two parts: the first part is the circle loss [sun2020circle] to learn a better matching between two voxel clouds and the second part is used for accurate overlap estimation.

As Equation 7, $\mathcal{L}_{i}$ is the total circle loss [sun2020circle] and the $\mathcal{L}_{l}(s)$ and $\mathcal{L}_{l}(k)$ represent the circle loss for the voxels in the current keyframe $s$ and the historic keyframe $k$, respectively. $\mathcal{I}_{i,j}$ is defined in Equation 3. Each $\mathcal{L}_{l}$ contains loss functions $\mathcal{L}_{l}^{p}$ and $\mathcal{L}_{l}^{n}$, which are for overlapped pairs and non-overlapping pairs. $\mathcal{P}$ and $\mathcal{N}$ represent the set of overlapped and non-verlapped voxel pairs, respectiely. LSE is the LogSumExp loss to keep the loss numerically stable. $\alpha$ and $\beta$ are all hyper-parameters.

[TABLE]

The loss for the overlap values is $\mathcal{L}_{o}$, where MSE represents the mean squared error and $\hat{O}=\{\hat{o}_{i,j}\}$ and $O=\{o_{i,j}\}$ are estimated and real overlap values for all voxels pairs, $\left\{{i,j}\right\}$, in the two frames $s$ and $k$:

[TABLE]

The total loss of the overlap estimation is $\mathcal{L}_{c}=\mathcal{L}_{o}+\mathcal{L}_{i}$. Next, we calculate the overlap of the matched frames based on Equation 3. If the keyframe and the current frame satisfy the overlapped criteria, those matched voxels are used for point registration.

III-C Point Registration

Registration is to provide an estimated transformation matrix for the potentially matched frames from the overlap estimation. Then the matrices are used to further select matched frames and are finally used as a constraint to low-level map rectification. In this section, we describe our novel method for point registration to generate the transformation matrix between two keyframes. Since we only use Lidar as the perceptive sensor, if the point clouds do not overlap much or are in very different shapes, it would be hard to estimate the accurate transformation matrix between them. Therefore, rather than using whole point clouds, we only choose the points from highly overlapped voxel pairs to leverage their matching relationships.

After the voxel matching step, we have the matched pairs of voxels $\{i,j\}$ with corresponding point sets $\mathcal{C}_{i}$ and $\mathcal{C}_{j}$ as the input of the registration step. As shown in Figure 2, the registration step includes a Registration Transformer model and a WSVD (weighted SVD) model [chen2017weighted]. The Registration transformer takes the features of voxels and points to get the score map of the points in two point clouds, and then the WSVD model takes the point pairs with the highest scores to generate the transformation matrix $\hat{T}$.

For the Registration Transformer, instead of only using the points in the registration task, as Figure 3 shows, we take the features of the matched voxels $\mathcal{F}^{v}$ to provide the larger scale of (voxel) space information for the point matching, where $\mathcal{F}^{v}=\left\{{\mathcal{F}^{v}_{s},\mathcal{F}^{v}_{k}}\right\}$ and $\mathbf{f}_{i}^{s}\in\mathcal{F}^{v}_{s}$ and $\mathbf{f}_{j}^{k}\in\mathcal{F}^{v}_{k}$. As shown in Figure 3, $\mathcal{F}^{p}=\left\{{\mathcal{F}^{p}_{s},\mathcal{F}^{p}_{k}}\right\}$ represents the features of points in both frames. We first project the processed voxel features, $W^{v}\mathcal{F}^{v}$, to the space of processed point features, $W^{p}\mathcal{F}^{p}$, where $W^{v}$ and $W^{p}$ are the weights for the features of voxels and points. After normalization, we put the features to the attention networks and then post-process the features by several linear layers. The entire process of the self-attention model $k_{self}(\cdot)$ is on the left. Our attention model is based on the multi-head attention model [vaswani2017attention]. The output of the self-attention model is $\hat{\mathcal{F}^{p}}$, as :

[TABLE]

After we process both $s$ and $k$ frames by self-attention module and generate $\hat{\mathcal{F}}_{s}^{p}$ and $\hat{\mathcal{F}}_{k}^{p}$, the cross-attention model $k_{cross}(\cdot)$ takes them as inputs. $W^{c}$ and $W^{s}$ correspond to the weights of the inputs and the corresponding cross-attention output features of the points are $\tilde{\mathcal{F}^{p}_{s}}$ and $\tilde{\mathcal{F}^{p}_{k}}$. All these features have the shape of $v\times p\times d$, where $v$ is the size of matched voxels, $p$ is the size of points in each voxel, and $d$ is the feature dimension.

[TABLE]

We use the Einstein sum to calculate the matching scores between two points features:

[TABLE]

where $a\in[0,v)$ is the index of matched voxel pairs. $m\in[0,\left|{\mathcal{C}_{i}}\right|)$ and $n\in[0,\left|{\mathcal{C}_{j}}\right|)$ are the indices of the points from the point sets $\mathcal{C}_{i}$ and $\mathcal{C}_{j}$ of the overlapped voxels $i$ and $j$. Then we have the score map with the shape $(v,\left|{\mathcal{C}_{i}}\right|,\left|{\mathcal{C}_{j}}\right|))$. We choose the points with the biggest value (”Top-k” in Figure 2 and $k=1$) in the last dimension to compose the point pairs with the score map $s$, which now has the shape of $(v,\left|{\mathcal{C}_{i}}\right|)$. Those scores are used as weights for the point pairs to be put into the weighted SVD model, whose gradience functions can be found in the work [chen2017weighted].

The loss function of the registration stage contains two parts: The first part aims at reducing the error of the estimated transformation matrix. Inspired by the transformation loss [wang2019deep], the first part of the loss function is given as:

[TABLE]

where $\hat{R}$ and $\hat{t}$ are the estimated rotation and translation transformations, and the estimated transformation matrix $\hat{T}$ is composed of $\hat{R}$ and $\hat{t}$. $I$ is a $(3\times 3)$ identity matrix. $R_{g}$ and $t_{g}$ are the ground truth transformations corresponding to rotation and translation.

Because the ground truth transformation matrices in some datasets [kitti, kitti360] are not very accurate, shown in Figure 11 [appendix], we also need to provide some loss to compensate for the inaccuracy. The second part is aimed at reducing the distances between the two transformed point clouds $\hat{T}\mathbf{p}_{s}$ and $T_{g}\mathbf{p}_{s}$, where $\hat{T}$ and $T_{g}$ represent the estimated transformation matrix and the ground truth transformation matrix and $\mathbf{p}_{s}$ represents the points in the current keyframe:

[TABLE]

The total loss for the registration stage is given as:

[TABLE]

where $\gamma$ and $\eta$ are coefficients. This loss function is for the registration of points. In the training phase, we combine the overlap loss function and registration loss function together $\mathcal{L}=\mathcal{L}_{c}+\mathcal{L}_{r}$ for the whole training.

III-D Loop Detection

As shown in Algorithm 1, when a robot is moving, our model gets the frames from Lio-sam and saves each keyframe $\mathbf{fr}_{c}$ from every N received frames, where N is 2 in this project.

The $RemoveFarFrames$ function removes the historic keyframes far from the current keyframe with a distance threshold $d_{f}$, because if the frames are too far it has less possibility as a loop. This function also removes the frames, $\mathcal{H}_{c}$, in the last $d_{h}$ meters of the trajectory from the current keyframe $\mathbf{fr}_{c}$. For all saved keyframes $\mathbf{fr}_{k}$, we have the constraints:

[TABLE]

The $OverlapEstimator$ predicts the overlap value between the two point clouds, and the $PointRegistration$ is the registration model, which estimates the transformation matrix between the two point clouds. These are two stages of filtering matched frames. The parameter values for different datasets can be different, and our values are in the Experiment Section. Given the transformation matrix, if the translation value is smaller than the threshold $\mathbf{d}_{th}=3$m, we consider the loop closed. The loop constraints are as what Lio-sam [liosam] takes and are published by $PublishLoopConstraints$ function.

IV Results and Comparisons

We tested our method on KITTI [kitti] and KITTI-360 [kitti360] datasets to validate our approach. We compared the accuracy of overlap estimation and pose estimation results with other state-of-the-art methods, including OverlapNet [overlapnet] and LCDNet [lcdnet]. For more comparisons with different datasets (Nuscenes [nuscenes], Complex Urban [urban], NCLT [nclt] and MulRan [mulran]) are in Tables V-X in Supplement [appendix].

The entire model is trained by the loop-closed data of all the datasets together (Nuscenes [nuscenes], Complex Urban [urban], NCLT [nclt] and MulRan [mulran]), without the pre-trained models of KPConv [thomas2019kpconv] or Geometric Transformer [geometric]. Specifically for the experiments, for KITTI and KITTI-260, we use Sequences [1,2,3,4,5,6,7,9,10] of KITTI and [0,3,4,5,6,7,10] of KITTI-360 for training and Sequences [0,8] of KITTI and [2,9] of KITTI-360 for evaluation. The Overlap Estimator and the Registration Transformer models are trained at the same time.

IV-A Runtime Analysis

We compare the running time of our approach with other state-of-the-art approaches. For the experiments, we use an NVIDIA RTX A5000 GPU and an Intel Xeon(R) W-2255 CPU. The average running time of our method includes 5 parts: 1. Point processing of each pair of frames takes 0.5s with CPU or 0.2s with CUDA (around 0.1s for single frame); 2. Voxel feature processing costs 0.03s; 3. Point feature processing takes 0.001s; 4 Registration takes 0.016s. We can observe a computational bottleneck in the point preprocessing step, as we have to get neighbors of the points and voxels in 5-stage voxelization. We accelerated it using CUDA and the dynamic voxelization method [zhou2020end].

Table I compares different state-of-the-art methods. Our approach has a running time comparable to these other approaches with similar accuracy.

IV-B Loop Detection

Loop detection has two stages, the first stage is the overlap estimation, where we use Overlap Estimator to estimate the overlaps of point clouds. Because the overlap values are very related to frame distances as mentioned in Figure 8 [appendix], our false positive cases do not have very far distances. This makes it possible to use registration to filter negative matches. Therefore, the second stage is to use the registration to remove the far frames.

We tested our Overlap Estimator model with the same critiera in LCDNet [lcdnet]. As Figure 4, our approach is the blue curve that has very competitive performance with LCDNet(pink curve). But instead of only having single stage place recognition(as LCDNet), after coarse matching we also use registration model to remove the far frames. Therefore, after estimating the transformation matrices, we remove the frames 3 meters away from the current frame as $\mathbf{d}_{th}=3m$ in III-D. As Table II, after the registration step, there are mostly all matched frames cases left.

IV-C Pose Estimation

To demonstrate the accuracy of the prediction of transformation matrices, we evaluated our model by the metrics of LCD-Net [lcdnet] in KITTI and KITTI-360 datasets. We compared our registration transformer’s performance with other algorithms. Since this module is used for loop-closing frames, we have to temporarily select the distant frames that closely overlap. To make a fair comparison with the other algorithms, we used the same criteria as LCDNet [lcdnet] to choose overlapped frames to test registration performance.

In Tables III and  IV, we present pose estimation errors for two sequences in each of the datasets. We compared both classical methods and learning-based methods, where LCDNet [lcdnet] is the closest competitor. Lio-Sam [liosam] uses ICP, but GICP is better [gicp] in registration so we compare with GICP. The translation error (TE) is calculated by the Euclidean distance between the two frames. The rotation error (RE) is calculated as:

[TABLE]

where $\hat{R}$ is the estimated rotation matrix and $R_{\text{g}}$ is the ground truth rotation matrix. We also did ablation study that compares the models w/wo the coarse features. From the tables III and  IV, voxels features help in both translation and rotation estimations. Comparing our model without Voxels’ features with Geometric Transformer [geometric], we can see the Registration Transformer in our model does better than the Sinkhorn algorithm used in Geometric Transformer [geometric]. This also demonstrates the power of transformers in cross relation estimation.

In Tables III and IV, we can observe that our Registration Transformer achieves the best results in translation estimation and comparable results in rotation estimation. Before doing SVD, compared with LCDNet, our approach uses transformers to enhance the point features by the other frame as Figure 2, which contributes to the more accurate SVD results. Compared to other methods, our approach has at least a $30\%$ improvement in translation estimation. For the rotation estimation, our approach is comparable to LCDNet. But because our model is trained by different datasets, we are more generalized to different sorts of point clouds as shown in Tables V-X in  [appendix].

V Limitations, Conclusions, and Future Work

We present a new learning pipeline, GeoLCR, for loop closure detection and points registration. We compare the accuracy of GeoLCR with LCDNet, OverlapNet, and other approaches in both KITTI and KITTI-360 datasets for points registration. Our method achieves up to two times improvements in terms of translation accuracy, and we also achieve comparable rotation accuracy.

Our approach has some limitations. First, our current formulation is only designed for using the 3D Lidar as the perception sensor. In practice, Lidar can be sensitive to rainy or foggy weather. In future work, RGB data can help to improve the robustness of the system. Second, in this work, we use voxels to remove redundant points, but the method still uses many points for registration. In the future, we can choose points directly from the point level for registration.

VI Supplement

VI-A Network Structures

In Figure 6, the inputs are points, $\mathcal{P}_{s}$ and $\mathcal{P}_{k}$, from two key frames, $s$ and $k$. After KPConv [thomas2019kpconv] feature encoder and Geometric Transformer [geometric], we process the features by 2 consecutive linear layers, and the details of the layers are mentioned in Section III-B. The outputs of the features are $N\times C$ and $M\times C$, respectively. Then we use Einstein sum to project the features to $N\times M\times C$ space. Then after post feature process, we project the two previous voxel features to the $N\times M\times C$ space again for more information about the voxel features themselves. The final output is the score map in the $N\times M$ space. The voxels features $\mathbf{f}^{s}$ and $\mathbf{f}^{k}$ have dimension of 256. For the linear layers, $h_{s}(\cdot)$, $h_{c}(\cdot)$, and $h_{k}(\cdot)$, we found two linear layers with the same feature dimensions(512) are good enough and $g(\cdot)$ outputs only one value for each pair as the estimation.

In Figure 7, we leverage the coarse features and project the point features to the voxel feature space. After the normalization, we use two attention models to process the self relationship in each point cloud and cross relationship between two point clouds, then output the point features for point matching. See Section 3.3 for the details of the Self-Attention and Cross-Attention models.

For the loss function of the overlap estimation, the circle loss has the same values (0.5) for $\alpha$ and $\beta$. The registration stage has $\gamma$ and $\eta$ are all $1.0$.

VI-B Coarse Matching Analysis

The overlap values are calculated by the Equation 3. After choosing the threshold $th$, we have the matching pairs $\left\{{i,j}\right\}$. Figure 5 shows the voxels matching after registration, where the green dots are voxels and the yellow lines indicates the matches voxel pairs from the two point clouds. We also show the matching in the video of the project.

We compare the overlap values directly from Superpoint Matching Module [geometric], Ground truth, and our approach. The LCDNet [lcdnet] is not here because it is trained with some positive/negative overlapped cases, not distances. The overlap values of the two point clouds are calculated by Equation 3. Also, as the Superpoint Matching Module is not able to directly estimate the overlap values of two point clouds, we took the exponential negative feature distances as the overlap values $o_{i,j}$ of voxels pairs, and the ground-truth voxel overlap values $o_{i,j}$ are computed by Equation 4. For our approach, the voxel overlap values $o_{i,j}$ are directly computed from the overlap estimation we presented before, and the overlap of the two point clouds is also calculated by 3.

From Figure 8, we can see that the overlap values of Superpoint Matching Module [geometric] cannot be used for overlap detection. In contrast, the overlap values from our model align well with the distance between two point clouds. Therefore, we can easily use it for loop closure estimation by giving a threshold to the overlap values.

VI-C Comparisons with Other Datasets

In this section, we compare our method with LCD-Net [lcdnet] and Geometric Transformer [geometric] in NCLT, Complex Urban, and MulRan datasets in terms of registration errors. The errors are collected averagely among all loop-closed conditions in the sequence. From the tables V and VI, we can see our approach has a comparable results w.r.t. Geometric Transformer [geometric] and better results than GICP [gicp] and LCD-Net [lcdnet]. For the Table VII, the NCLT [nclt] dataset is collected from small robots with 16-channel Lidar, which has very sparse point and less number of points than other datasets. Therefore, all methods have bad performance in this datasets because there are some cases in open space with less features of the objects and in this condition all methods would perform bad. However, compared with other methods our method still achieved good average accuracy of both rotation and translation.

VI-D SLAM Trajectory

Lio-sam uses ICP to estimate the transformation matrix for loop closure constraints. In the experiment, we use a better GICP [gicp] to substitute the ICP and compare it with our approach. Because the Lio-sam algorithm is relatively accurate, the distance threshold $d_{f}$ in Equation 16 is set as 5 meters and the $d_{h}$ is set to 20 meters in this experiment for the KITTI sequence dataset. For more comparisons please refer to the supplement material [appendix]. The keyframes of the loop closure models are chosen from the frames published by Lio-sam odometry as Algorithm 1. Figure 9 shows a sample of the complete trajectory using KITTI dataset.

Further implementations are shown in Figure 10. The built maps are KITI-360 sequence 02 and 09, where blue points are starting points and red points are ending points.

VI-E Comparisons with All Near Frames

6 We compared with LCD-Net [lcdnet] in other KITTI, KITTI-360, and Nuscenes datasets with not only loop closed cases, but all frame pairs with near distance. The table shows the results from all sequences from KITTI-360, Sequences 00 and 08 from KITTI datasets, and the results from the Nuscenes dataset. Compared with LCD-Net, our approach has a higher rate of nearby-frame detection and fewer translation and rotation errors. From Table VIII-X, we observe that our approach can detect all the near frames cases. Furthermore, our registration is more accurate than LCD-Net in both translation and rotation estimations.

For the two KITTI sequences in Table VIII, we directly use the results from the table of LCD-NET. Our approach achieves comparable results w.r.t. translation and rotation errors.

For the KITTI-360 sequences, LCD-Net is tested by using the open-sourced pre-trained model. To achieve the best performance of LCD-Net, we also applied ground point removal according to the Github [lcdnet] command lines. Table IX shows that our method is very robust in nearby frames detection, which is always $100\%$ compared with the LCD-Net (around 50%). Our approach is also much more accurate in nearby-frame detection and can achieve much higher accuracy than LCD-Net in translation and rotation.

The Nuscenes dataset has more features than KITTI. There are more pedestrians, moving cars, and buildings than in the scenarios in KITTI or KITTI-360. we collect the nearby-frame pair using a similar method and test the result with the dataset. From Table X, we can see LCD-Net does not perform well in the nearby-frame situations in the Nuscenes dataset and the success rate is only $21\%$. However, our approach is still robust in the Nuscenes dataset with $100\%$ success rate and accurate rotation and translation estimations.

VI-F Inaccurate Ground Truth

The public datasets do not always have accurate ground truth transformation matrices. As Figure 11, the red points are transformed by the ground truth transformation matrix. The white circle shows the two point clouds are not aligned only by using the ground truth transformation matrix. Therefore, in our loss function 14, we also use the distance of the points to optimize the estimated transformation matrices.