LingBot-Map Benchmark Datasets: Complete Guide to Supported Formats and Data Preparation

LingBot-Map supports ten major computer vision datasets including KITTI, TUM RGB-D, Tanks & Temples, and ETH3D through a unified BaseDataset interface that requires specific directory structures and offers optional COLMAP reconstruction for uncalibrated sequences.

The Robbyant/lingbot-map repository provides a modular benchmark framework for SLAM and visual odometry evaluation. At its core, the system uses an abstract BaseDataset class defined in benchmark/dataset/base.py to standardize loading across diverse formats. Understanding these LingBot-Map benchmark datasets and their specific preparation requirements ensures seamless integration with the evaluation pipeline.

Supported Dataset Formats

Each dataset loader inherits from BaseDataset and implements three core methods: get_scenes() to list available sequences, get_frame_list(scene) to return ordered frame indices, and load_frame_data(scene, frame_id) to return dictionaries containing RGB images, intrinsics, and poses.

General Image Folders and Video Files

The GeneralDataset class in benchmark/datasets/general.py handles arbitrary image collections or video files.

• Directory Layout: Place PNG, JPG, BMP, or TIFF files directly in <root>/ or provide a single video file at <root>/my_video.mp4 (frames extract to <root>/my_video_frames/)
• Key Features: No strict hierarchy required; optional COLMAP reconstruction via _use_colmap: true in configuration
• COLMAP Integration: When enabled, the loader executes feature extraction, sequential matching, and mapping, caching results in <image_dir>/colmap_workspace/

KITTI Odometry

The KittiDataset class in benchmark/datasets/kitti.py supports the KITTI visual odometry benchmark.

• Directory Layout:

  
  <root>/poses/00.txt ... 10.txt
  <root>/sequences/00/image_2/xxxxx.png
  

• Requirements: Ground-truth poses in poses/ directory; camera calibration in sequences/<seq>/calib.txt

• Options: Supports target_size parameter for patch-aligned resizing (dimensions must be multiples of 14)

VBR (Vision Benchmark in Rome)

The VbrDataset class in benchmark/datasets/vbr.py handles the VBR dataset with specific alignment requirements.

• Directory Layout:

  
  <root>/<scene>_processed_aligned/rgb/*.png
  <root>/<scene>_processed_aligned/camera_pose.txt
  <root>/<scene>_processed_aligned/intrinsics.txt
  <root>/processed_gt/<scene>_gt.txt
  

• Requirements: Intrinsics stored as 3×3 K matrix; ground-truth poses in TUM format within processed_gt/

• Resizing: Uses _cover_fit_center_crop to handle aspect ratio changes while maintaining intrinsics alignment

TUM RGB-D

The TumDataset class in benchmark/datasets/tum.py supports the TUM RGB-D SLAM dataset.

• Directory Layout:

  
  <root>/<scene_name>/rgb/*.png
  <root>/<scene_name>/rgb.txt
  <root>/<scene_name>/groundtruth.txt
  

• Requirements: Ground-truth poses in TUM format; intrinsics selected automatically based on Freiburg camera identifier (freiburg1/2/3)

• Association: Timestamps in rgb.txt associate frames with ground-truth trajectory data

Tanks & Temples (TNT)

The TntDataset class in benchmark/datasets/tnt.py supports the Tanks & Temples benchmark.

• Directory Layout:

  
  <root>/<scene>/000001.jpg ...
  <root>/<scene>/<scene>_COLMAP_SfM.log
  <root>/<scene>/<scene>.ply
  <root>/<scene>/<scene>.json
  <root>/<scene>/<scene>_trans.txt
  

• Requirements: COLMAP SfM log provides per-frame camera-to-world poses; intrinsics approximated as fx = fy ≈ 1.2 × width

ETH3D

The Eth3dDataset class in benchmark/datasets/eth3d.py supports the ETH3D SLAM benchmark.

• Directory Layout:

  
  <root>/undistorted/<scene>/images/*.png
  <root>/undistorted/<scene>/poses.txt
  

• Requirements: Poses stored in ETH3D format; intrinsics read from dataset calibration files

NeuralRGB-D

The NeuralRgbdDataset class in benchmark/datasets/neural_rgbd.py supports the NeuralRGB-D benchmark sequences.

• Directory Layout:

  
  <root>/data/<scene>/rgb/*.png
  <root>/data/<scene>/pose.txt
  

• Requirements: Per-frame poses stored in dedicated text files; designed for neural rendering evaluations

Oxford Spires

The OxfordSpiresDataset class in benchmark/datasets/oxford_spires.py handles outdoor Oxford Spires sequences.

• Directory Layout:

  
  <root>/oxford_spires/<scene>/rgb/*.png
  <root>/oxford_spires/<scene>/poses.txt
  

• Requirements: Fixed scene list similar to General loader but with standardized path conventions

Droid-W

The DroidWDataset class in benchmark/datasets/droid_w.py supports Droid-W sequences.

• Directory Layout:

  
  <root>/droid_w/<scene>/rgb/*.png
  <root>/droid_w/<scene>/colmap.txt
  

• Requirements: Uses COLMAP-generated trajectory files; intrinsics extracted from COLMAP reconstruction data

Seven Scenes

The SevenScenesDataset class in benchmark/datasets/seven_scenes.py supports the classic indoor Seven Scenes benchmark.

• Directory Layout:

  
  <root>/7scenes/<scene>/rgb/*.png
  <root>/7scenes/<scene>/groundtruth.txt
  

• Requirements: Intrinsics are hard-coded per scene in the loader; ground-truth poses follow TUM format

Data Preparation Workflow

Preparing LingBot-Map benchmark datasets requires strict adherence to directory structures and optional preprocessing steps.

1. Download and Organize Raw Data

Download sequences from official sources (KITTI website, TUM portal, etc.) and arrange them exactly as specified above. The benchmark code does not reshape or move files; it only reads pre-existing structures.

2. Configure COLMAP Reconstruction (Optional)

For datasets without pose data or when using the General loader, enable COLMAP reconstruction:

• Set _use_colmap: true in the YAML configuration
• Ensure the COLMAP binary is available on system PATH or specify via colmap_binary
• The loader executes feature extraction, sequential matching, and mapping automatically
• Results cache in <image_dir>/colmap_workspace/ to avoid recomputation

3. Resize Images for Patch Alignment

Many loaders accept target_size (width × height) or load_img_size parameters:

• The code automatically rescales intrinsics to match resized images
• For transformer-based models, both dimensions must be multiples of 14
• The loader raises ValueError if patch alignment constraints are violated

4. Validate the Layout

Test your preparation using the demo script:

python demo.py --config configs/kitti.yaml

This instantiates the dataset, lists available scenes, and loads sample frames, printing tensor shapes and pose information.

Configuration and Python API

YAML Configuration Examples

KITTI Odometry Configuration:

datasets:
  kitti_odometry:
    dataset: kitti
    raw_data_root: /data/kitti_odometry
    sequences: ["00", "02"]      # optional whitelist

    target_size: [640, 480]      # must be multiples of 14

    _use_colmap: false

General Dataset with COLMAP:

datasets:
  my_images:
    dataset: general
    raw_data_root: /data/my_image_folder
    _use_colmap: true            # triggers COLMAP reconstruction

    load_img_size: 720           # optional width resize

Registry Mapping:

The benchmark/benchmark/core/registry.py file maps the dataset: string in YAML to concrete loader classes. The benchmark/benchmark/core/loader.py module provides the high-level entry point that builds dataset objects from configuration dictionaries.

Programmatic Access

Loading a single frame from KITTI:

from benchmark.datasets.kitti import KittiDataset

kitti = KittiDataset(
    raw_data_root="/data/kitti_odometry",
    sequences=["00"],
    target_size=[640, 480],
)

scene = kitti.get_scenes()[0]      # "00"

frame_id = 10
frame = kitti.load_frame_data(scene, frame_id)

print(frame["rgb"].shape)          # (480, 640, 3)

print(frame["intrinsics"])         # [fx, fy, cx, cy]

print(frame["pose"].shape)         # (4, 4) or None

Iterating over VBR scenes:

from benchmark.datasets.vbr import VbrDataset

vbr = VbrDataset(
    raw_data_root="/data/vbr",
    target_size=[512, 512],
)

for scene in vbr.get_scenes():
    for fid in vbr.get_frame_list(scene):
        data = vbr.load_frame_data(scene, fid)
        # Access data["rgb"], data["pose"], data["intrinsics"]

Summary

• LingBot-Map supports ten dataset formats including KITTI, TUM RGB-D, ETH3D, Seven Scenes, Tanks & Temples, VBR, NeuralRGB-D, Oxford Spires, and Droid-W through specialized loader classes in benchmark/datasets/
• All loaders inherit from BaseDataset implemented in benchmark/dataset/base.py and expose standardized get_scenes(), get_frame_list(), and load_frame_data() methods
• Strict directory structures are required for each dataset format; the framework does not reorganize files automatically
• Optional COLMAP reconstruction enables pose estimation for uncalibrated sequences via the GeneralDataset or _use_colmap flag
• Patch alignment constraints require image dimensions to be multiples of 14 when using transformer-based models
• Unified registry system in benchmark/benchmark/core/registry.py maps configuration strings to dataset classes for seamless benchmark execution

Frequently Asked Questions

Does LingBot-Map automatically download datasets?

No. You must download raw data from official sources (KITTI, TUM, ETH3D, etc.) and organize them into the specific directory structures expected by each loader. The framework only reads existing files and does not perform data acquisition or reorganization.

How do I handle datasets without ground-truth poses?

Use the GeneralDataset class with _use_colmap: true in your YAML configuration. This triggers automatic COLMAP reconstruction to generate camera poses and intrinsics. Ensure COLMAP is installed and available on your system PATH, as the loader executes colmap feature_extractor, colmap sequential_matcher, and colmap mapper commands sequentially.

What happens if my image dimensions are not multiples of 14?

The loader raises a ValueError when patch alignment constraints are violated. You must specify target_size or load_img_size parameters that result in dimensions divisible by 14. The framework automatically rescales intrinsics (focal lengths and principal points) to match the resized images using methods like _cover_fit_center_crop in relevant loaders.

Can I use custom intrinsics with the General dataset loader?

Yes. When using GeneralDataset with existing COLMAP reconstructions, intrinsics are read from the COLMAP workspace. Alternatively, you can modify the returned dictionary from load_frame_data() to inject custom calibration parameters, though this requires extending the base class or post-processing the output dictionary in your evaluation script.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}