File size: 4,989 Bytes
d03d465
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0398603
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
---
pretty_name: Robohand multi-view RGB-D hand capture
tags:
  - rgb-d
  - depth
  - multi-view
  - hand
  - realsense
  - data-glove
size_categories:
  - n<1K
---

# Robohand multi-view RGB-D hand capture

Raw sessions recorded with [Robohand](https://github.com/Ever2after/robohand): three Intel RealSense D405
cameras (colour + colour-aligned depth) on a shared host clock, one session with a MANUS data glove,
and the ChArUco extrinsic calibrations used for the multi-camera point cloud.

The data is the unprocessed output of the capture tool. It has no annotations and no train/test split.

## Layout

```
calibration.json                     # calibration that was active at the end of the last session
recordings/<YYYYMMDD_HHMMSS_us>/
  session.json                       # devices, intrinsics, per-track stats, timing notes
  d405{,_2,_3}_color.mp4             # H.264, 640x480, 30 fps timeline
  d405{,_2,_3}_depth.mp4             # colourised depth preview (lossy, display only)
  d405{,_2,_3}_depth_raw.mkv         # lossless FFV1 uint16 depth, aligned to the colour image
  d405{,_2,_3}_*_timestamps.csv      # per-output-frame host timestamps and repeat flags
  *_encoder.log                      # ffmpeg logs
  manus.jsonl                        # (one session) MANUS glove ergonomics / skeleton / raw data
calibrations/
  checkerboard_<timestamp>/          # one ChArUco extrinsic calibration run
    calibration.json                 # result: per-camera T_board_from_camera, board size, residuals
    calibration_previous.json        # the calibration it replaced
    highres/frame_XXX/               # captured colour + depth (.png / .npy) per camera
    overlays/                        # detection overlays
  depth_scale_<timestamp>/           # board-scale fit against D405 depth (earlier board estimate)
```

## Sessions

All sessions: 3 x D405 at 640x480, 15 fps capture, written to a 30 fps timeline (frames repeated when
no new sample arrived; see `repeated_frames` in `session.json`).

| Session | Duration | Extra streams | Calibration in use (inferred from timestamps) |
|---|---|---|---|
| 20261117_134147_822622 | 24 s | - | checkerboard_20261116_222942 |
| 20261117_141513_950731 | 103 s | - | checkerboard_20261117_140852 |
| 20261117_142147_402231 | 102 s | - | checkerboard_20261117_142035 |
| 20261117_143224_555777 | 95 s | - | checkerboard_20261117_142035 |
| 20261117_143843_991204 | 137 s | MANUS glove (both hands) | checkerboard_20261117_142035 |
| 20261117_144553_427534 | 26 s | - | checkerboard_20261117_144446 |

`session.json` does not record which calibration was active. The last column is the most recent calibration
written before the session started.

## Formats

**Depth.** `*_depth_raw.mkv` holds uint16 frames (FFV1, `gray16le`). Metric depth in metres is
`value * devices[camera_key].depth_scale_m` (1e-4 for the D405). The values `0` and `65535` mean
no depth. Depth is aligned to the colour camera, so use the `color_intrinsics` from `session.json` for both.

```python
import imageio_ffmpeg, numpy as np
reader = imageio_ffmpeg.read_frames("d405_depth_raw.mkv", pix_fmt="gray16le")
meta = next(reader)
depth = np.frombuffer(next(reader), np.uint16).reshape(480, 640)   # first frame
```

**Timing.** Every stream uses the host `time.monotonic()` clock. `start_monotonic_s` in `session.json` is the
zero point. The cameras are not hardware-synchronised. Each 30 fps output frame carries the newest sample
available at that time.

**MANUS glove** (`manus.jsonl`). The first line is a header (`"type": "header"`). It defines the
ergonomics angle names, the skeleton node tree (`skeleton_nodes`: id, parent, finger chain and joint for
each hand) and the array layouts. Each following line has a `stream` (`ergonomics`: 40 joint angles in
degrees, `skeleton`: 25 nodes as `[id, px, py, pz, qw, qx, qy, qz]`, `raw`: sensor and IMU poses), a
`gloves` list, `t_host_s` relative to `start_monotonic_s`, and `publish_utc_ms` (MANUS Core publish time,
1 ms resolution). Coordinates follow the MANUS VUH
convention: X from the viewer, Z up, right-handed, metres. The glove IDs map to left/right in
`session.json > manus > glove_sides`.

**Calibration.** The board is ChArUco, 7 x 5 squares, `DICT_6X6_250`, with marker = square x 18/25.
The board frame has X along the columns, Y opposite to the rows and Z up, in metres. Each camera has
`T_board_from_camera` (4x4) and `T_camera_from_board`. Cameras are matched by `serial`.

## Loading with Robohand

```
git clone https://github.com/Ever2after/robohand && cd robohand && setup.cmd
set ROBOHAND_DATA=<path to this dataset>
"Depth Replay 3D.cmd"
```

The replay tool overlays the three point clouds in the board frame and draws the glove skeleton next to them.
For each session it uses the calibration that was in effect at record time. These sessions have no stored
copy, so the tool picks the newest `calibrations/*/calibration.json` created before the session started
(the table above).