Feature-based method

Feature-based methods [10,22–28] construct maps by identifying and extracting prominent feature points or feature descriptors from the environment. Different from some methods that utilize visual SIFT for detecting environmental features [29], LiDAR-based SLAM approaches obtain edge and plane feature points by calculating the curvature of each point. LOAM [9] is a widely recognized and classic LiDAR SLAM algorithm. It incorporates motion distortion correction and scene structure recognition using the abundant information available in high-resolution LiDAR data, creating a real-time system. LOAM employs parallel processing of features during mapping and localization, guaranteeing real-time performance and accuracy. To further improve the efficiency of ground vehicle SLAM, some researchers have made improvements based on LOAM. Lego-LOAM [30] optimizes specific features by subdividing the received point cloud data and reconstructing complex terrain. This enables Lego-LOAM to perform well in ground vehicle applications where high-density point clouds are not required. LIO-SAM [31] builds upon Lego-LOAM by providing a factor graph-based optimization framework that addresses the alignment issue between high-frequency IMU and low-frequency LiDAR data. This gives LIO-SAM strong information fusion capabilities, allowing it to achieve good trajectory estimation in noisy and challenging environments. MULLS [32] utilizes multiple LiDAR setups to achieve high-precision and robust localization and mapping capabilities, particularly in complex and dynamic indoor-outdoor environments. The core idea behind MULLS is that LiDAR data from multiple viewpoints and distance scales can complement each other, helping to reduce coverage blind spots and data sparsity issues that a single LiDAR device may encounter. F-LOAM [33] algorithm employs a two-step approach to correct distortion in raw point cloud data. During the nonlinear optimization process to solve for pose estimation, it applies weighted constraints on feature points, deviating from the parallel processing of LiDAR odometry and mapping threads in the LOAM algorithm. The BALM [34] algorithm introduces the Bundle Adjustment (BA) framework into LiDAR SLAM. It establishes a BA optimization model on sparse LiDAR feature points, including edges and planes. By directly minimizing the distances between feature points and edges/planes, the BA optimization is eventually reduced to handling the pose of a single LiDAR frame. This method utilizes feature points to construct maps, which increases computational efficiency. However, the limited nature of sparse map information prevents it from providing detailed obstacle and other relevant information required for supporting complex path planning. As a result, sparse maps are not suitable for the subsequent navigation tasks of inspection robots.

Voxel-based method

The map of above approaches is represented as a set of geometry feature points and the LiDAR odometry is achieved by minimizing the feature-to-feature matching distance. The global map is updated by directly aggregating the feature points, which tend to become redundant in long-term mapping process and thus burden the mapping efficiency. To alleviate such problem, voxel-based SLAM systems [35–43] formulate the map by occupied voxels. In the voxel, various information is encoded, such as line and plane features, surfels, approximated Gaussian distributions, etc. Ref. [44] utilizes a combination of LiDAR and a 3D voxel map constructed from outdoor point clouds for mobile robot localization. By integrating odometry and the 3D voxel map, the complete 6D state of the mobile robot can be estimated, achieving a high level of accuracy. Ref. [45] presents a voxel-based localization and mapping system that achieves real-time trajectory estimation for multi-robot systems in GPS-denied environments. This system formulates the registration problem as a Maximum A Posteriori (MAP) problem and simplifies it into a nonlinear least squares problem using Gaussian approximation and Principal Component Analysis (PCA). By utilizing a voxel-based matching approach, the computational efficiency is significantly improved, and the communication bandwidth of the localization and mapping system is reduced. Ref. [46] proposes an adaptive voxel construction method that can adapt to structurally diverse environments. This method utilizes an octree hash data structure to store the voxel representation, which improves the efficiency of voxel construction, updates, and queries. By adapting the size of the voxels to the changing environment, this method achieves a more flexible and efficient representation of the environment’s structure. VoxelMap++ [47] proposes a voxel mapping method with planar merging, where the map is represented using voxels. It utilizes a merging module to distinguish coplanar relationships within various voxels. This approach effectively improves the accuracy and efficiency of LiDAR SLAM. Sparse space voxelization improves the map scalability and significantly reduce the redundancy. Dense mapping methods rely on full-space voxelization. They compute the SDF values of the voxels passed through by LiDAR beams. Compared to sparse mapping methods, it can provide more detailed and accurate map information. But it also require more computational resources, which can affect the real-time performance of robot navigation tasks. Meanwhile, A common problem of these methods is that such mapping framework cannot well process drift errors. If the global trajectory is corrected by loop closure, all the associated voxels should be recomputed, which requires huge computational cost.

Local map-based method

Recently, local map-based mechanisms have been proposed. The global map is regarded as a set of local maps and the system focuses on maintaining the local maps and only fuse them into the global map when necessary. Karto SLAM [48] converts the data scans collected during the robot’s movement into submaps, with each submap corresponding to the robot’s observation data at a specific moment. When the robot moves to a new area, a new submap is created. The accuracy is improved by optimizing these local submaps. RatSLAM [49] divides the environment into many smaller regions or modules, each with its own local map. These local maps are linked together through relative pose relationships. Their main advantages are their robustness and ability to operate internally in large-scale environments, enabling precise long-term localization and mapping even in dynamically changing environments. A method for adaptive local map maintenance has been proposed [50], allowing the system to autonomously prune redundant local maps and render a global occupancy map from multiple local maps. This ensures the robustness and stability required for long-term mapping. Rtabmap [51] creates multiple local map systems, and when a loop closure occurs, it reassembles the newly optimized pose into the global map based on all the local maps in the map set. Additionally, in order to avoid restarting the mapping process from scratch when the robot loses localization, multi-session mapping allows for initializing a new map first, and if a previously visited location is encountered, the two maps are merged. This approach ensures that the mapping and localization process can be seamlessly continued even after temporary localization failure. Such mechanisms significantly improve mapping scalability and address the challenge of high computational cost in global optimization by efficiently utilizing limited computing resources. However, the mechanism should be sophisticated designed to be adapted to the real environment.

Long-term 3D map management is another fundamental capability required by a robot to reliably navigate in the non-stationary real-world. LT-mapper [52] develops open-source, modular, and readily available LiDAR-based lifelong mapping for urban sites. This is achieved by dividing the problem into successive subproblems: multi-session SLAM (MSS), high/low dynamic change detection, and positive/negative change management. Other dynamic removal methods are also proposed. These methods can be classified into the follows categories, ray-casting-based [53,54], visibility-based [55,56], and change-detection-based methods [57,58]. All these strategies strive to provide a perfect high-dynamic and low-dynamic point definition and aim to distinguish them according to specific rules. However, due the LiDAR points sparsity and only range information being encoded, all their experimental results demonstrate that there does not exist an unify geometry rule set that can fully avoid misclassification. Furthermore, most of these methods perform dynamic removal at voxel and point level, which neglects the integration of the object. Thus, in this paper, we propose novel mechanism aiming to distinguish unstable points at time dimension and segment level. The key motivation behind our approach is as follows: for highly dynamic objects, observations exhibit inconsistencies in both spatial and temporal dimensions, while for low-dynamic objects, inconsistencies primarily occur over time. Therefore, we leverage temporal cues to effectively distinguish between them.

The biggest difference between our method and other SLAM methods lies in the fact that traditional SLAM methods often encounter challenges in large-scale dynamic inspection environments due to the interference from dynamic surroundings and potential limitations in LiDAR accuracy. To address these issues, we have drawn inspiration from Voxel-based methods. By extracting environmental information and incorporating algorithms for dynamic object detection and removal, we effectively minimize the interference caused by moving objects. Additionally, we utilize a local map-based approach to enhance the efficiency and robustness of point cloud registration, enabling accurate long-term robot localization and map management.

System framework

The framework of our system is presented in Fig 1, which includes three subsystems, hierarchical SLAM system, global localization system, and map maintenance system. The aim is to achieve long-term self-localization and map maintenance for inspection equipped with 3D LiDAR sensor. The SLAM subsystem consists of the following modules: Local Map Set, LiDAR Odometry, Global Map Formulation and Optimization and Dense Map Generation. Its primary function is to construct both the raw map and dense map of the task environment. Additionally, by leveraging the use of submaps and graph optimization, it effectively mitigates drift errors in large-scale environments. The global localization system is responsible for relocating the robot on the map during the inspection process and performing global pose initialization when the robot is kidnapped or there is a sudden change in the environment. The map maintenance system takes responsible for tracking the environment changes and distinguish stable background, which benefits the global localization performance.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. System framework.

https://doi.org/10.1371/journal.pone.0328169.g001

Hierarchical SLAM system

Local map representation.

In our system, local map is used to model local scene centered at an anchor point within a certain distance. This local map plays a vital role in the SLAM system by providing a compact, voxel-based, and up-to-date geometric representation of the environment surrounding the robot. It facilitates efficient point cloud registration and supports real-time pose tracking. Compared to global representations, the local map maintains only a limited portion of the environment around the current pose, which significantly reduces memory usage and computational load while preserving sufficient geometric detail for accurate localization. This design is particularly well-suited for long-term deployment or large-scale environments, where frequent global map updates are computationally expensive and difficult to maintain.

Specifically, the local map stores LiDAR points in a voxelized structure centered at the anchor point. Given a set of LiDAR scans that have been transformed into the global coordinates, we assign them into a local map . Let denote one LiDAR scan. For each point , we compute its corresponding voxel index using Eq (1).

(1)

where is a hash function and g is the voxel size. Only occupied voxels are stored in the hash table, significantly reducing memory consumption. Importantly, we construct the hash table within the local map rather than the global map, which effectively mitigates hash collisions and ensures spatial locality for fast lookup during point cloud registration. After all the points are assigned into the voxels, one voxel can be represented using Eq (2).

(2)

where c is the center point and n is the normal of the contained points in . This representation preserves local geometric structure, which is essential for reliable point cloud alignment in subsequent ICP refinement.

LiDAR odometry.

Given a new LiDAR scan , LiDAR odometry is to optimize its global pose. Firstly, we transform the scan in the global coordinates using an initial global pose guess, which is generally obtained by constant velocity model. Then, for each point , we compute its corresponding voxel and access to the voxel by hash table. Finally, we compute the point-to-surface-based constraints using Implicit Moving Least Squares (IMLS)-based mechanism. Specifically, we compute the point-to-surface distance using Eq (3).

(3)

where denotes the neighboring voxels of and is defined as Eq (4).

(4)

where h is a cofficient. The weight is decreased with the distance to . Then, the ICP cost function is constructed as Eq (5).

(5)

where R and t are the two pose transformation parts and is defined as Eq (6).

(6)

is defined as the estimated corresponding point of on the surface. is the surface normal estimation at . Then, Gauss-Newton method is implemented to compute the optimal of Eq (5). In this paper, the IMLS-based constraints are computed by voxel-wise instead of point-wise strategy, which avoid computing point-wise normal estimation. Normal in each voxel can be computed more accurately and voxel-wise strategy makes the cost function construction more efficient. After the current LiDAR scan are aligned with the local map by the proposed LiDAR odometry, the LiDAR points are then used to update the center point and normal of their corresponding voxels. For voxel , we define its stability as Eq (7).

(7)

where returns dot product of two normalized normals. If and closed, it means that adding new observations to the voxel does not change the normal too much and the voxel is defined as stable voxel. Thus, we also incorporate the index into the cost function as Eq (8). The pseudo code of the LiDAR odometry algorithm as shown in Algorithm 1.

(8)

Algorithm 1 LiDAR Odometry Algorithm

Input: A LiDAR scan

Output: Optimized global pose X_i and Updated map M_i

1: initial pose X₀ and transform the scan to global coordinates

2: for each LiDAR point do

3:   Find its corresponding voxel using a hash table

4:   Compute its voxels weight

5:   Compute point-to-surface distance

 

6: end for

7: Minimize distance residuals using implicit moving least

  squares((IMLS)) for point cloud registration

8: Construct ICP cost function

9: Compute optimal Pose Transformation Matrix using

  Gauss-Newton method

10: Align current LiDAR scan with local map using the optimized

  pose

11: Compute voxel stability

12: Incorporate stability into the cost function

 

13: Use LiDAR point cloud to update the center point c and

  normal vector n of each corresponding voxels .

14: Update the voxel map M_i.

15: end.

Global map formulation and optimization.

Our global map is formulated as a set of local maps. Specifically, we denote a local map as Eq (9).

(9)

where is the global pose transformation of the anchor coordinates of the local map. In each local map, the anchor coordinates are regarded as reference coordinates. represents the space region, which is generally defined as a 3D bounding box centered at the anchor point. is the set containing all the occupied voxels and is organized by . The global map is then represented as Eq (10).

(10)

where represents the relative pose transformation between the anchor poses of the k₀-th and k₁-th local map. During the mapping process, if the current LiDAR observation exceeds the range of the current local map, then a new local map is initialized and activated. Generally, the anchor pose is set as the current LiDAR pose. With such mechanism, there exists overlap between local maps. For LiDAR points belonging to multiple local maps, we update the corresponding voxels in each local map separately. In this paper, we use ScanContext for loop detection, which is achieved by computing the ScanContext distance between the current scan and the history keyframes. If the distance is smaller than a threshold and keyframe timestamp is not close to the current time, loop is detected and loop closure is performed. Specifically, we firstly construct anchor pose graph and perform global graph optimization [59]. Then, based on the optimized results, we perform locally trajectory estimation within each local map. The local constraints is the relative pose transformation between the local maps. After the hierarchical map optimization, the drift errors can be significantly reduced and the global voxel map can be generated by merging all the local maps. Essentially, the map merging process is to fuse the voxel information located in the overlap areas between neighboring local maps. Benefitted from the hash table, it is efficient to retrieve the overlapped voxels.

Dense map generation.

To generate dense map is highly required in inspection tasks. There exist lots of methods for dense mapping in large-scale environment. However, their mapping process is achieved by incrementally integrating LiDAR observations. In this work, we directly derive dense map from our global voxel-based map. Firstly, since each voxel has normal and points’ center, we can easily compute the voxel center’s signed distance Function (SDF). The SDF value of a voxel center point p can be determined using Eq (11).

(11)

where p represents the position of the voxel center point, represents the entire three-dimensional shape, is the surface (boundary) of the shape, q denotes the position of any point on the shape’s surface, and is a sign function which reflects the position of point p relative to the shape . Then, we incorporate VDBFusion [60] as a module in our system and all the voxels in our map are directly mapped to the voxel map in VDBFusion. In contrast to most state-of-the-art SLAM and mapping approaches, VDBFusion makes no assumptions on the size of the environment nor the employed range sensor. Unlike most other approaches, VDBFusion introduces an effective system that works in multiple domains using different sensors. They build upon the Academy-Award-winning OpenVDB library used in filmmaking to realize an effective 3D map representation. Based on this, their proposed system is flexible and highly effective and, in the end, capable of integrating point clouds and generate dense model of the environment.

Global localization system

After constructing the global map, if the inspection robot encounters human interference or sudden environmental changes that cause it to lose its position, it becomes necessary to re-localize the robot within the constructed global map to restore its localization. In this section, we focus on introducing our ScanContext-ICP, which integrates ScanContext++ into the ICP framework for global point cloud alignment and localization. This process consists of two key steps: global pose initialization and pose tracking. Firstly, the robot needs to obtain an accurate initial pose transformation based on the previously constructed offline map and the current LiDAR scan data. This initial estimation is crucial for accurately localizing the robot within the prior map.

To improve the accuracy of the initial pose estimation, we propose a modified version of ScanContext, termed as ScanContext++. In ScanContext, the LiDAR points are transformed into a matrix and each element corresponds to 2D square ground block. Each element is defined as the maximum z-value of the points mapped to the corresponding block. However, this approach leads to a significant loss of geometric information. In ScanContext++, each element stores an approximated Gaussian distribution of the contained points, represented by the mean and standard deviation, as defined in Eq (12).

(12)

where is the mean of the z-values of the points mapped to the block, and is the square of the standard deviation of the z-values of these points.

For a LiDAR scan, we evenly sample points on the ground and construct local ScanContext++ descriptor centered at each sampled point. To match two LiDAR scans, we construct their sampled points correspondences by computing their local ScanContext++ distance. The distance between the corresponding elements e_(i,j) and is computed using the Gaussian distribution distance, as shown in Eq (13).

(13)

Then, Singular Value Decomposition (SVD) and fine-ICP are performed to obtain the pose transformation given the point correspondence.

Secondly, once the initial pose is initialized, it is essential to continuously track the robot’s pose changes to ensure that its position is updated in real-time with the changing environment. We adopt the Scan-to-Map approach, where the LiDAR’s point cloud data is iteratively matched to the offline point cloud map near the initial pose using ICP. Since we have constructed LiDAR odometry before, the pose tracking can directly leverage odometry data for global localization. In the event of tracking failure (e.g., ICP convergence failure), we will repeat the initial localization process to re-localize the robot, using the ScanContext++ descriptor to recover the robot’s initial pose.

Map maintenance system

The task environment is dynamic and it is important to make the global map keep tracking of the environment. Though the environment changes can be caused by many reasons, these changes can be generally described as follows. Some occupied voxels turned into free voxels due to object moving or free voxels turned into occupied voxels due to new objects added. It is critical to distinguish these changes of voxels and accurately update their state. A common mechanism is to track all the traversed voxels using ray-casting algorithm. However, it is time-consuming. In this paper, we propose a time distribution-based map maintenance mechanism. Specifically, instead of processing each voxel, we use a prior knowledge that the changes often happen at object level. Thus, we perform LiDAR segmentation in each local map, and associate voxels with each segment. Then, for each segment, the observed timestamps are stored in a set . These timestamps are discrete values. Then, we define time distribution as shown in Eq (14).

(14)

where denotes Gaussian distribution. It means that the time distribution of one segment is regarded as a mixture Gaussian distributions and each Gaussian distribution is defined by each observed timestamp. is the hyperparameter. Then, the time distribution of the local map can also be easily constructed by counting the contained LiDAR poses’ timestamps following the same strategy. Then, we compute the Wasserstein Distance between time distribution of each segment and the local map. If the distance is larger than a threshold, it indicates that the corresponding segment is dynamic. For instance, as shown in Fig 2, the time distribution segments of high-dynamic and low-dynamic objects are considered dynamic segments. The dynamic objects within these segments will be removed from the map.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Illustration of the time distribution.

https://doi.org/10.1371/journal.pone.0328169.g002

Essentially, such mechanism aims to extract segments that are relatively frequently observed through time distribution comparison. For a dynamic object, its timestamps are distributed in peak, while the local map’s time distribution is flat in the time space. For a static object that is removed later, its time distribution is missing on the near time space. Thus, through time distribution distance computing, we can distinguish the state of the segment, and thus the corresponding voxels. Actually, performing map maintenance at the segment level can effectively avoid voxel misclassification, since the voxel state judgement is more prone to errors.

Experiment setup

To validate the proposed system and mechanisms, we conducted experiments using public datasets, including KITTI [61] and M2DGR [63]. The environmental conditions during testing included a variety of outdoor settings such as urban streets, highways, and rural areas. These sequences were recorded in daylight, with ambient lighting conditions varying based on weather and time of day. In some sequences, light rain and varying sunlight conditions were present, which may have influenced the quality of the point cloud data. All experiments were performed using the Velodyne-VLP32 LiDAR configuration, with a scanning frequency of 10 Hz, horizontal FOV of 360°, and a vertical FOV of 30°. The LiDAR sensor had a range from 0.1 m to 100 m, and data was collected at a resolution of 0.5° per scan. The hardware setup consisted of an Intel i5-10400F 4.30 GHz processor with 16 GB RAM, which provided sufficient computational power to process the LiDAR data and run the localization algorithms concurrently. The software components, running on Robot Operating System (ROS) Noetic on Ubuntu 20.04, interacted with the hardware to process the raw LiDAR data in real time. The LiDAR driver read the point cloud data from the sensor and sent it to the software system for processing, where the proposed algorithms, including LiDAR Odometry and ScanContext-ICP, were applied for localization and mapping. Real-time data processing was essential for the system’s performance. To achieve this, the software was optimized for efficiency by employing asynchronous message passing between ROS nodes, enabling prompt handling of incoming sensor data while minimizing latency and ensuring the synchronization of asynchronous information. Data processing and map generation were carried out using the PCL point cloud library(version 1.11.0). Qualitative and quantitative evaluations were performed, and since our system is a combination of multiple subsystems, we evaluated each subsystem individually to assess its contribution to the overall performance.

Trajectory estimation of our SLAM system

The KITTI datasets are widely used public datasets for research in autonomous driving and SLAM. They provide a large amount of sensor data, including LiDAR, cameras, inertial measurement units (IMUs), GPS, and high-precision ground truth annotations. The datasets cover various large-scale scenarios such as urban streets, rural roads, and highways, enabling researchers to design and evaluate trajectory generation algorithms. We compared our proposed method with LiDAR Odometry and Mapping (LOAM) [9], Fast LiDAR Odometry and Mapping (F-LOAM) [33], and Bundle Adjustment for LiDAR Mapping (BALM) [34], which are well-established LiDAR SLAM algorithms, on nine different sequences from the KITTI dataset. The average error (mean), median error, and root mean square error (RMSE) are shown in Table 1, evaluated using absolute trajectory error (ATE) [62]. The BALM algorithm performed poorly on some sequences and failed, likely due to the high-speed vehicle motion during data collection, which caused a loss of feature points and led to the algorithm’s failure. In contrast, our method demonstrated higher accuracy compared to the other three algorithms.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Error comparison in the KITTI datasets (in units of meters).

https://doi.org/10.1371/journal.pone.0328169.t001

To further demonstrate the accuracy of the trajectory generated by our proposed method, we present a comparison between the estimated trajectories of our method, ground truth trajectories, and the trajectories estimated by the LOAM, F-LOAM, and BALM algorithms on the street06 and street08 sequences of the M2DGR dataset. As shown in Fig 3, which includes trajectory plots and error distribution graphs, our method exhibits superior overall trajectory consistency compared to the other algorithms, particularly in terms of the x, y, and z axes. The trajectory errors of each algorithm are shown in Table 2. BALM fails in the middle, so no result is shown. From these, we can conclude that our method achieves unbiased positioning estimation.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. The experimental results on M2DGR dataset.

Our method displays a solid red line trajectory, with the ground truth as a black dashed line, LOAM’s estimate as a solid green line, and F-LOAM’s trajectory represented by a solid blue line for comparison. (a) The trajectory of the street06 sequence. (b) error distribution on the x, y, z axes in the street06 sequence. (c) APE result on street06 sequence. (d) The trajectory of the street08 sequence. (e) error distribution on the x, y, z axes in the street08 sequence. (f) APE result on street08 sequence.

https://doi.org/10.1371/journal.pone.0328169.g003

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Error comparison in the M2DGR datasets (in units of meters).

https://doi.org/10.1371/journal.pone.0328169.t002

Dense mapping results

To show the mapping performance of our proposed method, part of the mapping results are presented in Fig 4. We can tell that the map is locally and globally consistent. However, Point cloud maps alone cannot be directly used for subsequent robot navigation, as they lack explicit information on which areas are passable and which are not. In contrast, mesh models are crucial for robot navigation because they not only provide a more accurate surface representation of the environment but also offer essential information about traversability and non-traversability of areas. By utilizing mesh models, we can capture rich surface details, such as complex architectural structures and terrain variations, which are vital for performing collision detection and obstacle avoidance. This allows the robot to better understand its environment, ensuring safer and more efficient navigation and inspection tasks in subsequent operations.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. The mapping results on the dataset sequences.

https://doi.org/10.1371/journal.pone.0328169.g004

Therefore, in order to further construct dense maps for inspection robot navigation, we employed the VDB-Fusion module to build high-precision 3D map models. The difference is that we directly compute SDF values by point-to-plane distance computing instead of the voxel-to-LiDAR beam end strategy in the ray-casting algorithm. The results are shown in Fig 5. Our method demonstrates significant improvements in reconstructing clear three-dimensional scenes of the real environment compared to the cluttered maps generated by VDB-Fusion. It is evident that our approach produces a more precise mesh model compared to the raw VDB-Fusion.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. The dense mapping results on the KITTI Seq 00 (part).

https://doi.org/10.1371/journal.pone.0328169.g005

ScanContext-ICP evaluation

To highlight the superiority of the proposed ScanContext-ICP method, we introduce a new evaluation metric for scan matching, defined as the sum of distances between points in the source and target point clouds using point-to-surfel distance. This metric allows us to assess the scan matching performance for detected true-positive looped scans. The resulting matching errors are shown in Fig 6. Among the four sequences, our method achieves fewer matching errors compared with other two methods. While ScanContext struggles to accurately match some looped scans, our ScanContext-ICP method leverages an initial alignment based on local descriptor matching followed by a refinement step using the ICP technique. This dual-step approach ensures that our method achieves better initial scan alignment and significantly reduces matching errors. The ScanContext++ (red points) consistently exhibit lower error values compared to the FPFH (green) and ScanContext (blue) points, particularly in the presence of large viewpoint changes, as demonstrated in KITTI 08 (reverse). These findings suggest that our method is more robust to variations in viewpoint, which are common in real-world scenarios. The cost time of the scan matching process is also given in Fig 7. FPFH based method is less efficient than our method. Compared with the Scancontext-based scan matching method, out method is also competitive in terms of efficiency. For global alignment, we utilize two pairs of scans for evaluation, with baselines including BVMatch [64], ScanContext, and Teaser [65]. BVMatch converts the LiDAR frame into a birdview image and extracts visual keypoints, performing frame alignment through Bag-of-words-based keypoint association. In contrast, Teaser reformulates the registration problem using a truncated least squares (TLS) cost, which makes the estimation less sensitive to spurious correspondences. It also employs a graph-theoretic framework to decouple scale, rotation, and translation, solving each transformation in sequence. Both methods represent state-of-the-art global registration techniques. Despite their strengths, neither of these methods outperform our ScanContext-ICP approach in terms of robustness and alignment accuracy. As shown in Fig 8, our method handles significant viewpoint changes more effectively. In the process of initial scan alignment, it is normal for the current viewpoint to differ from the one used when constructing the map. Our method is capable of managing these variations, achieving more accurate and stable LiDAR scan alignments than the baselines.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. The scan matching results on the KITTI sequences.

https://doi.org/10.1371/journal.pone.0328169.g006

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. The cost time of scan matching process on the KITTI sequences.

https://doi.org/10.1371/journal.pone.0328169.g007

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 8. The scan matching results KITTI LiDAR scans.

https://doi.org/10.1371/journal.pone.0328169.g008

Map maintenance results

The function of map maintenance is to distinguish environment changes and update the map. In this paper, environmental changes refer mainly to dynamic elements in the testing environments, especially vehicles that appear or disappear over time. For instance, in datasets such as KITTI, parked or moving cars often introduce inconsistencies in the point cloud. When the robot revisits the same location, the absence of previously present vehicles or the presence of new ones can negatively affect position recognition and map consistency. As shown in Fig 9, our Map Maintenance Module is capable of effectively removing corresponding point cloud data while preserving the static background. This allows our map to maintain accuracy and consistency over an extended period, providing a reliable foundation for robot navigation.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 9. The map maintenance results in local map.

https://doi.org/10.1371/journal.pone.0328169.g009