DSLO-SLAM

Deep Salient Loop-closure SLAM — An RGB-D Visual SLAM system built on the ORB-SLAM framework, integrating deep learning-based feature extraction (YOLO) and CNN-based loop closure detection for robust localization and 3D reconstruction in indoor environments.

System Architecture

slam/
├── main/              # C++ core SLAM system
│   ├── src/           # Main system source (including cnn_lcd module)
│   ├── include/       # Header files
│   ├── Thirdparty/    # Third-party dependencies (DBoW2, g2o, Sophus, YOLO variants, TensorRT)
│   ├── Examples/      # RGB-D example programs
│   ├── evaluation/    # Accuracy evaluation tools
│   └── Vocabulary/    # Bag-of-Words vocabulary files
└── cnn_lcd_torch/     # PyTorch-based CNN loop closure detection module
    ├── models/        # Network model definitions
    └── src/           # Python training and inference source code

Core Modules

Module	Description
ORB Feature Extraction	Keypoint detection and descriptor extraction using ORB
DBoW2 Bag-of-Words	Visual vocabulary model for scene recognition and loop candidate retrieval
g2o Graph Optimization	Back-end pose estimation via graph optimization
YOLO Object Detection	Integrated YOLOv5/v7/v8 with TensorRT acceleration, supports dynamic object filtering
CNN Loop Closure Detection	Deep convolutional network (Inception, etc.) based loop closure detection, supplementing traditional BoW

Dependencies & Runtime Environment

• OS: Ubuntu 20.04 / 22.04
• CUDA: 11.6+ (11.8 recommended)
• cuDNN: 8.x
• TensorRT: 8.6.x (for YOLO inference acceleration)
• OpenCV: 3.4.5 (built in-tree)
• Pangolin: 3D visualization
• Python: 3.7 (CNN module)
• PyTorch: 1.13.1 + CUDA 11.6

All dependencies are managed through a Docker image — no manual installation required.

Quick Start

1. Build the Development Container (first time only)

./scripts/containnerize.sh   # Build the Docker image with all dependencies
./scripts/create_dev_container.sh

2. Launch the Development Environment

./scripts/launch_dev_container.sh

Connect to the container (choose one):

# Method 1: SSH
ssh -p 2222 root@127.0.0.1

# Method 2: Docker exec
docker exec -it VSLAM-DEV /bin/bash

3. Set Up Environment Variables

Inside the container:

source .env.sh

4. Prepare Datasets

Place RGB-D datasets under data/main/, then run the timestamp association script:

./scripts/associate.sh

Supported datasets (TUM RGB-D / Bonn RGB-D):

• rgbd_dataset_freiburg1_*
• rgbd_dataset_freiburg2_*
• rgbd_dataset_freiburg3_*
• rgbd_bonn_*

5. Build the Core System

./scripts/build_main.sh

6. Run SLAM

./scripts/run.sh

7. Run CNN Loop Closure Detection

./scripts/run_lcd.sh

Output Directory Structure

After running source .env.sh, output paths are controlled by environment variables:

Variable	Default Path	Description
LCD_OUTPUT_BASE	/workspace/dev/out/lcd	Loop closure detection output
MAIN_OUTPUT_BASE	/workspace/dev/out/main	Main SLAM system output
SLAM_OUTPUT_BASE	/workspace/dev/out/slam	SLAM comprehensive results

Evaluation

Accuracy evaluation tools are located in slam/main/evaluation/. They compare the estimated trajectory against ground truth:

cd slam/main/evaluation/

Project Structure Overview

├── Dockerfile          # Base container definition
├── .env.sh             # Environment variable configuration
├── .dep-versions       # Dependency version records
├── scripts/            # Build and run scripts
│   ├── containnerize.sh       # Build Docker image
│   ├── create_dev_container.sh
│   ├── launch_dev_container.sh
│   ├── associate.sh           # Dataset timestamp association
│   ├── build.sh / build_main.sh
│   ├── run.sh / run_lcd.sh
│   └── lib/associate.py       # Association utility (Python)
├── slam/
│   ├── main/           # C++ SLAM core
│   └── cnn_lcd_torch/  # CNN loop closure detection (PyTorch)
└── fixtures/           # Pretrained weights (YOLOv8, etc.)

Notes

• When building the Docker image, third-party library archives (TensorRT, OpenCV, Pangolin) must be prepared in advance; see scripts/containnerize.sh for details
• YOLO TensorRT engine files (.engine) are generated at first runtime inside the container
• Running visualizations (Pangolin) requires GPU passthrough; launch_dev_container.sh already configures --gpus all
• .gitignore excludes large files (weights, engines, build artifacts) — check before committing