Environmental mapping is crucial for autonomous systems, and SLAM has been a major research topic in the robotics field. An important aspect of SLAM is global consistency. It is desirable that a mapping system is able to retain the consistency of every single part of a map after running on a long trajectory and closing large loops.
One way to refine a trajectory estimation result and improve the mapping consistency is pose graph optimization, which minimizes the relative pose errors between frames in the pose space [Grisetti2010]. This approach has been well established in the literature and is widely used [Behley2018, Reijgwart2020]
. Pose graph optimization requires modeling each relative pose constraint in the form of a Gaussian distribution (i.e., mean and covariance matrix). However, representing a relative pose, which is typically a result of scan matching, as a Gaussian distribution is obviously too approximated. Scan matching solutions have many local minima and thus cannot be accurately modeled in the form of a unimodal distribution. Furthermore, estimating the uncertainty (i.e., covariance matrix) of a scan matching result is difficult in practice[Landry2019]. Most existing studies use only a constant covariance matrix [Behley2018], a simple weighting scheme [liosam2020shan], or Hessian-based closed-form covariance estimation [Hess2016], which tends to be optimistic [Landry2019]. Inaccurate modeling of relative pose constraints can lead to deteriorated estimation accuracy of a long trajectory with large loops.
Global matching cost minimization is another approach to improve the consistency of a map. Early on, Lu and Milios proposed a graph-based 2D mapping approach that minimized the matching cost between frames over the entire map [Lu1997]. This method was then extended to three dimensions by reducing the number of global optimization executions by explicitly handling loop closure events [Borrmann2008, Sprickerhof2011]. These approaches ensured that all the frames were aligned together and thereby retained the local consistency of every part of the map (i.e., global consistency) while closing loops. They evaluated the global matching cost and updated each factor for every optimization iteration; this can be interpreted as the SE3 relative pose factor with variable mean and covariance. Furthermore, each factor can represent a deficient constraint in this way. They thus can more accurately model the constraint of the relative pose between frames compared to pose graph-based approaches. However, performing global matching cost minimization was still computationally expensive, and application to large-scale and real-time mapping was considered to be infeasible.
In this work, we revisit the global matching cost minimization approach with modern GPU computation techniques and propose a real-time and globally consistent 3D LiDAR mapping framework. The core of the proposed framework is the multi-scan registration algorithm, which minimizes the errors of Generalized ICP (GICP) matching cost factors with voxel-based data association [vgicp, Segal2009] over the entire map by fully leveraging GPU parallel processing. This approach has several advantages. First, this enables constraint of the relative pose between frames with a very small overlap, where it is difficult to explicitly estimate the relative pose through scan matching (Fig. LABEL:fig:kitti00(A)). Second, the GPU-powered implementation enables the creation of a massive amount of factors (Fig. LABEL:fig:kitti00(B)). Although we create a matching cost factor between every frame pair with an overlap rate larger than a small threshold (e.g., 2.5%), the global map optimization converges in a few seconds on a middle-class GPU.
The proposed framework consists of local and global mapping modules, which perform matching cost minimization locally and globally, respectively (see Fig. -1). Both of the mapping modules are managed based on a voxel-based overlap metric that can quickly be evaluated on a GPU. In order to prevent the voxel-based matching cost factors from becoming stuck at a local minimum, we explicitly detect a few loops with an external loop detector (e.g., ScanContext [Kim2018]) and add these loops to the factor graph as SE3 relative pose constraints. Through evaluation on the KITTI dataset [Geiger2012], we show that the proposed approach improves the estimation accuracy of long trajectories with large loops.
The key contributions of this work are as follows:
We present a globally consistent 3D mapping framework based on the GPU-accelerated matching cost factor and show that the matching cost minimization over the entire map is feasible in real-time. To the best of our knowledge, this is the first real-time method that performs scan matching at a global scale.
We propose a mapping management mechanism based on an overlap metric that can quickly be evaluated on a GPU and enables the design of a general mapping process.
We show that the global matching cost minimization approach enables retention of the global consistency of large maps and increases the mapping quality.
Ii Related Work
Since the main contribution of this work is a method by which to retain the global consistency of a map, we focus in this section on global map optimization approaches.
Ii-a Pose Graph Optimization
While many frontend methods for 3D LiDAR SLAM have been proposed [Behley2018, liosam2020shan, yokozuka2021, pan2021mulls]
, most of these systems rely on pose graph-based maximum a posteriori estimation[Grisetti2010] as the backend in order to refine trajectory estimation results and improve the mapping consistency. Pose graph-based approaches construct a factor graph with relative pose (SE3) constraints and estimate the sensor trajectory that minimizes the errors in the pose space. This approach has been well established and has become the gold standard for the 3D LiDAR SLAM backend.
In pose graph optimization, relative pose constraints are modeled as a Gaussian distribution. However, the Gaussian distribution form is a too-approximated representation for scan matching results. A scan matching solution inherently has many local minima and thus cannot be accurately modeled in the unimodal distribution form, and this approximated representation would affect the optimization result once the scan matching converges to a local solution.
Furthermore, estimation of the covariance matrix of a scan matching result is difficult in practice [Landry2019]. Although closed-form uncertainty estimation methods based on the Hessian matrix of the cost function have been commonly used [Bengtsson2003, Hess2016], it is known that closed-form methods tend to be optimistic because these methods are not able to take into account the cost function deviation caused by data association changes [Landry2019]. On the other hand, Monte-Carlo-based covariance estimation methods can more accurately estimate the uncertainty of scan matching results [Iversen2017]. These Monte-Carlo-based methods, however, are computationally expensive. Although data-driven covariance estimation approaches [Landry2019] have been proposed in order to balance the real-time performance and estimation accuracy, most existing SLAM frameworks use only a constant covariance matrix [Behley2018], a simple weighting scheme [liosam2020shan, yokozuka2021], or Hessian-based closed form covariance estimation [Hess2016].
Ii-B Deformation Graph
Map deformation is another approach to retain the surface consistency of mapping results including loops [Whelan2013]. This approach constructs a graph that deforms the mapping result such that the local consistency is preserved. Deformation graph-based map-centric mapping approaches without estimation of the full sensor trajectory have been proposed [Park2018] . These methods, however, do not accurately take all available information into account and may disrupt the global consistency of the map.
Ii-C Bundle Adjustment
Bundle adjustment (BA) that simultaneously optimizes sensor poses and environmental parameters over frames has been important in the visual SLAM field [MurArtal2017]. It has been shown that BA-based methods show good trajectory and reconstruction accuracy while it is known to be computationally expensive. For real-time performance, BA is typically carried out at two different scale levels (real-time local BA and low frequency global BA) with a limited number of feature points [MurArtal2017]. Notably, Schöps et al. recently showed that direct BA-based visual odometry at a global level is feasible in real-time with GPU processing [Schops2019]. In the context of 3D LiDAR SLAM, however, it is rare to see BA-based approaches due to the difficulty of feature tracking on sparse LiDAR data, and few studies on BA-based approaches have been proposed [liu2020balm, Wisth2021].
Ii-D Global Matching Cost Minimization
Lu and Milios formulated the mapping problem as minimization of the matching cost of frames over a factor graph [Lu1997], and their method was extended to three dimensions by several studies by explicitly handling loop detection events [Borrmann2008, Sprickerhof2011], their method was still considered to be infeasible in real-time because it needs to re-evaluate the matching cost of every frame pair at every optimization iteration.
Recently, Reijgwart et al. proposed a volumetric mapping method that takes into account registration errors between local submaps [Reijgwart2020]. They used an efficient registration error metric based on Euclidean Signed Distance Field (ESDF) representation in order to avoid the costly correspondence search. The cost evaluation was, however, still computationally expensive, and optimization was carried out with only a random subset of residuals and with the support of SE3 relative pose constraints.
Ii-E GPU-based SLAM
The GPU has been commonly used for almost every component of dense visual and RGB-D SLAM (from frontend [Schops2019] to backend [Whelan2013]). In contrast, in the context of LiDAR SLAM, the use of GPU was mostly limited to accelerating scan matching in the frontend [Behley2018, elo]
. While there have been also proposed deep learning-based frontend[Li2019] and loop detection methods [Chen2020] with GPU processing, in most of the works, pose graph optimization performed on a CPU is in charge of global optimization.
Figure -1 shows an overview of the proposed system. We first remove dynamic objects (e.g., cars and pedestrians) from input point clouds using RandLA-Net [Hu2020] and run an odometry estimation algorithm (e.g., MULLS [pan2021mulls]) to obtain an initial guess for the latest sensor pose. Meanwhile, we estimate the covariance matrix of each point from its k-neighboring points. Note that the costly nearest neighbor search is used only in this preprocessing step, which is performed once for every input point cloud.
The preprocessed point cloud and the sensor pose initial guess are fed to the local mapping module that merges approximately 10 to 20 frames into one submap, and the submaps are then merged into one global map in the following global mapping module. The core of the local and global mapping modules is the multi-scan registration algorithm that constructs a factor graph with voxelized GICP matching cost factors (see Fig. ‣ III). This optimizes the sensor poses such that all neighboring frames are aligned together. In the local mapping module, we construct a fully-connected factor graph. In the global mapping module, we create constraints between the latest submap and every past submap that has a certain overlap with the latest submap. As a result, all of the submaps are aligned with not only adjacent submaps on the graph but also every revisited submap that results in closing loops implicitly. We obtain the final mapping result by concatenating submap point clouds based on the optimized trajectory.
Iii-a Voxelized GICP Matching Cost Factor
We estimate a set of sensor poses by minimizing the matching cost over a set of point cloud pairs . The objective function to be minimized is defined as:
where and are a point cloud pair, and are their poses, and is a matching cost function.
As the matching cost function, we choose the voxelized GICP (VGICP) cost [vgicp] that is as accurate as GICP and suitable for GPU processing. The VGICP cost is based on the GICP distribution-to-distribution error that is the most accurate among the ICP variants [Segal2009]. The GICP error between a point with covariance and its corresponding point on a transformation is defined as:
where is the residual between and .
In the original GICP algorithm, corresponding points are given by a nearest neighbor search, e.g., by a KD tree. However, the use of a KD tree is not suitable for a GPU because the KD tree uses a number of conditional branches, which affects the performance of the GPU. In order to maximize the processing speed, VGICP uses a voxel-based data association approach. It discretizes each input point cloud into voxels at resolution
and calculates the mean and covariance of each voxel based on the points that fall within the voxel. VGICP aggregates point distributions into one voxel distribution, unlike Normal Distributions Transform (NDT)-based algorithms that compute a voxel distribution from a set of points[Stoyanov2012]. This approach enables a valid distribution on a voxel to be obtained with only a few points and results in robustness to voxel resolution changes and more accuracy than NDT [vgicp].
Then, the matching cost between a point cloud and another point cloud is defined as:
where is the relative pose estimate between and . The corresponding points are given by looking up the voxel map of . From the derivatives of Eq. 3, we obtain a Hessian factor to constrain and that is composed of Hessian matrices , and
and coefficient vectorsand :
where , and . Note that we re-evaluate the matching cost function every optimization iteration, and thus and are also updated at the current linearization point.
Iii-B Local Mapping
The local mapping module aggregates a number of consecutive frames into one local submap in order to reduce the number of pose variables optimized in the following global mapping module.
In order to manage the mapping process, we use criteria based on a simple fine-grained voxel-based overlap metric. We define the overlap rate between two point clouds and as the fraction of points that fall within a voxel of :
Equation 8 can quickly be evaluated on a GPU, and evaluation takes less than 0.1 ms for a point cloud pair with approximately 50,000 points for each. This voxel-based overlap metric enables the design of a general mapping process compared to metrics based on time interval [liosam2020shan] or sensor displacement [pan2021mulls] that require careful tuning of parameters depending on the environment, while more accurately detecting overlapping frames as compared to bounding box-based overlap metrics [Reijgwart2020].
If the overlap between the current frame and the last frame in the submap is larger than a threshold (e.g., 95%), then the sensor is considered not to have made a move, and we skip that frame. Otherwise, we create its voxel map with resolution of and insert the pair of the current frame and the voxel map into the submap factor graph. We create matching cost factors between the inserted frame and all the other frames in the submap, and thus a fully connected factor graph is created for local mapping. Whenever the overlap between the very first and last frames in the submap becomes smaller than threshold (e.g., 10%) or the number of frames in the factor graph becomes larger than threshold , we perform factor graph optimization and merge all of the frames into one submap based on the optimized sensor poses. A voxel map with a resolution of is created from the submap and then fed to the following global mapping module. We assume that the estimation drift in the short time span of the submap window is negligible and fix the relative poses between frames in the submap in the global mapping.
Iii-C Global Mapping
The global mapping module takes the optimized submaps as input and optimizes their poses such that they are all aligned together. Every time a new submap is created, we compare the overlap between that submap and all past submaps, and create a matching cost factor between every submap pair with an overlap rate larger than a small threshold (e.g., 2.5%). This results in a densely connected factor graph, as shown in Fig. LABEL:fig:kitti00. The proposed approach aggressively creates matching cost factors between submaps with a very small overlap, where scan matching would fail to align the submaps, and thus obtaining an accurate SE3 relative pose constraint is difficult (see Fig. 1). Although the matching cost factors over such submaps would represent deficient constraints, they do not disrupt the optimization because the entire system is well constrained by other factors. This approach helps in not only implicitly closing loops but also improving the odometry estimation accuracy because every submap is connected to all of the submaps in sight of that submap.
Since the matching cost factor uses voxel-based data association, it can be trapped at a local solution when the estimation drift is large, as shown in Fig. 2(A). In order to overcome this problem, we explicitly detect loops with an external loop detector and add detected loops to the factor graph as SE3 relative pose constraints to help the matching cost factors to escape from local minima. The objective function for the global mapping is thus defined as follows:
where is the set of overlapping submap pairs, is the set of loop constraints, is the relative pose measurement, is the logarithmic map, and is a robust kernel. In this work, we obtain explicit loop measurements by applying the conventional GICP to a loop candidate frame pair with initial heading estimate given by ScanContext [Kim2018].
Although we want the explicit loop constraints to steer the optimization toward a better solution, we want to avoid hindering the matching cost factors when the current estimate sufficiently satisfies the detected loop constraint. For this purpose, we apply Tukey’s robust kernel shifted with an offset to each relative pose constraint. The shifted Tukey robust kernel is defined as:
where is the kernel width, and offset is the amount of shift. As shown in Fig. 3
, this robust kernel forces the optimization in order to satisfy the loop constraint while avoiding disrupting matching cost factors when the relative pose error is small. The kernel also removes loop constraints with errors that are too large as outliers.
With explicit SE3 loop constraints, we aim to steer the optimization toward a better solution but not to correct the trajectory consistency directly, and we need only a few loop detections. We thus use strict loop detection threshold values to avoid false positive loop detections. To build SE3 loop constraints, we simply use a constant covariance matrix. They, however, will not affect the final optimization result because the robust kernel will eliminate them once the current estimate satisfies them. In Fig. 2(B), we can see that the optimization converged in a better solution after adding a few explicit loop constraints.
Iii-D Implementation Details
For factor graph optimization, we used the Levenberg-Marquardt optimizer in GTSAM111https://github.com/borglab/gtsam. In order to fully leverage GPU acceleration, we used a customized NonlinearFactorGraph class that first issues all of the cost evaluation tasks on a GPU, performs GPU synchronization, and then collects the calculated results to build a linearized system. Note that we used an efficient reduction technique to compute the summation of Eqs. 3, 5, and 6 on a GPU without atomic operations.
|Num. of Frames||closure||4541||1101||4661||801||271||2761||1101||1101||4071||1591||1201||Mean (ST/S)||Mean (ST)|
|Proposed (matching cost)||0.16||0.10||0.12||0.19||0.10||0.10||0.07||0.11||0.18||0.11||0.15||0.14 / 0.13||0.15|
|Proposed (matching cost)||✓||0.12||0.09||0.10||0.19||0.10||0.06||0.08||0.10||0.14||0.08||0.15||0.11 / 0.11||-|
|Proposed (SE3)||✓||0.18||0.15||0.17||0.33||0.17||0.21||0.10||0.17||0.50||0.17||0.31||0.24 / 0.22||-|
|SuMa [Behley2018]||✓||0.23||0.54||0.48||0.50||0.27||0.20||0.30||0.54||0.38||0.22||0.32||0.36 / 0.36||0.34|
|SuMa++ [Chen2019]||✓||0.22||0.46||0.37||0.46||0.26||0.20||0.21||0.19||0.35||0.23||0.28||0.29 / 0.29||0.34|
|LiTAMIN2 [yokozuka2021]||✓||0.28||0.46||0.32||0.48||0.52||0.25||0.34||0.32||0.29||0.40||0.47||0.33 / 0.38||-|
Red and blue respectively indicate the first and second best results.
Mean ST and S respectively indicate the means of sub-trajectory and sequence errors.
|Num. of Frames||closure||4541||1101||4661||801||271||2761||1101||1101||4071||1591||1201||Mean (ST/S)||Mean (ST)|
|Proposed (matching cost)||0.49||0.65||0.50||0.62||0.41||0.24||0.29||0.30||0.80||0.46||0.54||0.52 / 0.48||0.59|
|Proposed (matching cost)||✓||0.56||0.66||0.55||0.63||0.42||0.28||0.34||0.35||0.81||0.55||0.54||0.56 / 0.52||-|
|Proposed (SE3)||✓||0.58||0.61||0.60||0.69||0.44||0.38||0.34||0.37||1.51||0.68||0.74||0.74 / 0.63||-|
|IMLS-SLAM [Deschaud2018]||0.50||0.82||0.53||0.68||0.33||0.32||0.33||0.33||0.80||0.55||0.53||0.55 / 0.52||0.69|
|SuMa [Behley2018]||✓||0.68||1.70||1.20||0.74||0.44||0.43||0.54||0.74||1.20||0.62||0.72||0.83 / 0.82||1.39|
|SuMa++ [Chen2019]||✓||0.64||1.60||1.00||0.67||0.37||0.40||0.46||0.34||1.10||0.47||0.66||0.70 / 0.70||1.06|
|LiTAMIN2 [yokozuka2021]||✓||0.70||2.10||0.98||0.96||1.05||0.45||0.59||0.44||0.95||0.69||0.80||0.85 / 0.88||-|
Red and blue respectively indicate the first and second best results.
Mean ST and S respectively indicate the means of sub-trajectory and sequence errors.
We evaluated the proposed framework on the KITTI odometry dataset [Geiger2012]. We calculated the relative trajectory errors (RTEs) averaged over 100 to 800 m trajectories with the KITTI official evaluation code (Development kit). We used an Intel Core i7-8700 (12 threads) with an NVIDIA GeForce GTX 1660 Ti to run the proposed framework. The parameters for the proposed framework used in the evaluation appear on the project page222See the project page for details: https://staff.aist.go.jp/k.koide/projects/ral2021/index.html.
Comparison with State-of-the-art Methods: We compared the proposed framework with state-of-the-art real-time 3D LiDAR SLAM methods (LOAM [Zhang2016], MULLS [pan2021mulls], ELO [elo], IMLS-SLAM [Deschaud2018], SuMa [Behley2018], SuMa++ [Chen2019], LiTAMIN2 [yokozuka2021]), and a deep-learning-based method (LO-Net [Li2019]).
We ran the proposed framework with two settings: 1) without implicit and explicit loop closure (i.e., every submap is connected to only other submaps in a sliding window) and 2) with both implicit and explicit loop closure. Similar to [pan2021mulls, elo, Deschaud2018], we applied an intrinsic vertical scan angle correction to compensate for the point cloud distortion in the KITTI dataset for all the settings.
Tables I and II show the average rotational and translational RTEs, respectively, of the proposed method and the state-of-the-art methods. We noticed that while the KITTI official benchmark uses the average of sub-trajectory errors to summarize errors, several works report the mean of sequence errors that would overemphasize the errors of short sequences. For a fair comparison, we report both the metrics in Tables I and II (Means ST: mean of sub-trajectory errors, Mean S: mean of sequence errors).
The proposed method shows the best RTEs (0.14 / 0.13° and 0.52 / 0.48 m) without loop closing among the state-of-the-art methods for the sequence 00 to 10. In particular, the proposed method shows good accuracy on long trajectories (Sequences 00, 02, 05, and 08). For Sequence 11 to 21, the proposed method shows the RTEs that are ranked at the second place among LiDAR-based methods on the KITTI online leaderboard at the time of submission (0.15° and 0.59 m)333The method GLIM on http://www.cvlibs.net/datasets/kitti/eval_odometry.php. With loop closing, although the rotational RTEs of the proposed method are largely improved, the translational RTEs are slightly deteriorated (0.11 / 0.11° and 0.56 / 0.52 m). Similar trends are reported in several works [Behley2018, pan2021mulls], and we infer point cloud distortion in the KITTI dataset affected the translational RTEs when loop closing is enabled.
To assess the mapping quality, we created a local map for every 10 frames by aggregating frames within 10 m and evaluated its mean map entropy (MME) [Razlaw2015]. For the sequence 00, the proposed method showed a small MME (0.14 0.20) while a pose graph-based method, SuMa [Behley2018], exhibited a larger MME (0.19 0.20)22footnotemark: 2. Figure 5 shows local map MME of the proposed method and SuMa at a junction where a large loop closure happened. We can see points with large entropy (large inconsistency) on the ground and walls of the local map of SuMa, while the proposed method showed significantly smaller entropy (better consistency). This result suggests that the inaccurate modeling of relative pose constraints in the traditional pose graph optimization can result in inconsistent mapping results while the global matching cost minimization approach can accurately retain the map consistency.
Ablation Study: In order to show that the matching cost minimization enables accurate trajectory estimation in comparison with pose graph optimization, we replaced every matching cost factor with an SE3 relative pose constraint estimated by GICP scan matching [Segal2009]. The initial guess for the scan matching is given based on the optimization result with the matching cost factors. The information matrix of each relative pose factor is calculated based on the Hessian matrix for the GICP scan matching result [Bengtsson2003]. Considering that the scan matching would fail on small overlapping frames, we applied Huber’s robust kernel to each relative pose factor.
From Tables I and II, we can see that the accuracy of the proposed method strongly deteriorated with the relative pose factors, although the graph structure (submap connectivity) had not changed. Figure 6 shows a factor graph with SE3 relative pose factors. The color of lines indicates the magnitude of errors (Green: small error, Red: large error). We can see that factors between submaps in distance tend to have large errors because the scan matching failed to align the submap pairs with small overlap. The factors with large errors were removed by the robust kernel and thus did not contribute to the optimization result. Note that more factors would have worse relative pose measurements in a practical situation because a good initial guess cannot be expected for scan matching. This result suggests that the pose graph optimization scheme, which requires explicit estimation of the relative pose between frames, has difficulty in constraining distant frames and preserving the consistency over a long trajectory.
|Local mapping||Factor creation||2.8 5.0|
|Global mapping||Factor creation||7.7 12.3|
Runtime: Through the sequence 00, one of the longest sequences in KITTI, the proposed framework ran approximately twice as fast as the real-time elapsed (20 FPS). Note that we used pre-recorded frontend trajectory estimation results with MULLS [pan2021mulls] (ran at 26 FPS), and thus the processing time of the frontend algorithm was not taken into account.
Table III summarizes the runtime of the local and global mapping modules. The local submap optimization, which was performed approximately every 1.5 s, took 123.9 ms on average. The global optimization, which was performed approximately every 7.5 s, took 884.0 ms on average to optimize the factor graph, which had more than 4,500 factors at the end of the sequence by fully leveraging GPU parallel processing. Figure 7 shows how the runtime of the global optimization grew as the numbers of submaps and matching factors increased. Although a longer time (3 to 4 s) was required after closing large loops, most of the time, the optimization quickly converged in less than one second. Note that while the linearization and error evaluation of matching cost factors occupied most of the optimization time, the linear solver (performed on a CPU) took only approximately 3% of the total optimization time on average.
This paper presented a 3D LiDAR mapping framework based on VGICP matching cost factors. The GPU-accelerated matching cost evaluation enables simultaneous alignment of all frame pairs in the factor graph and preserves the global consistency over a long trajectory. The local and global mapping modules are managed based on the overlap metric, which can quickly be evaluated on a GPU, and the explicit loop closing mechanism helps the voxel-based matching cost factors to avoid convergence in a local minimum.