---
task_categories:
- depth-estimation
tags:
- robotics
- 3d-reconstruction
- realsense
- multi-view
- stereo
- tabletop
size_categories:
- 1K<n<10K
---

# RealSense Multi-Camera Tabletop

Synchronized multi-view RGB + stereo IR captures of a tabletop scene from **4 Intel RealSense
cameras**, recorded with fixed camera positions. Includes FoundationStereo depth for two scenes
and chessboard-derived extrinsics for merging the views into a single point cloud.

## Layout

```
scene_000NN/
├── camera_poses.json          # extrinsics, only in calibration scenes (see table)
└── <camera_serial>/
    ├── rgb/00000.jpg ... 00119.jpg      # 640x480 RGB
    ├── left/00000.jpg  ... 00119.jpg    # 640x480 grayscale, left IR
    ├── right/00000.jpg ... 00119.jpg    # 640x480 grayscale, right IR
    ├── stereo_depth/00000.npy           # (480,640) float64, metres — FoundationStereo output
    ├── stereo_aligned_depth/00000.npy   # (480,640) uint16 — above, reprojected to the colour frame
    └── meta_info.json                   # per-camera intrinsics + depth_scale
```

Camera serials, identical across all scenes:
`234322305266`, `336222300744`, `336522303601`, `339522301222`

## Contents

Every scene has all 4 cameras × 120 frames of `rgb`, `left`, and `right`. Depth and poses are
**not** uniform across scenes:

| scene | rgb/left/right | stereo_depth | stereo_aligned_depth | camera_poses.json | role |
|---|---|---|---|---|---|
| `scene_00001` | 120 | 120 | 120 | — | object |
| `scene_00002` | 120 | — | — | ✅ | chessboard calibration |
| `scene_00003` | 120 | — | — | — | object |
| `scene_00004` | 120 | — | — | — | object |
| `scene_00005` | 120 | 120 | 120 | — | object |
| `scene_00006` | 120 | — | — | ✅ | chessboard calibration |

Depth is a derived artifact: it is regenerated by running FoundationStereo on `left/` + `right/`,
so the four scenes without it can be filled in locally. Calibration scenes only ever need `rgb/`.

## Conventions

**`meta_info.json`** — `depth_intrinsics` and `color_intrinsics` each carry a 9-element
`intrinsic_matrix` in **column-major** order, i.e. `[fx, 0, 0, 0, fy, 0, cx, cy, 1]`. To use it:

```python
import json, numpy as np
m = json.load(open("scene_00001/234322305266/meta_info.json"))
K = np.array(m["color_intrinsics"]["intrinsic_matrix"]).reshape(3, 3).T
depth_scale = m["depth_scale"]   # 0.001 -> uint16 units are millimetres
```

**Depth units** — `stereo_depth/*.npy` is `float64` **metres**. `stereo_aligned_depth/*.npy` is
`uint16`; multiply by `depth_scale` (0.001) to get metres. Zero means no return.

**`camera_poses.json`** — maps each camera serial to `w2c` and `c2w`, both 4×4 row-major
homogeneous matrices, as produced by OpenCV chessboard pose estimation. `c2w` is the
inverse of `w2c`:

```python
poses = json.load(open("scene_00002/camera_poses.json"))
c2w = np.array(poses["234322305266"]["c2w"])   # camera -> world
```

## Merging views

Poses come from a chessboard scene; geometry and colour come from an object scene. This is valid
**only because the cameras never moved between them** — pair an object scene with a calibration
scene captured in the same session, matching cameras by serial:

```
object scene_00001 + poses from scene_00002
```

Reproject each camera's `stereo_aligned_depth` with its `color_intrinsics`, transform by that
camera's `c2w`, and concatenate to get a single merged cloud.

## Provenance

Captured and processed with the `realsense_multicam_tabletop` pipeline (RealSense capture →
FoundationStereo → depth-to-colour alignment → chessboard pose estimation → merge).