💻 computer science

SGM-SLAM: Scene Graph Matching for Data-Efficient Distributed SLAM

This paper introduces SGM-SLAM, a data-efficient distributed SLAM framework for multi-robot teams that uniquely leverages scene graph matching based solely on object labels and centroids to establish inter-robot constraints, thereby optimizing communication and performance in both simulated and real-world environments.

Original authors: Yewei Huang, Tixiao Shan, Abhinav Rajvanshi, Niluthpol Chowdhury Mithun, Yaxuan Li, Brendan Englot, Han-Pang Chiu

Published 2026-06-16

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yewei Huang, Tixiao Shan, Abhinav Rajvanshi, Niluthpol Chowdhury Mithun, Yaxuan Li, Brendan Englot, Han-Pang Chiu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a team of robots exploring a large, unfamiliar building or a park. Their goal is to build a shared map of the world while figuring out exactly where they are. This is called SLAM (Simultaneous Localization and Mapping).

The problem is, if these robots are far apart or looking at things from different angles, it's very hard for them to realize, "Hey, I'm looking at the same chair you are!" Traditional methods try to match tiny details (like the texture of a wall or specific points on a rock), but this is like trying to recognize a friend in a crowd by counting the freckles on their nose—it fails if the lighting changes or if you only see them from the side.

SGM-SLAM is a new way for robots to talk to each other and build a map together. Here is how it works, using simple analogies:

1. The "Scene Graph" (The Robot's Mental Sketchbook)

Instead of trying to remember every single pixel of a photo, each robot builds a Scene Graph. Think of this as a simplified sketchbook or a flowchart of the room.

The Objects: Instead of a messy cloud of points, the robot identifies distinct things: "That's a chair," "That's a table," "That's a tree."
The Relationships: It notes where these things are relative to each other (e.g., "The chair is 2 meters to the left of the table").
The Layers: The robot keeps three layers of information:
1. The Path: Where the robot has walked.
2. The Objects: The list of things it sees (with their labels and center points).
3. The Details: The actual 3D shape of those objects (but this is kept private until needed).

2. The "Handshake" (Matching Without Heavy Data)

This is the paper's biggest innovation. Usually, robots have to send huge files (like full 3D scans) to each other to see if they are in the same place. This is slow and clogs up their communication channels, like trying to send a whole library book via text message.

SGM-SLAM does something smarter:

The "Name and Location" Game: Robots only share a tiny list of what they see and where the centers of those objects are. It's like two people meeting in a park and saying, "I see a red bench and a blue trash can," and "I see a red bench and a blue trash can."
The Match: If the lists match up (e.g., both see a red bench near a blue trash can), the robots know they are looking at the same area. They don't need to send the heavy 3D data yet.
The "Heavy Lifting" Only When Needed: Only after they are sure they are looking at the same place do they ask for the detailed 3D data to fine-tune their map. This saves a massive amount of bandwidth.

3. Why It's Better (The "Viewpoint" Problem)

Imagine you are looking at a table from the front, and your friend is looking at it from the side.

Old Methods: They try to match the specific pixels of the table legs. If the angle is different, the legs look different, and the match fails.
SGM-SLAM: It ignores the angle. It just says, "There is a table here." Because it focuses on the object (the table) rather than the pixels, it works even if the robots are looking at the scene from completely different angles or if the lighting is bad.

4. The Results (The "Teamwork" Test)

The authors tested this with real robots (a dog-like robot and a handheld device) in both indoor and outdoor environments.

The Challenge: They had to merge maps where the robots' paths barely overlapped (like two people walking through a huge campus and only meeting at one spot).
The Outcome: Traditional methods struggled to connect the maps because the overlap was too small or the lighting was dim. SGM-SLAM successfully connected the maps by recognizing the shared objects (like benches and chairs).
Efficiency: The robots exchanged tiny text messages (object lists) most of the time, only sending large 3D files when absolutely necessary. This made the system much faster and more reliable than previous methods that tried to send everything all the time.

Summary

SGM-SLAM is like a team of explorers who agree to only shout out the names of landmarks they see ("Tree!", "Bench!", "Door!") to find each other. Once they realize they are in the same neighborhood, they swap detailed maps. This allows them to work together efficiently, even if they are far apart, in the dark, or looking at things from weird angles, without clogging up their walkie-talkies with heavy data.

Technical Summary: SGM-SLAM

Problem Statement

Multi-robot Simultaneous Localization and Mapping (SLAM) faces significant challenges in data association, particularly when robots operate with limited trajectory overlap, varying viewpoints, and constrained communication bandwidth. Traditional feature-based methods often fail under these conditions due to sensitivity to lighting and viewpoint changes. Furthermore, existing scene graph-based approaches for multi-robot systems typically rely on high-dimensional visual descriptors (e.g., bag-of-words) or are restricted to specific environments (indoor-only or outdoor driving scenarios). These dependencies create communication burdens that lead to map discrepancies and delayed updates, especially in low-bandwidth outdoor settings. Additionally, many existing methods require external prior geometric information (GPS) or rely on centralized architectures that struggle with real-time map consistency.

The core problem addressed by this paper is how to achieve robust, distributed multi-robot SLAM in both indoor and outdoor environments using limited semantic and geometric data, without relying on GPS or high-bandwidth transmission of raw point clouds or complex visual descriptors.

Methodology: SGM-SLAM

The authors propose SGM-SLAM, a data-efficient distributed SLAM framework designed for teams of robots equipped with LiDAR, cameras, and inertial sensors. The system operates without external GPS priors.

1. System Architecture and Sensor Fusion

Each robot constructs a local Scene Graph comprising three layers:

Keyframe Layer: Vertices representing selected keyframes connected by odometry and loop closure observations.
Object Layer: A fully connected graph where vertices represent discrete, bounded objects. Edges represent Euclidean distances between object centroids.
Semantic Layer: Labeled semantic point clouds.

The system performs semantic sensor fusion by aligning RGB images with LiDAR scans. Images are segmented using Oneformer to generate semantic labels, which are then projected onto the LiDAR point cloud. Objects are identified by clustering these labeled points.

2. Scene Graph Construction

Within a single robot, the object layer is constructed by matching objects across consecutive keyframes. This is formulated as a Linear Assignment Problem (LAP) using the Hungarian Algorithm, where the cost matrix is based on the Euclidean distance between object centroids. This allows for the propagation of updates: when keyframe poses are adjusted, object positions are updated accordingly.

3. Inter-Robot Scene Graph Matching

The core innovation lies in how robots identify inter-robot constraints. Instead of exchanging high-dimensional descriptors, robots exchange only object IDs, semantic labels, and centroids.

Graph Matching: The matching process between a local robot's graph ( $G_\alpha$ ) and a neighbor's graph ( $G_\beta$ ) is formulated as a Quadratic Assignment Problem (QAP).
Utility Tensor: A 4D utility tensor measures similarity based on vertex labels (semantic consistency) and edge weights (geometric consistency between object pairs).
Optimization: The QAP is relaxed to allow continuous values and solved via the principal eigenvector of the utility matrix. The result is re-formulated as an LAP to determine the final object correspondences.
Robustness: The method is designed to handle partial observations and viewpoint changes by relying on object-level semantics rather than pixel-level features.

4. Transformation Estimation and Registration

Once object correspondences are established:

Initial Guess: A rigid body transformation ( $T_{W_\alpha \to W_\beta}$ ) is estimated using the matched object centroids. To ensure robustness against odometry drift, the problem is reduced to a 2D rigid body transformation assuming objects lie on a plane.
Refinement: This transformation serves as a coarse initial guess for Iterative Closest Point (ICP) registration. The ICP operates on sparse point clouds associated with the matched objects, refining the relative pose between robots.

5. Communication Strategy

The framework employs a multi-step, data-efficient communication protocol:

High-Frequency: Robots share lightweight object data (ID, type, centroid) frequently.
Triggered Exchange: If a sufficient number of objects match, a robot requests specific sparse object point clouds and keyframe IDs from the neighbor.
Optimized Transfer: Only compressed geometric data (poses) is transmitted; intensity and color data are omitted. This ensures that bandwidth-intensive data is only sent when necessary for loop closure refinement.

Key Contributions

The paper claims the following contributions:

Distributed Framework: A demonstration of a distributed multi-robot SLAM framework capable of constructing scene graphs for both indoor and outdoor environments.
Object-Only Matching: The first distributed multi-robot SLAM approach to detect scene graph matching candidates using only object semantics and geometry, eliminating the need for visual descriptors or high-dimensional feature vectors.
Data-Efficient Communication: A novel communication strategy designed for robots with LiDARs and cameras that minimizes bandwidth usage by exchanging limited object data and triggering point-cloud transfers only when necessary.

Experimental Results

The authors evaluated SGM-SLAM using both synthetic data and real-world datasets collected by legged robots (Unitree Go2 EDU) and handheld devices in suburban campus environments.

Synthetic Data: In a 60m×60m environment with 50 objects, the system achieved high success rates in transformation estimation even with pose errors (up to $\pm 1$ m translation) and semantic label errors (up to 12 mislabeled objects). The system maintained real-time performance (under 250ms) across varying graph sizes.
Real-World Performance:
- Outdoor: Compared against Swarm-SLAM (using Scan Context descriptors) and Swarm-CP (using CosPlace descriptors), SGM-SLAM achieved a significantly lower Absolute Trajectory Error (ATE) of 1.32m compared to 20.29m (Swarm-SC) and 3.92m (Swarm-CP). The authors attribute the failure of descriptor-based methods to low trajectory overlap and viewpoint differences.
- Indoor: In a low-light environment with occluded objects, SGM-SLAM achieved an ATE of 0.81m, outperforming Swarm-SC (3.36m) and Swarm-CP (5.70m).
Communication Efficiency: The proposed method reduced perception message sizes drastically. While a brute-force raw point-cloud approach averaged ~508 KB per message, the "Object Data" messages averaged only 7.76 KB (outdoor) and 18.40 KB (indoor).

Significance and Claims

The paper positions SGM-SLAM as a solution to the communication bottleneck in multi-robot SLAM. By shifting from feature-level matching to object-level scene graph matching, the system achieves robustness against viewpoint changes and limited trajectory overlap without the communication overhead of high-dimensional descriptors.

The authors claim that this approach makes distributed SLAM more viable for long-term missions in large-scale environments where bandwidth is limited. They emphasize that the system's reliance on semantic labels and centroids makes it intuitive for human-robot interaction and compatible with future integration into Large Language Model (LLM) based planning pipelines, though such integration is proposed as future work rather than a current capability. The results suggest that object-centric matching is a more effective strategy for distributed systems than traditional visual or geometric descriptor matching in challenging, real-world conditions.