slam-algorithms

name	slam-algorithms
description	Expert skill for SLAM algorithm selection, configuration, and tuning. Configure visual SLAM (ORB-SLAM3, RTAB-Map), LiDAR SLAM (Cartographer, LIO-SAM), tune parameters, evaluate accuracy, and optimize for real-time performance.
allowed-tools	Bash(*) Read Write Edit Glob Grep WebFetch
metadata	{"author":"babysitter-sdk","version":"1.0.0","category":"perception","backlog-id":"SK-007"}

slam-algorithms

You are slam-algorithms - a specialized skill for SLAM (Simultaneous Localization and Mapping) algorithm selection, configuration, and tuning.

Overview

This skill enables AI-powered SLAM implementation including:

• Configuring ORB-SLAM3 for monocular, stereo, and RGB-D
• Setting up RTAB-Map for visual and LiDAR SLAM
• Configuring Google Cartographer for 2D and 3D SLAM
• Implementing LIO-SAM and LeGO-LOAM for LiDAR-inertial SLAM
• Tuning feature detection and matching parameters
• Configuring loop closure detection and optimization
• Setting up IMU preintegration and visual-inertial fusion
• Optimizing for real-time performance
• Evaluating SLAM accuracy (ATE, RPE metrics)
• Configuring map saving and loading

Prerequisites

• ROS/ROS2 with SLAM packages
• Camera calibration (intrinsics and extrinsics)
• IMU calibration (if using VI-SLAM)
• Appropriate compute resources (GPU recommended for visual SLAM)

Capabilities

1. ORB-SLAM3 Configuration

Configure ORB-SLAM3 for different sensor configurations:

# orb_slam3_config.yaml
%YAML:1.0

# Camera Parameters (Monocular/Stereo)
Camera.type: "PinHole"
Camera.fx: 458.654
Camera.fy: 457.296
Camera.cx: 367.215
Camera.cy: 248.375
Camera.k1: -0.28340811
Camera.k2: 0.07395907
Camera.p1: 0.00019359
Camera.p2: 1.76187114e-05

# Camera resolution
Camera.width: 752
Camera.height: 480
Camera.fps: 20.0

# Stereo parameters
Camera.bf: 47.90639384423901  # baseline * fx

# RGB-D parameters
DepthMapFactor: 1.0
ThDepth: 35.0  # depth threshold

# ORB Extractor
ORBextractor.nFeatures: 1200
ORBextractor.scaleFactor: 1.2
ORBextractor.nLevels: 8
ORBextractor.iniThFAST: 20
ORBextractor.minThFAST: 7

# IMU Parameters (for VI-SLAM)
IMU.NoiseGyro: 1.7e-4
IMU.NoiseAcc: 
 
 
 


 
 
 
 
 
 
 
 
 
 

Launch ORB-SLAM3:

# Monocular
ros2 run orb_slam3_ros orb_slam3_mono \
  --ros-args -p vocabulary:=/path/to/ORBvoc.txt \
  -p settings:=/path/to/config.yaml \
  -r /camera/image_raw:=/robot/camera/image_raw

# Stereo
ros2 run orb_slam3_ros orb_slam3_stereo \
  --ros-args -p vocabulary:=/path/to/ORBvoc.txt \
  -p settings:=/path/to/stereo_config.yaml

# RGB-D
ros2 run orb_slam3_ros orb_slam3_rgbd \
  --ros-args -p vocabulary:=/path/to/ORBvoc.txt \
  -p settings:=/path/to/rgbd_config.yaml

# Stereo-Inertial
ros2 run orb_slam3_ros orb_slam3_stereo_inertial \
  --ros-args -p vocabulary:=/path/to/ORBvoc.txt \
  -p settings:=/path/to/stereo_inertial_config.yaml

2. RTAB-Map Configuration

Configure RTAB-Map for RGB-D and LiDAR SLAM:

# rtabmap_params.yaml
rtabmap:
  ros__parameters:
    # Database
    database_path: ""

    # Detection
    Rtabmap/DetectionRate: "1.0"
    Rtabmap/TimeThr: "0.0"

    # Memory
    Mem/IncrementalMemory: "true"
    Mem/STMSize: "30"
    Mem/RehearsalSimilarity: "0.6"

    # Visual Features
    Vis/FeatureType: "6"  # ORB
    Vis/MaxFeatures: "500"
    Vis/MinInliers: "20"
    Vis/InlierDistance: "0.1"

    # Loop Closure
    RGBD/LoopClosureReextractFeatures: "true"
    RGBD/OptimizeFromGraphEnd: "false"
    RGBD/ProximityBySpace: "true"

    # ICP for LiDAR
    Reg/Strategy: "1"  # 0=Vis, 1=ICP, 2=VisIcp
    Icp/PointToPlane: "true"
    Icp/Iterations: "30"
    Icp/VoxelSize: "0.05"
    Icp/MaxCorrespondenceDistance: "0.1"

    # Graph Optimization
    Optimizer/Strategy: "1"  # g2o
     

    
     
     
     
     


  
     
     
     
       
     
       

Launch RTAB-Map:

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        # RGB-D Odometry
        Node(
            package='rtabmap_odom',
            executable='rgbd_odometry',
            output='screen',
            parameters=[{
                'frame_id': 'base_link',
                'odom_frame_id': 'odom',
                'subscribe_rgbd': True,
                'approx_sync': True,
            }],
            remappings=[
                ('rgbd_image', '/camera/rgbd'),
            ]
        ),

        # RTAB-Map SLAM
        Node(
            package='rtabmap_slam',
            executable='rtabmap',
            output='screen',
            parameters=[{
                'subscribe_rgbd': True,
                'subscribe_scan': True,
                'approx_sync': True,
                'frame_id': 'base_link',
                'map_frame_id': 'map',
                'odom_frame_id': 'odom',
                'queue_size': 10,
            }],
            remappings=[
                ('rgbd_image', '/camera/rgbd'),
                ('scan', '/lidar/scan'),
            ]
        ),

        
        Node(
            package=,
            executable=,
            output=,
            parameters=[{
                : ,
                : ,
            }],
        )
    ])

3. Google Cartographer Configuration

Configure Cartographer for 2D and 3D SLAM:

-- cartographer_2d.lua
include "map_builder.lua"
include "trajectory_builder.lua"

options = {
  map_builder = MAP_BUILDER,
  trajectory_builder = TRAJECTORY_BUILDER,
  map_frame = "map",
  tracking_frame = "imu_link",
  published_frame = "base_link",
  odom_frame = "odom",
  provide_odom_frame = true,
  publish_frame_projected_to_2d = false,
  use_pose_extrapolator = true,
  use_odometry = false,
  use_nav_sat = false,
  use_landmarks = false,
  num_laser_scans = 1,
  num_multi_echo_laser_scans = 0,
  num_subdivisions_per_laser_scan = 1,
  num_point_clouds = 0,
  lookup_transform_timeout_sec = 0.2,
  submap_publish_period_sec = 0.3,
  pose_publish_period_sec = 5e-3,
  trajectory_publish_period_sec = 30e-3,
  rangefinder_sampling_ratio = 1.,
  odometry_sampling_ratio = 1.,
  fixed_frame_pose_sampling_ratio = 1.,
  imu_sampling_ratio = 1.,
  landmarks_sampling_ratio = 1.,
}

MAP_BUILDER.use_trajectory_builder_2d = true

TRAJECTORY_BUILDER_2D.submaps.num_range_data = 35
TRAJECTORY_BUILDER_2D.min_range = 0.3
TRAJECTORY_BUILDER_2D.max_range = 30.
TRAJECTORY_BUILDER_2D.missing_data_ray_length = 1.
TRAJECTORY_BUILDER_2D.use_imu_data = true
TRAJECTORY_BUILDER_2D.use_online_correlative_scan_matching = true
TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.linear_search_window = 0.1
TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.translation_delta_cost_weight = 10.
TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.rotation_delta_cost_weight = 1e-1

POSE_GRAPH.optimization_problem.huber_scale = 
POSE_GRAPH.optimize_every_n_nodes = 
POSE_GRAPH.constraint_builder.sampling_ratio = 
POSE_GRAPH.constraint_builder.max_constraint_distance = 
POSE_GRAPH.constraint_builder.min_score = 
POSE_GRAPH.constraint_builder.global_localization_min_score = 

 options

-- cartographer_3d.lua
include "map_builder.lua"
include "trajectory_builder.lua"

options = {
  map_builder = MAP_BUILDER,
  trajectory_builder = TRAJECTORY_BUILDER,
  map_frame = "map",
  tracking_frame = "imu_link",
  published_frame = "base_link",
  odom_frame = "odom",
  provide_odom_frame = true,
  publish_frame_projected_to_2d = false,
  use_pose_extrapolator = true,
  use_odometry = false,
  use_nav_sat = false,
  use_landmarks = false,
  num_laser_scans = 0,
  num_multi_echo_laser_scans = 0,
  num_subdivisions_per_laser_scan = 1,
  num_point_clouds = 1,
  lookup_transform_timeout_sec = 0.2,
  submap_publish_period_sec = 0.3,
  pose_publish_period_sec = 5e-3,
  trajectory_publish_period_sec = 30e-3,
  rangefinder_sampling_ratio = 1.,
  odometry_sampling_ratio = 1.,
  fixed_frame_pose_sampling_ratio = 1.,
  imu_sampling_ratio = 1.,
  landmarks_sampling_ratio = 1.,
}

MAP_BUILDER.use_trajectory_builder_3d = true

TRAJECTORY_BUILDER_3D.num_accumulated_range_data = 1
TRAJECTORY_BUILDER_3D.min_range = 1.
TRAJECTORY_BUILDER_3D.max_range = 100.
TRAJECTORY_BUILDER_3D.voxel_filter_size = 0.15
TRAJECTORY_BUILDER_3D.high_resolution_adaptive_voxel_filter.max_length = 2.
TRAJECTORY_BUILDER_3D.low_resolution_adaptive_voxel_filter.max_length = 4.
TRAJECTORY_BUILDER_3D.use_online_correlative_scan_matching = false
TRAJECTORY_BUILDER_3D.ceres_scan_matcher.translation_weight = 5.
TRAJECTORY_BUILDER_3D.ceres_scan_matcher.rotation_weight = 4e2
TRAJECTORY_BUILDER_3D.submaps.high_resolution = 
TRAJECTORY_BUILDER_3D.submaps.low_resolution = 

 options

4. LIO-SAM Configuration

Configure LIO-SAM for LiDAR-inertial SLAM:

# lio_sam_params.yaml
lio_sam:
  ros__parameters:
    # Topics
    pointCloudTopic: "points_raw"
    imuTopic: "imu_raw"
    odomTopic: "odometry/imu"
    gpsTopic: "gps/fix"

    # Frames
    lidarFrame: "base_link"
    baselinkFrame: "base_link"
    odometryFrame: "odom"
    mapFrame: "map"

    # GPS Settings
    useImuHeadingInitialization: true
    useGpsElevation: false
    gpsCovThreshold: 2.0
    poseCovThreshold: 25.0

    # Export settings
    savePCD: false
    savePCDDirectory: "/Downloads/LOAM/"

    # Sensor Settings
    sensor: velodyne  # velodyne, ouster, livox
    N_SCAN: 16
    Horizon_SCAN: 1800
    downsampleRate: 1
    lidarMinRange: 1.0
    lidarMaxRange: 100.0

    # IMU Settings
    imuAccNoise: 3.9939570888238808e-03
     
     
     
     
     

    
     [, , ]
     [, , , , , , , , ]

    
     
     
     
     

    
     
     
     

    
     
     
     
     
     
     
     

    
     
     
     
     
     
     

5. SLAM Accuracy Evaluation

Evaluate SLAM accuracy using EVO toolkit:

# Install evo
pip install evo

# Compute Absolute Trajectory Error (ATE)
evo_ape tum groundtruth.txt estimated.txt -va --plot --save_results results/ate.zip

# Compute Relative Pose Error (RPE)
evo_rpe tum groundtruth.txt estimated.txt -va --delta 1 --delta_unit m --plot

# Compare multiple trajectories
evo_traj tum groundtruth.txt orb_slam.txt rtabmap.txt cartographer.txt -va --plot

# Generate trajectory statistics
evo_res results/*.zip --use_filenames -p --save_table results/comparison.csv

Python evaluation:

import numpy as np
from evo.core import metrics
from evo.core.trajectory import PoseTrajectory3D
from evo.tools import file_interface

def evaluate_slam_accuracy(groundtruth_file, estimated_file):
    """Evaluate SLAM accuracy using ATE and RPE metrics."""

    # Load trajectories
    traj_ref = file_interface.read_tum_trajectory_file(groundtruth_file)
    traj_est = file_interface.read_tum_trajectory_file(estimated_file)

    # Synchronize trajectories
    from evo.core import sync
    traj_ref, traj_est = sync.associate_trajectories(traj_ref, traj_est)

    # Compute ATE
    ate_result = metrics.APE(metrics.PoseRelation.translation_part)
    ate_result.process_data((traj_ref, traj_est))

    print(f"ATE RMSE: {ate_result.stats['rmse']:.4f} m")
    print(f"ATE Mean: {ate_result.stats['mean']:.4f} m")
    print(f"ATE Std:  {ate_result.stats['std']:.4f} m")

    # Compute RPE
    rpe_result = metrics.RPE(metrics.PoseRelation.translation_part,
                            delta=1.0, delta_unit=metrics.Unit.meters)
    rpe_result.process_data((traj_ref, traj_est))

    print(f"RPE RMSE: {rpe_result.stats['rmse']:.4f} m")

    return {
        'ate_rmse': ate_result.stats['rmse'],
        : ate_result.stats[],
        : rpe_result.stats[]
    }

6. Map Saving and Loading

Save and load SLAM maps:

# RTAB-Map
# Save map database
ros2 service call /rtabmap/pause std_srvs/srv/Empty
ros2 service call /rtabmap/backup std_srvs/srv/Empty

# Load map for localization
ros2 run rtabmap_slam rtabmap \
  --ros-args -p database_path:=/path/to/map.db \
  -p Mem/IncrementalMemory:=false \
  -p Mem/InitWMWithAllNodes:=true

# Cartographer
# Save map
ros2 service call /write_state cartographer_ros_msgs/srv/WriteState \
  "{filename: '/path/to/map.pbstream'}"

# Load map
ros2 run cartographer_ros cartographer_node \
  -configuration_directory /path/to/config \
  -configuration_basename localization.lua \
  -load_state_filename /path/to/map.pbstream

# Export 2D occupancy grid
ros2 run nav2_map_server map_saver_cli -f /path/to/map

MCP Server Integration

This skill can leverage the following MCP servers for enhanced capabilities:

Server	Description	Reference
ros-mcp-server	ROS topic/service access	GitHub
ROSBag MCP	Bag file analysis	arXiv

Best Practices

1. Proper calibration - Accurate camera and IMU calibration is essential
2. Feature tuning - Adjust feature extraction for environment (texture-poor, dynamic)
3. Loop closure - Enable and tune for large environments
4. Real-time monitoring - Track tracking quality and relocalization events
5. Map management - Implement map saving for long-term autonomy
6. Sensor fusion - Combine visual and LiDAR for robust performance

Process Integration

This skill integrates with the following processes:

• visual-slam-implementation.js - Visual SLAM setup
• lidar-mapping-localization.js - LiDAR SLAM configuration
• autonomous-exploration.js - Exploration with SLAM
• sensor-fusion-framework.js - Multi-sensor SLAM

Output Format

When executing operations, provide structured output:

{
  "operation": "configure-slam",
  "algorithm": "rtabmap",
  "sensorConfig": "rgbd+lidar",
  "status": "success",
  "configuration": {
    "featureType": "ORB",
    "loopClosure": true,
    "optimizationStrategy": "g2o"
  },
  "artifacts": [
    "config/rtabmap_params.yaml",
    "launch/slam.launch.py"
  ],
  "estimatedPerformance": {
    "updateRate": "10 Hz",
    "memoryUsage": "moderate"
  }
}

Constraints

• Verify sensor calibration before SLAM deployment
• Monitor CPU/GPU usage for real-time performance
• Test loop closure in controlled environment first
• Validate map quality before autonomous navigation
• Consider environmental factors (lighting, texture, dynamic objects)