1. Prerequisites

Before understanding Graph SLAM, it is essential to grasp the following foundational concepts:

1.1 Probability and Bayes' Theorem

Graph SLAM relies on probabilistic models to estimate uncertainties.

• Bayes’ Theorem: Updates beliefs based on new sensor data.
• Gaussian Distributions: Used for representing noise in measurements.

1.2 Graph Theory

Graph SLAM represents the environment as a graph where nodes are robot poses and landmarks, and edges represent constraints.

• Nodes: Represent the robot’s estimated positions.
• Edges: Represent spatial constraints between nodes.
• Optimization: Finding the best-fit trajectory using graph optimization techniques.

1.3 Robot Kinematics and Motion Models

Understanding how robots move and sense the environment is crucial.

• Odometry: Measures robot movement but accumulates errors.
• Sensor Models: LiDAR, GPS, and cameras provide observations.

1.4 Least Squares and Optimization

Graph SLAM is solved through non-linear optimization methods.

• Non-linear Least Squares (NLS): Minimizes the error between predicted and observed positions.
• Gauss-Newton & Levenberg-Marquardt Algorithms: Used to solve the optimization problem.

2. What is Graph Simultaneous Localization and Mapping (Graph SLAM)?

Graph SLAM is an algorithm for mapping an unknown environment while simultaneously estimating the robot’s trajectory.

2.1 Core Idea

• Graph Representation: The environment and robot motion are modeled as a graph.
• Constraint-Based Optimization: The algorithm minimizes errors in pose estimation by solving a global optimization problem.
• Loop Closure: Corrects errors by recognizing previously visited locations.

2.2 How It Works

• Pose Graph Construction: Each robot position is a node, and edges represent odometry and sensor constraints.
• Error Minimization: The system refines the graph by reducing inconsistencies in sensor measurements.
• Final Map Generation: After convergence, the optimized graph provides an accurate map.

2.3 Mathematical Formulation

The optimization problem in Graph SLAM can be represented as:

$$ \hat{x} = \arg\min_x \sum_{(i,j) \in C} || z_{ij} - h(x_i, x_j) ||^2 $$

• \( x \): Set of all robot poses.
• \( z_{ij} \): Observations between pose \( i \) and \( j \).
• \( h(x_i, x_j) \): Predicted transformation between nodes.
• \( C \): Set of constraints derived from observations.

3. Why Does Graph SLAM Exist?

Graph SLAM addresses the fundamental problem of simultaneous localization and mapping in unknown environments.

3.1 Autonomous Navigation

• Used in self-driving cars to map roads and obstacles.
• Improves navigation accuracy using LiDAR and cameras.

3.2 Robotics and Drones

• Essential for autonomous drones and robotic vacuum cleaners.
• Helps robots understand surroundings and avoid obstacles.

3.3 Search and Rescue Operations

• Deployed in disaster-struck areas where pre-existing maps are unreliable.
• Enables robots to navigate debris and locate survivors.

3.4 Augmented Reality (AR) and Virtual Reality (VR)

• Used for accurate indoor localization in AR applications.
• Improves object placement and scene reconstruction.

4. When Should You Use Graph SLAM?

4.1 When High Accuracy in Mapping is Required

• Graph SLAM is ideal for applications requiring precise maps.
• Examples: Urban planning, construction mapping, and detailed indoor mapping.

4.2 When Loop Closures Need to be Handled

• Graph SLAM excels in environments where robots revisit locations.
• Useful for indoor navigation in warehouses, hospitals, and office spaces.

4.3 When Sensor Fusion is Needed

• Combines multiple sensor sources (LiDAR, IMU, GPS) for better localization.
• Reduces errors from any single sensor failure.

4.4 When Computational Resources are Available

• Graph SLAM requires solving large-scale optimization problems.
• Best suited for systems with high computational power (e.g., cloud computing, edge devices).

5. How Does Graph SLAM Compare to Alternatives?

5.1 Strengths

• Globally Consistent Maps: Reduces accumulated drift by solving for the best global estimate.
• Loop Closure Handling: Identifies and corrects errors when revisiting locations.
• Flexible Sensor Integration: Works with different sensor types (LiDAR, vision-based, GPS).
• Scalability: Suitable for large environments when optimized properly.

5.2 Weaknesses

• High Computational Cost: Solving a large graph optimization problem can be expensive.
• Memory Usage: Storing the entire pose graph requires significant memory.
• Loop Closure Detection Challenges: Requires robust feature detection for accurate results.
• Real-Time Constraints: Not always suitable for real-time applications due to computational delays.

5.3 Comparison with Other SLAM Methods

6. Basic Implementation of Graph SLAM

The following is a basic implementation of Graph SLAM using Python and the g2o library for graph optimization.

6.1 Installing Dependencies

pip install g2o numpy

6.2 Python Implementation of Graph SLAM

import numpy as np
import g2o

class GraphSLAM:
    def __init__(self):
        self.optimizer = g2o.SparseOptimizer()
        solver = g2o.BlockSolverX(g2o.LinearSolverCholmodX())
        algorithm = g2o.OptimizationAlgorithmLevenberg(solver)
        self.optimizer.set_algorithm(algorithm)
        self.vertex_id = 0
    
    def add_pose(self, x, y, theta):
        """Adds a pose node to the graph."""
        vertex = g2o.VertexSE2()
        vertex.set_id(self.vertex_id)
        vertex.set_estimate(g2o.SE2(x, y, theta))
        self.optimizer.add_vertex(vertex)
        self.vertex_id += 1
    
    def add_edge(self, id1, id2, dx, dy, dtheta, information=np.eye(3)):
        """Adds an edge between two pose nodes."""
        edge = g2o.EdgeSE2()
        edge.set_vertex(0, self.optimizer.vertex(id1))
        edge.set_vertex(1, self.optimizer.vertex(id2))
        edge.set_measurement(g2o.SE2(dx, dy, dtheta))
        edge.set_information(information)
        self.optimizer.add_edge(edge)
    
    def optimize(self, iterations=10):
        """Optimizes the graph using least-squares optimization."""
        self.optimizer.initialize_optimization()
        self.optimizer.optimize(iterations)
    
    def get_estimates(self):
        """Returns the optimized pose estimates."""
        estimates = {}
        for i in range(self.vertex_id):
            estimates[i] = self.optimizer.vertex(i).estimate()
        return estimates

# Example usage
slam = GraphSLAM()
slam.add_pose(0, 0, 0)  # Initial pose
slam.add_pose(1, 2, 0.1)  # Next pose
slam.add_pose(2, 4, 0.2)  # Another pose
slam.add_edge(0, 1, 1, 2, 0.1)  # Constraint between first and second pose
slam.add_edge(1, 2, 1, 2, 0.1)  # Constraint between second and third pose
slam.optimize()

# Print optimized pose estimates
estimates = slam.get_estimates()
for k, v in estimates.items():
    print(f"Pose {k}: x={v.translation()[0]:.2f}, y={v.translation()[1]:.2f}, theta={v.angle():.2f}")

7. Dry Run of Graph SLAM Algorithm

Let's manually track how the Graph SLAM algorithm processes a small input set.

7.1 Initial Input Set

• Pose 0: (0, 0, 0) - Initial robot position.
• Pose 1: (1, 2, 0.1) - Estimated movement based on odometry.
• Pose 2: (2, 4, 0.2) - Further movement.
• Edges (Constraints):
  • Between Pose 0 and Pose 1: (dx=1, dy=2, dtheta=0.1)
  • Between Pose 1 and Pose 2: (dx=1, dy=2, dtheta=0.1)

7.2 Step-by-Step Execution

7.3 Expected Output

The optimizer refines the estimates, reducing drift errors:

Pose 0: x=0.00, y=0.00, theta=0.00
Pose 1: x=0.98, y=1.98, theta=0.10  # Slight correction
Pose 2: x=1.96, y=3.95, theta=0.19  # Corrected errors in trajectory

Here, the small adjustments indicate Graph SLAM is refining pose estimates using global constraints.

8. Time & Space Complexity Analysis of Graph SLAM

Graph SLAM involves constructing and optimizing a pose graph, which directly affects its time and space complexity.

8.1 Worst-Case, Best-Case, and Average-Case Complexity

8.2 Explanation

• Graph Construction: Each pose and edge is inserted in constant time, leading to O(n + m), where n is the number of nodes (poses), and m is the number of edges (constraints).
• Graph Optimization: Uses nonlinear least squares, solved using Gauss-Newton or Levenberg-Marquardt, typically O(n²) but O(n³) in the worst case.
• Loop Closure Detection: Uses spatial nearest-neighbor search, averaging O(log n) but degrading to O(n) in large unstructured environments.

9. Space Complexity Analysis

The space consumption of Graph SLAM depends on storing graph nodes, edges, and intermediate computations.

9.1 Space Consumption Trends

• Pose Storage: O(n) for storing pose variables.
• Edge Storage: O(m) where m ≤ O(n²) in dense graphs.
• Optimization Storage: Requires storing a Jacobian matrix, which grows as O(n²) in sparse graphs and O(n³) in dense graphs.
• Total Space Complexity: O(n²) in sparse graphs and O(n³) in worst-case scenarios.

9.2 How Space Grows with Input Size

For large-scale applications, reducing redundant nodes or using sparse approximations can help manage memory.

10. Understanding the Trade-offs

10.1 Strengths

• High Accuracy: Graph SLAM ensures global consistency.
• Robust Loop Closure: Detects previously visited locations to correct drift errors.
• Flexible Sensor Integration: Works with LiDAR, cameras, and GPS.

10.2 Weaknesses

• Computational Overhead: O(n²) to O(n³) complexity makes it slow for real-time applications.
• High Memory Consumption: Storing large graphs increases space requirements.
• Convergence Issues: Nonlinear optimization can get stuck in local minima.

10.3 Practical Optimizations

• Graph Sparsification: Reduces graph size by removing redundant poses.
• Incremental Solvers: Updates graph without re-solving from scratch.
• Distributed Computation: Splits large graphs across multiple processors.

11. Optimizations & Variants of Graph SLAM

Graph SLAM is computationally expensive, but optimizations and variations improve efficiency.

11.1 Common Optimizations

• Graph Sparsification: Reduces the number of nodes and edges by removing redundant poses.
• Incremental Optimization: Updates the graph dynamically instead of re-solving from scratch.
• Hierarchical SLAM: Divides the environment into submaps, optimizing locally before merging globally.
• Preconditioned Conjugate Gradient (PCG): Speeds up solving large linear systems during optimization.
• Pose Graph Partitioning: Clusters poses into smaller graphs for parallel processing.
• Information Filtering: Reduces memory usage by selectively storing constraints.

11.2 Variants of Graph SLAM

11.2.1 Incremental Graph SLAM (iSAM)

Instead of batch processing, iSAM updates the pose graph incrementally.

• Faster optimization for real-time applications.
• Uses factor graphs to update only necessary parts of the graph.

11.2.2 Sparse Pose Adjustment (SPA)

A variation that assumes sparsity in the pose graph.

• Exploits the sparsity of pose constraints for faster optimization.
• Reduces computational complexity from O(n³) to O(n²).

11.2.3 Distributed Graph SLAM

Optimizes parts of the graph across multiple computing nodes.

• Useful for large-scale mapping using cloud computing.
• Reduces memory and computation burden on individual robots.

11.2.4 Visual Graph SLAM (VSLAM)

Uses camera-based feature detection instead of LiDAR.

• Lower cost, as it relies on standard cameras.
• Challenges include feature tracking and occlusion handling.

11.2.5 Hybrid Graph SLAM

Combines odometry, LiDAR, and visual features to improve accuracy.

• Uses multiple sensor inputs for robust mapping.
• Common in autonomous vehicles and drones.

12. Iterative vs. Recursive Implementations

Graph SLAM can be implemented using iterative or recursive methods, each with trade-offs.

12.1 Iterative Implementation

The algorithm solves the optimization problem repeatedly in a loop.

• Pros:
  • Simpler to implement.
  • Works well for offline batch processing.
• Cons:
  • High computational cost (O(n³) for large graphs).
  • Not suitable for real-time applications.

12.2 Recursive Implementation

Updates the graph dynamically as new data arrives.

• Pros:
  • More efficient (O(n²) in sparse cases).
  • Suitable for real-time applications like self-driving cars.
• Cons:
  • More complex implementation.
  • Can be sensitive to sensor noise.

12.3 Performance Comparison

12.4 Choosing the Right Approach

• For real-time applications: Use recursive or incremental methods like iSAM.
• For high-accuracy mapping: Use batch iterative Graph SLAM.
• For large-scale SLAM: Use distributed or hierarchical methods.

13. Edge Cases & Failure Handling in Graph SLAM

Graph SLAM can fail due to various issues, from sensor noise to incorrect loop closures. Identifying and handling these cases is crucial.

13.1 Common Pitfalls and Edge Cases

13.1.1 Sensor Noise and Outliers

• Issue: Noisy GPS, LiDAR, or camera readings introduce errors in pose estimation.
• Handling: Apply robust estimation techniques like RANSAC or Mahalanobis distance filtering.

13.1.2 Incorrect Loop Closures

• Issue: The algorithm mistakenly recognizes a previously visited location, causing large positional errors.
• Handling: Use geometric verification techniques and feature consistency checks.

13.1.3 Degenerate Cases (Sparse Features or Repetitive Environments)

• Issue: Hallways, tunnels, or large empty spaces lead to localization ambiguity.
• Handling: Incorporate additional sensors (IMU, depth sensors) and increase feature detection sensitivity.

13.1.4 Memory and Computational Overhead

• Issue: Large-scale maps cause excessive memory consumption and slow optimization.
• Handling: Use hierarchical SLAM, graph sparsification, or out-of-core memory management.

13.1.5 Non-Uniform Motion (Robot Skidding, Slipping, or Sudden Stops)

• Issue: Unexpected motion introduces inconsistencies between odometry and sensor data.
• Handling: Apply Kalman filters or factor graphs to smooth out erratic movement.

14. Test Cases to Verify Correctness

To ensure Graph SLAM is functioning correctly, structured test cases should be executed.

14.1 Basic Functionality Tests

def test_add_pose():
    slam = GraphSLAM()
    slam.add_pose(0, 0, 0)
    slam.add_pose(1, 2, 0.1)
    assert len(slam.optimizer.vertices()) == 2, "Pose addition failed."

def test_add_edge():
    slam = GraphSLAM()
    slam.add_pose(0, 0, 0)
    slam.add_pose(1, 2, 0.1)
    slam.add_edge(0, 1, 1, 2, 0.1)
    assert len(slam.optimizer.edges()) == 1, "Edge addition failed."

14.2 Edge Case Tests

def test_noisy_sensor_data():
    slam = GraphSLAM()
    slam.add_pose(0, 0, 0)
    slam.add_pose(1, 2, 0.1)
    slam.add_edge(0, 1, 5, 5, 1.0)  # Large discrepancy (error injection)
    slam.optimize()
    estimate = slam.get_estimates()
    assert abs(estimate[1].translation()[0] - 1) < 1, "Graph SLAM failed to handle noise."

def test_loop_closure_handling():
    slam = GraphSLAM()
    slam.add_pose(0, 0, 0)
    slam.add_pose(1, 2, 0.1)
    slam.add_pose(2, 4, 0.2)
    slam.add_edge(0, 2, 1.9, 3.9, 0.2)  # Loop closure
    slam.optimize()
    estimate = slam.get_estimates()
    assert abs(estimate[2].translation()[0] - 2) < 0.5, "Loop closure handling failed."

15. Real-World Failure Scenarios

Understanding failure scenarios helps in improving robustness.

15.1 Self-Driving Cars: GPS Outages

• Problem: Loss of GPS signal in tunnels or urban environments.
• Solution: Integrate IMU data and use dead reckoning until GPS is restored.

15.2 Drones: Fast Movements and Feature Loss

• Problem: Rapid altitude changes lead to loss of visual features.
• Solution: Use optical flow sensors and onboard SLAM to estimate movement.

15.3 Indoor Robotics: Ambiguous Loop Closures

• Problem: Similar-looking hallways lead to incorrect re-localization.
• Solution: Use additional sensor modalities like RFID tags or depth sensors.

15.4 Large-Scale Mapping: Memory Overflow

• Problem: Processing millions of nodes consumes excessive memory.
• Solution: Implement graph partitioning or distributed SLAM approaches.

16. Real-World Applications & Industry Use Cases of Graph SLAM

Graph SLAM is widely used in industries where autonomous navigation, mapping, and localization are critical.

16.1 Self-Driving Cars

• Use Case: Autonomous vehicles use Graph SLAM for real-time localization and mapping.
• How It Works: Combines LiDAR, camera, and GPS data to create maps and track vehicle position.
• Example: Tesla’s Autopilot and Waymo’s autonomous taxis use SLAM for navigation.

16.2 Robotics & Warehouse Automation

• Use Case: Autonomous mobile robots (AMRs) navigate warehouses efficiently.
• How It Works: SLAM-based robots create maps of shelves and optimize paths to pick items.
• Example: Amazon’s warehouse robots use SLAM to manage inventory.

16.3 Augmented Reality (AR) and Virtual Reality (VR)

• Use Case: AR applications overlay digital objects on real-world environments.
• How It Works: Uses visual SLAM (V-SLAM) with cameras to track positions in real-time.
• Example: Microsoft HoloLens and Apple’s ARKit use SLAM for AR experiences.

16.4 Drones & Aerial Mapping

• Use Case: SLAM enables drones to autonomously map unknown environments.
• How It Works: LiDAR or vision-based SLAM helps drones avoid obstacles and navigate.
• Example: DJI drones use SLAM for stabilization and autonomous flight.

16.5 Search & Rescue Operations

• Use Case: Robots explore disaster-struck areas where GPS is unavailable.
• How It Works: SLAM helps rescue robots map collapsed buildings and locate survivors.
• Example: DARPA’s rescue robots use SLAM in disaster relief missions.

17. Open-Source Implementations of Graph SLAM

Several open-source libraries provide Graph SLAM implementations for research and development.

17.1 g2o (General Graph Optimization)

• Features: Optimizes pose graphs efficiently.
• Language: C++ with Python bindings.
• GitHub: github.com/RainerKuemmerle/g2o

17.2 Ceres Solver

• Features: Nonlinear least squares optimization.
• Language: C++.
• GitHub: github.com/ceres-solver/ceres-solver

17.3 ORB-SLAM

• Features: Feature-based SLAM for monocular, stereo, and RGB-D cameras.
• Language: C++.
• GitHub: github.com/raulmur/ORB_SLAM2

17.4 RTAB-Map (Real-Time Appearance-Based Mapping)

• Features: Uses visual and LiDAR SLAM for real-time mapping.
• Language: C++.
• GitHub: github.com/introlab/rtabmap

18. A Practical Graph SLAM Project: Autonomous Indoor Navigation

This project simulates an autonomous robot navigating an indoor environment using Graph SLAM.

18.1 Problem Statement

A robot must navigate a simulated environment while mapping obstacles and estimating its trajectory.

18.2 Python Implementation

import numpy as np
import g2o
import matplotlib.pyplot as plt

class GraphSLAM:
    def __init__(self):
        self.optimizer = g2o.SparseOptimizer()
        solver = g2o.BlockSolverX(g2o.LinearSolverCholmodX())
        algorithm = g2o.OptimizationAlgorithmLevenberg(solver)
        self.optimizer.set_algorithm(algorithm)
        self.vertex_id = 0
    
    def add_pose(self, x, y, theta):
        """Adds a robot pose to the graph."""
        vertex = g2o.VertexSE2()
        vertex.set_id(self.vertex_id)
        vertex.set_estimate(g2o.SE2(x, y, theta))
        self.optimizer.add_vertex(vertex)
        self.vertex_id += 1
    
    def add_edge(self, id1, id2, dx, dy, dtheta, information=np.eye(3)):
        """Adds an edge (constraint) between two poses."""
        edge = g2o.EdgeSE2()
        edge.set_vertex(0, self.optimizer.vertex(id1))
        edge.set_vertex(1, self.optimizer.vertex(id2))
        edge.set_measurement(g2o.SE2(dx, dy, dtheta))
        edge.set_information(information)
        self.optimizer.add_edge(edge)
    
    def optimize(self, iterations=10):
        """Optimizes the pose graph."""
        self.optimizer.initialize_optimization()
        self.optimizer.optimize(iterations)
    
    def get_estimates(self):
        """Returns optimized robot poses."""
        estimates = []
        for i in range(self.vertex_id):
            pose = self.optimizer.vertex(i).estimate()
            estimates.append((pose.translation()[0], pose.translation()[1]))
        return estimates

# Simulating an indoor navigation scenario
slam = GraphSLAM()
slam.add_pose(0, 0, 0)  # Start position
slam.add_pose(1, 1, 0.1)  # Move forward
slam.add_pose(2, 2, 0.2)  # Move forward again
slam.add_edge(0, 1, 1, 1, 0.1)
slam.add_edge(1, 2, 1, 1, 0.1)
slam.optimize()

# Visualizing the optimized path
estimates = slam.get_estimates()
x_vals, y_vals = zip(*estimates)
plt.plot(x_vals, y_vals, marker='o', linestyle='-', label="Optimized Path")
plt.xlabel("X Position")
plt.ylabel("Y Position")
plt.title("Graph SLAM Optimized Trajectory")
plt.legend()
plt.grid()
plt.show()

18.3 Expected Output

• A plotted graph showing the robot's optimized trajectory.
• Correction of minor drift errors from odometry data.

18.4 Extensions

• Integrate LiDAR or camera-based loop closure detection.
• Implement real-time graph updates for autonomous robots.
• Extend to 3D SLAM using RGB-D or stereo cameras.

19. Graph SLAM in Competitive Programming & System Design

Graph SLAM is not typically used in standard competitive programming but is highly relevant in system design for robotics, self-driving cars, and large-scale mapping systems. Understanding its application in constrained environments helps in both algorithmic problem-solving and large-scale system design.

19.1 Using Graph SLAM in Competitive Programming

While Graph SLAM itself is too complex for direct competitive programming problems, its components—graph theory, optimization, and probability—are frequently tested. Mastering these will indirectly improve performance in competitions.

• Graph Optimization: Implementing Dijkstra’s and Floyd-Warshall’s algorithms to optimize shortest paths.
• Dynamic Programming on Graphs: Solving shortest path problems with constraints.
• Nonlinear Optimization: Practicing matrix factorization and least-squares methods.

19.2 System Design Integration of Graph SLAM

Graph SLAM can be integrated into complex system designs for real-world applications.

• Autonomous Vehicle Architecture: Combining Graph SLAM with sensor fusion (LiDAR, GPS, IMU) for self-driving cars.
• Cloud-Based Mapping System: Storing and optimizing SLAM graphs in cloud environments for large-scale mapping.
• Multi-Robot Coordination: Using Graph SLAM to allow multiple robots to share map data and collaborate.
• Augmented Reality & VR: Tracking real-time poses for seamless virtual overlays in AR applications.

20. Assignments: Mastering Graph SLAM

20.1 Solve at Least 10 Problems Using Graph SLAM Concepts

Work on the following problems to reinforce key SLAM-related concepts:

1. Graph Path Optimization: Given a set of nodes with constraints, optimize their layout using least squares.
2. Loop Closure Detection: Implement a system to detect previously visited locations.
3. Noise Filtering in Graphs: Use Kalman filters to refine node positions.
4. Dynamic Graph Updates: Modify an existing SLAM graph to incorporate new observations.
5. SLAM with Constraints: Optimize a pose graph with fixed points.
6. Robot Motion Planning: Use A* search or Dijkstra’s algorithm to navigate a mapped environment.
7. Simulated Sensor Data Processing: Convert noisy sensor readings into meaningful position estimates.
8. Distributed SLAM: Implement SLAM for multiple agents operating in the same environment.
9. Large-Scale Map Compression: Reduce the complexity of a large SLAM graph.
10. Real-Time SLAM Optimization: Implement incremental optimization to make SLAM work in real-time.

20.2 Use Graph SLAM in a System Design Problem

Design a system where Graph SLAM plays a central role:

1. Autonomous Warehouse System: Implement a robot fleet using SLAM for navigation.
2. AR-Based Indoor Navigation: Use Graph SLAM for real-time location tracking in large buildings.
3. Self-Driving Car Sensor Integration: Design a system where Graph SLAM integrates with LiDAR and GPS.
4. Rescue Robot System: Simulate a rescue operation where a robot maps a disaster-struck area.
5. AI-Powered Museum Guide: Use Graph SLAM for an interactive robotic tour guide in museums.

20.3 Practice Implementing Graph SLAM Under Time Constraints

To improve efficiency, attempt to implement Graph SLAM in various time-constrained settings:

• Basic SLAM Implementation (1 hour): Implement a minimal SLAM system with pose graphs.
• Noise Filtering (30 minutes): Add noise handling to improve accuracy.
• Loop Closure (1 hour): Implement a system that detects revisited locations.
• Real-Time SLAM (2 hours): Modify the system to handle real-time data input.
• Optimize an Existing Graph (45 minutes): Take an unoptimized pose graph and improve its accuracy.

Tracking improvement over multiple sessions helps in competitive and practical applications of Graph SLAM.