examples/play_react_pt.py: interactive .pt viewer (same key bindings as twm.visualize, adapted to the downsampled .pt content). Supports both mode1_v1 episodes and mode2_v1 segments. Self-contained (numpy + torch + cv2). Headless MP4 export via --save_video.

examples/README.md

@@ -117,3 +117,24 @@ pre-trim timeline.
 trim_offset = ep["_contact_meta"]["trim_offset"]
 h5_index = pt_index + trim_offset    # only needed when reading raw H5
 ```
+
+
+## Visualizing a single .pt file
+
+If you want to scrub through one recording or segment frame-by-frame (the
+same way `python -m twm.visualize` plays the original H5 archive), use:
+
+```bash
+# Interactive cv2 window (space / arrows / 1..6 / r / q)
+python examples/play_react_pt.py     processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
+
+# Headless MP4 export (no display required)
+python examples/play_react_pt.py <pt_path> --save_video out.mp4
+```
+
+The viewer shows: cam0 view | tactile_L raw + diff | tactile_R raw + diff
+on the top row, and OptiTrack pose text + a sliding contact-intensity
+trail plot + the controls cheatsheet on the bottom row. The GelSight diff
+is computed against the `_contact_meta.ref_p01_*` baseline (the
+quietest moment of the recording), so it reads as 'what is currently
+pressing on the gel' rather than 'change since the start of the clip.'

examples/play_react_pt.py

@@ -0,0 +1,351 @@
+"""Interactive playback for a React `.pt` file — same key bindings as
+`twm.visualize`, but operates on the downsampled, single-camera, cam-aligned
+content that's actually inside the `.pt`. Works for both `mode1_v1/` whole
+recordings and `mode2_v1/` clean segments.
+
+Usage
+-----
+Interactive (cv2 window):
+    python examples/play_react_pt.py \\
+        processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt
+
+Headless export to MP4:
+    python examples/play_react_pt.py <pt_path> --save_video out.mp4
+
+Controls
+--------
+    space       — pause / resume
+    → / d       — next frame (works while paused)
+    ← / a       — previous frame
+    1 / 2 / 3 / 4 / 5 / 6 — playback speed 1× / 2× / 5× / 10× / 25× / 50×
+    r           — reset GelSight diff reference to current frame
+    q           — quit
+
+Panel layout (1280 × 480)
+-------------------------
+    Row 1 (240 tall):  view | tactile_L_raw | tactile_L_diff | tactile_R_raw | tactile_R_diff
+    Row 2 (240 tall):  OT pose panel | contact-intensity trail plot | controls cheatsheet
+    Status bar at top: episode / segment, frame index, wall-clock t, playback speed
+
+The diff is computed against the per-episode `ref_p01_{left,right}` image
+stored in `_contact_meta` (the "quietest moment of the recording" — the
+same baseline `twm.contact_index` uses), so it reads as "what is *currently*
+pressing on the gel" rather than "what changed since this clip started."
+"""
+import argparse
+import collections
+import sys
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import torch
+
+# ─── color conventions ──────────────────────────────────────────────────────
+# OT pose-text colors (BGR for cv2 calls)
+TRACKER_COLORS = {
+    "sensor_left":  (  0, 255, 120),
+    "sensor_right": (  0, 180, 255),
+}
+
+PANEL_W, PANEL_H = 1280, 480
+VIEW_THUMB = (320, 240)
+TAC_THUMB = (240, 240)
+OT_PANEL = (320, 240)
+TRAIL_PANEL = (640, 240)
+CONTROLS_PANEL = (320, 240)
+
+
+def _to_hwc(t):
+    return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy()
+
+
+def _view_to_bgr(view_chw):
+    """`view` is BGR (rs.format.bgr8 → contact_index keeps byte order).
+    cv2.imshow expects BGR, so just permute to HWC."""
+    return view_chw.permute(1, 2, 0).numpy()
+
+
+def _tactile_to_bgr(tac_chw):
+    """`tactile_*` is RGB. Convert to BGR for cv2.imshow."""
+    rgb = tac_chw.permute(1, 2, 0).numpy()
+    return rgb[..., ::-1]
+
+
+def _diff_thumb(frame_bgr, ref_bgr, size):
+    diff = np.clip(frame_bgr.astype(np.int16) - ref_bgr.astype(np.int16) + 128, 0, 255).astype(np.uint8)
+    return cv2.resize(diff, size, interpolation=cv2.INTER_NEAREST)
+
+
+def _make_ot_panel(pose_L, pose_R, t_idx, t_sec, w, h):
+    panel = np.zeros((h, w, 3), np.uint8)
+    cv2.putText(panel, "OptiTrack (this frame)", (8, 22),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55, (200, 200, 200), 1, cv2.LINE_AA)
+    cv2.line(panel, (8, 30), (w - 8, 30), (60, 60, 60), 1)
+    y = 56
+    for name, p, color in [("sensor_left", pose_L, TRACKER_COLORS["sensor_left"]),
+                            ("sensor_right", pose_R, TRACKER_COLORS["sensor_right"])]:
+        cv2.putText(panel, name, (8, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 1, cv2.LINE_AA)
+        y += 18
+        if p is None or all(v == 0 for v in p):
+            cv2.putText(panel, "  no data", (8, y),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, (100, 100, 100), 1, cv2.LINE_AA)
+            y += 36
+            continue
+        x, yv, z, qx, qy, qz, qw = p
+        cv2.putText(panel, f"  x={x:+.3f} y={yv:+.3f} z={z:+.3f}", (8, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (220, 220, 220), 1, cv2.LINE_AA)
+        y += 16
+        cv2.putText(panel, f"  qx={qx:+.2f} qy={qy:+.2f}", (8, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
+        y += 16
+        cv2.putText(panel, f"  qz={qz:+.2f} qw={qw:+.2f}", (8, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.38, (160, 160, 160), 1, cv2.LINE_AA)
+        y += 24
+    cv2.putText(panel, f"t = {t_sec:.2f} s   (frame {t_idx})",
+                (8, h - 14), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (200, 200, 200), 1, cv2.LINE_AA)
+    return panel
+
+
+def _make_trail_panel(iL_trail, iR_trail, w, h, threshold=0.4):
+    """Plot the last ~N frames of tactile_*_mixed as a paired waveform."""
+    panel = np.zeros((h, w, 3), np.uint8)
+    cv2.putText(panel, "Contact intensity (tactile_*_mixed)  — orange=L  blue=R",
+                (8, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1, cv2.LINE_AA)
+    cv2.line(panel, (8, 30), (w - 8, 30), (60, 60, 60), 1)
+
+    # Bipolar plot: L above mid, R below mid
+    mid_y = h - 26
+    max_y = 50
+    plot_top = mid_y - max_y
+    plot_bot = mid_y + max_y
+    cv2.line(panel, (8, mid_y), (w - 8, mid_y), (80, 80, 80), 1)
+
+    if not iL_trail:
+        return panel
+    N = len(iL_trail)
+    # Auto-scale by combined max so both stay visible
+    smax = max(max(iL_trail), max(iR_trail), float(threshold) * 1.5, 1e-3)
+    x_scale = (w - 16) / max(N - 1, 1)
+    for i in range(N - 1):
+        x0 = int(8 + i * x_scale)
+        x1 = int(8 + (i + 1) * x_scale)
+        # left = orange #E69F00 in BGR
+        y0L = mid_y - int(min(iL_trail[i],     smax) / smax * max_y)
+        y1L = mid_y - int(min(iL_trail[i + 1], smax) / smax * max_y)
+        cv2.line(panel, (x0, y0L), (x1, y1L), (0, 159, 230), 1, cv2.LINE_AA)
+        # right = blue #0072B2 in BGR
+        y0R = mid_y + int(min(iR_trail[i],     smax) / smax * max_y)
+        y1R = mid_y + int(min(iR_trail[i + 1], smax) / smax * max_y)
+        cv2.line(panel, (x0, y0R), (x1, y1R), (178, 114, 0), 1, cv2.LINE_AA)
+    # Threshold lines
+    yT_up = mid_y - int(min(threshold, smax) / smax * max_y)
+    yT_dn = mid_y + int(min(threshold, smax) / smax * max_y)
+    cv2.line(panel, (8, yT_up), (w - 8, yT_up), (60, 60, 60), 1, cv2.LINE_AA)
+    cv2.line(panel, (8, yT_dn), (w - 8, yT_dn), (60, 60, 60), 1, cv2.LINE_AA)
+    # Current values readout
+    cv2.putText(panel, f"L = {iL_trail[-1]:.2f}", (10, plot_top + 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.42, (0, 159, 230), 1, cv2.LINE_AA)
+    cv2.putText(panel, f"R = {iR_trail[-1]:.2f}", (10, plot_bot + 18),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.42, (178, 114, 0), 1, cv2.LINE_AA)
+    cv2.putText(panel, f"window: last {N} frames  (threshold = {threshold:.2f})",
+                (w - 280, h - 8), cv2.FONT_HERSHEY_SIMPLEX, 0.38, (140, 140, 140), 1, cv2.LINE_AA)
+    return panel
+
+
+def _make_controls_panel(w, h, paused, speed):
+    panel = np.zeros((h, w, 3), np.uint8)
+    cv2.putText(panel, "Controls", (10, 22),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55, (200, 200, 200), 1, cv2.LINE_AA)
+    cv2.line(panel, (10, 30), (w - 10, 30), (60, 60, 60), 1)
+    keys = [
+        ("SPACE",    "pause / resume"),
+        ("← / a",    "previous frame"),
+        ("→ / d",    "next frame"),
+        ("1..6",     "speed 1x/2x/5x/10x/25x/50x"),
+        ("r",        "reset gel-diff ref"),
+        ("q",        "quit"),
+    ]
+    y = 52
+    for k, v in keys:
+        cv2.putText(panel, f"[{k}]", (10, y), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (140, 200, 140), 1, cv2.LINE_AA)
+        cv2.putText(panel, v, (110, y), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (200, 200, 200), 1, cv2.LINE_AA)
+        y += 22
+    # State indicator
+    state = "|| PAUSED" if paused else "> PLAYING"
+    state_col = (0, 140, 255) if paused else (0, 220, 80)
+    cv2.putText(panel, state, (10, h - 26),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.55, state_col, 2, cv2.LINE_AA)
+    cv2.putText(panel, f"speed: {speed}x", (10, h - 8),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA)
+    return panel
+
+
+def _episode_label(meta: dict, fallback: str) -> str:
+    """Pretty label for header. mode2_v1 segments expose source_episode; older mode1_v1 doesn't."""
+    src = meta.get("source_episode")
+    seg = meta.get("source_segment_idx")
+    if src and seg is not None:
+        return f"{src} / seg{int(seg):02d}"
+    return fallback
+
+
+def build_panel(ep, frame_idx, ref_L_bgr, ref_R_bgr, iL_trail, iR_trail,
+                ep_label, paused, speed, n_frames):
+    view_bgr  = _view_to_bgr(ep["view"][frame_idx])
+    tac_L_bgr = _tactile_to_bgr(ep["tactile_left"][frame_idx])
+    tac_R_bgr = _tactile_to_bgr(ep["tactile_right"][frame_idx])
+
+    view_thumb  = cv2.resize(view_bgr,  VIEW_THUMB, interpolation=cv2.INTER_NEAREST)
+    tac_L_thumb = cv2.resize(tac_L_bgr, TAC_THUMB,  interpolation=cv2.INTER_NEAREST)
+    tac_R_thumb = cv2.resize(tac_R_bgr, TAC_THUMB,  interpolation=cv2.INTER_NEAREST)
+    tac_L_diff  = _diff_thumb(tac_L_bgr, ref_L_bgr, TAC_THUMB)
+    tac_R_diff  = _diff_thumb(tac_R_bgr, ref_R_bgr, TAC_THUMB)
+
+    # Tile-label headers
+    for img, label in [(view_thumb, "cam0 / view"),
+                       (tac_L_thumb, "tactile_left"),
+                       (tac_L_diff,  "tac_L diff (vs p01)"),
+                       (tac_R_thumb, "tactile_right"),
+                       (tac_R_diff,  "tac_R diff (vs p01)")]:
+        cv2.putText(img, label, (6, 14),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, (220, 220, 220), 1, cv2.LINE_AA)
+
+    row1 = np.hstack([view_thumb, tac_L_thumb, tac_L_diff, tac_R_thumb, tac_R_diff])
+
+    pose_L = ep["sensor_left_pose"][frame_idx].tolist()
+    pose_R = ep["sensor_right_pose"][frame_idx].tolist()
+    t_sec  = float(ep["timestamps"][frame_idx] - ep["timestamps"][0])
+    ot_panel       = _make_ot_panel(pose_L, pose_R, frame_idx, t_sec, *OT_PANEL)
+    trail_panel    = _make_trail_panel(list(iL_trail), list(iR_trail), *TRAIL_PANEL)
+    controls_panel = _make_controls_panel(*CONTROLS_PANEL, paused=paused, speed=speed)
+
+    row2 = np.hstack([ot_panel, trail_panel, controls_panel])
+    panel = np.vstack([row1, row2])
+
+    # Top status bar (orange, on a dark band so it's legible over the cams)
+    cv2.rectangle(panel, (0, 0), (PANEL_W, 22), (30, 30, 30), -1)
+    state = "PAUSED" if paused else "PLAYING"
+    status = (f"[{state}]  {ep_label}  ·  frame {frame_idx + 1}/{n_frames}  "
+              f"·  t = {t_sec:.2f}s  ·  {speed}x")
+    cv2.putText(panel, status, (10, 16),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.48, (0, 200, 255), 1, cv2.LINE_AA)
+    return panel
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Interactive playback of a React .pt file.")
+    ap.add_argument("pt_path", help="path to a .pt under processed/mode{1,2}_v1/.../")
+    ap.add_argument("--save_video", default=None,
+                    help="Path to write an MP4 instead of opening a window (headless mode).")
+    ap.add_argument("--fps", type=float, default=30.0, help="Playback / output fps.")
+    ap.add_argument("--trail_frames", type=int, default=120,
+                    help="How many recent frames to plot in the contact-intensity trail (default 120 = 4s).")
+    args = ap.parse_args()
+
+    pt_path = Path(args.pt_path)
+    if not pt_path.is_file():
+        print(f"Not a file: {pt_path}", file=sys.stderr); sys.exit(1)
+
+    print(f"Loading {pt_path}...")
+    ep = torch.load(pt_path, weights_only=False, map_location="cpu")
+    n_frames = ep["view"].shape[0]
+    meta = ep.get("_contact_meta", {})
+    ep_label = _episode_label(meta, fallback=pt_path.stem)
+    print(f"  {ep_label}: {n_frames} frames  ({n_frames / args.fps:.1f}s @ {args.fps:.0f} fps)")
+
+    # Initial GelSight diff reference — use the per-episode p01 frame stored
+    # in _contact_meta (cleanest "no contact" baseline). Fall back to frame 0
+    # if the .pt was produced before that field existed.
+    def _ref_from_meta_or_first(side):
+        key = f"ref_p01_{side}"
+        if key in meta and meta[key] is not None:
+            ref = meta[key]
+            if hasattr(ref, "permute"):
+                return _tactile_to_bgr(ref)
+        return _tactile_to_bgr(ep[f"tactile_{side}"][0])
+    ref_L = _ref_from_meta_or_first("left")
+    ref_R = _ref_from_meta_or_first("right")
+
+    iL = ep["tactile_left_mixed"].numpy()
+    iR = ep["tactile_right_mixed"].numpy()
+
+    paused, speed, frame_idx = False, 1, 0
+    SPEEDS = {ord('1'): 1, ord('2'): 2, ord('3'): 5,
+              ord('4'): 10, ord('5'): 25, ord('6'): 50}
+
+    headless = args.save_video is not None
+    if headless:
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(args.save_video, fourcc, args.fps, (PANEL_W, PANEL_H))
+        if not writer.isOpened():
+            print(f"Could not open {args.save_video} for writing.", file=sys.stderr); sys.exit(1)
+        print(f"Headless: writing {args.save_video}  ({n_frames} frames at {args.fps} fps)")
+    else:
+        cv2.namedWindow(ep_label, cv2.WINDOW_AUTOSIZE)
+        cv2.createTrackbar("Frame", ep_label, 0, max(1, n_frames - 1), lambda v: None)
+        print("Controls:  space / ←→ / 1..6 / r / q")
+
+    iL_trail = collections.deque(maxlen=args.trail_frames)
+    iR_trail = collections.deque(maxlen=args.trail_frames)
+    last_drawn = -1
+
+    try:
+        while True:
+            frame_idx = max(0, min(frame_idx, n_frames - 1))
+            if not headless:
+                pos = cv2.getTrackbarPos("Frame", ep_label)
+                if pos != frame_idx and pos != last_drawn:
+                    frame_idx = pos
+                    paused = True
+
+            iL_trail.append(float(iL[frame_idx]))
+            iR_trail.append(float(iR[frame_idx]))
+
+            panel = build_panel(ep, frame_idx, ref_L, ref_R,
+                                iL_trail, iR_trail, ep_label, paused, speed, n_frames)
+
+            if headless:
+                writer.write(panel)
+                if frame_idx % 30 == 0:
+                    print(f"  wrote frame {frame_idx + 1}/{n_frames}")
+                if frame_idx >= n_frames - 1:
+                    break
+                frame_idx += 1
+                continue
+
+            cv2.imshow(ep_label, panel)
+            if cv2.getTrackbarPos("Frame", ep_label) != frame_idx:
+                cv2.setTrackbarPos("Frame", ep_label, frame_idx)
+            last_drawn = frame_idx
+
+            key = cv2.waitKey(1) & 0xFF
+            if   key == ord('q'): break
+            elif key == ord(' '): paused = not paused
+            elif key in (81, ord('a')): paused = True; frame_idx -= 1
+            elif key in (83, ord('d')): paused = True; frame_idx += 1
+            elif key in SPEEDS:   speed = SPEEDS[key]
+            elif key == ord('r'):
+                ref_L = _tactile_to_bgr(ep["tactile_left"][frame_idx])
+                ref_R = _tactile_to_bgr(ep["tactile_right"][frame_idx])
+                print(f"  diff ref reset to frame {frame_idx}")
+
+            if not paused:
+                frame_idx += speed
+                if frame_idx >= n_frames:
+                    frame_idx = n_frames - 1
+                    paused = True
+                    print("End of file.")
+                time.sleep(max(0.0, 1.0 / (args.fps * speed) - 0.001))
+
+    finally:
+        if headless:
+            writer.release()
+            print(f"Wrote {args.save_video}")
+        else:
+            cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()