# Data Dictionary — `Bigenlight/carrot_in_pot_raw`

Raw teleoperation recordings for the task **"Put carrot in pot"**, captured via a
**GELLO leader → UR7e follower** setup with two Intel RealSense D435 cameras — **colour and
depth** — in a single session on **2026-09-14**.

This document describes the **RAW** release: the original per-take HDF5 signal logs, the original
camera MP4s, and the original compressed-depth HDF5s, exactly as recorded. For a ready-to-train
version see the LeRobot dataset
[`carrot_in_pot_lerobot_v3`](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_lerobot_v3).

- **Scale:** 54 takes (`take_*`) · 18,557 cam1 colour frames (18,557 cam2) · 18,541 cam1 depth
  frames (18,538 cam2) · 619.33 s (10.3 min) · 3.73 GB
- **Every take folder** `take_NN_20260914_HHMMSS/` contains exactly four files:
  `vectors.h5`, `depth.h5`, `cam1.mp4`, `cam2.mp4`. Measured: no hidden or stray files, no
  sub-directories, in any of the 54 folders.
- Verified read-only against all 54 `vectors.h5`, all 54 `depth.h5` and all 108 MP4s; **no
  absolute-path leakage** and no PII inside the HDF5 files.
- Every figure in this document was measured from the files themselves by
  `make_carrot_raw_stats.py`. The machine-readable version is
  [`dataset_stats.json`](dataset_stats.json).
- ⚠️ **Read §3.6 before you align streams.** Three of the nine groups — `ur_joint_states`,
  `tcp_pose` and `wrench` — carry timestamps that are **late by a constant** (0.900 s and ≈0.41 s).
  It is a recorder artefact, it is a pure delay, and it is **not** corrected in these files.

---

## 1. Hardware & recording setup

| Component | Spec |
|---|---|
| **Robot (follower)** | **Universal Robots UR7e** — 6-DOF collaborative arm. Joint angles/velocities in **radians** / rad·s⁻¹. This is the arm that executes and the **only** arm used as policy input at inference. |
| **Teleoperation (leader)** | **GELLO** — low-cost 3D-printed 6-DOF leader arm, moved by hand. The recorded `gello_*` streams are the **leader** signal. Because this session ran in EEF mode (next row) they are **not** a joint-space mirror of the follower — see §3.4 and §9. Do not use `gello_*` as an input feature. |
| **Control mode** | **End-effector (EEF) delta teleop** — `ur7e_gello_real.launch.py robot_ip:=<ROBOT_IP> headless_mode:=true control_mode:=eef`. The bridge computes the leader's end-effector pose by forward kinematics of a *virtual leader chain*, takes the **pose delta**, and solves **IK on the UR7e**; the resulting absolute joint targets are what `command` contains. **This is the first EEF-mode release in the family** — `cube_in_cup_raw` and `banana_in_pot_raw` are joint-mode recordings. |
| **Gripper** | **Robotiq 2F-85** two-finger parallel gripper. Continuous normalized command (`grip_cmd`), continuous measured position (`grip_pos`), and the leader-side trigger (`gello_grip`). **0.0 = open, 1.0 = closed** in all three. |
| **Camera 1 — scene** | **Intel RealSense D435, serial `143322071682`**, on a black desk-clamp camera stand to the left of the robot, looking down at the work surface (third-person view). Colour 1280×720 @ 30 fps + depth 848×480 @ 30 fps. |
| **Camera 2 — wrist** | **Intel RealSense D435, serial `143322072540`**, strapped to the robot wrist just above the gripper (eye-in-hand). Colour 1280×720 @ 30 fps + depth 848×480 @ 30 fps. |
| **Camera model** | Both are plain **D435** (no D435if in this session). Both on a powered USB-3 hub. |
| **Video format** | 1280×720, **30 fps**, MPEG-4 (`mpeg4`), `yuv420p`. Measured identical across all 108 videos (`ffprobe`: `mpeg4 1280 720 yuv420p 30/1`). The LeRobot copy re-encodes; RAW keeps MPEG-4. |
| **Depth format** | 848×480 `uint16` **millimetres**, one 16-bit PNG per frame stored verbatim in `depth.h5` (§5). `aligned_to_color = False`. |
| **Scene** | A white desk holding one **plastic carrot** (orange-red body, green leaves) and one **silver steel saucepan** with a black handle. Small **yellow sticky notes** on the table are placement markers for the operator. Grey felt partition and white shelving behind. |

The `cam1` ↔ `cam2` mapping above is asserted and verified from the imagery: `cam1` shows the
table from outside (pot + carrot, robot entering from the right), `cam2` shows the gripper fingers
at the bottom of every frame. See `assets/take01_cam1_first_frame.jpg` and
`assets/take01_cam2_first_frame.jpg`.

---

## 2. Files in a take folder

| File | What it is | Total bytes (54 takes) |
|---|---|--:|
| `vectors.h5` | all robot/teleop/gripper/camera-timeline signals, multi-rate (§3) | 38.7 MB |
| `depth.h5` | per-camera compressed depth frames + intrinsics/extrinsics (§5) | 3.29 GB |
| `cam1.mp4` | scene camera colour video, 1280×720 @ 30 fps | 185.4 MB |
| `cam2.mp4` | wrist camera colour video, 1280×720 @ 30 fps | 218.8 MB |

Total **3,729,216,578 bytes (3.73 GB)**. Depth dominates: measured **88.6 kB per depth frame**
averaged over all 37,079 stored depth frames.

---

## 3. `vectors.h5` — top-level layout

One file per take. Root has **9 groups** (schema measured identical in all 54 files), each a
time-series recorded at its **own native rate** on its own clock. Each group has a `t_rel_s`
dataset = seconds since take start. All datasets are **1-D `float64`**, one array per channel
(columnar layout — a channel `foo` is stored as dataset `group/foo`, NOT as a 2-D table).

| Group | Rows (all 54 takes) | Native rate | What it is |
|---|--:|---|---|
| `cam1_frames` | 18,557 | 30.0 Hz | Timestamp + frame index for each `cam1.mp4` frame |
| `cam2_frames` | 18,557 | 30.0 Hz | Timestamp + frame index for each `cam2.mp4` frame |
| `command` | 40,640 | **~67 Hz** | Commanded UR7e joint targets (the **action**), radians. `t_rel_s` **fresh** |
| `ur_joint_states` | 40,629 | **~67 Hz** | Measured UR7e joint state: position, velocity, effort. ⚠️ `t_rel_s` **0.900 s late** (§3.6) |
| `tcp_pose` | 40,619 | **~67 Hz** | Measured tool-center-point pose (position + quaternion). ⚠️ `t_rel_s` **≈0.41 s late** (§3.6) |
| `wrench` | 40,621 | **~67 Hz** | 6-axis force/torque at the TCP. ⚠️ `t_rel_s` **≈0.41 s late** (§3.6) |
| `gripper` | 24,015 | **~38.8 Hz** | Gripper command, measured position, leader trigger |
| `gello_joint_states` | 18,573 | 30.0 Hz | GELLO **leader** joint pos + vel (teleop only — see §3.4) |
| `synchronized` | **0 (EMPTY)** | — | Intended fused/aligned table; **empty in all 54 takes** — ignore |

### 3.1 Measured rates (all 54 takes, plus the two `depth.h5` streams)

Two different rate statistics are reported because they disagree, and both are true.

| Group | mean rate (Hz) | min–max across takes | median Δt (ms) | 5th pct Δt (ms) | max gap (ms) | 1 / median Δt (Hz) |
|---|--:|--:|--:|--:|--:|--:|
| `cam1_frames` | 30.00 | 29.94 – 30.03 | 33.0 | 30.0 | 55.1 | 30.3 |
| `cam2_frames` | 30.00 | 29.96 – 30.09 | 33.1 | 30.0 | 61.0 | 30.2 |
| `command` | 67.33 | 41.22 – 70.37 | 15.9 | 4.3 | 44.1 | 62.9 |
| `ur_joint_states` | 67.34 | 41.15 – 70.38 | 15.9 | 4.3 | 43.3 | 62.9 |
| `tcp_pose` | 67.34 | 41.16 – 70.34 | 15.9 | 4.2 | 40.2 | 62.9 |
| `wrench` | 67.34 | 41.16 – 70.34 | 15.9 | 4.2 | 41.0 | 62.9 |
| `gripper` | 38.83 | 37.58 – 41.14 | 31.4 | 2.2 | 69.4 | 31.9 |
| `gello_joint_states` | 30.01 | 29.96 – 30.06 | 33.1 | 20.7 | 69.6 | 30.2 |
| `depth.h5 cam1` | 30.00 | 29.92 – 30.07 | 33.0 | 20.2 | 68.8 | 30.3 |
| `depth.h5 cam2` | 30.00 | 29.92 – 30.10 | 32.9 | 19.9 | 69.2 | 30.4 |

*Mean rate* = `(N−1)/(t_last − t_first)` per take, then the **median** across takes. *Δt
percentiles* are pooled over all takes.

> **Why the two rate columns differ: the robot streams are bursty.** The inter-sample interval for
> `command` / `ur_joint_states` / `tcp_pose` / `wrench` is **bimodal** — 5 % of intervals are
> ≤ 4.3 ms (samples arriving back-to-back) while the median is 15.9 ms. Averaging over the whole
> take gives ~67 Hz, while the typical spacing corresponds to ~63 Hz. Logging is timestamp-driven,
> not fixed-period. **Always resample using `t_rel_s`; never assume a fixed dt and never
> index-align across streams.**

> **Four slow takes.** `take_24`, `take_25`, `take_26` and `take_28` log their robot streams at
> **41.2 – 49.2 Hz** against a 67.3 Hz median for the other 50 takes. Nothing else about them is
> unusual (durations 8.9–10.1 s, no NaN, frame counts match). They simply have fewer robot samples
> per camera frame — ~1.4 instead of ~2.2. Per-take rates are in §7 and `dataset_stats.json`.

> **Comparison with the sibling dataset.** These robot streams run at ~67 Hz, versus ~97–98 Hz in
> [`cube_in_cup_raw`](https://huggingface.co/datasets/Bigenlight/cube_in_cup_raw) — about **2.2
> robot samples per camera frame** here against ~3.2 there. Same rig family, different session.

### 3.2 ⚠️ The `columns` attribute quirk (still present — read this)

Every group carries an HDF5 **attribute** named `columns`. It is a **single scalar JSON string**,
e.g. `'["t_rel_s", "q1", ...]'` — NOT a native list/array. Measured: h5py returns Python `str` in
all 54 files (`dataset_stats.json → aggregate.columns_attr_python_types == ["str"]`). If a naive
consumer does `list(grp.attrs["columns"])` expecting a list, it **iterates the string
character-by-character** and you get `['[', '"', 't', '_', 'r', ...]`. **Always
`json.loads(grp.attrs["columns"])`.** The correct per-group column lists are given verbatim below
and do not depend on the attribute.

### 3.3 Per-group / per-channel schema

All datasets `float64`, shape `(N,)` where `N` = that group's row count for the take. Ranges are
**measured pooled across all 54 takes**.

#### `cam1_frames` — scene-camera frame timeline
| Channel | dtype | Unit | Meaning | Range |
|---|---|---|---|---|
| `t_rel_s` | float64 | s | Time of this frame, since take start | 0 → 17.76 |
| `frame_idx` | float64 | index | 0-based frame number in `cam1.mp4` (float-typed) | 0 → 532 |

#### `cam2_frames` — wrist-camera frame timeline
| Channel | dtype | Unit | Meaning | Range |
|---|---|---|---|---|
| `t_rel_s` | float64 | s | Time of this frame, since take start | 0 → 17.78 |
| `frame_idx` | float64 | index | 0-based frame number in `cam2.mp4` (float-typed) | 0 → 532 |

#### `command` — commanded UR7e joint targets ➜ **the ACTION**
| Channel | dtype | Unit | Meaning | min | max | mean |
|---|---|---|---|--:|--:|--:|
| `t_rel_s` | float64 | s | Timestamp — **fresh** (this table did not queue; §3.6) | — | — | — |
| `cmd1` | float64 | rad | Target angle, joint 1 (base) | −3.7024 | −2.6804 | −3.1542 |
| `cmd2` | float64 | rad | Target angle, joint 2 (shoulder) | −1.7302 | −0.9591 | −1.2976 |
| `cmd3` | float64 | rad | Target angle, joint 3 (elbow) | 1.2936 | 2.0710 | 1.7272 |
| `cmd4` | float64 | rad | Target angle, joint 4 (wrist 1) | −2.5877 | −1.5437 | −2.0579 |
| `cmd5` | float64 | rad | Target angle, joint 5 (wrist 2) | −1.8701 | −1.2600 | −1.5747 |
| `cmd6` | float64 | rad | Target angle, joint 6 (wrist 3) | −4.4081 | −2.0573 | −3.3696 |

#### `ur_joint_states` — measured UR7e joint state ➜ core of **observation.state**
| Channel | dtype | Unit | Meaning | min | max | mean |
|---|---|---|---|--:|--:|--:|
| `t_rel_s` | float64 | s | Timestamp — ⚠️ **stamped 0.900 s late; subtract it (§3.6)** | — | — | — |
| `q1` | float64 | rad | Measured angle, joint 1 | −3.7028 | −2.6809 | −3.1325 |
| `q2` | float64 | rad | Measured angle, joint 2 | −1.7284 | −0.9593 | −1.3023 |
| `q3` | float64 | rad | Measured angle, joint 3 | 1.3382 | 2.0708 | 1.7311 |
| `q4` | float64 | rad | Measured angle, joint 4 | −2.5867 | −1.5425 | −2.0613 |
| `q5` | float64 | rad | Measured angle, joint 5 | −1.8701 | −1.2621 | −1.5680 |
| `q6` | float64 | rad | Measured angle, joint 6 | −4.4087 | −2.0574 | −3.3592 |
| `qd1` | float64 | rad·s⁻¹ | Measured velocity, joint 1 | −0.3854 | 0.4454 | −0.0110 |
| `qd2` | float64 | rad·s⁻¹ | Measured velocity, joint 2 | −0.4081 | 0.4219 | 0.0198 |
| `qd3` | float64 | rad·s⁻¹ | Measured velocity, joint 3 | −0.5409 | 0.6098 | 0.0042 |
| `qd4` | float64 | rad·s⁻¹ | Measured velocity, joint 4 | −0.6037 | 0.6094 | −0.0284 |
| `qd5` | float64 | rad·s⁻¹ | Measured velocity, joint 5 | −0.5854 | 0.5897 | −0.0031 |
| `qd6` | float64 | rad·s⁻¹ | Measured velocity, joint 6 | −0.5925 | 0.5966 | −0.0159 |
| `eff1` | float64 | N·m (motor effort / current proxy) | Effort, joint 1 | −2.1749 | 2.3716 | −0.0579 |
| `eff2` | float64 | N·m | Effort, joint 2 | −6.2647 | 2.9379 | −2.8383 |
| `eff3` | float64 | N·m | Effort, joint 3 | −4.2612 | 3.6107 | −1.9856 |
| `eff4` | float64 | N·m | Effort, joint 4 | −0.8316 | 2.0361 | −0.3670 |
| `eff5` | float64 | N·m | Effort, joint 5 | −0.6181 | 1.0086 | 0.0195 |
| `eff6` | float64 | N·m | Effort, joint 6 | −0.4995 | 0.4773 | −0.0333 |

**Follower tracking.** The median per-take `|cmd_i − q_i|` (nearest-timestamp aligned onto the
command clock) is **0.023 / 0.061 / 0.033 / 0.080 / 0.029 / 0.031 rad** for joints 1–6, with a
worst single sample of **0.510 rad** (joint 6).

> ⚠️ **Those figures are computed on the raw timestamps, and most of that gap is the §3.6 timestamp
> artefact, not tracking error.** Aligned on the *corrected* clock (`ur_joint_states/t_rel_s`
> − 0.900 s) the same residual collapses to **0.0007–0.0103 rad** (median 0.0062) — and to
> 0.0004–0.0009 rad on the robust objective of §3.6. What is left there *is* the genuine servo
> following error, and it lives in the high-velocity transients. The uncorrected numbers are kept
> above because they describe the files as they are shipped, which is what a consumer who skips
> §3.6 will see.

`command` is a **target**, not a measurement — if you need where the arm actually was, use
`ur_joint_states` (on its corrected clock).

#### `tcp_pose` — measured tool-center-point pose (robot base frame)
| Channel | dtype | Unit | Meaning | min | max | mean |
|---|---|---|---|--:|--:|--:|
| `t_rel_s` | float64 | s | Timestamp — ⚠️ **stamped ≈0.41 s late; subtract it (§3.6)** | — | — | — |
| `x` | float64 | m | TCP position x in robot base frame | 0.4148 | 0.7095 | 0.5674 |
| `y` | float64 | m | TCP position y | −0.2141 | 0.3900 | 0.1307 |
| `z` | float64 | m | TCP position z | 0.0175 | 0.3066 | 0.1424 |
| `qx` | float64 | unit quaternion | Orientation x | −0.9577 | 0.8983 | 0.2690 |
| `qy` | float64 | unit quaternion | Orientation y | −0.9941 | 0.9943 | 0.3223 |
| `qz` | float64 | unit quaternion | Orientation z | −0.1567 | 0.1575 | −0.0030 |
| `qw` | float64 | unit quaternion | Orientation w | 0.000001 | 0.1547 | 0.0365 |

Workspace extent: **29 cm in x, 60 cm in y, 29 cm in z**. `qw` stays near 0 while `qx`/`qy`
dominate: the tool points essentially straight down throughout, as expected for a top-down
pick-and-place. The z floor of **0.0175 m** is the fingers reaching the table to pick the carrot.

#### `wrench` — 6-axis force/torque at TCP
| Channel | dtype | Unit | Meaning | min | max | mean |
|---|---|---|---|--:|--:|--:|
| `t_rel_s` | float64 | s | Timestamp — ⚠️ **stamped ≈0.41 s late; subtract it (§3.6)** | — | — | — |
| `fx` | float64 | N | Force along x | −18.711 | 36.708 | −1.179 |
| `fy` | float64 | N | Force along y | −20.573 | 35.621 | −0.536 |
| `fz` | float64 | N | Force along z | −114.883 | 7.142 | 0.987 |
| `tx` | float64 | N·m | Torque about x | −10.870 | 6.667 | 0.106 |
| `ty` | float64 | N·m | Torque about y | −7.891 | 9.525 | −0.152 |
| `tz` | float64 | N·m | Torque about z | −0.722 | 0.817 | −0.065 |

The wide `fz` excursion (down to −114.9 N) is a transient contact/acceleration spike; the mean is
+0.99 N with a standard deviation of 3.76 N, so the stream sits near zero the overwhelming
majority of the time.

#### `gripper` — gripper signals
| Channel | dtype | Unit | Meaning | min | max | mean |
|---|---|---|---|--:|--:|--:|
| `t_rel_s` | float64 | s | Timestamp | — | — | — |
| `gello_grip` | float64 | normalized 0–1 | Leader (GELLO) grip trigger — teleop only | 0.0000 | 1.0000 | 0.3883 |
| `grip_cmd` | float64 | normalized 0–1 (0 = open → 1 = closed) | Commanded gripper (part of the **action**) | 0.0001 | 0.9998 | 0.3904 |
| `grip_pos` | float64 | normalized (0 = open → 1 = closed) | Measured gripper opening (part of **observation.state**) | 0.0118 | 0.8980 | 0.2385 |

`grip_pos` **0.0118 is fully open** and larger is more closed. Two plateaus matter:

- **holding the carrot:** measured **0.4745 – 0.6627** across the 54 final grasps (median 0.5569).
  The fingers stop on the carrot, so this value *is* the carrot's width.
- **closed on nothing:** **0.8980**. This appears in exactly two takes (`take_39`, `take_40`) and
  is the signature of the missed first grasp described in §9.

#### `gello_joint_states` — GELLO **leader** joints (teleop only, NOT for inference)
| Channel | dtype | Unit | Meaning | min | max |
|---|---|---|---|--:|--:|
| `t_rel_s` | float64 | s | Timestamp | — | — |
| `q1` | float64 | rad | Leader joint 1 angle | −1.0048 | 0.5752 |
| `q2` | float64 | rad | Leader joint 2 angle | −1.9545 | −0.5724 |
| `q3` | float64 | rad | Leader joint 3 angle | 0.6025 | 2.4248 |
| `q4` | float64 | rad | Leader joint 4 angle | −3.2409 | −1.5090 |
| `q5` | float64 | rad | Leader joint 5 angle | −2.0874 | −1.0504 |
| `q6` | float64 | rad | Leader joint 6 angle | −2.1833 | 0.8279 |
| `qd1`…`qd6` | float64 | rad·s⁻¹ | Leader joint velocities 1–6 | −2.703 | 2.203 |

### 3.4 ⚠️ The leader stream does **not** mirror the follower in this session

This is the single largest difference from
[`cube_in_cup_raw`](https://huggingface.co/datasets/Bigenlight/cube_in_cup_raw), where leader
joints 1–5 tracked the follower to within ±0.011 rad and joint 6 was a clean +2π wrap. Measured
here (`gello_qi − ur_qi`, nearest-timestamp aligned, pooled over all 54 takes, n = 18,573 per
joint):

| joint | median diff (rad) | p05 → p95 (rad) | per-take median: min → max | per-take median std | r(`gello_qi`, `ur_qi`) | r(`gello_qi`, `cmd_i`) |
|---|--:|--:|--:|--:|--:|--:|
| 1 | **+2.7019** | +2.149 → +3.563 | +2.367 → +3.014 | 0.160 | **−0.785** | **−0.956** |
| 2 | −0.0147 | −0.508 → +0.399 | −0.516 → +0.401 | 0.203 | +0.078 | +0.261 |
| 3 | −0.0242 | −0.531 → +0.500 | −0.471 → +0.531 | 0.225 | −0.011 | −0.059 |
| 4 | −0.3328 | −0.695 → +0.119 | −0.604 → +0.108 | 0.167 | +0.537 | +0.603 |
| 5 | −0.0247 | −0.303 → +0.329 | −0.354 → +0.380 | 0.132 | +0.583 | +0.435 |
| 6 | **+2.8886** | +2.248 → +3.725 | +2.414 → +3.303 | 0.229 | +0.025 | −0.031 |

(`r` = Pearson correlation computed per take, then averaged over the 54 takes.)

Three things follow, and all three are measurements, not opinions:

1. **There is no single offset to subtract.** The per-take median of the difference itself moves by
   0.13–0.23 rad (std column), and within a take the difference has a standard deviation of
   0.03–0.84 rad. Joint 6 is *not* a 2π wrap here (+2.889 rad ≠ 6.283 rad).
2. **Joint 1 is anti-correlated with the follower** (r = −0.785 against `ur_q1`, −0.956 against
   `cmd1`, and −0.599 on first differences). The leader's joint-1 signal moves the opposite way to
   the arm it is driving.
3. **Therefore `gello_*` cannot be used to reconstruct the action, the follower state, or a
   leader/follower residual in this release.** It is retained because this is the raw release and
   because it is the operator's own hand signal at 30 Hz, but it is leader-frame telemetry with its
   own zeros and its own sign conventions. The LeRobot conversion drops it.

**Why:** this session was recorded in **end-effector (EEF) delta teleop mode**, not joint mode
(§1). The bridge takes the leader's *end-effector pose delta* — obtained by forward kinematics of a
virtual leader chain — and solves **IK on the UR7e** to produce `command`. The leader's own joint
angles are therefore a **different kinematic solution of a different chain**: they are related to the
follower only through the end-effector pose, never joint-by-joint. Under that mapping the joint-1
anti-correlation is expected and joint 6 has no reason to be a 2π wrap. The joint-mode siblings
`cube_in_cup_raw` and `banana_in_pot_raw` show ≈0 offsets for exactly the same reason, in reverse.
**`command` remains the true absolute joint target in both modes**, so nothing downstream changes:
use `command` for the action and `ur_joint_states` for the state.

### 3.5 `synchronized` — **EMPTY in all 54 takes** (do not use)

The group exists and declares **56 channels**, but **every dataset has shape `(0,)`** in every
take. Fusion is done downstream at conversion time, not stored here. Ignore it. The declared
header, in full:

```
t_rel_s, t_wall,
gello_q1, gello_q2, gello_q3, gello_q4, gello_q5, gello_q6,
gello_qd1, gello_qd2, gello_qd3, gello_qd4, gello_qd5, gello_qd6,
gello_grip,
cmd1, cmd2, cmd3, cmd4, cmd5, cmd6,
ur_q1, ur_q2, ur_q3, ur_q4, ur_q5, ur_q6,
ur_qd1, ur_qd2, ur_qd3, ur_qd4, ur_qd5, ur_qd6,
ur_eff1, ur_eff2, ur_eff3, ur_eff4, ur_eff5, ur_eff6,
grip_cmd, grip_pos,
fx, fy, fz, tx, ty, tz,
tcp_x, tcp_y, tcp_z, tcp_qx, tcp_qy, tcp_qz, tcp_qw,
cam1_frame_idx, cam2_frame_idx
```

### 3.6 ⚠️ Recorder timestamp artefact — three groups are stamped **late**

**The arm was not late; the recording is.** In this release the `t_rel_s` of three groups is behind
the rest of the take by a *constant*: their rows describe the robot as it was a fraction of a second
**earlier** than they claim. Nothing else in the file is affected, and nothing here has been
rewritten.

| group | stamped late by | per-take spread | how it was measured |
|---|--:|---|---|
| `ur_joint_states` | **0.900 s** | **0.895 – 0.900 s**, median **0.900 s**; most takes land exactly on 0.900 and the rest one 5 ms grid step below (38 of 54 at 0.900 in this release's own measurement, 41 of 54 in an independent re-measurement — same lag, different tie-break) | joint-space residual: shift the `ur_joint_states` clock by −τ, linearly interpolate `q1..q6` onto the `command` timestamps, take the τ on a **5 ms grid** over 0–1.5 s that minimises mean \|ur_q − cmd\| |
| `tcp_pose` | **≈ 0.41 s** (= 0.900 − 0.495; speed cross-correlation against `command` independently gives 0.41. Its *absolute* queue age is ≈0.50 s — the difference is `command`'s own residual ≈0.08 s) | **0.495 – 0.500 s** *ahead of* `ur_joint_states` (median 0.495) — exactly the half-queue prediction | forward-kinematics residual: `fk(q) ⊕ 0.174 m` against `tcp_pose`, **11.2 – 23.3 mm** at zero shift and **0.52 – 2.89 mm** at the optimum |
| `wrench` | **≈ 0.41 s** | measured **0.000 s** from `tcp_pose` in 7 of 8 takes | velocity cross-correlation; `wrench` shares `tcp_pose`'s QoS depth (50) and publisher, so it carries the same age |

**Fresh — do not shift these:** `cam1_frames`, `cam2_frames`, both `depth.h5` streams,
`gello_joint_states`, `gripper`, and `command`. ⚠️ For all of them but `command` that is the queue
model *and* the measurement; for **`command` it is the measurement alone** — it is published at 250 Hz behind a
depth-50 queue, so the model predicts ~0.20 s, while the scene-camera cross-correlation (evidence 2
below) puts it at τ ≈ 0 and the queue algebra at ≈0.08 s. Treat `command` as fresh to within
≈0.08 s — under three camera frames — not to zero.

Three independent observations make "the robot was slow" impossible and pin the blame on the
recorder:

1. **Depth frames carry the driver's own `header.stamp`** (`depth.h5/<cam>/stamp_s`, §5), and their
   measured age at the moment they were written is **0.022 s**. The images are fresh; that is the
   absolute reference point the other streams are compared against.
2. **The scene camera sees the arm move when `command` says it moved.** Frame-to-frame motion energy
   in `cam1.mp4` correlates with the `command` TCP speed at **τ ≈ 0** (−0.055 s and +0.010 s on the
   two takes checked) and with `ur_joint_states` at **+0.865 / +0.935 s**. If the *arm* had lagged,
   the video would have lagged with it.
3. **`tcp_pose` and `wrench` are 0.000 s apart.** Both are *measurements* published in the same
   `controller_manager` cycle from the same RTDE packet, so their physical time difference is zero —
   and that is exactly what is measured. Meanwhile `tcp_pose` → `ur_joint_states`, also two
   measurements from that same packet, sit **0.495–0.500 s** apart (median 0.495, measured on all
   54 takes by forward-kinematics residual; the sibling velocity-correlation analysis independently
   reports 0.495 s, and the release script's speed cross-correlation 0.465 s). Two streams out of
   one packet cannot physically disagree; only their *stamps* can.

**Mechanism.** The recorder writes each row inside its ROS subscription callback and stamps it with
the time that callback *ran* — message header stamps were not stored — and every callback shares one
rclpy spin thread, which a `SingleThreadedExecutor` services one message per subscription per round.
Adding depth recording to this session (≈5.3 MB/s of HDF5 writes plus four extra 30 Hz callbacks on
that same thread) dropped the round rate from ~98–100 Hz to **≈67 Hz — 41–70 Hz across takes
(§3.1)**, so every publisher faster than that kept its `KEEP_LAST` queue permanently full and each
row emerged already `queue_depth ÷ publish_rate` old:

| topic | QoS depth | publish rate | predicted age | measured |
|---|--:|--:|--:|--:|
| `/joint_states` → `ur_joint_states` | **100** | ~100 Hz | **1.00 s** | 0.900 s vs `command` |
| `/tcp_pose_broadcaster/pose` → `tcp_pose` | **50** | ~100 Hz | **0.50 s** | **0.495 s** *ahead of* `ur_joint_states` — half the queue, half the age |
| `/force_torque_sensor_broadcaster/wrench` → `wrench` | **50** | ~100 Hz | **0.50 s** | 0.000 s from `tcp_pose` |
| `/forward_position_controller/commands` → `command` | 50 | **250 Hz** (`publish_rate_hz`) | 0.20 s | **≈0.08 s** — the one row where the model over-predicts (see the *Fresh* note above) |
| `/gello/joint_states`, gripper, colour, depth | 10–50 | 30–40 Hz | **~0** | 0.022 s (depth, header-stamped) |

The **starvation signature is visible in §3.1**: `command`, `ur_joint_states`, `tcp_pose` and
`wrench` have two *different* publish rates — 250 Hz for `command`, ~100 Hz for the three
`controller_manager` broadcasters — yet converge on the same recorded rate to five
decimals (`take_01`: 59.79218 / 59.79089 / 59.79282 / 59.79153 Hz). Streams that were *not* starved
keep their own native rate (`gello_joint_states` 29.99–30.06 Hz, `cam1_frames` 29.96–30.01 Hz).

**It is a pure delay, not a distortion.** The waveform survives the shift intact, which is both why
one constant recovers it and how we know it is not servo lag — a real tracking lag is a low-pass and
would smear the shape, so no shift could collapse the residual like this:

| residual | uncorrected (τ = 0) | at the per-take optimum |
|---|--:|--:|
| `ur_joint_states` vs `command`, mean \|Δq\| over 6 joints | **0.049 – 0.090 rad** (median 0.063) | **0.0007 – 0.0103 rad** (median 0.0062) |
| same, on the release script's median-over-time objective | 0.034 – 0.081 rad | **0.0004 – 0.0009 rad** |
| `tcp_pose` vs `fk(q) ⊕ 0.174 m` | **11.2 – 23.3 mm** (median 17.6) | **0.52 – 2.89 mm** (median 1.61) |

⚠️ **Quote the lag with its method attached.** Four estimators land within ±0.02 s of one another
and none of them is wrong; published numbers that look contradictory are the same measurement:

| estimator | grid | result |
|---|---|--:|
| joint-space residual, mean \|ur_q − cmd\| over 6 joints | 5 ms | **0.895 – 0.900 s** (median 0.900) — `dataset_stats.json` → `timestamp_lag.ur_joint_states_lag_s_mean_objective` |
| same, median-over-time objective | 5 ms | **0.900 s in all 54 takes** — `dataset_stats.json` → `timestamp_lag.ur_joint_states_lag_s` |
| velocity cross-correlation, `command` → `ur_joint_states` | 5 ms | **0.875 – 0.915 s** (median 0.900; the sibling analysis reports 0.910 s) |
| TCP-position residual | 10 ms | **0.90 s** in 11 of 11 takes checked (residual median 0.42 – 0.64 mm, against 44 – 67 mm at τ = 0) |

So: **0.89 – 0.91 s depending on method and grid.** The derived LeRobot release applies the
**per-take optimum** from the first row — **0.900 s** for 41 takes, **0.895 s** for 13 — and records
it episode by episode. It also **drops** the frames that shift leaves without a joint sample — the
last 26–28 master frames (~0.9 s) of every take, **1,469 of 18,557** — so that release holds
**54 episodes / 17,088 frames**. A single 0.900 s for everything is within one 5 ms grid step of
that, i.e. a seventh of a camera frame, and is perfectly usable.

The second-order lags in the session are worth knowing so you do not mistake one for the other:
`gello_joint_states` → `command` is **+0.25 s** and is *real* — the leader→command latency of the
One-Euro filter and slew limiter, measured at +0.253 s in the joint-mode sibling session where
nothing was starved and +0.260 s here. `grip_cmd` → `grip_pos` is **+0.37 s** and is also real: the
Robotiq's open/close time (+0.34 s in the sibling). Neither is a stamping artefact and neither
should be corrected.

**Fix rule for consumers**

```python
import h5py, numpy as np

UR_LAG_S, TCP_LAG_S = 0.900, 0.405         # 0.405 = 0.900 - 0.495; wrench uses TCP_LAG_S too
with h5py.File("take_01_20260914_164811/vectors.h5", "r") as f:
    cam_t = f["cam1_frames"]["t_rel_s"][:]                      # master clock, already correct
    ur_t  = f["ur_joint_states"]["t_rel_s"][:] - UR_LAG_S       # <- the whole fix
    ur_q  = np.stack([f["ur_joint_states"][f"q{i}"][:] for i in range(1, 7)], 1)
ur_on_cam = np.stack([np.interp(cam_t, ur_t, ur_q[:, k]) for k in range(6)], 1)
```

**Do not shift anything else.** `command`, `gripper`, `gello_joint_states`, the colour frames and
the depth frames already share one correct timebase; applying the same offset to them would *create*
a 0.9 s misalignment that is not in the data — including the two real lags listed above, which are
physics, not stamping.

**What this means for the derived release.** The LeRobot conversion builds `observation.state[0:6]`
from `ur_joint_states`, so it shifts that table by that take's measured τ (**−0.900 s** for 41
takes, **−0.895 s** for 13) *before* resampling onto the 30 fps
camera grid; `grip_pos`, `action` (`command` + `grip_cmd`), the RGB videos and both depth streams are
resampled unchanged. The applied τ is recorded per episode there in `meta/source_takes.json`
(`ur_joint_states_lag_s`). After the shift the last ~0.9 s of every take has no `ur_joint_states`
sample at or after its corrected lookup time; rather than repeat the final joint row under a
still-moving arm, that release **drops** those frames whole — the last **26–28** master frames per
take, **1,469 of 18,557**, leaving **54 episodes / 17,088 frames**. The dropped window is the arm's
post-placement return motion, and it exists only here. `tcp_pose` and `wrench` are **not** part of
that release — take them from here and subtract ≈0.41 s yourself.

**Status.** The raw files are published exactly as recorded: a documented constant is recoverable,
a silently re-stamped file is not. Per-take values, both residual definitions and the
cross-correlation checks are in [`dataset_stats.json`](dataset_stats.json) under `timestamp_lag`.
The recorder itself was **fixed after this release** — header stamps are now stored alongside
`t_rel_s`, the high-rate queue depths were shrunk, camera/depth writes were moved off the spin
thread, and it now warns when the recorded rates of unrelated topics converge (the signature above);
**depth recording is now opt-in (`ENABLE_DEPTH=1`), default RGB-only**.
Later sessions in this family are not affected; the sibling joint-mode releases
`cube_in_cup_raw` / `banana_in_pot_raw`, recorded before depth existed, show ≈0.05 s.

---

## 4. Complete pooled value ranges

Every channel that carries a value (the per-group `t_rel_s` clocks are excluded; their spans are
the take durations in §7). Pooled over all 54 takes.

| channel | min | max | mean | std | n |
|---|--:|--:|--:|--:|--:|
| `cam1_frames/frame_idx` | 0.0000 | 532.0000 | 177.0869 | 109.6896 | 18,557 |
| `cam2_frames/frame_idx` | 0.0000 | 532.0000 | 177.0590 | 109.6378 | 18,557 |
| `command/cmd1` | −3.7024 | −2.6804 | −3.1542 | 0.1980 | 40,640 |
| `command/cmd2` | −1.7302 | −0.9591 | −1.2976 | 0.1420 | 40,640 |
| `command/cmd3` | 1.2936 | 2.0710 | 1.7272 | 0.1178 | 40,640 |
| `command/cmd4` | −2.5877 | −1.5437 | −2.0579 | 0.1856 | 40,640 |
| `command/cmd5` | −1.8701 | −1.2600 | −1.5747 | 0.1043 | 40,640 |
| `command/cmd6` | −4.4081 | −2.0573 | −3.3696 | 0.3043 | 40,640 |
| `gello_joint_states/q1` | −1.0048 | 0.5752 | −0.3531 | 0.2950 | 18,573 |
| `gello_joint_states/q2` | −1.9545 | −0.5724 | −1.3268 | 0.2227 | 18,573 |
| `gello_joint_states/q3` | 0.6025 | 2.4248 | 1.7092 | 0.2698 | 18,573 |
| `gello_joint_states/q4` | −3.2409 | −1.5090 | −2.3761 | 0.2560 | 18,573 |
| `gello_joint_states/q5` | −2.0874 | −1.0504 | −1.5830 | 0.1967 | 18,573 |
| `gello_joint_states/q6` | −2.1833 | 0.8279 | −0.3985 | 0.5574 | 18,573 |
| `gello_joint_states/qd1` | −1.1920 | 1.3504 | 0.0152 | 0.1502 | 18,573 |
| `gello_joint_states/qd2` | −0.9621 | 0.8062 | −0.0023 | 0.1170 | 18,573 |
| `gello_joint_states/qd3` | −1.0662 | 1.2119 | 0.0069 | 0.1484 | 18,573 |
| `gello_joint_states/qd4` | −0.8872 | 1.4505 | −0.0018 | 0.1864 | 18,573 |
| `gello_joint_states/qd5` | −1.3970 | 1.3019 | −0.0049 | 0.1201 | 18,573 |
| `gello_joint_states/qd6` | −2.7027 | 2.2032 | 0.0172 | 0.2816 | 18,573 |
| `gripper/gello_grip` | 0.0000 | 1.0000 | 0.3883 | 0.4728 | 24,015 |
| `gripper/grip_cmd` | 0.0001 | 0.9998 | 0.3904 | 0.4697 | 24,015 |
| `gripper/grip_pos` | 0.0118 | 0.8980 | 0.2385 | 0.2616 | 24,015 |
| `tcp_pose/qw` | 0.0000 | 0.1547 | 0.0365 | 0.0265 | 40,619 |
| `tcp_pose/qx` | −0.9577 | 0.8983 | 0.2690 | 0.5684 | 40,619 |
| `tcp_pose/qy` | −0.9941 | 0.9943 | 0.3223 | 0.7042 | 40,619 |
| `tcp_pose/qz` | −0.1567 | 0.1575 | −0.0030 | 0.0533 | 40,619 |
| `tcp_pose/x` | 0.4148 | 0.7095 | 0.5674 | 0.0417 | 40,619 |
| `tcp_pose/y` | −0.2141 | 0.3900 | 0.1307 | 0.1296 | 40,619 |
| `tcp_pose/z` | 0.0175 | 0.3066 | 0.1424 | 0.0643 | 40,619 |
| `ur_joint_states/eff1` | −2.1749 | 2.3716 | −0.0579 | 0.9634 | 40,629 |
| `ur_joint_states/eff2` | −6.2647 | 2.9379 | −2.8383 | 1.1063 | 40,629 |
| `ur_joint_states/eff3` | −4.2612 | 3.6107 | −1.9856 | 0.9204 | 40,629 |
| `ur_joint_states/eff4` | −0.8316 | 2.0361 | −0.3670 | 0.2433 | 40,629 |
| `ur_joint_states/eff5` | −0.6181 | 1.0086 | 0.0195 | 0.2220 | 40,629 |
| `ur_joint_states/eff6` | −0.4995 | 0.4773 | −0.0333 | 0.2094 | 40,629 |
| `ur_joint_states/q1` | −3.7028 | −2.6809 | −3.1325 | 0.1858 | 40,629 |
| `ur_joint_states/q2` | −1.7284 | −0.9593 | −1.3023 | 0.1471 | 40,629 |
| `ur_joint_states/q3` | 1.3382 | 2.0708 | 1.7311 | 0.1170 | 40,629 |
| `ur_joint_states/q4` | −2.5867 | −1.5425 | −2.0613 | 0.1840 | 40,629 |
| `ur_joint_states/q5` | −1.8701 | −1.2621 | −1.5680 | 0.1014 | 40,629 |
| `ur_joint_states/q6` | −4.4087 | −2.0574 | −3.3592 | 0.3053 | 40,629 |
| `ur_joint_states/qd1` | −0.3854 | 0.4454 | −0.0110 | 0.1080 | 40,629 |
| `ur_joint_states/qd2` | −0.4081 | 0.4219 | 0.0198 | 0.1153 | 40,629 |
| `ur_joint_states/qd3` | −0.5409 | 0.6098 | 0.0042 | 0.1150 | 40,629 |
| `ur_joint_states/qd4` | −0.6037 | 0.6094 | −0.0284 | 0.1933 | 40,629 |
| `ur_joint_states/qd5` | −0.5854 | 0.5897 | −0.0031 | 0.1031 | 40,629 |
| `ur_joint_states/qd6` | −0.5925 | 0.5966 | −0.0159 | 0.1489 | 40,629 |
| `wrench/fx` | −18.7112 | 36.7076 | −1.1785 | 0.8813 | 40,621 |
| `wrench/fy` | −20.5731 | 35.6206 | −0.5359 | 1.1133 | 40,621 |
| `wrench/fz` | −114.8831 | 7.1419 | 0.9871 | 3.7562 | 40,621 |
| `wrench/tx` | −10.8697 | 6.6670 | 0.1063 | 0.2696 | 40,621 |
| `wrench/ty` | −7.8906 | 9.5245 | −0.1523 | 0.2298 | 40,621 |
| `wrench/tz` | −0.7222 | 0.8171 | −0.0647 | 0.1000 | 40,621 |

---

## 5. `depth.h5` — the depth stream

New in this release relative to the cube/banana siblings. One file per take, written by
the recorder's `depth_writer.py`. Layout:

```
/cam1/                          <- scene camera; attrs below
    png        vlen uint8  (N,)   a COMPLETE 16-bit PNG file per frame, verbatim
    t_rel_s    float64     (N,)   session-relative capture time, same origin as vectors.h5
    frame_idx  int64       (N,)   0-based running index (== row)
    stamp_s    float64     (N,)   ROS header stamp (s), NaN if unknown
    camera_info/                  attrs: width, height, distortion_model, frame_id, D, K, R, P
    extrinsics_depth_to_color/    attrs: rotation (9, COLUMN-major), translation (3, metres),
                                         layout='column_major'
/cam2/                          <- wrist camera; identical structure
```

### 5.1 Group attributes (measured identical in all 54 takes, both cameras)

| attr | value | meaning |
|---|---|---|
| `encoding` | `16UC1` | single-channel 16-bit unsigned |
| `unit` | `mm` | **millimetres** |
| `depth_scale_m` | `0.001` | multiply by this to get metres |
| `container` | `png` | each `png[i]` cell is a whole PNG file |
| `header_bytes_stripped` | `12` | the `compressed_depth_image_transport` ConfigHeader was already removed on write — the cell starts at the PNG magic |
| `width` / `height` | `848` / `480` | depth resolution, **not** the 1280×720 colour resolution |
| `aligned_to_color` | `False` | frames are in the **depth optical frame**; see §5.4 |
| `source_topic` | `/cam1/cam1/depth/image_rect_raw/compressedDepth` (and `cam2`) | the ROS topic that fed it |

**`0` means no return / invalid** — not "zero distance". Always mask with `d > 0`.

### 5.2 `camera_info` (the **depth** imager, measured identical across all 54 takes per camera)

| | cam1 (scene) | cam2 (wrist) |
|---|---|---|
| `width` × `height` | 848 × 480 | 848 × 480 |
| `fx`, `fy` | 426.74179077, 426.74179077 | 425.26434326, 425.26434326 |
| `cx`, `cy` | 423.93927002, 233.14932251 | 425.04409790, 232.82229614 |
| `distortion_model` | `plumb_bob` | `plumb_bob` |
| `D` | all zeros (rectified) | all zeros (rectified) |
| `R` | identity | identity |
| `frame_id` | `cam1_depth_optical_frame` | `cam2_depth_optical_frame` |

`K` is stored row-major: `[fx, 0, cx, 0, fy, cy, 0, 0, 1]`.

### 5.3 `extrinsics_depth_to_color` (measured identical across all 54 takes per camera)

| | cam1 | cam2 |
|---|---|---|
| `translation` (m) | `[0.01506947, −0.00010992, −0.00005541]` | `[0.01489252, 0.00028989, 0.00014352]` |
| ‖translation‖ | **15.07 mm** | **14.90 mm** |
| `rotation` | ≈ identity (max off-diagonal 0.0103) | ≈ identity (max off-diagonal 0.0056) |
| `layout` | `column_major` | `column_major` |

That 15 mm is the D435's physical baseline between the depth and RGB imagers.
**`layout='column_major'` is load-bearing:** `np.asarray(rot).reshape(3, 3)` gives you the
**transpose** of the rotation matrix. Use `.reshape(3, 3).T`.

### 5.4 Decoding, and aligning depth to colour

```python
import h5py, cv2, numpy as np

take = "take_01_20260914_164811"
with h5py.File(f"{take}/depth.h5", "r") as f:
    g = f["cam1"]
    t_depth = g["t_rel_s"][:]                       # 30 Hz, same origin as vectors.h5
    png     = np.asarray(g["png"][0], dtype=np.uint8)          # one whole PNG file
    depth_mm = cv2.imdecode(png, cv2.IMREAD_UNCHANGED)         # uint16 (480, 848), mm
    K   = np.array(g["camera_info"].attrs["K"]).reshape(3, 3)  # row-major
    R   = np.array(g["extrinsics_depth_to_color"].attrs["rotation"]).reshape(3, 3).T
    tvec = np.array(g["extrinsics_depth_to_color"].attrs["translation"])   # metres

valid = depth_mm > 0                 # 0 == no return; mask before you do anything
depth_m = depth_mm.astype(np.float32) * 0.001
```

The recorder also ships a ROS-free reader — `read_depth_frame(h5, cam, idx)`,
`iter_depth_frames(h5, cam)` and `depth_meta(h5, cam)` in `gello_recorder/depth_writer.py` — which
does exactly the above.

To back-project and move a depth pixel into the **colour** camera's frame:

```python
fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
v, u = np.nonzero(valid)
Z = depth_m[v, u]
P_depth = np.stack([(u - cx) / fx * Z, (v - cy) / fy * Z, Z], axis=1)   # metres
P_color = P_depth @ R.T + tvec                                         # colour optical frame
```

> ⚠️ **The colour intrinsics are not in this release.** `depth.h5/<cam>/camera_info` describes the
> **848×480 depth** imager only (see its `frame_id`), so the last step — projecting `P_color` onto
> the 1280×720 image — needs the colour `K`, which was not recorded. Two honest options: read the
> factory calibration off the same two D435 bodies (serials in §1) with `rs-enumerate-devices
> -c`, or treat the 15 mm baseline as negligible for your purpose and use the depth frame as its
> own coordinate system. **Do not assume `depth[v, u]` is the depth of `colour[v, u]`** — the
> resolutions differ (848×480 vs 1280×720) and so do the fields of view; the D435 depth FOV is
> visibly wider, which you can see in `assets/color_depth_samples.jpg`.

### 5.5 Measured depth quality

Sampled on **one mid-take frame per camera per take** (108 decoded frames), plus a second sample
on the frame nearest each take's final gripper closure:

| | cam1 (scene) | cam2 (wrist) |
|---|--:|--:|
| valid pixels (`d > 0`), mid frame | **85.15 – 88.71 %**, median **86.94 %** | **50.48 – 67.95 %**, median **62.32 %** |
| median range of valid pixels, mid frame | 0.526 – 0.549 m, median **0.540 m** | 0.184 – 0.341 m, median **0.207 m** |
| valid pixels at the grasp instant | 85.36 – 88.35 %, median **86.91 %** | **37.13 – 67.50 %**, median **61.51 %** |

> ⚠️ **The wrist camera works below the D435 minimum range.** At 848×480 the D435's minimum
> depth is ~0.2 m, and the measured median range from `cam2` is **0.207 m** — i.e. the whole scene
> sits at or under the sensor's floor. The consequence is in the numbers above: a third to a half of
> every wrist depth frame is invalid, and at the moment of the grasp it gets worse (worst take
> **37.13 %** valid). The carrot and the gripper fingers are frequently holes exactly when you most
> want them. `cam1` has no such problem at 0.54 m. **Treat `cam2` depth as a sparse, partially
> reliable cue, not as a depth map.** The black regions in the two right-hand columns of
> `assets/color_depth_samples.jpg` are these holes.

### 5.6 Depth frame counts

Depth is an independent stream with its own clock, so it does not match the colour frame counts
exactly: totals are **18,541** depth frames against 18,557 colour frames for cam1, and **18,538**
against 18,557 for cam2. Per take the difference is **−1 or +1 in 24 takes (cam1) and in 29 takes
(cam2)**, plus `take_28`, where cam2 depth is **2 frames short** — 30 cam2 takes differing in
total. Align depth to colour by nearest `t_rel_s`, never by index. Per-take deltas are in §7 and
`dataset_stats.json`.

---

## 6. Camera timelines and the colour videos

`cam1.mp4` / `cam2.mp4`, 1280×720, 30 fps, MPEG-4, `yuv420p` — measured identical across all 108
files. Frame `k` of the video corresponds to row `k` of `cam*_frames`, whose `frame_idx` is the
0-based video frame number and whose `t_rel_s` is its timestamp.

**Measured: MP4 frame counts equal `cam*_frames` row counts in all 54 takes, both cameras
(108/108 videos), verified with `ffprobe -count_frames`.**

The two cameras run on independent clocks: in **24 of 54 takes** `cam1` and `cam2` differ by
**±1 frame** (12 takes at +1, 12 at −1; no take differs by more than 1). The session totals happen
to be equal at 18,557 each, which is a coincidence of the per-take signs cancelling — do **not**
read it as the two cameras being in lockstep. **Never assume `cam1[k]` and `cam2[k]` are
simultaneous.**

---

## 7. Per-take statistics

Row counts per stream, duration, the measured mean `command` rate, and the sampled depth
valid-pixel percentage. `Δcam` = cam1 rows − cam2 rows; `d-cam1` / `d-cam2` are depth frame counts.
⚠️ marks the three re-grasp takes (§9).

| take | dur (s) | cam1 | cam2 | Δcam | d-cam1 | d-cam2 | `command` | `ur_joint_states` | `tcp_pose` | `wrench` | `gripper` | `gello` | cmd Hz | cam1 valid % | cam2 valid % |
|---|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|--:|
| `take_01_20260914_164811` | 9.36 | 280 | 281 | -1 | 280 | 280 | 558 | 558 | 558 | 558 | 369 | 281 | 59.8 | 86.5 | 53.6 |
| `take_02_20260914_164845` | 10.06 | 301 | 302 | -1 | 301 | 301 | 695 | 695 | 695 | 695 | 398 | 302 | 69.1 | 88.0 | 59.1 |
| `take_03_20260914_164930` | 11.17 | 335 | 334 | +1 | 335 | 334 | 704 | 704 | 704 | 704 | 431 | 336 | 63.1 | 85.8 | 60.7 |
| `take_04_20260914_165011` | 9.53 | 286 | 285 | +1 | 285 | 286 | 648 | 649 | 649 | 649 | 369 | 286 | 68.1 | 86.9 | 66.8 |
| `take_05_20260914_165156` | 10.61 | 317 | 318 | -1 | 318 | 317 | 718 | 719 | 719 | 718 | 425 | 318 | 67.7 | 86.8 | 64.9 |
| `take_06_20260914_165238` | 10.78 | 323 | 323 | 0 | 323 | 323 | 724 | 723 | 723 | 723 | 422 | 323 | 67.2 | 88.0 | 63.4 |
| `take_07_20260914_165316` | 9.25 | 277 | 277 | 0 | 277 | 276 | 574 | 574 | 574 | 574 | 362 | 277 | 62.2 | 86.6 | 62.1 |
| `take_08_20260914_165353` | 10.96 | 329 | 328 | +1 | 328 | 328 | 766 | 765 | 765 | 765 | 432 | 328 | 69.9 | 86.5 | 64.0 |
| `take_09_20260914_165429` | 8.70 | 261 | 260 | +1 | 260 | 261 | 584 | 584 | 584 | 584 | 349 | 261 | 67.2 | 87.6 | 59.3 |
| `take_10_20260914_165510` | 9.94 | 298 | 298 | 0 | 297 | 298 | 681 | 682 | 681 | 681 | 380 | 298 | 68.6 | 87.1 | 65.9 |
| `take_11_20260914_165557` | 12.59 | 378 | 377 | +1 | 377 | 378 | 885 | 886 | 885 | 885 | 487 | 378 | 70.3 | 87.1 | 67.9 |
| `take_13_20260914_165647` | 9.37 | 280 | 281 | -1 | 280 | 281 | 614 | 613 | 613 | 613 | 361 | 281 | 65.6 | 86.9 | 62.4 |
| `take_14_20260914_165719` | 12.35 | 370 | 370 | 0 | 370 | 369 | 822 | 822 | 822 | 822 | 475 | 371 | 66.6 | 86.5 | 61.8 |
| ⚠️ `take_15_20260914_165753` | 13.92 | 417 | 417 | 0 | 417 | 417 | 956 | 955 | 955 | 955 | 549 | 417 | 68.7 | 86.8 | 58.9 |
| `take_16_20260914_165825` | 11.18 | 335 | 336 | -1 | 335 | 335 | 753 | 753 | 753 | 753 | 436 | 336 | 67.4 | 87.2 | 65.1 |
| `take_17_20260914_165859` | 10.03 | 300 | 301 | -1 | 301 | 300 | 705 | 704 | 704 | 704 | 388 | 300 | 70.4 | 88.4 | 65.5 |
| `take_18_20260914_165926` | 11.84 | 355 | 355 | 0 | 355 | 354 | 804 | 803 | 803 | 803 | 462 | 355 | 68.0 | 85.7 | 62.4 |
| `take_19_20260914_170024` | 12.38 | 371 | 371 | 0 | 371 | 370 | 849 | 848 | 847 | 847 | 468 | 372 | 68.6 | 86.0 | 63.7 |
| `take_20_20260914_170107` | 10.62 | 318 | 319 | -1 | 319 | 318 | 707 | 707 | 707 | 707 | 414 | 319 | 66.6 | 85.8 | 57.0 |
| `take_21_20260914_170135` | 10.06 | 302 | 301 | +1 | 301 | 302 | 661 | 661 | 661 | 661 | 394 | 302 | 65.8 | 85.2 | 62.0 |
| `take_22_20260914_170211` | 12.77 | 383 | 383 | 0 | 383 | 382 | 868 | 869 | 868 | 868 | 491 | 383 | 68.0 | 88.0 | 61.2 |
| `take_23_20260914_170302` | 10.76 | 323 | 322 | +1 | 322 | 322 | 715 | 716 | 715 | 715 | 422 | 322 | 66.5 | 85.8 | 62.2 |
| `take_24_20260914_170339` | 8.89 | 266 | 266 | 0 | 266 | 266 | 393 | 394 | 393 | 393 | 354 | 266 | 44.3 | 87.5 | 50.5 |
| `take_25_20260914_170407` | 8.86 | 265 | 266 | -1 | 265 | 266 | 418 | 419 | 418 | 418 | 361 | 265 | 47.2 | 87.1 | 67.9 |
| `take_26_20260914_170447` | 10.11 | 302 | 303 | -1 | 301 | 302 | 497 | 496 | 496 | 496 | 391 | 303 | 49.2 | 87.3 | 56.3 |
| `take_27_20260914_170519` | 9.03 | 271 | 270 | +1 | 270 | 270 | 560 | 560 | 560 | 560 | 348 | 271 | 62.1 | 87.7 | 67.3 |
| `take_28_20260914_170557` | 9.71 | 291 | 291 | 0 | 290 | 289 | 400 | 399 | 399 | 399 | 377 | 291 | 41.2 | 87.1 | 57.6 |
| `take_29_20260914_170629` | 11.34 | 339 | 339 | 0 | 339 | 340 | 714 | 714 | 714 | 714 | 438 | 340 | 63.0 | 86.9 | 65.5 |
| `take_30_20260914_170700` | 11.03 | 330 | 331 | -1 | 330 | 331 | 678 | 678 | 678 | 678 | 425 | 331 | 61.6 | 87.4 | 60.3 |
| `take_31_20260914_170732` | 10.34 | 310 | 310 | 0 | 310 | 309 | 639 | 638 | 638 | 638 | 395 | 310 | 61.8 | 86.3 | 62.3 |
| `take_32_20260914_170803` | 9.80 | 294 | 293 | +1 | 293 | 293 | 601 | 600 | 600 | 600 | 383 | 294 | 61.4 | 86.6 | 62.4 |
| `take_33_20260914_170854` | 9.00 | 270 | 270 | 0 | 270 | 269 | 540 | 539 | 539 | 539 | 354 | 270 | 60.0 | 86.9 | 60.7 |
| `take_34_20260914_170932` | 12.38 | 371 | 371 | 0 | 370 | 371 | 835 | 835 | 835 | 835 | 480 | 371 | 67.5 | 88.7 | 61.5 |
| `take_35_20260914_171001` | 13.34 | 400 | 400 | 0 | 399 | 400 | 927 | 927 | 927 | 927 | 511 | 400 | 69.6 | 88.5 | 64.9 |
| `take_36_20260914_171037` | 15.63 | 469 | 468 | +1 | 468 | 468 | 1059 | 1059 | 1058 | 1059 | 606 | 469 | 67.8 | 87.7 | 64.7 |
| `take_37_20260914_171113` | 13.26 | 397 | 397 | 0 | 397 | 397 | 899 | 898 | 898 | 898 | 502 | 398 | 67.8 | 87.2 | 62.9 |
| `take_38_20260914_171144` | 10.75 | 322 | 322 | 0 | 321 | 322 | 718 | 718 | 718 | 718 | 421 | 323 | 66.8 | 87.0 | 61.5 |
| ⚠️ `take_39_20260914_171227` | 13.15 | 394 | 394 | 0 | 394 | 393 | 875 | 875 | 875 | 875 | 528 | 394 | 66.6 | 87.2 | 63.4 |
| ⚠️ `take_40_20260914_171256` | 12.76 | 383 | 382 | +1 | 382 | 382 | 851 | 851 | 851 | 851 | 523 | 382 | 66.8 | 85.3 | 64.0 |
| `take_41_20260914_171328` | 10.94 | 328 | 328 | 0 | 328 | 327 | 740 | 740 | 740 | 740 | 423 | 328 | 67.8 | 87.7 | 62.1 |
| `take_42_20260914_171358` | 11.05 | 331 | 331 | 0 | 331 | 331 | 765 | 765 | 765 | 765 | 431 | 331 | 69.3 | 87.4 | 68.0 |
| `take_43_20260914_171435` | 10.54 | 316 | 316 | 0 | 315 | 315 | 703 | 702 | 702 | 702 | 414 | 316 | 66.8 | 86.1 | 66.3 |
| `take_44_20260914_171505` | 10.27 | 307 | 308 | -1 | 308 | 307 | 673 | 673 | 673 | 673 | 391 | 308 | 65.6 | 86.4 | 60.6 |
| `take_45_20260914_171534` | 12.96 | 388 | 388 | 0 | 388 | 388 | 877 | 877 | 877 | 877 | 490 | 389 | 67.7 | 86.9 | 54.8 |
| `take_46_20260914_171603` | 13.89 | 416 | 416 | 0 | 416 | 415 | 952 | 952 | 951 | 952 | 526 | 417 | 68.6 | 86.2 | 63.8 |
| `take_47_20260914_171640` | 12.90 | 386 | 386 | 0 | 386 | 386 | 882 | 881 | 880 | 881 | 495 | 387 | 68.4 | 88.5 | 61.6 |
| `take_48_20260914_171732` | 10.17 | 305 | 305 | 0 | 304 | 304 | 651 | 651 | 651 | 651 | 395 | 304 | 64.2 | 87.3 | 60.0 |
| `take_49_20260914_171812` | 17.78 | 533 | 533 | 0 | 533 | 532 | 1243 | 1242 | 1242 | 1242 | 677 | 533 | 70.0 | 86.7 | 65.6 |
| `take_50_20260914_171849` | 15.12 | 453 | 453 | 0 | 453 | 453 | 1055 | 1056 | 1056 | 1056 | 574 | 453 | 69.9 | 86.0 | 55.2 |
| `take_51_20260914_171924` | 14.61 | 438 | 438 | 0 | 438 | 437 | 1019 | 1018 | 1018 | 1018 | 549 | 438 | 69.8 | 87.8 | 66.6 |
| `take_52_20260914_171957` | 14.87 | 446 | 446 | 0 | 445 | 446 | 1021 | 1021 | 1021 | 1021 | 560 | 446 | 68.7 | 87.0 | 52.2 |
| `take_53_20260914_172033` | 10.42 | 312 | 312 | 0 | 312 | 312 | 709 | 708 | 708 | 708 | 401 | 313 | 68.1 | 85.7 | 57.1 |
| `take_54_20260914_172116` | 16.97 | 509 | 508 | +1 | 508 | 509 | 1126 | 1125 | 1125 | 1125 | 641 | 509 | 66.4 | 88.0 | 65.6 |
| `take_55_20260914_172155` | 9.23 | 276 | 277 | -1 | 276 | 276 | 629 | 628 | 628 | 628 | 367 | 277 | 68.2 | 85.8 | 63.7 |
| **TOTAL** | **619.33** | **18,557** | **18,557** | — | **18,541** | **18,538** | **40,640** | **40,629** | **40,619** | **40,621** | **24,015** | **18,573** | — | — | — |

Duration: median **10.86 s**, min **8.70 s** (`take_09`), max **17.78 s** (`take_49`).

---

## 8. How to load (h5py)

```python
import json, h5py, numpy as np

path = "take_03_20260914_164930/vectors.h5"
with h5py.File(path, "r") as f:
    # correct way to read the column list (do NOT list() the raw attr string):
    cols = json.loads(f["ur_joint_states"].attrs["columns"])   # -> ['t_rel_s','q1',...]

    # measured UR7e joint positions (N_ur, 6), radians, on the UR clock (~67 Hz)
    # NOTE: this clock is stamped 0.900 s LATE -- subtract it before aligning (§3.6)
    ur_t = f["ur_joint_states"]["t_rel_s"][:] - 0.900
    ur_q = np.stack([f["ur_joint_states"][f"q{i}"][:] for i in range(1, 7)], axis=1)

    # commanded joint targets = the action (N_cmd, 6), ~67 Hz
    cmd_t = f["command"]["t_rel_s"][:]
    cmd   = np.stack([f["command"][f"cmd{i}"][:] for i in range(1, 7)], axis=1)

    # camera master timeline (30 Hz); frame_idx maps into cam1.mp4
    cam1_t   = f["cam1_frames"]["t_rel_s"][:]
    cam1_idx = f["cam1_frames"]["frame_idx"][:].astype(int)

# streams are at DIFFERENT rates and arrive in bursts — align to the camera grid
# by nearest timestamp, never by index:
def nearest_idx(src_t, query_t):
    j = np.clip(np.searchsorted(src_t, query_t), 1, len(src_t) - 1)
    left, right = src_t[j - 1], src_t[j]
    return np.where(query_t - left <= right - query_t, j - 1, j)

ur_on_cam = ur_q[nearest_idx(ur_t, cam1_t)]   # (N_frames, 6) aligned to video
```

Read a specific video frame (OpenCV): `cv2.VideoCapture("cam1.mp4")` then read sequentially;
frame `k` corresponds to `cam1_frames/frame_idx[k]`. Because cam1 and cam2 differ by ±1 frame in
24 of 54 takes, map between the two cameras by nearest timestamp too — and likewise for depth
(§5.6).

---

## 9. Anomalies & data-quality notes

- ⚠️ **Timestamp artefact — `ur_joint_states`, `tcp_pose` and `wrench` rows are stamped late**
  (§3.6). `ur_joint_states` by **0.900 s** (per-take optimum 0.895–0.900 s, median 0.900;
  **0.89–0.91 s** depending on estimator and grid), `tcp_pose` and `wrench` by **≈0.41 s**
  (= 0.900 − 0.495, the tightest measured quantity here). It is a recorder artefact — a
  single spin thread, `t_rel_s` = callback execution time, and `KEEP_LAST` queues of depth 100/50
  kept permanently full once depth recording lowered the service rate to ≈67 Hz (41–70 Hz) — **not** robot or
  controller lag. `command`, both cameras, both depth streams, `gello_joint_states` and `gripper`
  are fresh (depth header-stamp age **0.022 s**). It is a pure delay: subtract **0.900 s** from
  `ur_joint_states/t_rel_s` and **≈0.41 s** from `tcp_pose`/`wrench`, and shift **nothing else**.
  The files here are as recorded; the derived LeRobot release has the `ur_joint_states` correction
  already applied and **drops** the last ~0.9 s of every take (**1,469 frames**, leaving
  **54 episodes / 17,088 frames**) because the shift leaves it with no joint sample; the recorder
  was fixed after this release.
- **Take-number gap `{12}` is by design.** Folders run `take_01` … `take_55` but `take_12` was
  discarded during recording, giving exactly **54** folders. It is not missing data and there is
  no partial `take_12` anywhere in the release.
- **Three takes contain a missed first grasp and a re-grasp.** They are the only three takes with
  more than one `grip_cmd ≥ 0.7` closure. Measured:

  | take | 1st close | released | `grip_pos` peak during 1st close | 2nd close | released | `grip_pos` peak |
  |---|--:|--:|--:|--:|--:|--:|
  | `take_15_20260914_165753` | 4.20 s | 4.61 s | **0.4314** | 6.67 s | 11.61 s | 0.6078 |
  | `take_39_20260914_171227` | 3.39 s | 4.45 s | **0.8980** | 6.65 s | 10.59 s | 0.5451 |
  | `take_40_20260914_171256` | 2.88 s | 3.80 s | **0.8980** | 6.81 s | 10.35 s | 0.5137 |

  `take_39` and `take_40` are true closures **on nothing**: the fingers reach 0.8980, the
  empty-gripper stop, and are then reopened. `take_15` is different and the distinction is worth
  keeping — its first closure was **aborted after 0.41 s**, with `grip_pos` only reaching 0.4314
  (less closed than the 0.6078 it later reaches on the carrot), so the fingers never met. All three
  then re-approach and grasp successfully. All three are **included** in both the raw and the
  LeRobot releases: a recovery is a legitimate demonstration, not a defect. Full traces are in
  `dataset_stats.json → regrasp_takes` and `per_take[*].grip_closures`.
- **The leader stream is not a follower mirror** (§3.4) — the single biggest behavioural difference
  from `cube_in_cup_raw`, and a direct consequence of this session running in **EEF delta mode**
  rather than joint mode (§1).
- **`cam1` / `cam2` frame-count mismatch:** 24 of 54 takes differ by exactly ±1 (§6).
- **Depth / colour frame-count mismatch:** 24 takes (cam1) and 29 takes (cam2) differ by ±1, plus
  `take_28` cam2 at −2 — 30 cam2 takes differing in total (§5.6).
- **Wrist depth is below the sensor's minimum range** (§5.5) — 37–68 % valid.
- **Four takes log the robot streams at 41–49 Hz** instead of ~67 Hz: `take_24`, `take_25`,
  `take_26`, `take_28` (§3.1).
- **`synchronized/` is empty** in all 54 takes (§3.5).
- **`columns` attribute is a JSON string, not a list** — always `json.loads` it (§3.2).
- **Bursty sampling** on the robot streams (bimodal Δt, §3.1) — resample by timestamp.
- **No NaN and no Inf** anywhere: measured over every channel of every group of all 54 takes.
- **Video ↔ HDF5 agreement is exact:** all 54 takes, both cameras (108/108 videos), verified with
  `ffprobe -count_frames`.
- **Timing:** largest single gap in any robot stream is **44.1 ms**; in any colour camera stream
  **61.0 ms** (~2 frame periods); in any depth stream **69.2 ms**; in `gripper` **69.4 ms**; in
  `gello_joint_states` **69.6 ms**.
- **Uniform schema:** identical 9 groups, identical channel names, all `float64`, in all 54
  `vectors.h5`; identical depth `camera_info` and `extrinsics_depth_to_color` in all 54 `depth.h5`,
  per camera.
- Cleanliness: 0 stray files, 0 hidden files, no sub-directories in the take folders, and **no
  `/home/` absolute-path string anywhere in the 216 data files** (54 `vectors.h5` + 54 `depth.h5` +
  108 MP4s, verified by full byte scan).

**Every take ends with the carrot in the pot (operator-reported, 54/54).** That is the only
outcome label available; there are no per-step success/failure labels, no human quality ratings,
and no policy-performance numbers in this release.

---

## 10. Reproducing these numbers

```bash
python3 make_carrot_raw_stats.py --data /path/to/Put_carrot_in_pot
```

(system `python3` with `h5py`, `numpy`, `cv2`; `ffprobe` on `PATH` for exact frame counts — the
script records which method it used in `aggregate.video_frame_count_method`). It reads the take
folders read-only and writes `dataset_stats.json`.

See [`dataset_stats.json`](dataset_stats.json) for exact per-take frame counts, durations, row
counts, byte sizes, rate statistics, depth quality samples, leader/follower statistics,
per-channel min/max/mean/std, and — under `timestamp_lag` — the per-take timestamp offsets of §3.6
with both residual definitions and the cross-correlation cross-checks.