# react_preprocess — building the React release

The producer side of the dataset. `toolbox/` (`react_toolbox`) reads the
published data; this package is what turns raw rig recordings into it, and
ships alongside the data so the release is reproducible.

```bash
python -m react_preprocess build --task pushT [--with-depth]
python -m react_preprocess audit --task pushT
python -m react_preprocess backfill-flags --task pushT
python -m react_preprocess verify-flags --task pushT --against h5
```

## Pipeline

```
recording.h5
   │  h5io      read timestamps/poses, resolve tactile↔camera alignment
   │  tactile   pass 1: pick the p01 no-contact reference
   │            pass 2: contact metrics + new-frame flags + encode
   │  encode    H.264 yuv444p CRF18 (RGB), FFV1 gray16le (depth)
   │  meta      per-frame parquet
   ▼
release/<task>/{videos,depth,meta}/<date>/episode_NNN/…
```

| Module | Responsibility |
|---|---|
| `config` | paths, camera mapping, encoding and contact constants |
| `h5io` | source reading, pose alignment, **tactile time alignment** |
| `contact` | contact metrics, p01 reference, duplicate-frame detection |
| `encode` | ffmpeg writers |
| `tactile` | two-pass GelSight processing |
| `meta` | parquet assembly and index columns |
| `detect` | bad-interval detectors + clean-span complement |
| `curation` | per-task `bad_frames.json` / `segments.json` / `episodes.jsonl` |
| `previews` | preview policy (calibration choice, trim, world offset, layout) |
| `pipeline` | per-episode orchestration |
| `backfill` | recover flags for already-published parquet |
| `publish` | mirror data + code to the Hub |

`previews` holds policy only — the panel renderer needs rig-local calibration
the release does not ship, so it stays in `twm/scripts/build_release_previews.py`
as a thin adapter over `previews.plan()`. Port checks: `detect`/`curation`
reproduce the published `bad_frames.json` and `segments.json` for all 36
episodes with zero differences; the preview adapter re-renders
`pushT/episode_000` bit-identically (first-frame MAD 0.00, same 900 frames).

## Tactile time alignment

How a GelSight frame is paired with a camera frame depends on the recording:

| | legacy (≤ 2026-06-18) | timestamped (2026-06-27 →) |
|---|---|---|
| Pairing | by tick index | nearest capture timestamp |
| Systematic lag | ~15 frames (0.5 s) | removed at the source |
| Constant shift needed | yes | **no — would double-correct** |

The rig used to decode full 8 MP MJPG frames on the capture thread (~71 ms
each), so tactile really ran at ~8 fps while rows were written at 30 Hz. That
produced both the lag and heavy frame duplication. The rig now decodes at
reduced scale and records `gelsight/<side>/timestamps`.

`h5io.TactileAlignment.needs_legacy_shift` is the guard: it is False for
timestamped recordings, so a latency shift can never be applied twice.

## `tactile_*_is_new`

The GelSight Mini tops out at 18.75 fps while parquet rows are written at
30 Hz, so some rows necessarily repeat the previous tactile frame. Legacy
recordings repeat far more. These boolean columns mark the rows that are
genuinely fresh readings:

```python
df = pq.read_table("episode_000.parquet").to_pandas()
fresh = df[df.tactile_left_is_new]        # train tactile dynamics on these
```

Measured — legacy over the whole published release (480 080 rows, 36 episodes),
fixed rig over `test/2026-06-29/episode_001` (1 294 rows, both sensors):

| | capture rate | duplicate rows | effective rate | longest frozen run |
|---|---|---|---|---|
| legacy | ~8 fps (decode-bound) | 71.8 % | 8.5 fps | 30 frames (1.0 s) |
| fixed rig | 19.3 fps | 39.5–41.5 % | 17.6–18.2 fps | 5 frames (0.17 s) |

The residual ~40 % on the fixed rig is irreducible: a 19 fps sensor sampled onto
a 30 Hz row clock must repeat roughly a third of its rows. Only the legacy
excess above that was a bug.

**How the flags are recovered for already-published data.** A repeated frame
yields a bit-identical contact triple, so a row is fresh exactly when its
triple differs from the previous row's — no video decode required.
`verify-flags --against h5` checks this against source pixels: on all seven
audited episodes (4 pushT + 3 motherboard) it reproduces the source
frame-by-frame with **0 mismatches in 899 frames each**, and independently
recovers the +15 shift baked into the release (every other offset in 0..20
disagrees on >33 % of frames, so the detection is unambiguous).

Checking against the published MP4s can only ever be approximate — H.264 is
lossy, so a duplicated frame does not decode back to identical pixels.
`--against video` therefore compares with a tolerance and reports the observed
separation rather than asserting exactness.

## Conventions

- Frame `i` of every MP4 == parquet row `i` == source frame `trim_offset + i`
- Cameras: `cam0 → view_right`, `cam1 → view_left`, `cam2 → view_middle`
  (verified against calibration serials)
- Tactile frames are RGB in HDF5 and converted to BGR only for ffmpeg
- Depth is uint16 millimetres, `0` = no return
- The 2026-05-19 motherboard world-origin offset is baked into stored poses

Paths come from `REACT_DATA_ROOT` / `REACT_STAGE_ROOT` when set, so the
package runs off the rig.