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.

_images/gui_parts.png

The labeled parts in the GUI are:

  1. 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”.

  2. 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!).

  3. Main subwindows control panel: You can minimize, restore, etc. subwindows from here.

  4. Raw LiDAR view: A subwindow with the details (type of observation, timestamp, etc.) of incoming raw scans.

  5. Camera view: Although not used by the LO, it is useful sometimes to see the environment from camera images.

  6. 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.

  7. Log messages with priority higher than INFO will 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.

MolaVizImGui (default)

MolaViz

MolaVizImGui GUI screenshot MolaViz GUI screenshot

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 to true to 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 installed lidar3d-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 to false to run a mola-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::MolaVizImGui only. 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_viz and RViz2 (or use FoxGlove if preferred).

  • How MOLA mola_lidar_odometry publishes the local map, the estimated trajectory, and /tf for the estimated odometry.

https://mrpt.github.io/imgs/mola-lo-ros2-launch-demo-live-forest.png
# 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 second sensor_msgs/Imu topic with absolute attitude (e.g. an AHRS). Its readings are only stored into simplemap keyframes, for later geo-referencing, instead of those of imu_topic_name.

  • camera_topic_name (default "", disabled): Optional sensor_msgs/Image topics, comma-separated, up to three (labels camera, 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. Needs generate_simplemap:=True and a BridgeROS2 with image support. Raw images only (not CompressedImage), 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 (default False): 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) and gnss_mode:=live_georef may flip it to true automatically.

  • forward_ros_tf_odom_to_mola (default False): Whether to import an existing /tf odom → base_link odometry (2D CObservationOdometry). Mutually exclusive with odom_topic_name.

  • generate_simplemap (default False): Whether to create a .simplemap.

  • gnss_mode (default none): High-level GNSS usage: none | log_only | live_georef | relocalize. live_georef and relocalize require use_state_estimator:=True.

  • gnss_topic_name (default gps): Topic name to listen for NavSatFix input from a GNSS (e.g. /gps).

  • gpsfix_topic_name (default gpsfix): Topic name to listen for gps_msgs/GPSFix input from a GNSS (e.g. /gpsfix).

  • ignore_imu_pose_from_tf (default false): If true, the IMU pose is assumed to be at the origin (base_link). Leave false if you want to read the actual sensor pose from /tf.

  • ignore_lidar_pose_from_tf (default false): If true, the LiDAR pose is assumed to be at the origin (base_link). Leave false if you want to read the actual sensor pose from /tf.

  • imu_gravity_avg_samples (default 20): Number of IMU samples to average when estimating the gravity direction for pitch/roll correction.

  • imu_gravity_correction (default true): 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 (default 2.0): Maximum age [seconds] of IMU samples used for gravity alignment. Older samples are discarded.

  • imu_gravity_sigma_deg (default 2.0): Sigma [degrees] for the gravity-derived pitch/roll prior. Lower = more trust in IMU.

  • imu_topic_name (default imu): Topic name to listen for Imu input (e.g. /imu).

  • imu_qos_reliability (default best_effort): QoS reliability of the IMU subscription. Options: best_effort or reliable. Defaults to best_effort per REP-2003. Set to reliable to match a reliable high-rate publisher (e.g. Ouster’s 640 Hz IMU) and avoid silent drops. The publisher must also be reliable for end-to-end reliable delivery.

  • imu_qos_depth (default 50): 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 (default best_effort): QoS reliability of the LiDAR subscription. Options: best_effort or reliable. See imu_qos_reliability for guidance.

  • lidar_qos_depth (default 50): 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) and gnss_mode:=relocalize may switch it to FromStateEstimator.

  • initial_pose (default ""): Known initial pose for InitLocalization::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, or MOLA_INITIAL_X, _Y, _Z, _YAW, _PITCH, _ROLL).

  • lidar_scan_validity_minimum_point_count (default 100): 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/points for PointCloud2 or /scan for LaserScan. See lidar_topic_type.

  • lidar_topic_type (default PointCloud2): The type of LiDAR topic to subscribe to. Options: PointCloud2 or LaserScan.

  • localization_publish_tf_source (default ""): Which localization source (method) is published to /tf. If empty (default), state_estimation with use_state_estimator:=True, else lidar_odometry. With the smoother publishing map → odom itself (MOLA_PUBLISH_MAP_TO_ODOM_TF=true), set it to state_estimation/map_odom.

  • mola_bridge_odometry_frame (default odom): BridgeROS2’s odom /tf frame name (the REP-105 “odom” child or the parent of an externally-published odometry TF).

  • mola_deskew_method (default MotionCompensationMethod::Linear): Motion-compensation (deskew) method for LiDAR scans. Options: MotionCompensationMethod::None, MotionCompensationMethod::Linear (constant-velocity), MotionCompensationMethod::IMU (requires an IMU topic; use use_imu_for_lio:=True as the higher-level shortcut).

  • mola_footprint_to_base_link_tf (default [0, 0, 0, 0, 0, 0]): Custom transformation between base_footprint and base_link, as [x, y, z, yaw_deg, pitch_deg, roll_deg].

  • mola_initial_map_mm_file (default ""): Optional path to a metric map .mm file to load as the initial map.

  • mola_initial_map_sm_file (default ""): Optional path to a keyframes .simplemap file to load.

  • mola_lo_pipeline (default ../pipelines/lidar3d-default.yaml): The LO pipeline configuration YAML file. A relative path is relative to the installed share/mola_lidar_odometry/mola-cli-launchs/ directory, so the provided pipelines can be given as ../pipelines/<name>.yaml.

  • mola_lo_reference_frame (default map): Parent /tf frame of the localization update emitted by MOLA-LO (the reference_frame of its LocalizationUpdate; see ROS 2 API docs on published /tf).

  • mola_state_estimator_reference_frame (default map): Parent /tf frame of the pose updates emitted by the MOLA State Estimator, and BridgeROS2’s reference_frame parameter.

  • mola_tf_base_link (default base_link): The /tf frame name for the robot base link.

  • namespace (default ""): Top-level ROS 2 namespace to push the MOLA stack into (together with use_namespace:=True).

  • odom_sensor_label (default odom_wheels): sensorLabel attached to observations from odom_topic_name. Use distinct labels per source when fusing multiple external odometries.

  • odom_topic_name (default ""): If non-empty, BridgeROS2 subscribes directly to this nav_msgs/Odometry topic and forwards each message as a 3D CObservationRobotPose (6×6 covariance), preferred for smoother fusion. Mutually exclusive with forward_ros_tf_odom_to_mola. With MOLA_ODOM_AS_ROBOT_POSE_OBS=false, it is forwarded as a planar CObservationOdometry instead, which the smoother fuses with its wheel odometry motion model (odom_motion_model_a1..a4) rather than with the relative_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 (default True): 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 (default True): Whether the bridge publishes localization TFs as map → odom (REP-105, true) or directly map → base_link (false). REP-105 needs an odom → base_link from another source (e.g. wheel odometry): set it to false if there is none. Recent bridge versions fall back to map → base_link when no odom frame appears within a few seconds. It works with both state estimators.

  • start_active (default True): Whether MOLA-LO starts active (processing incoming sensor data) or idle.

  • min_nearby_poses_occupied (default 1): 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 of 1 reproduces the classic behavior. Increase to 2 or 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 var MOLA_MIN_NEARBY_POSES_OCCUPIED and the pipeline YAML key local_map_updates.min_nearby_poses_occupied.

  • simplemap_min_nearby_poses (default 1): Same as min_nearby_poses_occupied but for the simplemap keyframe insertion. Maps to the env var MOLA_SIMPLEMAP_MIN_NEARBY_POSES and the pipeline YAML key simplemap.min_nearby_poses_occupied.

  • start_mapping_enabled (default True): 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 on use_state_estimator.

  • use_diagnostic_aggregator (default False): Launch a standalone diagnostic_aggregator with the bundled MOLA-LO config (publishes /diagnostics_agg for rqt_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 (default False): If true, enables LIO mode (forces MotionCompensationMethod::IMU for deskew). Requires a working imu_topic_name.

  • use_mola_gui (default True): Whether to open the MolaViz GUI for live mapping visualization and control.

  • use_namespace (default false): Whether to apply namespace to the MOLA stack (remaps /tf and /tf_static).

  • use_namespaced_tf (default true): With use_namespace:=True, whether /tf and /tf_static are also namespaced. Set it to false for namespaced sensor topics with global /tf and /tf_static.

  • use_rviz (default True): Whether to launch RViz2 with the default lidar-odometry.rviz configuration.

  • use_sim_time (default false): If true, all nodes use the /clock topic as their time source instead of the system wall clock. Enable this when replaying a rosbag with ros2 bag play --clock.

  • use_state_estimator (default False): If true, uses StateEstimationSmoother (requires the optional mola_state_estimation_smoother package).

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 (0 disables it). Empty means 0 in localization-only mode (start_mapping_enabled:=False), since the loaded map is already gravity-aligned, and the smoother default when mapping. A MOLA_IMU_GRAVITY_ALIGNMENT_SIGMA environment variable is respected.

  • navstate_kinematic_model (default empty, KinematicModel::ConstantVelocity in the smoother): Kinematic model for internal motion-model factors. Options: KinematicModel::ConstantVelocity, KinematicModel::Tricycle.

  • navstate_sigma_random_walk_angacc (default empty, 10.0 in the smoother): Random-walk angular acceleration uncertainty [rad/s²].

  • navstate_sigma_random_walk_linacc (default empty, 0.5 in the smoother): Random-walk linear acceleration uncertainty [m/s²].

  • navstate_sliding_window_sec (default empty, 6.0 in 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'): The sensor_msgs/PointCloud2 topic 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 and mola-lidar-odometry-cli with a .bag); not available for ROS 2 bags or live input.

  • MOLA_GNSS_TOPIC (Default: '/gps'): The sensor_msgs/NavSatFix topic 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'): The sensor_msgs/Imu topic 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 second sensor_msgs/Imu topic with absolute attitude (e.g. an AHRS), stored into simple-map keyframes for geo-referencing instead of MOLA_IMU_TOPIC. Setting the topic is enough with mola-lo-gui-rosbag2, mola-lo-cli-rosbag2 and the ROS 2 launch file (attitude_imu_topic_name:=). Running lidar_odometry_from_rosbag2.yaml directly with mola-cli also needs MOLA_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 three sensor_msgs/Image topics (labels MOLA_CAMERA_SENSOR_NAME, _1, _2, defaults camera, camera_1, camera_2), whose images are stored into simple-map keyframes if MOLA_SIMPLEMAP_ATTACH_LABEL matches their labels (the ROS 2 launch file sets all of them with camera_topic_name:=). MOLA_CAMERA_QOS_DEPTH (Default: 5) and MOLA_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, from CAMERA_POSE_X, CAMERA_POSE_Y, CAMERA_POSE_Z (in meters) and CAMERA_POSE_YAW, CAMERA_POSE_PITCH, CAMERA_POSE_ROLL (in degrees). The same for the other two cameras with MOLA_USE_FIXED_CAMERA_1_POSE / CAMERA_1_POSE_* and MOLA_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_viz and RViz2 (or use FoxGlove if preferred).

  • How MOLA core modules and mola_lidar_odometry publish raw observations from a dataset, the local map, the estimated trajectory, and /tf for the vehicle and all sensors.

https://mrpt.github.io/imgs/mola-lo-ros2-launch-demo-kitti.png
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_DIR to 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).