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

> Explore LingBot-Map benchmark datasets. Learn about supported formats like KITTI and TUM RGB-D, and get clear instructions for data preparation. Enhance your computer vision projects.

- Repository: [Robbyant/lingbot-map](https://github.com/Robbyant/lingbot-map)
- Tags: how-to-guide
- Published: 2026-07-08

---

**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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/rgb.txt) associate frames with ground-truth trajectory data

### Tanks & Temples (TNT)

The `TntDataset` class in [`benchmark/datasets/tnt.py`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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:

```bash
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:**

```yaml
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:**

```yaml
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`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/benchmark/core/registry.py) file maps the `dataset:` string in YAML to concrete loader classes. The [`benchmark/benchmark/core/loader.py`](https://github.com/Robbyant/lingbot-map/blob/main/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:**

```python
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:**

```python
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`](https://github.com/Robbyant/lingbot-map/blob/main/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`](https://github.com/Robbyant/lingbot-map/blob/main/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.