LiDAR-based SLAM (gmapping, cartographer) in ROS - Deep Dive

Overview - LiDAR-based SLAM (gmapping, cartographer)

What is it?

LiDAR-based SLAM is a method robots use to build a map of an unknown place while figuring out where they are inside it. It uses a LiDAR sensor that sends out laser beams to measure distances to nearby objects. Gmapping and Cartographer are popular software tools that help robots do this mapping and localization automatically. They process the LiDAR data to create a map and track the robot's position in real time.

Why it matters

Without LiDAR-based SLAM, robots would get lost in new environments because they wouldn't know where they are or what the space looks like. This technology lets robots explore, navigate, and work safely without needing pre-made maps or GPS. It makes robots smarter and more useful in places like homes, warehouses, and outdoors where GPS might not work well.

Where it fits

Before learning LiDAR-based SLAM, you should understand basic robotics concepts like sensors, coordinate systems, and robot movement. After this, you can explore advanced topics like multi-sensor fusion, 3D SLAM, and autonomous navigation planning. This topic fits in the middle of a robotics learning path, bridging sensing and intelligent movement.

Mental Model

Core Idea

LiDAR-based SLAM lets a robot simultaneously build a map of its surroundings and figure out its location using laser distance measurements.

Think of it like...

Imagine walking blindfolded in a dark room with a flashlight that shines a laser line on walls and furniture. By seeing where the laser hits, you slowly draw a map on paper and know where you are inside the room at the same time.

┌───────────────┐       ┌───────────────┐
│   LiDAR Data  │──────▶│  SLAM System  │
└───────────────┘       └───────────────┘
          │                      │
          ▼                      ▼
   Distance Scans          Map + Position
          │                      │
          └──────────────┬───────┘
                         ▼
                  Robot Navigation

Build-Up - 7 Steps

1

Foundation

Understanding LiDAR Sensor Basics

Concept: Learn what LiDAR sensors do and how they measure distances using laser beams.

LiDAR sensors send out laser pulses and measure how long it takes for the light to bounce back from objects. This time tells the distance to those objects. The sensor spins or scans to collect many distance points, creating a 2D or 3D picture of the surroundings called a point cloud.

Result

You get a set of distance measurements representing the shape and position of nearby objects.

Understanding how LiDAR works is key because SLAM depends on accurate distance data to build maps and locate the robot.

2

Foundation

What is SLAM and Why It’s Needed

Concept: Introduce the problem SLAM solves: mapping and localization at the same time.

SLAM stands for Simultaneous Localization and Mapping. A robot needs to know where it is (localization) and what the environment looks like (mapping). Doing both together is hard because each depends on the other. SLAM algorithms use sensor data to solve this chicken-and-egg problem.

Result

You understand the core challenge SLAM addresses and why it’s essential for autonomous robots.

Knowing SLAM’s dual goal helps you appreciate why algorithms like gmapping and Cartographer are complex and powerful.

3

Intermediate

How Gmapping Uses Particle Filters

🤔Before reading on: do you think Gmapping guesses robot position by trying many possibilities at once or by following a single guess? Commit to your answer.

Concept: Gmapping uses a particle filter to track many possible robot positions and pick the best one.

Gmapping creates many 'particles,' each representing a guess of where the robot might be. Each particle has its own map estimate. As new LiDAR scans come in, particles update their guesses based on how well the scan fits their map. Over time, particles that don't match well are discarded, and the best guess emerges.

Result

The robot can localize itself and build a map even with noisy data and uncertainty.

Understanding particle filters reveals how SLAM handles uncertainty and avoids getting lost by considering multiple hypotheses.

4

Intermediate

Cartographer’s Scan Matching and Optimization

🤔Before reading on: do you think Cartographer builds maps by only looking at current scans or by comparing many scans together? Commit to your answer.

Concept: Cartographer uses scan matching and optimization to align multiple LiDAR scans and improve map accuracy.

Cartographer compares new LiDAR scans to previous scans and the current map to find the best alignment. It uses optimization techniques to adjust the robot’s estimated path and the map simultaneously. This approach reduces errors and creates smoother, more accurate maps.

Result

The robot produces high-quality maps and precise localization even in complex environments.

Knowing Cartographer’s optimization approach shows how combining many data points improves SLAM beyond simple filtering.

5

Intermediate

Integrating SLAM with ROS Ecosystem

Concept: Learn how gmapping and Cartographer fit into ROS and communicate with other robot parts.

In ROS, gmapping and Cartographer run as nodes that subscribe to LiDAR data topics and publish map and pose information. Other nodes like navigation and visualization tools use this data to move the robot and show maps on screen. Understanding ROS topics, messages, and node communication is essential to use SLAM effectively.

Result

You can set up SLAM in a ROS robot and connect it to sensors and navigation systems.

Seeing SLAM as part of a bigger system helps you build complete robot applications, not just isolated algorithms.

6

Advanced

Handling Loop Closures and Map Corrections

🤔Before reading on: do you think SLAM maps stay fixed once created or can they change when the robot revisits places? Commit to your answer.

Concept: SLAM systems detect when the robot returns to a known place (loop closure) and adjust the map to fix errors.

Over time, small errors in position add up, causing the map to drift. When the robot recognizes a previously visited area, SLAM algorithms correct the map and robot path to align old and new data. This process improves map consistency and localization accuracy.

Result

The robot maintains a reliable map even after long exploration.

Understanding loop closure is crucial because it prevents map distortion and keeps navigation trustworthy.

7

Expert

Trade-offs Between Gmapping and Cartographer

🤔Before reading on: do you think Gmapping or Cartographer is better for large, complex environments? Commit to your answer.

Concept: Explore the strengths and limitations of gmapping and Cartographer for different robot applications.

Gmapping is simpler and lighter, good for small to medium indoor spaces with limited computing power. Cartographer is more complex, uses advanced optimization, and handles large, dynamic environments better but needs more resources. Choosing between them depends on robot hardware, environment size, and accuracy needs.

Result

You can select the right SLAM tool for your robot’s mission and constraints.

Knowing these trade-offs helps avoid common mistakes like overloading a robot with heavy SLAM or using a weak SLAM for complex tasks.

Under the Hood

LiDAR-based SLAM processes raw laser distance data to create spatial measurements called scans. These scans are matched against an evolving map using algorithms like particle filters (gmapping) or graph optimization (Cartographer). The system maintains hypotheses of robot poses and map features, updating them as new data arrives. Loop closures trigger global map adjustments to reduce accumulated errors. Internally, SLAM balances sensor noise, motion uncertainty, and computational limits to produce real-time localization and mapping.

Why designed this way?

SLAM was designed to solve the chicken-and-egg problem of mapping and localization simultaneously without external references like GPS. Early methods used simple filters but struggled with drift and noise. Particle filters and graph-based optimization were introduced to handle uncertainty and large-scale environments more robustly. Gmapping and Cartographer reflect different design choices balancing accuracy, speed, and resource use to fit diverse robot platforms and tasks.

┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│  LiDAR Scan   │─────▶│ Scan Matching │─────▶│ Pose Estimation│
└───────────────┘      └───────────────┘      └───────────────┘
         │                      │                      │
         ▼                      ▼                      ▼
  Raw Distance          Map Update &          Robot Position
  Measurements          Optimization
         │                      │                      │
         └──────────────┬───────┴──────────────┬───────┘
                        ▼                      ▼
                 Loop Closure           Map Correction
                        │                      │
                        └──────────────┬───────┘
                                       ▼
                                Updated Map & Pose

Myth Busters - 4 Common Misconceptions

Quick: Does SLAM always produce perfect maps on the first try? Commit to yes or no.

Common Belief: SLAM instantly creates a perfect map as the robot moves.

Reality: SLAM maps improve gradually and may have errors initially that get corrected over time, especially after loop closures.

Why it matters: Expecting perfect maps immediately can lead to frustration and misinterpretation of SLAM performance during early exploration.

Quick: Is LiDAR the only sensor that can be used for SLAM? Commit to yes or no.

Common Belief: SLAM only works with LiDAR sensors.

Reality: SLAM can use various sensors like cameras, sonar, or IMUs, but LiDAR is popular for its accuracy and reliability in distance measurement.

Why it matters: Believing SLAM requires LiDAR limits understanding of alternative approaches and sensor fusion possibilities.

Quick: Does SLAM always run perfectly on any robot hardware? Commit to yes or no.

Common Belief: SLAM algorithms like gmapping and Cartographer run well on all robots regardless of hardware.

Reality: SLAM performance depends on hardware capabilities; limited CPU or memory can cause slow or inaccurate mapping.

Why it matters: Ignoring hardware limits can cause failed deployments or poor robot navigation.

Quick: Does loop closure mean the robot physically stops when it revisits a place? Commit to yes or no.

Common Belief: Loop closure requires the robot to stop and scan carefully to recognize places.

Reality: Loop closure happens automatically during movement by matching current scans to past data without stopping.

Why it matters: Misunderstanding loop closure can lead to incorrect assumptions about robot behavior and SLAM timing.

Expert Zone

1

Cartographer’s use of submaps allows efficient local mapping and global optimization, balancing speed and accuracy in large environments.

2

Gmapping’s particle filter can suffer from particle depletion if not enough particles are used, causing localization failure in ambiguous areas.

3

Both gmapping and Cartographer require careful tuning of parameters like sensor noise and motion models to perform well in different environments.

When NOT to use

Avoid gmapping or Cartographer in highly dynamic environments with many moving objects; instead, use visual-inertial SLAM or multi-sensor fusion approaches. For 3D mapping needs, consider 3D SLAM frameworks like RTAB-Map or LOAM. Also, if computational resources are very limited, simpler localization methods or pre-mapped navigation might be better.

Production Patterns

In real robots, SLAM is often combined with sensor fusion from IMUs and wheel odometry to improve robustness. Cartographer is popular in large-scale indoor mapping projects like warehouses, while gmapping suits smaller robots with limited hardware. Both are integrated into ROS navigation stacks, feeding maps and poses to planners and controllers for autonomous movement.

Connections

Kalman Filters

SLAM algorithms like gmapping build on the idea of Kalman filters to estimate robot position under uncertainty.

Understanding Kalman filters helps grasp how SLAM fuses sensor data and motion models to reduce noise and improve localization.

Graph Theory

Cartographer uses graph optimization, a concept from graph theory, to adjust robot poses and map features globally.

Knowing graph theory concepts clarifies how SLAM corrects accumulated errors by solving optimization problems over pose graphs.

Human Spatial Navigation

SLAM mimics how humans build mental maps and localize themselves using landmarks and movement cues.

Recognizing this connection reveals how biological systems inspired robotic mapping and localization techniques.

Common Pitfalls

#1 Running SLAM without calibrating the LiDAR sensor.

Wrong approach:

Launching gmapping node with default parameters and uncalibrated LiDAR data.

Correct approach:

Calibrating LiDAR sensor and adjusting gmapping parameters to match sensor specs before running SLAM.

Root cause:

Assuming default sensor settings are accurate leads to poor data quality and mapping errors.

#2 Using too few particles in gmapping causing localization failure.

Wrong approach:

Setting particle count to a very low number like 5 in gmapping configuration.

Correct approach:

Setting particle count to a higher value like 30 or more to maintain multiple hypotheses.

Root cause:

Misunderstanding particle filter mechanics causes insufficient coverage of possible robot positions.

#3 Ignoring loop closure leads to map drift over time.

Wrong approach:

Disabling loop closure detection in Cartographer or ignoring its importance.

Correct approach:

Enabling loop closure and tuning parameters to detect revisited places and correct the map.

Root cause:

Not recognizing that accumulated errors must be corrected for reliable long-term mapping.

Key Takeaways

LiDAR-based SLAM enables robots to build maps and locate themselves simultaneously using laser distance data.

Gmapping uses particle filters to track multiple position guesses, while Cartographer uses scan matching and graph optimization for accuracy.

Loop closure is essential to correct map errors when revisiting places, preventing drift and improving reliability.

SLAM performance depends on sensor quality, hardware resources, and proper parameter tuning.

Understanding SLAM’s internal mechanisms and trade-offs helps choose the right tool and avoid common pitfalls in robot navigation.

Practice

1. What is the main purpose of LiDAR-based SLAM in ROS?

easy

A. To process camera images for object detection

B. To control robot motors directly

C. To help robots create maps and know their location using laser scans

D. To send commands to robot arms

Solution

1. Step 1: Understand SLAM basics

   SLAM stands for Simultaneous Localization and Mapping, which means building a map and knowing the robot's position at the same time.

2. Step 2: Identify LiDAR role

   LiDAR uses laser scans to sense the environment, which helps SLAM create accurate maps and localize the robot.

3. Final Answer:

   To help robots create maps and know their location using laser scans -> Option C

4. Quick Check:

   LiDAR-based SLAM = mapping + localization with lasers [OK]

Hint: SLAM = map + location using sensors like LiDAR [OK]

Common Mistakes:

• Confusing SLAM with motor control
• Thinking SLAM processes camera images only
• Assuming SLAM sends commands to robot arms

2. Which ROS launch command correctly starts the gmapping SLAM node?

easy

A. rosstart gmapping slam.launch

B. roslaunch gmapping slam_gmapping.launch

C. rosrun gmapping slam_gmapping.py

D. roslaunch cartographer slam.launch

Solution

1. Step 1: Recall ROS launch syntax

   ROS uses roslaunch to start nodes with launch files, specifying package and launch file name.

2. Step 2: Match gmapping launch file

   The gmapping package provides slam_gmapping.launch to start the SLAM node.

3. Final Answer:

   roslaunch gmapping slam_gmapping.launch -> Option B

4. Quick Check:

   Use roslaunch + package + launch file [OK]

Hint: Use roslaunch with package and launch file name [OK]

Common Mistakes:

• Using rosrun instead of roslaunch for launch files
• Typing rosstart which is invalid
• Confusing cartographer launch with gmapping

3. Given this ROS launch snippet for Cartographer:

<launch>
  <include file="$(find cartographer_ros)/launch/demo_backpack_2d.launch" />
</launch>

What will happen when you run this launch file?

medium

A. It launches a robot simulation without SLAM

B. It starts gmapping SLAM with a 3D map

C. It causes a syntax error due to missing parameters

D. It starts Cartographer SLAM with a 2D LiDAR backpack demo configuration

Solution

1. Step 1: Understand the include tag

   The <include> tag loads another launch file from the cartographer_ros package.

2. Step 2: Identify the included launch file

   demo_backpack_2d.launch is a Cartographer demo for 2D SLAM using a backpack LiDAR sensor.

3. Final Answer:

   It starts Cartographer SLAM with a 2D LiDAR backpack demo configuration -> Option D

4. Quick Check:

   Include demo_backpack_2d.launch = Cartographer 2D SLAM [OK]

Hint: Include demo_backpack_2d.launch means Cartographer 2D SLAM [OK]

Common Mistakes:

• Confusing Cartographer with gmapping
• Assuming missing parameters cause errors here
• Thinking it launches simulation without SLAM

4. You try to run gmapping with this command:

roslaunch gmapping slam_gmapping.launch

But get an error: "Could not find node of type slam_gmapping in package gmapping". What is the likely cause?

medium

A. The gmapping package is not installed or sourced properly

B. You used rosrun instead of roslaunch

C. The launch file name is misspelled

D. Your LiDAR sensor is not connected

Solution

1. Step 1: Analyze the error message

   The error says it cannot find the node type in the gmapping package, meaning the package or node is missing.

2. Step 2: Check common causes

   This usually happens if the gmapping package is not installed or the ROS environment is not sourced to find it.

3. Final Answer:

   The gmapping package is not installed or sourced properly -> Option A

4. Quick Check:

   Missing package or source = node not found error [OK]

Hint: Check package installed and sourced if node not found error [OK]

Common Mistakes:

• Assuming rosrun vs roslaunch causes this error
• Thinking a typo in launch file name causes node type error
• Blaming LiDAR connection for node not found

5. You want to create a 3D map using Cartographer with a LiDAR sensor on a robot. Which approach is best?

hard

A. Use Cartographer's 3D SLAM launch files and configure sensor topics properly

B. Use gmapping with default 2D settings and add a 3D camera

C. Run gmapping and Cartographer simultaneously for better accuracy

D. Use Cartographer's 2D demo launch files and convert output to 3D later

Solution

1. Step 1: Understand SLAM capabilities

   Gmapping supports only 2D SLAM, so it cannot create 3D maps directly.

2. Step 2: Choose Cartographer for 3D

   Cartographer supports 3D SLAM and has launch files designed for 3D mapping with LiDAR sensors.

3. Step 3: Configure sensor topics

   Properly setting sensor topics in Cartographer launch files ensures correct data flow for 3D mapping.

4. Final Answer:

   Use Cartographer's 3D SLAM launch files and configure sensor topics properly -> Option A

5. Quick Check:

   3D map needs Cartographer 3D launch + sensor config [OK]

Hint: 3D mapping needs Cartographer 3D launch and sensor setup [OK]

Common Mistakes:

• Trying to use gmapping for 3D maps
• Running both SLAM systems at once
• Using 2D demos and expecting 3D output