pyLiDAR-SLAM
This codebase proposes modular light python and pytorch implementations of several LiDAR Odometry methods, which can easily be evaluated and compared on a set of public Datasets.
It heavily relies on omegaconf and hydra, which allows us to easily test the different modules and parameters with few but structured configuration files.
This is a research project provided "as-is" without garanties, use at your own risk. It is actively used for Kitware Vision team internal research thus is likely to be heavily extended, rewritten (and hopefully improved) in a near future.
Overview
pyLIDAR-SLAM is designed to be modular, multiple components are implemented at each stage of the pipeline. Its modularity can make it a bit complicated to use. We provide this wiki to help you navigate it. If you have any questions, do not hesitate raising issues.
The documentation is organised as follows:
INSTALLATION:
Describes how to install pyLiDAR-SLAM and its different componentsDATASETS:
Describes the different datasets integrated in pyLiDAR-SLAM, and how to install themTOOLBOX:
Describes the contents of the toolbox and the different modules proposedBENCHMARK:
Describes the benchmarks supported in the Dataset /!\ Note: This section is still in construction
The goal for the future is to gradually add functionalities to pyLIDAR-SLAM (Loop Closure, Motion Segmentation, Multi-Sensors, etc...).
News
[08/10/2021]: We also introduce support for individual rosbags (Introducing naturally an overhead compared to using ROS directly, but provides the flexibility of pyLiDAR-SLAM)
[08/10/2021]: We release code for Loop Closure with pyLiDAR-SLAM accompanied with a simple PoseGraph Optimization.
[08/10/2021]: We release our new work on arXiv. It proposes a new state-of-the-art pure LiDAR odometry implemented in C++ (check the project main page). python wrappings are available, and it can be used with pyLiDAR-SLAM.
Installation
See the wiki page INSTALLATION for instruction to install the code base and the modules you are interested in.
DATASETS
pyLIDAR-SLAM incorporates different datasets, see DATASETS for installation and setup instructions for each of these datasets.
Only the datasets implemented in pyLIDAR-SLAM are compatible with hydra's mode and the scripts run.py
and train.py
.
But you can define your own datasets by extending the class DatasetLoader
.
New: We support individual rosbags (without requiring a complete ROS installation). See the minimal example for more details.
A Minimal Example
Download a rosbag (e.g. From Rosbag Cartographer): example_rosbag
Note: You need the
rosbag
python module installed to run this example (see INSTALLATION for instructions)
Launch the SLAM:
python3 run.py num_workers=1 / # The number of process workers to load the dataset (should be at most 1 for a rosbag)
slam/initialization=NI / # The initialization considered (NI=No Initialization / CV=Constant Velocity, etc...)
slam/preprocessing=grid_sample / # Preprocessing on the point clouds
slam/odometry=icp_odometry / # The Odometry algorithm
slam.odometry.viz_debug=True / # Whether to launch the visualization of the odometry
slam/loop_closure=none / # The loop closure algorithm selected (none by default)
slam/backend=none / # The backend algorithm (none by default)
dataset=rosbag / # The dataset selected (a simple rosbag here)
dataset.main_topic=horizontal_laser_3d / # The pointcloud topic of the rosbag
dataset.accumulate_scans=True / # Whether to accumulate multiple messages (a sensor can return multiple scans lines or an accumulation of scans)
dataset.file_path=<path_to_rosbag_dir>/b3-2016-04-05-15-51-36.bag / # The path to the rosbag file
hydra.run.dir=.outputs/TEST_DOC # The log directory where the trajectory will be saved
This will output the trajectory, log files (including the full config) on disk at location
.outputs/TEST_DOC
.Our minimal LiDAR Odometry, is actually a naïve baseline implementation, which is mostly designed and tested on driving datasets (see the KITTI benchmark). Thus in many cases it will fail, be imprecise or too slow.
We recommend you install the module
pyct_icp
from our recent work, which provides a much more versatile and precise LiDAR-Odometry.See the wiki page INSTALLATION for more details on how to install the different modules. If you want to visualize in real time the quality of the SLAM, consider also installing the module
pyviz3d
.
Once
pyct_icp
is installed, you can modify the command line above:
python3 run.py num_workers=1 /
slam/initialization=NI /
slam/preprocessing=none /
slam/odometry=ct_icp_robust_shaky / # The CT-ICP algorithm for shaky robot sensor (here it is for a backpack)
slam.odometry.viz_debug=True /
slam/loop_closure=none /
slam/backend=none /
dataset=rosbag /
dataset.main_topic=horizontal_laser_3d /
dataset.accumulate_scans=True /
dataset.file_path=<path_to_rosbag_dir>/b3-2016-04-05-15-51-36.bag /
hydra.run.dir=.outputs/TEST_DOC
It will launch pyct_icp on the same rosbag (running much faster than our python based odometry)
With
pyviz3d
you should see the following reconstruction (obtained by a backpack mounting the stairs of a museum):
More advanced examples / Motivation
pyLiDAR-SLAM will progressively include more and more modules, to build more powerful and more accessible LiDAR odometries.
For a more detailed / advanced usage of the toolbox please refer to our documentation in the wiki HOME.
The motivation behind the toolbox, is really to compare different modules, hydra is very useful for this purpose.
For example the script below launches consecutively the
pyct_icp
andicp_odometry
odometries on the same datasets.
python3 run.py -m / # We specify the -m option to tell hydra to perform a sweep (or grid search on the given arguments)
num_workers=1 /
slam/initialization=NI /
slam/preprocessing=none /
slam/odometry=ct_icp_robust_shaky, icp_odometry / # The two parameters of the grid search: two different odometries
slam.odometry.viz_debug=True /
slam/loop_closure=none /
slam/backend=none /
dataset=rosbag /
dataset.main_topic=horizontal_laser_3d /
dataset.accumulate_scans=True /
dataset.file_path=<path_to_rosbag_dir>/b3-2016-04-05-15-51-36.bag /
hydra.run.dir=.outputs/TEST_DOC
Benchmarks
We use this functionality of pyLIDAR-SLAM to compare the performances of its different modules on different datasets. In Benchmark we present the results of pyLIDAR-SLAM on the most popular open-source datasets.
Note this work in still in construction, and we aim to improve it and make it more extensive in the future.
Research results
Small improvements will be regularly made to
pyLiDAR-SLAM
, However major changes / new modules will more likely be introduced along research articles (which we aim to integrate with this project in the future)Please check RESEARCH to see the research papers associated to this work.
System Tested
OS | CUDA | pytorch | python | hydra |
---|---|---|---|---|
Ubuntu 18.04 | 10.2 | 1.7.1 | 3.8.8 | 1.0 |
Author
This is a work realised in the context of Pierre Dellenbach PhD thesis under supervision of Bastien Jacquet (Kitware), Jean-Emmanuel Deschaud & François Goulette (Mines ParisTech).
Cite
If you use this work for your research, consider citing:
@misc{dellenbach2021s,
title={What's in My LiDAR Odometry Toolbox?},
author={Pierre Dellenbach,
Jean-Emmanuel Deschaud,
Bastien Jacquet,
François Goulette},
year={2021},
}