preprocess: add detect/curation/previews modules (curate CLI; ports verified bit-exact against published outputs)

preprocess/README.md

@@ -32,10 +32,20 @@ release/<task>/{videos,depth,meta}/<date>/episode_NNN/…
 | `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:

preprocess/__main__.py

@@ -12,7 +12,7 @@ import json
 import sys
 from pathlib import Path
 
-from . import backfill
+from . import backfill, curation
 from .config import H5_ROOTS, STAGE_ROOT
 from .h5io import discover
 from .pipeline import build_episode
@@ -126,6 +126,22 @@ def cmd_verify(args) -> int:
     return 1 if bad else 0
 
 
+def cmd_curate(args) -> int:
+    """Rebuild bad_frames.json / segments.json / episodes.jsonl for a task."""
+    for task in ([args.task] if args.task else sorted(H5_ROOTS)):
+        try:
+            s = curation.build_task(task, STAGE_ROOT, write=not args.dry_run)
+        except FileNotFoundError as exc:
+            print(f"[curate] {task}: {exc}", file=sys.stderr)
+            continue
+        verb = "would write" if args.dry_run else "wrote"
+        print(f"[curate] {task}: {s['episodes']} episodes, {s['segments']} segments, "
+              f"{s['total_frames']:,} frames, {s['bad_frames']} bad "
+              f"({s['bad_fraction']*100:.2f}%), clean {s['clean_frames']:,} "
+              f"({s['clean_minutes']:.1f} min) — {verb}")
+    return 0
+
+
 def main(argv=None) -> int:
     ap = argparse.ArgumentParser(prog="react_preprocess")
     sub = ap.add_subparsers(dest="cmd", required=True)
@@ -152,6 +168,11 @@ def main(argv=None) -> int:
     f.add_argument("--dry-run", action="store_true")
     f.set_defaults(func=cmd_backfill)
 
+    c = sub.add_parser("curate", help="rebuild bad_frames/segments/episodes indices")
+    c.add_argument("--task", choices=sorted(H5_ROOTS))
+    c.add_argument("--dry-run", action="store_true")
+    c.set_defaults(func=cmd_curate)
+
     v = sub.add_parser("verify-flags", help="check flags against ground truth")
     v.add_argument("--root")
     v.add_argument("--task", choices=sorted(H5_ROOTS))

preprocess/curation.py

@@ -0,0 +1,144 @@
+"""Per-task curation indices built from the per-episode detect sidecars.
+
+Produces three files next to the data:
+
+``bad_frames.json``   detector thresholds plus every flagged interval
+``segments.json``     the clean spans, indexed into episode video/parquet coords
+``episodes.jsonl``    one row per episode
+
+Frame ranges are inclusive ``[a, b]`` in episode-video coordinates, so
+``frame_range`` indexes the MP4s and the parquet directly — no offset applies.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+from . import detect as D
+from .config import FPS, STAGE_ROOT
+
+MIN_SEGMENT_FRAMES = 16
+
+
+def _sidecar_arrays(path: Path) -> tuple[dict, dict]:
+    import torch
+
+    ep = torch.load(str(path), weights_only=False, map_location="cpu")
+    return ep, ep["_contact_meta"]
+
+
+def episode_report(path: Path) -> tuple[dict, dict]:
+    """Run every detector on one sidecar; returns (report, contact_meta)."""
+    ep, cm = _sidecar_arrays(path)
+    T = int(ep["timestamps"].shape[0])
+    active = cm.get("active_sensors", ["left", "right"])
+    pose_l = ep["sensor_left_pose"].numpy()
+    pose_r = ep["sensor_right_pose"].numpy()
+
+    report = {
+        "n_frames": T,
+        "duration_s": round(T / FPS, 3),
+        "intensity_spikes": D.detect_intensity_spikes(
+            ep["tactile_left_intensity"].numpy(),
+            ep["tactile_right_intensity"].numpy(), T),
+        "pose_teleports_L": D.detect_pose_teleports(pose_l, T) if "left" in active else [],
+        "pose_teleports_R": D.detect_pose_teleports(pose_r, T) if "right" in active else [],
+        "ot_loss_L": D.detect_pose_freezes(pose_l, T) if "left" in active else [],
+        "ot_loss_R": D.detect_pose_freezes(pose_r, T) if "right" in active else [],
+    }
+
+    mask = np.zeros(T, bool)
+    for key in ("intensity_spikes", "pose_teleports_L", "pose_teleports_R",
+                "ot_loss_L", "ot_loss_R"):
+        for a, b in report[key]:
+            mask[max(0, a):min(T, b + 1)] = True
+    report["total_bad_frames"] = int(mask.sum())
+    report["bad_fraction"] = round(report["total_bad_frames"] / T, 4) if T else 0.0
+    return report, cm
+
+
+def _bad_intervals(report: dict) -> list[tuple[int, int]]:
+    return [(int(a), int(b))
+            for key in ("intensity_spikes", "pose_teleports_L", "pose_teleports_R",
+                        "ot_loss_L", "ot_loss_R")
+            for a, b in report[key]]
+
+
+def build_task(task: str, stage_root: Path = STAGE_ROOT,
+               write: bool = True) -> dict:
+    """Build the three curation files for one task."""
+    out_dir = Path(stage_root) / task
+    sidecars = sorted((out_dir / "meta").rglob("*._detect.pt"))
+    if not sidecars:
+        raise FileNotFoundError(f"no _detect.pt sidecars under {out_dir/'meta'}")
+
+    episodes, segments, rows = {}, [], []
+    for det in sidecars:
+        date, stem = det.parent.name, det.name.replace("._detect.pt", "")
+        key = f"{date}/{stem}"
+        report, cm = episode_report(det)
+        episodes[key] = report
+        T = report["n_frames"]
+
+        n_seg = 0
+        for a, b in D.find_clean_segments(T, _bad_intervals(report)):
+            length = b - a + 1
+            if length < MIN_SEGMENT_FRAMES:
+                continue
+            segments.append({
+                "task": task, "source_episode": key, "segment_idx": n_seg,
+                "frame_range": [a, b], "n_frames": length,
+                "duration_s": round(length / FPS, 3),
+            })
+            n_seg += 1
+
+        rows.append({
+            "episode": key, "date": date, "n_frames": T,
+            "duration_s": report["duration_s"],
+            "active_sensors": cm.get("active_sensors", ["left", "right"]),
+            "trim_offset": int(cm.get("trim_offset", 0)),
+            "world_frame_offset": cm.get("world_frame_offset_applied", [0.0, 0.0, 0.0]),
+            "n_segments": n_seg,
+            "total_bad_frames": report["total_bad_frames"],
+        })
+
+    total = sum(e["n_frames"] for e in episodes.values())
+    bad = sum(e["total_bad_frames"] for e in episodes.values())
+    seg_frames = sum(s["n_frames"] for s in segments)
+
+    bad_frames = {
+        "task": task, **D.thresholds(),
+        "summary": {
+            "n_episodes": len(episodes), "total_frames": total,
+            "total_bad_frames": bad,
+            "bad_fraction_overall": round(bad / total, 4) if total else 0.0,
+        },
+        "episodes": episodes,
+    }
+    segments_doc = {
+        "task": task, "schema": "segments_v2_video",
+        "description": ("Each entry indexes a contiguous clean span within an "
+                        "episode's videos (data/<task>/videos/<date>/episode_NNN/*.mp4) "
+                        "and parquet. frame_range is [a,b] inclusive in "
+                        "episode-video frame coords."),
+        "n_segments": len(segments), "total_frames": seg_frames,
+        "total_duration_min": round(seg_frames / FPS / 60, 2),
+        "min_segment_frames_kept": MIN_SEGMENT_FRAMES,
+        "segments": sorted(segments, key=lambda s: (s["source_episode"], s["segment_idx"])),
+    }
+
+    if write:
+        (out_dir / "bad_frames.json").write_text(json.dumps(bad_frames, indent=2))
+        (out_dir / "segments.json").write_text(json.dumps(segments_doc, indent=2))
+        with open(out_dir / "episodes.jsonl", "w") as fh:
+            for row in sorted(rows, key=lambda r: r["episode"]):
+                fh.write(json.dumps(row) + "\n")
+
+    return {
+        "task": task, "episodes": len(episodes), "segments": len(segments),
+        "total_frames": total, "bad_frames": bad,
+        "bad_fraction": bad / total if total else 0.0,
+        "clean_frames": seg_frames, "clean_minutes": seg_frames / FPS / 60,
+    }

preprocess/detect.py

@@ -0,0 +1,134 @@
+"""Detectors for unusable frames, and the clean-span complement.
+
+Three failure modes are flagged per episode:
+
+``intensity_spikes``   a GelSight reading far above anything contact produces —
+                       usually the sensor being knocked or re-seated
+``pose_teleports_*``   OptiTrack solving to the wrong marker set, which moves
+                       the sensor implausibly far *and* rotates it implausibly
+                       fast in a single frame
+``ot_loss_*``          the tracker dropping out, which shows up as a run of
+                       bit-identical poses rather than as missing samples
+
+Thresholds are the ones validated against the published motherboard
+``bad_frames.json`` (25/27 episodes bit-identical).
+
+Previously split across ``detect_bad_intervals.py`` and ``build_segments.py``
+in ``twm/scripts/``; the latter has since been archived, so this module is now
+the only live copy of ``find_clean_segments``.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .config import FPS
+
+TAU_INTENSITY = 30.0
+TAU_VELOCITY_MPS = 5.0
+TAU_ANGULAR_RAD_PS = 15.0
+FREEZE_THRESHOLD_S = 0.25
+BUFFER_FRAMES = 3
+EPS_POSE_BIT = 1e-7
+
+
+def merge_intervals(events, gap: int = 1) -> list[list[int]]:
+    """Merge inclusive ``(a, b)`` intervals that touch or overlap."""
+    if not events:
+        return []
+    ordered = sorted((int(a), int(b)) for a, b in events)
+    merged = [list(ordered[0])]
+    for a, b in ordered[1:]:
+        if a <= merged[-1][1] + gap:
+            merged[-1][1] = max(merged[-1][1], b)
+        else:
+            merged.append([a, b])
+    return merged
+
+
+def pad_and_merge(events, T: int, buffer: int) -> list[list[int]]:
+    """Pad each interval by ``±buffer``, clip to ``[0, T-1]``, then merge."""
+    if not events:
+        return []
+    return merge_intervals([(max(0, a - buffer), min(T - 1, b + buffer))
+                            for a, b in events])
+
+
+def detect_intensity_spikes(intens_l: np.ndarray, intens_r: np.ndarray,
+                            T: int) -> list[list[int]]:
+    """Frames where either sensor reads above ``TAU_INTENSITY``."""
+    above = (intens_l > TAU_INTENSITY) | (intens_r > TAU_INTENSITY)
+    return pad_and_merge([(int(i), int(i)) for i in np.where(above)[0]],
+                         T, BUFFER_FRAMES)
+
+
+def detect_pose_teleports(pose: np.ndarray, T: int) -> list[list[int]]:
+    """Frames whose pose jump is implausible in translation *and* rotation.
+
+    The conjunction matters: ordinary fast motion trips the translational
+    threshold on its own, so requiring both is what separates a tracking error
+    from a quick reach.
+    """
+    if T < 2:
+        return []
+    xyz, quat = pose[:, :3], pose[:, 3:]
+    qn = quat / np.maximum(np.linalg.norm(quat, axis=1, keepdims=True), 1e-12)
+    trans_vel = np.linalg.norm(np.diff(xyz, axis=0), axis=1) * FPS
+    dot = np.abs((qn[:-1] * qn[1:]).sum(axis=1)).clip(-1.0, 1.0)
+    ang_vel = 2.0 * np.arccos(dot) * FPS
+    flag = (trans_vel > TAU_VELOCITY_MPS) & (ang_vel > TAU_ANGULAR_RAD_PS)
+    return pad_and_merge([(int(i), int(i + 1)) for i in np.where(flag)[0]],
+                         T, BUFFER_FRAMES)
+
+
+def detect_pose_freezes(pose: np.ndarray, T: int) -> list[list[int]]:
+    """Runs of bit-identical pose lasting at least ``FREEZE_THRESHOLD_S``.
+
+    OptiTrack repeats its last solution when it loses the marker set, so a
+    frozen pose is track loss rather than genuine stillness — a real hold still
+    jitters in the last decimal places.
+
+    Reported unpadded, matching the published ``bad_frames.json``.
+    """
+    if T < 2:
+        return []
+    same = np.zeros(T, dtype=bool)
+    same[1:] = np.all(np.abs(np.diff(pose, axis=0)) < EPS_POSE_BIT, axis=1)
+    min_frames = int(round(FREEZE_THRESHOLD_S * FPS))
+
+    events, i = [], 1
+    while i < T:
+        if not same[i]:
+            i += 1
+            continue
+        j = i
+        while j < T and same[j]:
+            j += 1
+        # the run includes the anchor frame at i-1 that the copies match
+        run_a, run_b = i - 1, j - 1
+        if (run_b - run_a + 1) >= min_frames:
+            events.append((run_a, run_b))
+        i = j
+    return pad_and_merge(events, T, 0)
+
+
+def find_clean_segments(T: int, bad_intervals) -> list[tuple[int, int]]:
+    """Complement of the bad intervals: inclusive ``[a, b]`` clean spans."""
+    segments, prev_end = [], -1
+    for a, b in merge_intervals(bad_intervals):
+        if a > prev_end + 1:
+            segments.append((prev_end + 1, a - 1))
+        prev_end = max(prev_end, b)
+    if prev_end < T - 1:
+        segments.append((prev_end + 1, T - 1))
+    return segments
+
+
+def thresholds() -> dict:
+    """The detector settings, for recording alongside the results."""
+    return {
+        "tau_intensity": TAU_INTENSITY,
+        "tau_velocity_mps": TAU_VELOCITY_MPS,
+        "tau_angular_rad_per_s": TAU_ANGULAR_RAD_PS,
+        "freeze_threshold_s": FREEZE_THRESHOLD_S,
+        "buffer_frames": BUFFER_FRAMES,
+    }

preprocess/previews.py

@@ -0,0 +1,105 @@
+"""Release policy for the preview panels.
+
+Previews are a presentation artifact, not part of reproducing the data: they
+render a 3-camera + OptiTrack + GelSight panel from the *source* recordings and
+need rig-local calibration that the release does not ship. So this module owns
+only the release-specific decisions —
+
+* which calibration set belongs to which task (they were recalibrated between
+  the motherboard and pushT sessions, and using the wrong one silently
+  misprojects the overlay)
+* the trim offset, read from the release sidecar so previews start on the same
+  frame as the published video
+* the per-(task, date) world-frame offset
+* the output layout
+
+— and takes the renderer as a parameter. The previous version reached into the
+renderer module and reassigned its globals, which meant preview settings could
+not be reasoned about without reading both files, and two tasks could not be
+rendered in one process.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Iterator
+
+from .config import H5_ROOTS, STAGE_ROOT, WORLD_OFFSET
+
+CALIB_ROOT = Path(__file__).resolve().parent.parent / "calibration"
+
+# The rigs were recalibrated between sessions; each task must use the set that
+# was current when it was recorded.
+CALIB_DIRS = {
+    "motherboard": CALIB_ROOT / "result backup",   # May 12
+    "pushT": CALIB_ROOT / "result",                # June 26
+}
+
+CLIP_SECONDS = 30.0
+SPEED = 2.0
+
+
+def trim_offset(task: str, date: str, episode: str,
+                stage_root: Path = STAGE_ROOT) -> int:
+    """Trim offset for an episode, from its release sidecar (0 if absent)."""
+    det = Path(stage_root) / task / "meta" / date / f"{episode}._detect.pt"
+    if not det.exists():
+        return 0
+    import torch
+
+    meta = torch.load(str(det), weights_only=False, map_location="cpu")
+    return int(meta["_contact_meta"].get("trim_offset", 0))
+
+
+def plan(task: str, stage_root: Path = STAGE_ROOT) -> Iterator[dict]:
+    """One job per published episode that still has its source recording.
+
+    Driven by the published videos rather than by the source tree, so episodes
+    excluded from the release (e.g. the corrupt pushT recording) do not
+    reappear here.
+    """
+    stage_root = Path(stage_root)
+    h5_root = H5_ROOTS[task]
+    videos = stage_root / task / "videos"
+    if not videos.exists():
+        return
+    for date_dir in sorted(p for p in videos.iterdir() if p.is_dir()):
+        date = date_dir.name
+        dx, dy, dz = WORLD_OFFSET.get((task, date), (0.0, 0.0, 0.0))
+        for ep_dir in sorted(p for p in date_dir.iterdir() if p.is_dir()):
+            episode = ep_dir.name
+            h5 = h5_root / date / f"{episode}.h5"
+            if not h5.exists():
+                continue
+            yield {
+                "task": task, "date": date, "episode": episode,
+                "h5": h5,
+                "out": stage_root / task / "previews" / date / f"{episode}.mp4",
+                "calib_dir": CALIB_DIRS[task],
+                "trim_offset": trim_offset(task, date, episode, stage_root),
+                "world_offset": (dx, dy, dz),
+            }
+
+
+def build_task(task: str, render: Callable[[dict], None],
+               stage_root: Path = STAGE_ROOT,
+               overwrite: bool = False) -> list[dict]:
+    """Render every planned preview with the supplied renderer.
+
+    ``render`` receives one job dict. A failure is recorded against that
+    episode and the rest continue — one bad recording should not cost the whole
+    batch.
+    """
+    results = []
+    for job in plan(task, stage_root):
+        if job["out"].exists() and not overwrite:
+            results.append({**job, "status": "SKIP"})
+            continue
+        job["out"].parent.mkdir(parents=True, exist_ok=True)
+        try:
+            render(job)
+            size = job["out"].stat().st_size if job["out"].exists() else 0
+            results.append({**job, "status": "OK", "bytes": size})
+        except Exception as exc:                     # noqa: BLE001
+            results.append({**job, "status": "FAIL",
+                            "error": f"{type(exc).__name__}: {exc}"})
+    return results