# Removert: cleaning dynamic points out of a LiDAR map, then reverting

> Removert is a C++ and ROS tool that builds a static point cloud map by removing dynamic objects such as cars and pedestrians from a pre-recorded LiDAR scan sequence, then reverting the survivors into a globally consistent map. It runs offline on saved scans, and the repository is a research release with an explicit TODO list of what is still missing.

**gisbi-kim/removert** — Remove then revert (IROS 2020) 

- Repository: https://github.com/gisbi-kim/removert
- Stars: 653 · Forks: 115
- Language: C++
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/gisbi-kim-removert

## What the tool does, and where the name comes from

Removert is a static map construction tool for LiDAR, and the README gives the capabilities in two lines. It is a dynamic points removing tool by constructing a static map, and the work is static map construction in the wild. The name is the abbreviation of the paper title, Remove-then-Revert, from IROS 2020, and both the paper and a video are linked. The primary language is C++, the default branch is master, the last push was on 2026-04-25, and the repository publishes no GitHub releases. The contact address in the README is a KAIST one, and the licence section says the work is supported by Naver Labs Corporation and by the National Research Foundation of Korea, and the repository carries the paper PDF at gkim-2020-iros.pdf alongside a docs/ folder with the architecture diagram.

## Why removal has to be followed by a revert

The two capabilities the README lists are easily construct and save a static map, and easily parse dynamic points, and the reason they come as a pair is the interesting part. If you delete the points that belong to a car in every scan and then stitch the remaining scans together, the map you get is not simply the clean map, because removing points leaves gaps and the geometry around a removed object is inconsistent from scan to scan. The revert step is what puts the survivors back into a coherent frame. The paper title, Remove, then Revert, and the repository layout, with include/, src/, launch/, config/ and a CMakeLists.txt, describe a system where the removal identifies which points are dynamic and the revert reconstructs a static map from what remains. The README is honest that the revert steps are not in the current code.

## The preparation step: you have to bring your own poses

The Preparations section is the part to read before anything else, because the tool does not do the work you might assume it does. Step one is to get a set of LiDAR scans and corresponding poses by running any open source LiDAR odometry or SLAM algorithm, and the README links a pose-and-scan saver from SC-LIO-SAM and one from SC-A-LOAM. Step two is to make a pair of a scan's point cloud and a corresponding pose using associated timestamps. The formats are specified tightly. A scan must be saved in a binary format as KITTI does, and the pose file must be a single text file with SE(3) poses written line by line, twelve numbers per line, which the README says is the equivalent format as the KITTI odometry ground truth pose txt file. So the input contract is a directory of scans plus a KITTI-style pose file, and the part of the pipeline you build yourself is the odometry.

## Compiling in a catkin workspace and running the launch file

The build is a standard ROS catkin workspace build, and the README gives the commands.

```bash
$ mkdir -p ~/catkin/removert_ws/src
$ cd ~/catkin/removert_ws/src
$ git clone https://github.com/irapkaist/removert.git
$ cd ..
$ catkin_make
$ source devel/setup.bash
```

There is a configuration step between compiling and running. Before starting the launch file you need to replace the data paths in the config/params.yaml file, and the README refers you to the tutorial video for the details. Then the run itself, with a launch file per dataset.

```bash
$ roslaunch removert run_kitti.launch # if you use KITTI dataset 
 or
$ roslaunch removert run_scliosam.launch # see this tutorial: https://youtu.be/UiYYrPMcIRU
```

There are two worked examples, a KITTI 09 sequence with SuMa poses and the MulRan dataset with poses from SC-LIO-SAM, and the README also mentions optional Matlab tools for visualising comparisons of the original and cleaned maps under tools/matlab. The package.xml at the root marks this as a ROS package, and the launch/ directory holds the launch files referenced in the README.

## The requirements, and the fact that this runs offline today

The Requirements section is short. The code is based on C++17, and it needs ROS with Eigen, PCL and OpenMP, with all the examples in the README tested under Ubuntu 18.04 and ROS Melodic. That is a specific and dated target, which is a fair indicator of when the work was done rather than a recommendation for a new deployment. The README then makes an important architectural disclosure. The project uses ROS's parameter parser for convenience, despite there being no topic flows within the system, because the repository currently runs offline on the pre-prepared scans saved on an HDD or an SSD. The speed is described as fast, over 10Hz for a single removing, and the plan is to extend to real time SLAM integration in the future. So the design is a ROS node that happens to be driven offline today, and the parameter server is doing configuration work rather than communication.

## The TODO list, which is the most honest document in the repository

The README ends with a TODO section, split into near future and future, and it is worth reading in full because it tells you exactly what the tool does not do yet. On the near future list are a full sequence cleaned-scan saver that automatically iterates batches, with a note that using 50 to 100 scans for a single batch is recommended for computation speed, and adding the revert steps, with the reasoning that removing dynamic points is generally more worthy for many applications so the reverting step is omitted currently. Also on the list is automatically parsing dynamic segments from the dynamic points in a scan, for example using DBSCAN on those points, a SemanticKITTI evaluation tool that would calculate true and false positive counts, and a possible change of all floats to double. The future list is larger: real-time LiDAR SLAM integration for odometry that tolerates dynamic objects, a multi-session change detection example, defining and measuring the quality of a static map, and using that measure to decide when removal can stop at which resolution. The note that generally 1 to 3 removings are empirically enough, but for highly crowded environments such as urban roads, tells you the intended usage pattern.

## The licence, and the alternative way to clean a map

The licence is the first thing to check if this is commercial work. The repository is classified as carrying a licence GitHub cannot categorise, and the README states the work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. That is a content licence with a non-commercial clause, so a company wanting to use it in a product needs to sort that out rather than assume the permissiveness of an MIT or Apache licence. On the alternative approach, the README itself proposes the comparison, recommending combining recent deep learning-based dynamic removal such as LiDAR-MOS with the Removert method for better map cleaning. The difference in approach is precise. Deep learning removal can run online and is good for proactive removal of bunches of points, whereas Removert currently runs offline and is good at finer cleaning of the remaining 3D points after LiDAR-MOS has run. A second alternative is to skip removal altogether and build the static map from a session with no traffic, which is a research luxury that rarely exists, or to accept a map with ghosts and filter them at query time, which trades a one-off offline cost for permanent downstream noise.

## Conclusion

Adopt Removert if you have a saved LiDAR sequence with poses and a map contaminated by moving traffic, since the removal-then-revert approach handles the global consistency problem that naive point removal creates. Do not adopt it as a live SLAM component, because the README says it currently runs offline and that real time integration is future work, and the revert step is still listed as something to add. Before you build it, prepare the scan and pose pairs yourself with an odometry or SLAM package such as SC-LIO-SAM or SC-A-LOAM, and check the licence, since the work is under Creative Commons BY-NC-SA 4.0 rather than a software licence, which matters for commercial use.

## FAQ

### What is Removert?

It is a static map construction tool for LiDAR that works by removing dynamic points and then reverting the survivors into a consistent map, the name coming from the Remove-then-Revert title of its IROS 2020 paper. The primary language is C++ and it runs as a ROS package.

### What input does Removert need?

A set of LiDAR scans and corresponding poses, which you produce yourself with an open source odometry or SLAM algorithm such as the pose-and-scan savers in SC-LIO-SAM or SC-A-LOAM. Scans must be saved in a binary format like KITTI, and the poses go in a single text file with SE(3) poses written line by line, twelve numbers per line.

### How do I build and run Removert?

You create a catkin workspace, clone the repository into its src directory, run catkin_make and source devel/setup.bash. Before launching you replace the data paths in config/params.yaml, then start it with the launch file for your dataset, run_kitti.launch for KITTI or run_scliosam.launch for the SC-LIO-SAM example.

### Does Removert work in real time?

Not currently. The README says the repository currently runs offline on the pre-prepared scans saved on an HDD or an SSD, describes the speed as over 10Hz for a single removing, and lists real-time LiDAR SLAM integration under future work.

### What licence does Removert use?

The README states the work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License, and it says the work is supported by Naver Labs Corporation and by the National Research Foundation of Korea. The non-commercial clause is the part to check before using it in a product.

## Sources

- [gisbi-kim/removert on GitHub](https://github.com/gisbi-kim/removert)
- [Issues](https://github.com/gisbi-kim/removert/issues)
- [README](https://github.com/gisbi-kim/removert/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gisbi-kim-removert