---
license: cc-by-nc-4.0
task_categories:
- robotics
tags:
- lerobot
- egocentric
- multimodal
- stereo
- imu
pretty_name: Robotrain Multi-Camera Sample Dataset
size_categories:
- 100K<n<1M
---

# Robotrain Multi-Camera Sample Dataset

A multimodal human egocentric observation dataset in **LeRobot v3** format.
It captures synchronized multi-view video and head motion sensing during
workshop material organization and object handling.

## About Robotrain

This dataset was collected by **Robotrain**, a robotics research company.

For more information about Robotrain and our work, visit our website: [https://robotrain.ai](https://robotrain.ai)

**What this dataset offers**

- Five time-aligned camera views: head RGB, head stereo pair, left wrist RGB,
  right wrist RGB
- Head 9-axis IMU (accelerometer, gyroscope, magnetometer) plus a fused
  orientation quaternion, resampled to the video clock
- Published stereo intrinsics, distortion, extrinsics and baseline for metric
  depth reconstruction from the stereo pair
- A measured cross-camera alignment bound (maximum skew **16.69 ms**, within
  one frame at 30 fps)
- Official LeRobot v3 layout with statistics suitable for normalization and
  dataset surgery
- Anonymous multi-session indices for session-aware splits

The release contains **observations only** (no robot actions or robot state).
It is intended for representation learning, cross-view learning, perception,
stereo/depth research and related pretraining.

Recorder/participant permission and venue authorization for this release have
been obtained. Licensed under **CC BY-NC 4.0** (noncommercial use with
attribution).

---

## Dataset summary

| Metric | Value |
| --- | --- |
| Total episodes | 213 |
| Total frames | 189,823 |
| Frame rate | 30 fps |
| Total duration | 105.5 minutes (1 h 45.5 min) |
| Recording sessions | 3 anonymous (`session_index` 0-2) |
| Video streams | 5 synchronized cameras |
| Sensor modalities | Head IMU (9) + orientation quaternion (4) |
| Unique tasks | 1 |
| Cross-camera alignment | < 1 frame at 30 fps (measured max skew 16.69 ms) |
| Video data size | ~20.1 GB |
| Sensor data size | ~5.9 MB (Parquet) |
| Typical / median episode | 30.0 s (900 frames) |
| Shortest episode | 7.3 s (219 frames) |
| Longest episode | 30.0 s (900 frames) |

### By session

| `session_index` | Episodes | Duration frames | Episode index range |
| --- | --- | --- | --- |
| 0 | 132 | 118,132 | 0-131 |
| 1 | 15 | 12,972 | 132-146 |
| 2 | 66 | 58,719 | 147-212 |

### By task

| Task | Episodes | Frames |
| --- | --- | --- |
| organizing workshop materials and handling objects | 213 | 189,823 |

Three episodes (indices 131, 146, 212) are shorter than the 30 s target; they
are session-boundary tails retained after unlabeled-frame curation.

---

## File structure

```text
dataset/
|__ README.md
|__ LICENSE
|__ meta/
|   |__ info.json                     # schema, features, configuration
|   |__ stats.json                    # per-feature statistics
|   |__ tasks.parquet                 # task label table
|   |__ stereo_calibration.json       # stereo intrinsics / extrinsics
|   |__ publication_manifest.json
|   |__ verification.json
|   |__ episodes/chunk-000/file-000.parquet
|__ data/chunk-000/file-000.parquet   # all sensor rows
|__ videos/
    |__ observation.images.egocentric/chunk-000/file-{000-212}.mp4
    |__ observation.images.stereo_left/chunk-000/file-{000-212}.mp4
    |__ observation.images.stereo_right/chunk-000/file-{000-212}.mp4
    |__ observation.images.wrist_left/chunk-000/file-{000-212}.mp4
    |__ observation.images.wrist_right/chunk-000/file-{000-212}.mp4
```

Each video file corresponds to one episode. Episode `N` maps to
`file-{N:03d}.mp4` across all camera streams.

---

## Modalities

### 1. Video streams (5 cameras)

All videos are H.264, 30 fps, `yuv420p`, with no audio.

| Stream | Resolution | Mounting / role |
| --- | --- | --- |
| `observation.images.egocentric` | 1280x800 | Head-mounted first-person RGB |
| `observation.images.stereo_left` | 640x400 | Head-mounted stereo left (3-channel container) |
| `observation.images.stereo_right` | 640x400 | Head-mounted stereo right (3-channel container) |
| `observation.images.wrist_left` | 1920x1080 | Left wrist / forearm RGB |
| `observation.images.wrist_right` | 1920x1080 | Right wrist / forearm RGB |

### 2. Head IMU

| Feature | Shape | Channels | Placement |
| --- | --- | --- | --- |
| `observation.imu.head` | (9,) | accel(3) + gyro(3) + mag(3) | Head / camera frame |
| `observation.imu.head_quat` | (4,) | `qi, qj, qk, qreal` | Fused orientation |

IMU streams are resampled to 30 fps to align with video frames.

### 3. Temporal alignment

All camera streams are synchronized to a shared 30 fps frame clock.
Measured maximum cross-camera skew for this release is **16.69 ms** (less than
one frame). Variable-rate IMU samples are held to the nearest video frame.

### 4. Stereo calibration and depth

`meta/stereo_calibration.json` describes the **shipped** stereo pixels
(640x400). Videos are **not** pre-rectified.

```text
Left  fx=284.19  fy=284.14  cx=323.84  cy=197.25
Right fx=285.46  fy=285.49  cx=316.32  cy=197.73
Distortion model: rational_polynomial_14 (14 coefficients per camera)
Baseline: 75.183 mm
left->right translation_mm ≈ [-75.17, 0.24, -1.10]
```

After rectification and stereo matching:

```text
depth_mm ≈ (fx * baseline_mm) / disparity
```

Use the published matrices as-is for these frames.

```python
import json
from pathlib import Path

import cv2
import numpy as np

root = Path("/path/to/dataset")
calib = json.loads((root / "meta/stereo_calibration.json").read_text())

K1 = np.asarray(calib["stereo_left"]["intrinsic_matrix"], dtype=np.float64)
K2 = np.asarray(calib["stereo_right"]["intrinsic_matrix"], dtype=np.float64)
D1 = np.asarray(calib["stereo_left"]["distortion_coefficients"], dtype=np.float64)
D2 = np.asarray(calib["stereo_right"]["distortion_coefficients"], dtype=np.float64)
R = np.asarray(calib["left_to_right_rotation"], dtype=np.float64)
T = np.asarray(calib["left_to_right_translation_mm"], dtype=np.float64).reshape(3, 1)
image_size = (calib["stereo_left"]["width"], calib["stereo_left"]["height"])

R1, R2, P1, P2, Q, _, _ = cv2.stereoRectify(
    K1, D1, K2, D2, image_size, R, T, flags=cv2.CALIB_ZERO_DISPARITY, alpha=0
)
print("baseline_mm", float(calib["baseline_mm"]))
print("Q shape", Q.shape)
```

---

## Loading the dataset

### Prerequisites

```bash
pip install lerobot pandas pyarrow opencv-python-headless
```

### Official LeRobot loader

```python
from pathlib import Path

from lerobot.datasets.lerobot_dataset import LeRobotDataset

root = Path("/path/to/dataset")
ds = LeRobotDataset(repo_id="local/Robotrain-multi-cam-sample", root=root)

print(len(ds), ds.meta.total_episodes, ds.fps)
sample = ds[0]
print(sample["observation.images.egocentric"].shape)  # (3, 800, 1280)
print(sample["observation.imu.head"].shape)           # (9,)
print(sample["task"])
```

### Parquet + video paths

```python
import json
from pathlib import Path

import numpy as np
import pandas as pd

root = Path("/path/to/dataset")
info = json.loads((root / "meta/info.json").read_text())
tasks = pd.read_parquet(root / "meta/tasks.parquet")
episodes = pd.read_parquet(root / "meta/episodes/chunk-000/file-000.parquet")
data = pd.read_parquet(root / "data/chunk-000/file-000.parquet")

episode_id = 0
ep = data[data["episode_index"] == episode_id].reset_index(drop=True)
imu = np.stack(ep["observation.imu.head"].to_numpy())
quat = np.stack(ep["observation.imu.head_quat"].to_numpy())

video = root / "videos/observation.images.egocentric/chunk-000/file-000.mp4"
print(info["total_frames"], len(episodes), list(tasks.index), imu.shape, video.is_file())
```

---

## Feature reference

| Feature | Type | Shape | Description |
| --- | --- | --- | --- |
| `observation.images.egocentric` | video | 1280x800x3 | Head RGB |
| `observation.images.stereo_left` | video | 640x400x3 | Stereo left |
| `observation.images.stereo_right` | video | 640x400x3 | Stereo right |
| `observation.images.wrist_left` | video | 1920x1080x3 | Left wrist RGB |
| `observation.images.wrist_right` | video | 1920x1080x3 | Right wrist RGB |
| `observation.imu.head` | float32 | (9,) | accel + gyro + mag |
| `observation.imu.head_quat` | float32 | (4,) | orientation quaternion |
| `timestamp` | float32 | (1,) | seconds within episode |
| `frame_index` | int64 | (1,) | frame within episode |
| `episode_index` | int64 | (1,) | episode id |
| `index` | int64 | (1,) | global row index |
| `task_index` | int64 | (1,) | task id |
| `session_index` | int64 | (1,) | anonymous session id |

Public training features are limited to the table above. Internal timing
diagnostics, sensor-confidence flags, source identifiers and unpublished
calibration are not part of this release. Standard LeRobot `meta/stats.json`
and per-episode `stats/*` columns are retained for normalization and surgery.

---

## License

Creative Commons Attribution-NonCommercial 4.0 International (`cc-by-nc-4.0`).
You may share and adapt for noncommercial purposes with attribution. Commercial
use is not permitted. See `LICENSE`.