Launching MOLA-LO¶
1. MOLA-LO GUI applications¶
All these commands are actually shortcuts (small scripts) to launch mola-cli and
one of the predefined mola-cli launch files containing one dataset source
and the mola_viz module, which enables the real-time GUI visualization.
First, we enumerate the existing scripts together with their specific environment variables and CLI usage, next we list the environment variables common to all of them.
Note
Apart from the environment variables defined here, which are specific to these mola-cli launch files (see: role of MOLA-LO module), remember that there are many additional parameters associated to the LO pipeline YAML file, listed here.
Common elements of all GUI apps¶
mola_viz provides a unified API for all MOLA modules to display custom UI subwindows, controls, and 3D objects.
Next we describe how to manipulate or interpret the common elements in this UI, which is the same in all MOLA-LO
programs, except mola-lidar-odometry-cli which is explicitly designed not to have any GUI.
The labeled parts in the GUI are:
The main space of the “main” GUI window: used to render the latest 3D local map, together with the incoming raw scan, the 3D vehicle model (if provided), etc. Use the same mouse and keyboard shortcuts than in any MRPT 3D window to rotate the view, pan and zoom, etc. The rest of small windows floating in this large windows are dubbed “subwindows”.
Dataset source UI: All dataset sources (offline datasets, rawlog, rosbag2, etc.) offer a common API that can be operated through these controls to pause or resume the publication of observations to the LiDAR front-end or to change the playback speed. Most datasets also support directly jumping forth and back in time by clicking on the time slider (It is recommended to pause mapping and reset the map while doing so!).
Main subwindows control panel: You can minimize, restore, etc. subwindows from here.
Raw LiDAR view: A subwindow with the details (type of observation, timestamp, etc.) of incoming raw scans.
Camera view: Although not used by the LO, it is useful sometimes to see the environment from camera images.
mola_lidar_odometry module own UI: Direct access to the internals of the LO module. There are tabs providing direct access to variables that normally can be set via environment variables, to make it easier to record a simple-maps directly from the GUI.
Log messages with priority higher than
INFOwill be dumped to both, the terminal, and to this scrolling transparent terminal at the bottom.
Choosing a visualizer module¶
MOLA provides two alternative visualizer modules, both allowing MRPT’s OpenGL rendering, that can be used with all GUI applications:
MolaVizImGui (
mola_viz_imgui): The most recent visualizer, built on Dear ImGui, with dockable subwindows, a log console and live metric plots. This is the default.MolaViz (
mola_viz): The older visualizer, based on nanogui.
To switch between them, set the MOLA_GUI_MODULE environment variable before launching
any of the GUI applications:
# Explicitly select MolaVizImGui (Dear ImGui-based, the default):
MOLA_GUI_MODULE=mola::MolaVizImGui mola-lo-gui-rosbag2 /path/to/your/dataset.mcap
# Fall back to the older MolaViz (nanogui-based):
MOLA_GUI_MODULE=mola::MolaViz mola-lo-gui-rosbag2 /path/to/your/dataset.mcap
1.1. mola-lo-gui-rosbag2¶
Tip
See offline rosbag2 recipes in the ROS 2
configurations page for ready-to-copy mola-lo-gui-rosbag2 and
mola-lo-cli-rosbag2 commands (LO, LIO, smoother, namespaced bags),
with a live parameter editor.
This command will open the mola_viz GUI and build a map from ROS 2 bags:
# Use LIO (Lidar-Inertial) from a live Ouster: MOLA_DESKEW_METHOD=MotionCompensationMethod::IMU \ MOLA_IMU_TOPIC="/ouster/imu" \ MOLA_LIDAR_TOPIC="/ouster/points" \ MOLA_TF_BASE_LINK="os_sensor" \ mola-lo-gui-rosbag2 /path/to/your/dataset.mcap # Usage for LO (LiDAR odometry) a single bag file: MOLA_LIDAR_TOPIC=/ouster/points \ mola-lo-gui-rosbag2 /path/to/your/dataset.mcap # Usage for a directory with split bag files: # Note: in this case, the directory is expected to contain a metadata.yaml to determine "rosbag_storage_id". MOLA_LIDAR_TOPIC=/ouster/points \ mola-lo-gui-rosbag2 /path/to/your/dataset_directory/
If your bag has no /tf for the sensors, see Run MOLA on your own ROS 2 bag. If only the Ouster
driver was recorded, MOLA_TF_BASE_LINK=os_sensor uses the frames of its own /tf_static.
Environment variables specific for mola-lo-gui-rosbag2:
See complete mola launch YAML listing
File: mola-cli-launchs/lidar_odometry_from_rosbag2.yaml
# -----------------------------------------------------------------------------
# SLAM system definition for MOLA
# This file defines:
# An input sensor from a ROS 2 bag file, and the MOLA Visualizer.
# -----------------------------------------------------------------------------
modules:
# =====================
# MolaViz
# =====================
- name: viz
type: ${MOLA_GUI_MODULE|mola::MolaVizImGui}
enabled: ${MOLA_WITH_GUI|true}
verbosity_level: "${MOLA_VERBOSITY_MOLA_VIZ|INFO}"
params:
imgui_app_name: lidar_odometry_from_rosbag2
# =====================
# LIDAR ODOMETRY
# =====================
- name: lidar_odom
type: mola::LidarOdometry
verbosity_level: "${MOLA_VERBOSITY_MOLA_LO|INFO}"
raw_data_source: "dataset_input"
# This includes here a whole block "params: (...)"
# with the LIDAR-Odometry pipeline configuration:
params: "${MOLA_ODOMETRY_PIPELINE_YAML|../pipelines/lidar3d-default.yaml}"
# =====================
# State Estimation
# =====================
- name: state_estimation
type: "${MOLA_STATE_ESTIMATOR|mola::state_estimation_simple::StateEstimationSimple}"
verbosity_level: "${MOLA_VERBOSITY_MOLA_STATE_ESTIMATOR|INFO}"
raw_data_source: "dataset_input"
# This includes here a whole block "params: (...)":
params: "${MOLA_STATE_ESTIMATOR_YAML|../state-estimator-params/state-estimation-simple.yaml}"
# =========================
# Offline dataset source
# =========================
- type: mola::Rosbag2Dataset
name: dataset_input
verbosity_level: "${MOLA_VERBOSITY_ROSBAG2|INFO}"
export_to_rawlog: ${MOLA_ROS2BAG_EXPORT_TO_RAWLOG_FILE|''}
# In Rosbag2Dataset, this execution rate (Hz) determines the
# maximum rate of publishing topics from the bag file.
# If a message in the bag has an actually rate higher than this, their
# messages will be still sent out with the correct timestamps, but physically
# in bursts.
execution_rate: 50 # Hz
#verbosity_level: INFO
quit_mola_app_on_dataset_end: ${MOLA_QUIT_ON_DATASET_END|false}
# Optional visualization of raw sensor streams in the MolaViz GUI
gui_preview_sensors:
- raw_sensor_label: "${MOLA_LIDAR_NAME|lidar}"
decimation: 1
enabled: ${MOLA_WITH_GUI|true}
win_pos: 5 5 400 400
#- raw_sensor_label: '/ouster/range_image'
# decimation: 1
# win_pos: 5 420 400 400
# Optional camera preview, shown only when MOLA_CAMERA_PREVIEW=true:
- raw_sensor_label: "${MOLA_CAMERA_SENSOR_NAME|camera}"
decimation: 1
enabled: ${MOLA_CAMERA_PREVIEW|false}
win_pos: 5 420 600 380
params:
# We use an environment variable to force the user to specify a bag file:
rosbag_filename: ${MOLA_INPUT_ROSBAG2}
time_warp_scale: ${MOLA_TIME_WARP|1.0}
start_paused: ${MOLA_DATASET_START_PAUSED|false}
base_link_frame_id: "${MOLA_TF_BASE_LINK|base_link}"
# Optional ground-truth trajectory (TUM format), drawn by the GUI:
ground_truth_tum_file: "${MOLA_GROUND_TRUTH_TUM_FILE|}"
# /tf topic names in the bag. Override for namespaced bags,
# e.g. MOLA_TF_TOPIC=/robot1/tf MOLA_TF_STATIC_TOPIC=/robot1/tf_static
tf_topic: "${MOLA_TF_TOPIC|/tf}"
tf_static_topic: "${MOLA_TF_STATIC_TOPIC|/tf_static}"
# 'sensors' contains maps from output "sensorLabel"s, to the
# configuration of that data source (mainly, 'type', 'topic'):
# If no 'sensors' entry is given, all ROSBAG topics will be exposed
# to the MOLA subsystem. Note that if you want to override sensor poses
# (or if you do not have /tf), it is mandatory to define 'sensors' and
# define 'fixed_sensor_pose' for each sensor here:
sensors:
- topic: ${MOLA_LIDAR_TOPIC|'/ouster/points'}
type: CObservationPointCloud
sensorLabel: "${MOLA_LIDAR_NAME|lidar}"
# If present, this will override whatever /tf tells about the sensor pose:
fixed_sensor_pose: "${LIDAR_POSE_X|0} ${LIDAR_POSE_Y|0} ${LIDAR_POSE_Z|0} ${LIDAR_POSE_YAW|0} ${LIDAR_POSE_PITCH|0} ${LIDAR_POSE_ROLL|0}" # 'x y z yaw_deg pitch_deg roll_deg'
use_fixed_sensor_pose: ${MOLA_USE_FIXED_LIDAR_POSE|false}
# For GPS messages of type 'sensor_msgs/NavSatFix' or 'gps_msgs/GpsFix'
- topic: ${MOLA_GNSS_TOPIC|'/gps'}
sensorLabel: "gps"
#type: CObservationGPS # This will be determined automatically by Rosbag2Dataset
is_optional: true
# If present, this will override whatever /tf tells about the sensor pose:
fixed_sensor_pose: "${GNSS_POSE_X|0} ${GNSS_POSE_Y|0} ${GNSS_POSE_Z|0} ${GNSS_POSE_YAW|0} ${GNSS_POSE_PITCH|0} ${GNSS_POSE_ROLL|0}" # 'x y z yaw_deg pitch_deg roll_deg''
use_fixed_sensor_pose: ${MOLA_USE_FIXED_GNSS_POSE|false}
- topic: ${MOLA_IMU_TOPIC|'/imu'}
sensorLabel: "imu"
type: CObservationIMU
# If present, this will override whatever /tf tells about the sensor pose:
fixed_sensor_pose: "${IMU_POSE_X|0} ${IMU_POSE_Y|0} ${IMU_POSE_Z|0} ${IMU_POSE_YAW|0} ${IMU_POSE_PITCH|0} ${IMU_POSE_ROLL|0}" # 'x y z yaw_deg pitch_deg roll_deg''
use_fixed_sensor_pose: ${MOLA_USE_FIXED_IMU_POSE|false}
# If true, use the bag's own recv/storage time for this sensor's
# observations instead of the ROS message header stamp. Workaround
# for drivers that stamp with a monotonic/uptime clock instead of
# wall-clock epoch time (seen with some IMU drivers), which
# otherwise trips the "mis-timestamped sensors" time reference
# reset. Default false.
use_bag_recv_time_as_timestamp: ${MOLA_IMU_USE_BAG_RECV_TIME|false}
# Optional second IMU, only stored into simplemap keyframes (absolute
# attitude for geo-referencing). Disabled unless MOLA_ATTITUDE_IMU_TOPIC
# is set. When running this file directly with mola-cli, also set
# MOLA_ATTITUDE_IMU_NAME=imu_attitude so the odometry uses it
# (mola-lo-gui-rosbag2 and mola-lidar-odometry-cli do this by themselves).
- topic: ${MOLA_ATTITUDE_IMU_TOPIC|''}
sensorLabel: ${MOLA_ATTITUDE_IMU_NAME|imu_attitude}
type: CObservationIMU
is_optional: true
# Optional cameras, for visualization, and stored in simplemap keyframes
# with MOLA_SIMPLEMAP_ATTACH_LABEL='camera.*' (disabled by default):
- topic: ${MOLA_CAMERA_TOPIC|''}
is_optional: true
sensorLabel: ${MOLA_CAMERA_SENSOR_NAME|camera}
type: CObservationImage
- topic: ${MOLA_CAMERA_TOPIC_1|''}
is_optional: true
sensorLabel: ${MOLA_CAMERA_SENSOR_NAME_1|camera_1}
type: CObservationImage
- topic: ${MOLA_CAMERA_TOPIC_2|''}
is_optional: true
sensorLabel: ${MOLA_CAMERA_SENSOR_NAME_2|camera_2}
type: CObservationImage
# Wheel/robot odometry (disabled by default). CObservationOdometry is
# planar: (x, y, yaw) plus a 2D twist. For a 3D odometry source
# (legged robot, VIO, aerial platform) set
# MOLA_ODOMETRY_OBS_CLASS=CObservationRobotPose to keep z, roll,
# pitch and the source's 6x6 covariance, matching the offline CLI's
# dataset_from_rosbag1()/dataset_from_rosbag2().
- topic: ${MOLA_ODOMETRY_TOPIC|''}
sensorLabel: ${MOLA_ODOM_SENSOR_LABEL|odom_wheels}
type: ${MOLA_ODOMETRY_OBS_CLASS|CObservationOdometry}
MOLA_TIME_WARP(Default: 1.0): Time warping (playback speed factor) for the replay.MOLA_DATASET_START_PAUSED(Default: false): Start with replay paused. Then can be resumed from the GUI.
Also, see variables to control sensor inputs, including manually-provided sensor poses for the LiDAR, IMU, or GNSS sensors.
1.2. mola-lo-gui-rawlog¶
This command will open the mola_viz GUI and build a map from dataset stored as a .rawlog file.
Environment variables specific for mola-lo-gui-rawlog:
See complete mola launch YAML listing
File: mola-cli-launchs/lidar_odometry_from_rawlog.yaml
# -----------------------------------------------------------------------------
# SLAM system definition for MOLA
# This file defines:
# An input sensor from a ROS 2 topic, and the MOLA Visualizer.
# -----------------------------------------------------------------------------
modules:
# =====================
# MolaViz
# =====================
- name: viz
type: ${MOLA_GUI_MODULE|mola::MolaVizImGui}
enabled: ${MOLA_WITH_GUI|true}
verbosity_level: "${MOLA_VERBOSITY_MOLA_VIZ|INFO}"
params:
imgui_app_name: lidar_odometry_from_rawlog
# Offline or online sensory data sources =====================
# =====================
# KittiOdometryDataset
# =====================
- name: dataset_input
type: mola::RawlogDataset
execution_rate: 150 # Hz
#verbosity_level: INFO
quit_mola_app_on_dataset_end: ${MOLA_QUIT_ON_DATASET_END|false}
gui_preview_sensors:
- raw_sensor_label: ${MOLA_LIDAR_NAME|lidar}
decimation: 1
enabled: ${MOLA_WITH_GUI|true}
win_pos: 5 40 600 200 # [x,y,width,height]
- raw_sensor_label: ${MOLA_CAMERA_NAME|camera}
decimation: 1
enabled: ${MOLA_WITH_GUI|true}
win_pos: 5 370 600 200
params:
rawlog_filename: ${MOLA_INPUT_RAWLOG}
time_warp_scale: ${MOLA_TIME_WARP|1.0}
read_all_first: ${MOLA_INPUT_RAWLOG_READ_ALL_FIRST|false} # read from disk as needed
start_paused: ${MOLA_DATASET_START_PAUSED|false}
- name: lidar_odom
type: mola::LidarOdometry
verbosity_level: "${MOLA_VERBOSITY_MOLA_LO|INFO}"
raw_data_source: "dataset_input"
# This includes here a whole block "params: (...)"
# with the LIDAR-Odometry pipeline configuration:
params: "${MOLA_ODOMETRY_PIPELINE_YAML|../pipelines/lidar3d-default.yaml}"
- name: state_estimation
type: "${MOLA_STATE_ESTIMATOR|mola::state_estimation_simple::StateEstimationSimple}"
verbosity_level: "${MOLA_VERBOSITY_MOLA_STATE_ESTIMATOR|INFO}"
raw_data_source: "dataset_input"
# This includes here a whole block "params: (...)":
params: "${MOLA_STATE_ESTIMATOR_YAML|../state-estimator-params/state-estimation-simple.yaml}"
MOLA_TIME_WARP(Default: 1.0): Time warping (playback speed factor) for the replay.MOLA_DATASET_START_PAUSED(Default: false): Start with replay paused. Then can be resumed from the GUI.MOLA_INPUT_RAWLOG_READ_ALL_FIRST(Default:false): Set totrueto load the whole .rawlog file at start up, enabling the use of the dataset timeline slider in the UI.
1.3. Public datasets¶
Each supported public dataset (KITTI, MulRan, Newer College, …) has its own launcher,
mola-lo-gui-<dataset>, and a page with where to put the data and the exact commands:
see Running MOLA on a dataset.
1.4. Common env variables¶
MOLA_ODOMETRY_PIPELINE_YAML(Default: the installedlidar3d-default.yaml, which is a symlink to lidar3d-gicp.yaml): set it to override the default pipeline and experiment with custom MOLA-LO systems described through a modified YAML file. See the available pipelines. For example, to use the 3D-NDT pipeline:MOLA_ODOMETRY_PIPELINE_YAML=$(ros2 pkg prefix mola_lidar_odometry)/share/mola_lidar_odometry/pipelines/lidar3d-ndt.yaml \ MOLA_LOCAL_VOXELMAP_RESOLUTION=5.0 \ mola-lo-gui-mulran KAIST01
MOLA_WITH_GUI(Default:true): set tofalseto run amola-lo-gui-*launcher headless, e.g. over ssh or in a batch job.MOLA_GUI_MODULE(Default:mola::MolaVizImGui): selects the visualizer backend.MOLA_GUI_TARGET_FPS(Default:30): GUI refresh rate,mola::MolaVizImGuionly. The whole 3D view is redrawn on every frame, so the GPU load (and, to a lesser extent, the CPU load) grows with it: lower it (e.g.15) on weak machines, or raise it (e.g.60) for smoother interaction.
2. LiDAR odometry CLI¶
mola-lidar-odometry-cli is a standalone command line program to run
MOLA-LO on a dataset in an offline fashion.
The dataset is processed as fast as possible using all available CPU cores.
Its outputs include the vehicle trajectory (as a file in TUM format)
and the simple-map, which can be analyzed with sm-cli
and used to generate metric maps using sm2mm.
Hint
We recommend using evo to visualize
and compare the output TUM trajectories. You can also use
mrpt::poses::CPose3DInterpolator
to load and parse TUM files in C++, or its Python wrapped version within pymrpt.
2.1. Usage examples¶
Process a ROS 2 bag¶
mola-lidar-odometry-cli \ -c $(ros2 pkg prefix mola_lidar_odometry)/share/mola_lidar_odometry/pipelines/lidar3d-default.yaml \ --state-estimator-param-file $(ros2 pkg prefix mola_lidar_odometry)/share/mola_lidar_odometry/state-estimator-params/state-estimation-simple.yaml \ --input-rosbag2 /PATH/TO/YOUR/rosbag.mcap \ --lidar-sensor-label /ouster/points \ --output-tum-path trajectory.tum \ --output-simplemap myMap.simplemap
Note
Remember changing --lidar-sensor-label /ouster/points to your actual raw (unfiltered) LiDAR topic (sensor_msgs/PointCloud2).
Warning
--output-simplemap keeps every keyframe scan in RAM and stores it inside the .simplemap file:
lazy-load generation (MOLA_SIMPLEMAP_GENERATE_LAZY_LOAD=true) is ignored with this flag.
For long datasets, drop --output-simplemap and use instead:
MOLA_GENERATE_SIMPLEMAP=true \
MOLA_SIMPLEMAP_OUTPUT=$(pwd)/myMap.simplemap \
MOLA_SIMPLEMAP_GENERATE_LAZY_LOAD=true \
mola-lidar-odometry-cli \
[...] # the rest does not change, without --output-simplemap
Scans are then written to myMap_Images/ next to the map while running, which sm2mm and
other tools find by themselves.
If your bag has no /tf for the sensors, see Run MOLA on your own ROS 2 bag: otherwise, MOLA keeps
reporting that base_link does not exist in /tf.
Want to visualize the output in real-time?
mola-lidar-odometry-cli is explicitly designed to be as fast as possible by not interacting with any GUI or messaging system.
If you prefer to visualize the results as they are being processed, there are two options:
Use the built-in GUI in the provided apps: mola-lo-gui-rosbag2.
Replay the bag with ros2 bag play and launch the ROS 2 launch file so you can use RViz2 or FoxGlove for visualization.
More parameters
If using the default pipeline, the lidar3d-gicp.yaml pipeline file defines plenty
of additional parameters and options that you can explore.
Process a KITTI dataset sequence¶
First, make sure of downloading and extracting the dataset files following the layout
expected by mola::KittiDataset.
Then, set the KITTI_BASE_DIR environment variable and launch the desired sequence (e.g. 00) with:
export KITTI_BASE_DIR=/path/to/kitti_root mola-lidar-odometry-cli \ -c $(ros2 pkg prefix mola_lidar_odometry)/share/mola_lidar_odometry/pipelines/lidar3d-default.yaml \ --state-estimator-param-file $(ros2 pkg prefix mola_lidar_odometry)/share/mola_lidar_odometry/state-estimator-params/state-estimation-simple.yaml \ --input-kitti-seq 00 \ --output-tum-path kitti-00.tum
More parameters
If using the default pipeline, the lidar3d-gicp.yaml pipeline file defines plenty
of additional parameters and options that you can explore.
2.2. Complete list of arguments¶
mola-lidar-odometry-cli [OPTIONS] OPTIONS: -h, --help Print this help message and exit --version Display program version information and exit -c, --config TEXT REQUIRED Input pipeline YAML config file (required) (*.yml) -v, --verbosity TEXT Verbosity level: ERROR|WARN|INFO|DEBUG {Default: INFO} -l, --load-plugins foobar.so One or more {comma separated} *.so files to load as plugins --state-estimator (StateEstimationSimple|StateEstimationSmoother) The C++ class name of the state estimator to use --state-estimator-param-file TEXT REQUIRED Path to YAML parameters file to configure the state estimator. --output-tum-path output-trajectory.txt Save the estimated path as a TXT file using the TUM file format {see evo docs} --output-twist output-twist.txt Save the estimated twist as a TXT file --output-simplemap output-map.simplemap Enables building and saving the simplemap for the mapping session. Note: incompatible with lazy-load simplemaps; for those, use MOLA_GENERATE_SIMPLEMAP=true and MOLA_SIMPLEMAP_OUTPUT instead --only-first-n INT:NONNEGATIVE Run for the first N steps only {0=default, not used} --skip-first-n INT:NONNEGATIVE Skip the first N dataset entries {0=default, not used} --lidar-sensor-label TEXT If provided, this supersedes the values in the 'lidar_sensor_labels' entry of the odometry pipeline, defining the sensorLabel/topic name to read LIDAR data from. It can be a regular expression {std::regex} --imu-sensor-label TEXT [imu] If provided, this supersedes the values in the 'imu_sensor_label' entry of the odometry pipeline, defining the sensorLabel/topic name to read IMU data from. It can be a regular expression {std::regex} --base-link-frame-id TEXT [base_link] Only for rosbag input sources. This defines the /tf frame_id used as reference frame for the vehicle or robot. It is used to get sensors poses with respect to the vehicle from /tf data. --tf-topic TEXT [/tf] Only for rosbag2 input: /tf topic name in the bag. Override for namespaced bags (e.g. '/robot1/tf'). --tf-static-topic TEXT [/tf_static] Only for rosbag2 input: /tf_static topic name in the bag. Override for namespaced bags (e.g. '/robot1/tf_static'). --progress-bar-period FLOAT:FLOAT in [0 - 100] Minimum percentage step, in [0,100], between progress bar printouts. Use 0 to disable the progress bar entirely. Handy to cut down log verbosity in batch/CI runs (e.g. Jenkins). {Default: print on (almost) every processed entry} --input-rawlog dataset.rawlog INPUT DATASET: rawlog. Input dataset in rawlog format {*.rawlog} --input-rosbag2 dataset.mcap INPUT DATASET: rosbag2. Input dataset in rosbag2 format {*.mcap} --input-rosbag1 dataset.bag INPUT DATASET: rosbag1. Input dataset in ROS 1 bag format {*.bag} --input-kitti-seq 00 INPUT DATASET: Use KITTI dataset sequence number 00|01|... --kitti-correction-angle-deg 0.205 [degrees] Correction vertical angle offset {see Deschaud,2018} --input-kitti360-seq 00 INPUT DATASET: Use KITTI360 dataset sequence number 00|01|...|test_00|... --input-mulran-seq KAIST01 INPUT DATASET: Use Mulran dataset sequence KAIST01|KAIST02|... --input-paris-luco INPUT DATASET: Use Paris Luco dataset (unique sequence=00)
3. ROS 2 node¶
A ROS 2 node is provided for running MOLA-LO live on a robot or vehicle where sensor drivers are already working and publishing ROS topics.
Tip
For a full matrix of supported live configurations (Simple vs Smoother, REP-105 on/off, namespaces, GNSS modes) see the MOLA in ROS 2 cookbook.
3.1. ROS 2 launch file: live LiDAR odometry¶
Note
It is recommended to start with the tutorial on how to build a map.
This launch file (view sources) runs MOLA-LO live on point clouds received from a ROS 2 topic, demonstrating a few features:
Tip
See the MOLA in ROS 2 cookbook for a configuration-by-configuration walkthrough (Simple vs Smoother, namespaced, GNSS modes, etc.) with live-editable commands.
Launching and visualizing LO in both,
mola_vizandRViz2(or use FoxGlove if preferred).How MOLA
mola_lidar_odometrypublishes the local map, the estimated trajectory, and /tf for the estimated odometry.
# Minimal LO use case (requires correct LiDAR sensor /tf), without
# wheel odometry, so map -> base_link is published (no "odom" frame):
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
lidar_topic_name:=ouster/points \
publish_localization_following_rep105:=False
# LO usage without sensor /tf:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
lidar_topic_name:=ouster/points \
ignore_lidar_pose_from_tf:=True \
publish_localization_following_rep105:=False
This is how to use LiDAR-Inertial Odometry (LIO) by using LiDAR clouds plus an IMU:
# Example LIO usage for Ouster LiDAR + integrated IMU:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
mola_deskew_method:=MotionCompensationMethod::IMU \
lidar_topic_name:=/ouster/points \
imu_topic_name:=/ouster/imu \
mola_tf_base_link:=os_sensor \
publish_localization_following_rep105:=False
This is how to use LiDAR-Inertial Odometry (LIO) by using LiDAR clouds plus an IMU, when no /tf is available for the sensor poses so you must manually specify them:
# Example LIO usage for LiDAR + IMU for Oxford Spires Dataset:
IMU_POSE_YAW=90 \
LIDAR_POSE_YAW=180 \
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
mola_deskew_method:=MotionCompensationMethod::IMU \
lidar_topic_name:=/hesai/pandar \
imu_topic_name:=/alphasense_driver_ros/imu \
ignore_lidar_pose_from_tf:=True \
ignore_imu_pose_from_tf:=True \
publish_localization_following_rep105:=False
To replay a recorded bag with simulated time (required when playing .mcap or .db3 bags):
# Terminal 1: launch MOLA-LO with sim time enabled:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
lidar_topic_name:=/ouster/points \
use_sim_time:=true
# Terminal 2: play the bag and publish the /clock topic:
ros2 bag play /path/to/your/bag --clock
Note
Both use_sim_time:=true and --clock are required together.
--clock makes the bag publish on /clock; use_sim_time:=true
makes all nodes subscribe to it instead of the wall clock.
If your robot uses a ROS 2 namespace ROBOT_NS for all its sensor and tf topics, use:
# Minimal use case:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
lidar_topic_name:=ouster/points \
use_namespace:=True \
namespace:=ROBOT_NS
To use with a 2D LiDAR, define the argument lidar_topic_type:=LaserScan, e.g.:
# Minimal use case:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py \
lidar_topic_name:=/scan \
lidar_topic_type:=LaserScan \
mola_lo_pipeline:=../pipelines/lidar2d.yaml \
ignore_lidar_pose_from_tf:=False \
publish_localization_following_rep105:=True
How to invoke for a rosbag (.mcap, .db3)
You can also directly run MOLA-LO on a dataset instead of live ROS messages, which is normally more efficient. See MOLA-LO GUI apps for all the details.
To play a bag through the ROS 2 launch file with correct simulated time, use the
use_sim_time:=true argument together with ros2 bag play --clock.
See the Rosbag playback tab above for the full example.
Note however that MOLA-LO GUI apps can directly read rosbags
without the need to replay them.
# Example: run MOLA-LIO on a Ouster dataset.
MOLA_DESKEW_METHOD=MotionCompensationMethod::IMU \
MOLA_IMU_TOPIC=/ouster/imu \
MOLA_LIDAR_TOPIC=/ouster/points \
MOLA_TF_BASE_LINK=os_sensor \
mola-lo-gui-rosbag2 /path/to/your/dataset.mcap
All launch arguments
This listing is kept in sync with ros2-lidar-odometry.launch.py. You can always regenerate it locally with:
ros2 launch mola_lidar_odometry ros2-lidar-odometry.launch.py --show-args
Arguments (pass as <name>:=<value>):
attitude_imu_topic_name(default"", disabled): Optional secondsensor_msgs/Imutopic with absolute attitude (e.g. an AHRS). Its readings are only stored into simplemap keyframes, for later geo-referencing, instead of those ofimu_topic_name.camera_topic_name(default"", disabled): Optionalsensor_msgs/Imagetopics, comma-separated, up to three (labelscamera,camera_1,camera_2). Their images are only stored into simplemap keyframes, one of each camera per keyframe, the closest in time (MOLA_SIMPLEMAP_ATTACH_LABEL, set to their labels by the launch file unless already set), e.g. for visual place recognition. Needsgenerate_simplemap:=Trueand aBridgeROS2with image support. Raw images only (notCompressedImage), and the camera frames must be in/tf(or use the fixed poses below). Use low-rate topics: every image is decoded.enforce_planar_motion(defaultFalse): Whether to enforce z, pitch, and roll to be zero.estimate_geo_reference(default"") [Smoother only]: Whether to estimate the best geo-referencing for{enu} -> {map}from incoming GNSS readings. If empty (default), the pipeline YAML fallback is used (false) andgnss_mode:=live_georefmay flip it totrueautomatically.forward_ros_tf_odom_to_mola(defaultFalse): Whether to import an existing/tfodom → base_linkodometry (2DCObservationOdometry). Mutually exclusive withodom_topic_name.generate_simplemap(defaultFalse): Whether to create a.simplemap.gnss_mode(defaultnone): High-level GNSS usage:none | log_only | live_georef | relocalize.live_georefandrelocalizerequireuse_state_estimator:=True.gnss_topic_name(defaultgps): Topic name to listen forNavSatFixinput from a GNSS (e.g./gps).gpsfix_topic_name(defaultgpsfix): Topic name to listen forgps_msgs/GPSFixinput from a GNSS (e.g./gpsfix).ignore_imu_pose_from_tf(defaultfalse): Iftrue, the IMU pose is assumed to be at the origin (base_link). Leavefalseif you want to read the actual sensor pose from/tf.ignore_lidar_pose_from_tf(defaultfalse): Iftrue, the LiDAR pose is assumed to be at the origin (base_link). Leavefalseif you want to read the actual sensor pose from/tf.imu_gravity_avg_samples(default20): Number of IMU samples to average when estimating the gravity direction for pitch/roll correction.imu_gravity_correction(defaulttrue): Whether to use IMU accelerometer readings to constrain ICP pitch/roll (prevents vertical drift; safe to leave enabled even without an IMU).imu_gravity_max_age(default2.0): Maximum age [seconds] of IMU samples used for gravity alignment. Older samples are discarded.imu_gravity_sigma_deg(default2.0): Sigma [degrees] for the gravity-derived pitch/roll prior. Lower = more trust in IMU.imu_topic_name(defaultimu): Topic name to listen forImuinput (e.g./imu).imu_qos_reliability(defaultbest_effort): QoS reliability of the IMU subscription. Options:best_effortorreliable. Defaults tobest_effortper REP-2003. Set toreliableto match a reliable high-rate publisher (e.g. Ouster’s 640 Hz IMU) and avoid silent drops. The publisher must also bereliablefor end-to-end reliable delivery.imu_qos_depth(default50): QoS history depth of the IMU subscription. The default of 50 absorbs moderate executor stalls; raise (e.g. 200-1000) for high-rate IMUs consumed together with a heavy SLAM pipeline.lidar_qos_reliability(defaultbest_effort): QoS reliability of the LiDAR subscription. Options:best_effortorreliable. Seeimu_qos_reliabilityfor guidance.lidar_qos_depth(default50): QoS history depth of the LiDAR subscription.initial_localization_method(default""): Initial-localization method. Options:InitLocalization::FixedPose(start at identity or given pose),InitLocalization::FromStateEstimator(wait for smoother convergence, e.g. from GNSS),InitLocalization::PitchAndRollFromIMU(use IMU to estimate pitch/roll at startup, assumes sensor stationary). If empty (default), the pipeline YAML fallback is used (FixedPose) andgnss_mode:=relocalizemay switch it toFromStateEstimator.initial_pose(default""): Known initial pose forInitLocalization::FixedPose, as"[x, y, z, yaw_deg, pitch_deg, roll_deg]"in the frame of the loaded map. If empty (default), the pipeline YAML fallback is used (the origin, orMOLA_INITIAL_X,_Y,_Z,_YAW,_PITCH,_ROLL).lidar_scan_validity_minimum_point_count(default100): Minimum number of points required in an incoming LiDAR scan for it to be processed; scans below this threshold are discarded.lidar_topic_name(required): Topic name to listen for LiDAR input, e.g./ouster/pointsforPointCloud2or/scanforLaserScan. Seelidar_topic_type.lidar_topic_type(defaultPointCloud2): The type of LiDAR topic to subscribe to. Options:PointCloud2orLaserScan.localization_publish_tf_source(default""): Which localization source (method) is published to/tf. If empty (default),state_estimationwithuse_state_estimator:=True, elselidar_odometry. With the smoother publishingmap → odomitself (MOLA_PUBLISH_MAP_TO_ODOM_TF=true), set it tostate_estimation/map_odom.mola_bridge_odometry_frame(defaultodom): BridgeROS2’s odom/tfframe name (the REP-105 “odom” child or the parent of an externally-published odometry TF).mola_deskew_method(defaultMotionCompensationMethod::Linear): Motion-compensation (deskew) method for LiDAR scans. Options:MotionCompensationMethod::None,MotionCompensationMethod::Linear(constant-velocity),MotionCompensationMethod::IMU(requires an IMU topic; useuse_imu_for_lio:=Trueas the higher-level shortcut).mola_footprint_to_base_link_tf(default[0, 0, 0, 0, 0, 0]): Custom transformation betweenbase_footprintandbase_link, as[x, y, z, yaw_deg, pitch_deg, roll_deg].mola_initial_map_mm_file(default""): Optional path to a metric map.mmfile to load as the initial map.mola_initial_map_sm_file(default""): Optional path to a keyframes.simplemapfile to load.mola_lo_pipeline(default../pipelines/lidar3d-default.yaml): The LO pipeline configuration YAML file. A relative path is relative to the installedshare/mola_lidar_odometry/mola-cli-launchs/directory, so the provided pipelines can be given as../pipelines/<name>.yaml.mola_lo_reference_frame(defaultmap): Parent/tfframe of the localization update emitted by MOLA-LO (thereference_frameof itsLocalizationUpdate; see ROS 2 API docs on published/tf).mola_state_estimator_reference_frame(defaultmap): Parent/tfframe of the pose updates emitted by the MOLA State Estimator, and BridgeROS2’sreference_frameparameter.mola_tf_base_link(defaultbase_link): The/tfframe name for the robot base link.namespace(default""): Top-level ROS 2 namespace to push the MOLA stack into (together withuse_namespace:=True).odom_sensor_label(defaultodom_wheels):sensorLabelattached to observations fromodom_topic_name. Use distinct labels per source when fusing multiple external odometries.odom_topic_name(default""): If non-empty, BridgeROS2 subscribes directly to thisnav_msgs/Odometrytopic and forwards each message as a 3DCObservationRobotPose(6×6 covariance), preferred for smoother fusion. Mutually exclusive withforward_ros_tf_odom_to_mola. WithMOLA_ODOM_AS_ROBOT_POSE_OBS=false, it is forwarded as a planarCObservationOdometryinstead, which the smoother fuses with its wheel odometry motion model (odom_motion_model_a1..a4) rather than with therelative_pose_increment_sigma_*shared by every pose source (e.g. LiDAR odometry published in its own frame), so wheels and LiDAR odometry can be weighted apart.publish_local_map(defaultTrue): Whether to publish the local map as a point cloud on/lidar_odometry/localmap_points. Copying a large map out costs CPU and bandwidth; disable it if nothing consumes it. As for all map topics (REP-2003), it is published as reliable and transient-local, and only when the map changes: subscribe with the same QoS. A best-effort subscriber gets no retransmission of lost fragments, so it may silently miss large clouds.publish_localization_following_rep105(defaultTrue): Whether the bridge publishes localization TFs asmap → odom(REP-105, true) or directlymap → base_link(false). REP-105 needs anodom → base_linkfrom another source (e.g. wheel odometry): set it tofalseif there is none. Recent bridge versions fall back tomap → base_linkwhen noodomframe appears within a few seconds. It works with both state estimators.start_active(defaultTrue): Whether MOLA-LO starts active (processing incoming sensor data) or idle.min_nearby_poses_occupied(default1): Minimum number of stored scans from a pose region before that region is considered “occupied” in the local map distance checker and no new keyframe is inserted there. The default of1reproduces the classic behavior. Increase to2or more for non-repetitive-scan lidars (e.g. Livox) so that multiple scans are accumulated from each location before moving on. Maps to the env varMOLA_MIN_NEARBY_POSES_OCCUPIEDand the pipeline YAML keylocal_map_updates.min_nearby_poses_occupied.simplemap_min_nearby_poses(default1): Same asmin_nearby_poses_occupiedbut for the simplemap keyframe insertion. Maps to the env varMOLA_SIMPLEMAP_MIN_NEARBY_POSESand the pipeline YAML keysimplemap.min_nearby_poses_occupied.start_mapping_enabled(defaultTrue): Whether MOLA-LO starts with map update enabled, or in localization-only mode.state_estimator_config_yaml(default""): Path to estimator YAML. If empty, it is auto-resolved based onuse_state_estimator.use_diagnostic_aggregator(defaultFalse): Launch a standalonediagnostic_aggregatorwith the bundled MOLA-LO config (publishes/diagnostics_aggforrqt_robot_monitor). Enable only for isolated bring-up/demos; leave disabled when a central aggregator is launched elsewhere in the robot stack. See ROS 2 Diagnostics (REP-107).use_imu_for_lio(defaultFalse): Iftrue, enables LIO mode (forcesMotionCompensationMethod::IMUfor deskew). Requires a workingimu_topic_name.use_mola_gui(defaultTrue): Whether to open the MolaViz GUI for live mapping visualization and control.use_namespace(defaultfalse): Whether to applynamespaceto the MOLA stack (remaps/tfand/tf_static).use_namespaced_tf(defaulttrue): Withuse_namespace:=True, whether/tfand/tf_staticare also namespaced. Set it tofalsefor namespaced sensor topics with global/tfand/tf_static.use_rviz(defaultTrue): Whether to launch RViz2 with the defaultlidar-odometry.rvizconfiguration.use_sim_time(defaultfalse): Iftrue, all nodes use the/clocktopic as their time source instead of the system wall clock. Enable this when replaying a rosbag withros2 bag play --clock.use_state_estimator(defaultFalse): Iftrue, usesStateEstimationSmoother(requires the optionalmola_state_estimation_smootherpackage).
Smoother-only arguments (applied only when use_state_estimator:=True):
navstate_imu_gravity_alignment_sigma(default empty): Sigma [deg] of the IMU accelerometer gravity factor (0disables it). Empty means0in localization-only mode (start_mapping_enabled:=False), since the loaded map is already gravity-aligned, and the smoother default when mapping. AMOLA_IMU_GRAVITY_ALIGNMENT_SIGMAenvironment variable is respected.navstate_kinematic_model(default empty,KinematicModel::ConstantVelocityin the smoother): Kinematic model for internal motion-model factors. Options:KinematicModel::ConstantVelocity,KinematicModel::Tricycle.navstate_sigma_random_walk_angacc(default empty,10.0in the smoother): Random-walk angular acceleration uncertainty [rad/s²].navstate_sigma_random_walk_linacc(default empty,0.5in the smoother): Random-walk linear acceleration uncertainty [m/s²].navstate_sliding_window_sec(default empty,6.0in the smoother): Time window [seconds] to keep past observations in the filter.
Configure sensor inputs for ROS 2 node and rosbag2 input
The following environment variables can be set to change the behavior of how BridgeROS2
handles input ROS 2 messages on sensor inputs.
Please, refer to the actual mola-cli launch files where these variables are defined:
Environment variables:
MOLA_TF_BASE_LINK(Default:"base_link"): The robot reference frame id in/tf. Used to get sensor poses with respect to the vehicle.MOLA_TF_FOOTPRINT_LINK(Default:base_footprint): If not empty, the node will broadcast a static /tf from base_footprint to base_link with the TF base_footprint_to_base_link_tf at start up.MOLA_TF_FOOTPRINT_TO_BASE_LINK(Default:'[0, 0, 0, 0, 0, 0]'): [x, y, z, yaw_deg, pitch_deg, roll_deg].MOLA_LIDAR_TOPIC(Default:'/ouster/points'): Thesensor_msgs/PointCloud2topic with raw LiDAR data (mandatory).MOLA_USE_FIXED_LIDAR_POSE(Default:false): If false, sensor pose will be retrieved from/tf. You can also set it to true and then the sensor pose will be given by these env. variables:LIDAR_POSE_X,LIDAR_POSE_Y,LIDAR_POSE_Z(in meters).LIDAR_POSE_YAW,LIDAR_POSE_PITCH,LIDAR_POSE_ROLL(in degrees).
MOLA_LIDAR_TIME_OFFSET(Default:0.0): A constant correction, in seconds, added to the LiDAR stamps, e.g. for a driver that stamps each cloud at the end of its sweep. ROS 1 bags only (rosbag1 launch andmola-lidar-odometry-cliwith a.bag); not available for ROS 2 bags or live input.MOLA_GNSS_TOPIC(Default:'/gps'): Thesensor_msgs/NavSatFixtopic with GNSS data (optional).MOLA_USE_FIXED_GNSS_POSE(Default:false): If false, sensor pose will be retrieved from/tf. You can also set it to true and then the sensor pose will be given by these env. variables:GNSS_POSE_X,GNSS_POSE_Y,GNSS_POSE_Z(in meters).GNSS_POSE_YAW,GNSS_POSE_PITCH,GNSS_POSE_ROLL(in degrees).
MOLA_IMU_TOPIC(Default:'/imu'): Thesensor_msgs/Imutopic with IMU data (optional).MOLA_USE_FIXED_IMU_POSE(Default:false): If false, sensor pose will be retrieved from/tf. You can also set it to true and then the sensor pose will be given by these env. variables:IMU_POSE_X,IMU_POSE_Y,IMU_POSE_Z(in meters).IMU_POSE_YAW,IMU_POSE_PITCH,IMU_POSE_ROLL(in degrees).
MOLA_ATTITUDE_IMU_TOPIC(Default: empty, disabled): A secondsensor_msgs/Imutopic with absolute attitude (e.g. an AHRS), stored into simple-map keyframes for geo-referencing instead ofMOLA_IMU_TOPIC. Setting the topic is enough withmola-lo-gui-rosbag2,mola-lo-cli-rosbag2and the ROS 2 launch file (attitude_imu_topic_name:=). Runninglidar_odometry_from_rosbag2.yamldirectly withmola-clialso needsMOLA_ATTITUDE_IMU_NAME=imu_attitude(see pipeline sensor inputs).MOLA_CAMERA_TOPIC,MOLA_CAMERA_TOPIC_1,MOLA_CAMERA_TOPIC_2(Default: empty, disabled): Up to threesensor_msgs/Imagetopics (labelsMOLA_CAMERA_SENSOR_NAME,_1,_2, defaultscamera,camera_1,camera_2), whose images are stored into simple-map keyframes ifMOLA_SIMPLEMAP_ATTACH_LABELmatches their labels (the ROS 2 launch file sets all of them withcamera_topic_name:=).MOLA_CAMERA_QOS_DEPTH(Default:5) andMOLA_CAMERA_QOS_RELIABILITY(Default:best_effort), live only.MOLA_USE_FIXED_CAMERA_POSE(Default:false): If false, the camera pose will be retrieved from/tf. Else, fromCAMERA_POSE_X,CAMERA_POSE_Y,CAMERA_POSE_Z(in meters) andCAMERA_POSE_YAW,CAMERA_POSE_PITCH,CAMERA_POSE_ROLL(in degrees). The same for the other two cameras withMOLA_USE_FIXED_CAMERA_1_POSE/CAMERA_1_POSE_*andMOLA_USE_FIXED_CAMERA_2_POSE/CAMERA_2_POSE_*(ROS 2 node and rosbag1 inputs).
More LO parameters
If using the default pipeline, the lidar3d-gicp.yaml pipeline file defines plenty
of additional parameters and options that you can explore.
See also the docs for the ROS 2 API and this tutorial on how to save and load a map using ROS 2 MOLA-LO nodes.
Large point clouds and Fast DDS: late /tf
With the default Fast DDS settings (the default ROS 2 middleware, e.g. in Jazzy), nodes that
subscribe to large point clouds may receive small messages such as /tf late. Messages
larger than the default shared memory segments (512 KB) go through fragmented UDP, and in a
simulation publishing ~1 MB clouds at 10 Hz this delayed /tf by up to ~1 s in the nodes
subscribed to them.
Symptoms: transform lookups at the scan stamp fail (“extrapolation into the future”,
“no transform at the scan’s stamp”), map -> odom seems to lag the LiDAR by about a
second, or obstacles end up misplaced, or a local map goes stale. This can affect any node
that needs timely /tf and also receives the clouds, including MOLA when sensor poses are
read from /tf (MOLA_USE_FIXED_LIDAR_POSE=false).
Fix: use shared memory segments large enough for the clouds, with a Fast DDS profile:
<?xml version="1.0" encoding="UTF-8"?>
<profiles xmlns="http://www.eprosima.com/XMLSchemas/fastRTPS_Profiles">
<transport_descriptors>
<transport_descriptor>
<transport_id>shm_large</transport_id>
<type>SHM</type>
<segment_size>16777216</segment_size>
</transport_descriptor>
<transport_descriptor>
<transport_id>udp_buffers</transport_id>
<type>UDPv4</type>
<sendBufferSize>4194304</sendBufferSize>
<receiveBufferSize>4194304</receiveBufferSize>
</transport_descriptor>
</transport_descriptors>
<participant profile_name="large_msgs_participant" is_default_profile="true">
<rtps>
<userTransports>
<transport_id>shm_large</transport_id>
<transport_id>udp_buffers</transport_id>
</userTransports>
<useBuiltinTransports>false</useBuiltinTransports>
</rtps>
</participant>
</profiles>
Enable it for all nodes, before launching them:
export FASTRTPS_DEFAULT_PROFILES_FILE=/path/to/fastdds_large_msgs.xml
In that simulation, the /tf delay dropped to below 0.3 s. Each DDS participant (one per
process in ROS 2, by default) reserves one segment in /dev/shm: in Docker, whose
default /dev/shm is 64 MB, raise it
(shm_size: "1gb" in compose, or docker run --shm-size=1g), or Fast DDS falls back to
UDP. The UDP buffer sizes above are capped by the kernel limits
(net.core.rmem_max, net.core.wmem_max). Another ROS 2 middleware (e.g. Cyclone DDS)
may also avoid the issue, but was not tested here.
3.2. ROS 2 launch file: LiDAR odometry for KITTI¶
This demo launch file (view sources) runs MOLA-LO on a sequence of the KITTI odometry dataset [GLSU13], demonstrating a few features:
Launching and visualizing LO in both,
mola_vizandRViz2(or use FoxGlove if preferred).How MOLA core modules and
mola_lidar_odometrypublish raw observations from a dataset, the local map, the estimated trajectory, and /tf for the vehicle and all sensors.
How to run it
Download the KITTI Odometry dataset and extract them anywhere, such as the files layout matches the expected tree structure described in class mola::KittiOdometryDataset.
Set the environment variable
KITTI_BASE_DIRto the root “KITTI” directory in the tree layout above:export KITTI_BASE_DIR=/path/to/dataset/
And run it for the desired sequence number:
ros2 launch mola_lidar_odometry kitti-ros2-lidar-odometry.launch.py kitti_sequence:=00
4. Running from ROS 1 bags¶
ROS 1 bags (.bag) are read directly, with no ROS 1 installation needed, by
mola-lo-gui-rosbag1 and mola-lo-cli-rosbag1, or by mola-lidar-odometry-cli --input-rosbag1.
Several bags can be given at once, and are replayed jointly as one merged stream.
See ROS 1 bags.
They can also be converted, e.g. to use other tools: to ROS 2 bags (4. ROS1 ⇒ ROS2) or to MRPT rawlogs (2. rosbag ⇒ rawlog, ROS 1 version).

