examples/: upgraded ReactWindowDataset (adds motion filter to catch operator-paused windows the bad_frames check cant); canonical self-contained demo_react_window.py (no twm dependency); new examples/README.md with four-filter explanation and recipes per use case

examples/README.md

@@ -0,0 +1,119 @@
+# React — usage examples
+
+Reference code for sampling clean training windows from this dataset. **Use
+these examples (or copy their patterns) to avoid sampling on top of known
+data-quality issues.**
+
+## What's in here
+
+| File | Purpose |
+|---|---|
+| [`react_window_dataset.py`](react_window_dataset.py) | A PyTorch `Dataset` that yields short multimodal windows with all four quality filters applied at enumeration time. Drop-in usable. |
+| [`demo_react_window.py`](demo_react_window.py) | End-to-end usage example — builds the dataset, prints one sample's structure, renders a static grid of N random windows as a PNG. |
+
+## What the dataloader filters out
+
+The published `.pt` files have already had **OT-uninitialized recording
+prefixes** trimmed (those bad spans were before the dataloader ever sees
+the data — see [`docs/caveats.md`](../docs/caveats.md)). On top of that,
+`ReactWindowDataset` applies four enumeration-time filters:
+
+| # | Filter | What it catches |
+|---|---|---|
+| 1 | `skip_bad_frames` | Windows overlapping any interval in `bad_frames.json` (`intensity_spikes`, `pose_teleports_{L,R}`, `ot_loss_{L,R}`). These are *broken* data: LED glitches, mocap solver flips, mid-episode OptiTrack track loss. |
+| 2 | `respect_active_sensors` | Ignores inactive sensors per `tasks.json:per_date_notes` when checking contact + motion predicates. |
+| 3 | `min_contact_fraction` | Drops windows where fewer than `min_contact_fraction` of frames have tactile contact (chosen sensor + metric + threshold). Forces samples to be contact-rich. |
+| 4 | **`require_motion`** | **Drops windows where the active sensors are essentially stationary** (operator paused mid-manipulation). The recorded data is healthy, but a near-zero-motion window contains no dynamics to learn. |
+
+Filter (4) is the one most people forget. Without it, you'll get the
+occasional "wait, the sensor isn't moving in this clip" sample even
+though everything else is clean.
+
+## Minimal recipe
+
+```python
+from examples.react_window_dataset import ReactWindowDataset
+from torch.utils.data import DataLoader
+
+ds = ReactWindowDataset(
+    data_root        = "processed/mode1_v1/motherboard",
+    bad_frames_path  = "bad_frames.json",
+    tasks_json_path  = "tasks.json",
+    window_length    = 16,
+    # (1) (2) — broken data + inactive-sensor handling
+    skip_bad_frames        = True,
+    respect_active_sensors = True,
+    # (3) — contact-richness
+    contact_metric         = "mixed",
+    tactile_threshold      = 0.4,
+    min_contact_fraction   = 0.5,
+    which_sensors          = "any",
+    # (4) — motion content (recommended for dynamics learning)
+    require_motion              = True,
+    min_motion_mps              = 0.03,    # 30 mm/s
+    min_motion_fraction         = 0.5,
+    which_sensors_must_move     = "all_active",
+)
+loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2)
+```
+
+## Recommended defaults by use case
+
+- **Dynamics / world-model learning**: all four filters on. The recipe above.
+- **UMI-style imitation / pose-as-action**: same recipe; filter (4) is
+  critical here because stationary windows give you constant-action labels.
+- **Studying static tactile patterns** (e.g. classification of contact
+  shapes): turn filter (4) OFF (`require_motion=False`) — you specifically
+  want windows where the sensor is held still on an object.
+
+## Loading a single `.pt` directly (without this dataloader)
+
+If you're rolling your own sampler, replicate the filter logic by hand:
+
+```python
+import json, torch, numpy as np
+
+ep_key = "2026-05-11/episode_017"
+ep = torch.load(f"processed/mode1_v1/motherboard/{ep_key}.pt", weights_only=False)
+T = ep["view"].shape[0]
+bad = json.load(open("bad_frames.json"))["episodes"][ep_key]
+
+# Frame-level mask (True = drop)
+mask = np.zeros(T, dtype=bool)
+for s, e in (bad["intensity_spikes"]
+             + bad["pose_teleports_L"] + bad["pose_teleports_R"]
+             + bad["ot_loss_L"] + bad["ot_loss_R"]):
+    mask[s:e + 1] = True
+
+# Per-frame motion mask (use this in addition to bad_frames)
+pose_L = ep["sensor_left_pose"].numpy()
+pose_R = ep["sensor_right_pose"].numpy()
+speed_L = np.linalg.norm(np.diff(pose_L[:, :3], axis=0), axis=1) * 30      # m/s
+speed_R = np.linalg.norm(np.diff(pose_R[:, :3], axis=0), axis=1) * 30
+moving_L = np.concatenate([[speed_L[0]], speed_L]) >= 0.03                  # 30 mm/s
+moving_R = np.concatenate([[speed_R[0]], speed_R]) >= 0.03
+
+# Then when picking a window [t, t+L):
+def good(t, L):
+    if mask[t:t + L].any():
+        return False
+    return moving_L[t:t + L].mean() >= 0.5 and moving_R[t:t + L].mean() >= 0.5
+```
+
+## Coordinates note
+
+All frame indices in `bad_frames.json` and in the `.pt` files are in
+**trimmed** coordinates — the OT-uninitialized prefixes were cut from
+the published `.pt` files. The trim offset per file is recorded as
+`_contact_meta.trim_offset` inside the `.pt`. You don't need to apply
+it yourself: this loader and the metadata are already aligned.
+
+If you also need to read the original H5 archive (held in
+`MultimodalData/twm/data/<task>/<date>/`), remember to **add the trim
+offset back** before indexing into the H5 — the H5 still has the
+pre-trim timeline.
+
+```python
+trim_offset = ep["_contact_meta"]["trim_offset"]
+h5_index = pt_index + trim_offset    # only needed when reading raw H5
+```

examples/demo_react_window.py

@@ -1,128 +1,56 @@
-"""Demonstrate ReactWindowDataset:
-  - build the dataset with sensible defaults
-  - sample N random windows
-  - render static grid PNG (N rows × 8 cols, each cell a [view | tac_L | tac_R] composite)
-  - render one window as a GIF with sensor-frame axes projected on `view`
+"""End-to-end usage example for `ReactWindowDataset`.
+
+Run this against a local checkout of the React HF dataset:
+
+  python examples/demo_react_window.py \\
+      --data_root processed/mode1_v1/motherboard \\
+      --bad_frames bad_frames.json \\
+      --tasks_json tasks.json \\
+      --n_samples 4 \\
+      --out_dir /tmp/react_demo_out
+
+What this script does
+---------------------
+1. Builds `ReactWindowDataset` with all four quality filters on (see the
+   module docstring of `react_window_dataset.py` for what each catches).
+2. Prints how many windows survived and the shape of one sample.
+3. Renders a static grid of `--n_samples` random windows as a PNG. Each
+   row = one window; each cell = `view | tactile_left | tactile_right`
+   for a single frame inside that window.
+
+Self-contained: only depends on numpy, torch, Pillow, and `cv2`. No
+recording-machine code is needed — everything required to read the
+published .pt files is shipped here.
 """
-import json
+import argparse
 import sys
 from pathlib import Path
 
 import cv2
 import numpy as np
 import torch
-from PIL import Image, ImageDraw, ImageFont
-from scipy.spatial.transform import Rotation
+from PIL import Image
 
-sys.path.insert(0, "/tmp")
+# Same-directory import.
+sys.path.insert(0, str(Path(__file__).parent))
 from react_window_dataset import ReactWindowDataset
 
-OUT = Path("/media/yxma/Disk1/twm/figures/dataloader_examples")
-OUT.mkdir(parents=True, exist_ok=True)
 
-DATA_ROOT = Path("/media/yxma/Disk1/twm/processed/mode1_v1/motherboard")
-BAD_FRAMES = Path("/media/yxma/Disk1/twm/figures/dataset_figures/bad_frames.json")
-TASKS_JSON = Path("/tmp/tasks_local.json")    # written below from HF
-
-# `view` in the .pt = realsense/cam0/color, center-cropped 640→480 then resized → 128
-# cam0 serial = 143322063538 → T_mocap_to_cam_right.json
-CALIB_DIR = Path("/home/yxma/MultimodalData/twm/calibration/result")
-CAM_CALIB_FOR_VIEW = CALIB_DIR / "T_mocap_to_cam_right.json"
-GEL_LEFT_CALIB = CALIB_DIR / "T_gel_to_rigid_left.json"
-GEL_RIGHT_CALIB = CALIB_DIR / "T_gel_to_rigid_right.json"
-
-AX_COLORS_RGB = [(0, 0, 255), (0, 255, 0), (255, 128, 0)]   # X red, Y green, Z blue-ish
-AX_LABELS = ["X", "Y", "Z"]
-GEL_DOT_COLOR = {"L": (0, 255, 120), "R": (0, 180, 255)}
-
-
-def load_calib():
-    cam = json.loads(CAM_CALIB_FOR_VIEW.read_text())
-    return {
-        "T_mocap_to_cam": np.array(cam["T_mocap_to_cam"], np.float64),
-        "intrinsics": cam["intrinsics"],
-        "gel_left":  np.array(json.loads(GEL_LEFT_CALIB.read_text())["gel_center_in_rigid_mm"], np.float64),
-        "gel_right": np.array(json.loads(GEL_RIGHT_CALIB.read_text())["gel_center_in_rigid_mm"], np.float64),
-    }
-
-
-def pose_to_T(pose_7):
-    """7-vec (x,y,z, qx,qy,qz,qw) in meters → 4×4 in mm."""
-    pos_mm = np.array(pose_7[:3], np.float64) * 1000.0
-    q = np.array(pose_7[3:], np.float64)
-    q /= np.linalg.norm(q)
-    T = np.eye(4)
-    T[:3, :3] = Rotation.from_quat(q).as_matrix()
-    T[:3, 3] = pos_mm
-    return T
-
-
-def project_to_view(P_world_mm, calib, *, view_size=128, orig_w=640, orig_h=480):
-    """Project a single mocap-frame point (mm) into 128×128 view coords.
-
-    The .pt `view` was made by center-cropping cam0 from 640×480 → 480×480 and
-    then bilinear-resizing to 128×128. We replicate that here.
-    """
-    T_m2c = calib["T_mocap_to_cam"]
-    I = calib["intrinsics"]
-    P = (T_m2c @ np.append(P_world_mm, 1.0))[:3]
-    if P[2] <= 0:
-        return None
-    u640 = I["fx"] * P[0] / P[2] + I["ppx"]
-    v480 = I["fy"] * P[1] / P[2] + I["ppy"]
-    crop_left = (orig_w - orig_h) / 2.0          # 80
-    u_in_crop = u640 - crop_left
-    s = view_size / orig_h                       # 128/480
-    return (u_in_crop * s, v480 * s)
-
-
-def project_gel_with_axes(pose_7, gel_center_mm, calib, axis_len_mm=80.0):
-    """Return (center_uv, [(x_uv, y_uv, z_uv) or None])."""
-    if pose_7 is None or np.allclose(pose_7, 0.0):
-        return None, None
-    T_r2m = pose_to_T(pose_7)
-    P_gel = (T_r2m @ np.append(gel_center_mm, 1.0))[:3]
-    R = T_r2m[:3, :3]
-    tips = [P_gel + R @ np.array([axis_len_mm, 0, 0]),
-            P_gel + R @ np.array([0, axis_len_mm, 0]),
-            P_gel + R @ np.array([0, 0, axis_len_mm])]
-    center = project_to_view(P_gel, calib)
-    if center is None:
-        return None, None
-    return center, [project_to_view(t, calib) for t in tips]
-
-
-def to_hwc(t):
+def _to_hwc(t):
+    """(3, H, W) torch uint8 → (H, W, 3) numpy uint8."""
     return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy()
 
 
-def annotate_view(view_uint8, pose_L, pose_R, calib, *, scale=1):
-    """Draw sensor axes on a (H, W, 3) RGB image. Returns annotated copy."""
-    H, W, _ = view_uint8.shape
-    img = view_uint8.copy()
-    for side, pose, gel in [("L", pose_L, calib["gel_left"]),
-                             ("R", pose_R, calib["gel_right"])]:
-        ctr, axes = project_gel_with_axes(pose, gel, calib)
-        if ctr is None:
-            continue
-        cx, cy = int(round(ctr[0])), int(round(ctr[1]))
-        if axes is not None:
-            for tip, c, lab in zip(axes, AX_COLORS_RGB, AX_LABELS):
-                if tip is None:
-                    continue
-                tx, ty = int(round(tip[0])), int(round(tip[1]))
-                cv2.line(img, (cx, cy), (tx, ty), c, max(1, scale), cv2.LINE_AA)
-        dot_color = GEL_DOT_COLOR[side]
-        cv2.circle(img, (cx, cy), max(2, 3 * scale), dot_color, -1, cv2.LINE_AA)
-        cv2.circle(img, (cx, cy), max(2, 3 * scale) + 1, (255, 255, 255), 1, cv2.LINE_AA)
-        cv2.putText(img, side, (cx + 4, cy + 4),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.4 * scale,
-                    dot_color, max(1, scale), cv2.LINE_AA)
-    return img
+def _view_to_rgb(view_chw_uint8):
+    """`view` was extracted from RealSense cam0 which records BGR
+    (`rs.format.bgr8`); convert to RGB for PIL."""
+    return view_chw_uint8.permute(1, 2, 0).numpy()[..., ::-1].copy()
 
 
-def make_static_grid(ds, sample_indices, calib, out_path,
-                     n_cols=6, cell_scale=3):
+def make_static_grid(ds, sample_indices, out_path: Path, *,
+                     n_cols: int = 6, cell_scale: int = 3) -> None:
+    """One row per window, `n_cols` evenly-spaced frames per window. Each
+    cell is `view | tactile_left | tactile_right`."""
     rows = []
     for idx in sample_indices:
         s = ds[idx]
@@ -130,29 +58,24 @@ def make_static_grid(ds, sample_indices, calib, out_path,
         pick = np.linspace(0, T - 1, n_cols).astype(int)
         cells = []
         for t in pick:
-            view_rgb = to_hwc(s["view"][t]).astype(np.uint8)
-            view_rgb = annotate_view(view_rgb,
-                                      s["sensor_left_pose"][t].numpy() if "left" in s["active_sensors"] else None,
-                                      s["sensor_right_pose"][t].numpy() if "right" in s["active_sensors"] else None,
-                                      calib, scale=1)
-            tl = to_hwc(s["tactile_left"][t])
-            tr = to_hwc(s["tactile_right"][t])
-            # Stack horizontally: view | tac_L | tac_R, each 128×128
-            triplet = np.concatenate([view_rgb, tl, tr], axis=1)  # (128, 384, 3)
-            # Upscale for clarity
-            triplet = cv2.resize(triplet, (triplet.shape[1] * cell_scale, triplet.shape[0] * cell_scale),
-                                 interpolation=cv2.INTER_NEAREST)
+            view  = _view_to_rgb(s["view"][t]).astype(np.uint8)
+            tac_L = _to_hwc(s["tactile_left"][t]).astype(np.uint8)
+            tac_R = _to_hwc(s["tactile_right"][t]).astype(np.uint8)
+            triplet = np.concatenate([view, tac_L, tac_R], axis=1)  # (128, 384, 3)
+            triplet = cv2.resize(
+                triplet,
+                (triplet.shape[1] * cell_scale, triplet.shape[0] * cell_scale),
+                interpolation=cv2.INTER_NEAREST,
+            )
             cells.append(triplet)
         rows.append(np.concatenate(cells, axis=1))
 
     H_row = rows[0].shape[0]
     W_row = rows[0].shape[1]
+    label_h = 88
     pad_y = 16
-    label_h = 88                 # vertical label band above each row
     canvas_h = 60 + len(rows) * (H_row + label_h + pad_y)
-    canvas = np.full((canvas_h, W_row + 20, 3), 245, dtype=np.uint8)
-
-    # Page header
+    canvas = np.full((canvas_h, W_row + 20, 3), 245, np.uint8)
     cv2.putText(canvas, f"ReactWindowDataset — {n_cols} evenly-spaced frames per sample (time runs left → right)",
                 (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (50, 50, 50), 2, cv2.LINE_AA)
 
@@ -160,102 +83,86 @@ def make_static_grid(ds, sample_indices, calib, out_path,
     for r, idx in enumerate(sample_indices):
         s = ds[idx]
         y0 = 60 + r * (H_row + label_h + pad_y)
-        # Sample label band
-        ep = s["episode_key"]
         dur_s = float(s["timestamps"][-1] - s["timestamps"][0])
         mL = float(s["tactile_left_mixed"].max())
         mR = float(s["tactile_right_mixed"].max())
-        cv2.putText(canvas, f"sample #{idx}  ·  {ep}  ·  frames {s['frame_start']}-{s['frame_end']}  ({dur_s:.2f}s)  ·  active: {','.join(s['active_sensors'])}  ·  peak mixed L={mL:.2f}  R={mR:.2f}",
-                    (10, y0 + 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA)
-        # Per-cell time labels
+        cv2.putText(
+            canvas,
+            (f"sample #{idx}  ·  {s['episode_key']}  ·  frames {s['frame_start']}-{s['frame_end']}  "
+             f"({dur_s:.2f}s)  ·  active: {','.join(s['active_sensors'])}  ·  "
+             f"peak mixed L={mL:.2f}  R={mR:.2f}"),
+            (10, y0 + 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA,
+        )
         T = s["view"].shape[0]
         pick = np.linspace(0, T - 1, n_cols).astype(int)
         for c, t in enumerate(pick):
             cv2.putText(canvas, f"t = {int(t)}  (frame {s['frame_start'] + int(t)})",
-                        (10 + c * cell_w + 8, y0 + 56), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (90, 90, 90), 1, cv2.LINE_AA)
+                        (10 + c * cell_w + 8, y0 + 56),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.45, (90, 90, 90), 1, cv2.LINE_AA)
         cv2.putText(canvas, "view  |  tactile_left  |  tactile_right",
                     (10, y0 + 76), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (130, 130, 130), 1, cv2.LINE_AA)
-        # Place row
         canvas[y0 + label_h:y0 + label_h + H_row, 10:10 + W_row] = rows[r]
 
+    out_path.parent.mkdir(parents=True, exist_ok=True)
     Image.fromarray(canvas).save(out_path)
-    print(f"  static -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")
-
-
-def make_gif(ds, sample_idx, calib, out_path, *, panel_scale=3, fps=15):
-    s = ds[sample_idx]
-    T = s["view"].shape[0]
-    frames = []
-    for t in range(T):
-        view_rgb = to_hwc(s["view"][t]).astype(np.uint8)
-        view_ann = annotate_view(view_rgb,
-                                  s["sensor_left_pose"][t].numpy() if "left" in s["active_sensors"] else None,
-                                  s["sensor_right_pose"][t].numpy() if "right" in s["active_sensors"] else None,
-                                  calib, scale=1)
-        # Upscale each subpanel
-        view_big = cv2.resize(view_ann, (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
-        tl_big = cv2.resize(to_hwc(s["tactile_left"][t]),
-                            (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
-        tr_big = cv2.resize(to_hwc(s["tactile_right"][t]),
-                            (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
-        triplet = np.concatenate([view_big, tl_big, tr_big], axis=1)
-        # Header strip with frame counter
-        H, W, _ = triplet.shape
-        header = np.full((36, W, 3), 230, dtype=np.uint8)
-        text = f"{s['episode_key']}  frame {s['frame_start'] + t}/{s['frame_end']}  ({t+1}/{T})  |  view | tactile_L | tactile_R"
-        cv2.putText(header, text, (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA)
-        panel = np.concatenate([header, triplet], axis=0)
-        frames.append(panel)
-
-    # Shared-palette GIF
-    pil = [Image.fromarray(f) for f in frames]
-    mosaic = Image.new("RGB", (pil[0].width * min(8, len(pil)), pil[0].height))
-    for i, im in enumerate(pil[: min(8, len(pil))]):
-        mosaic.paste(im, (i * pil[0].width, 0))
-    pal = mosaic.quantize(colors=128, method=Image.MEDIANCUT, dither=Image.NONE)
-    qframes = [im.quantize(palette=pal, dither=Image.NONE) for im in pil]
-    qframes[0].save(out_path, save_all=True, append_images=qframes[1:],
-                     duration=int(round(1000 / fps)), loop=0, optimize=True, disposal=0)
-    print(f"  gif    -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")
+    print(f"  grid -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")
 
 
 def main():
-    # tasks.json was pre-fetched to TASKS_JSON via the base env
-    if not TASKS_JSON.exists():
-        raise FileNotFoundError(f"{TASKS_JSON} missing; fetch from yxma/React first")
-    calib = load_calib()
-
-    print("=== Build dataset ===")
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data_root", required=True,
+                    help="processed/mode1_v1/motherboard (relative to dataset root)")
+    ap.add_argument("--bad_frames", default="bad_frames.json")
+    ap.add_argument("--tasks_json", default="tasks.json")
+    ap.add_argument("--n_samples", type=int, default=4)
+    ap.add_argument("--out_dir", default="/tmp/react_demo_out")
+    ap.add_argument("--window_length", type=int, default=16)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--no_motion_filter", action="store_true",
+                    help="Disable the motion filter (useful if you want stationary "
+                         "contact windows for studying static tactile patterns).")
+    args = ap.parse_args()
+
+    print("=== Building dataset (all four quality filters on) ===")
     ds = ReactWindowDataset(
-        data_root=DATA_ROOT,
-        bad_frames_path=BAD_FRAMES,
-        tasks_json_path=TASKS_JSON,
-        window_length=16,
-        stride=1,
-        window_step=16,
-        contact_metric="mixed",
-        tactile_threshold=0.4,
-        min_contact_fraction=0.6,
-        which_sensors="any",
-        skip_bad_frames=True,
-        respect_active_sensors=True,
+        data_root        = args.data_root,
+        bad_frames_path  = args.bad_frames,
+        tasks_json_path  = args.tasks_json,
+        window_length    = args.window_length,
+        stride           = 1,
+        window_step      = max(1, args.window_length // 2),
+        contact_metric        = "mixed",
+        tactile_threshold     = 0.4,
+        min_contact_fraction  = 0.5,
+        which_sensors         = "any",
+        skip_bad_frames        = True,
+        respect_active_sensors = True,
+        require_motion              = not args.no_motion_filter,
+        min_motion_mps              = 0.03,
+        min_motion_fraction         = 0.5,
+        which_sensors_must_move     = "all_active",
     )
 
-    rng = np.random.default_rng(42)
-    pick = rng.choice(len(ds), 4, replace=False)
-    print(f"\n=== Render 4 random samples ===")
-    make_static_grid(ds, pick, calib, OUT / "sample_grid.png")
-    print(f"\n=== Render one as GIF ===")
-    make_gif(ds, int(pick[0]), calib, OUT / "sample_window.gif")
+    if len(ds) == 0:
+        print("No windows passed the filters. Try lowering `min_contact_fraction` "
+              "or disabling `require_motion`.")
+        return
 
-    print("\nSample dict shapes (sample 0):")
-    s = ds[int(pick[0])]
-    for k, v in s.items():
+    rng = np.random.default_rng(args.seed)
+    pick = rng.choice(len(ds), min(args.n_samples, len(ds)), replace=False)
+
+    print(f"\n=== One sample's structure (#{int(pick[0])}) ===")
+    s0 = ds[int(pick[0])]
+    for k, v in s0.items():
         if isinstance(v, torch.Tensor):
             print(f"  {k:30s} {tuple(v.shape)}  {v.dtype}")
         else:
             print(f"  {k:30s} {v!r}")
 
+    print(f"\n=== Static grid of {len(pick)} random windows ===")
+    out_dir = Path(args.out_dir)
+    make_static_grid(ds, pick, out_dir / "sample_grid.png")
+
 
 if __name__ == "__main__":
     main()

examples/react_window_dataset.py

@@ -1,8 +1,47 @@
-"""React: short-horizon contact-rich window dataset.
+"""React: short-horizon contact-rich window dataset (PyTorch).
 
-A PyTorch `Dataset` that yields short multimodal windows sampled from the
-React recordings, filtered to be contact-rich and free of known data-quality
-issues. Intended for tactile-visual dynamics / world-model learning.
+Yields short multimodal windows sampled from the React recordings, with all
+known data-quality issues filtered out at window-enumeration time. Intended
+for tactile-visual dynamics / world-model / UMI-style imitation learning.
+
+What each filter catches
+------------------------
+
+1. `skip_bad_frames`  →  windows overlapping any flagged interval in
+   `bad_frames.json` are dropped. Covers:
+   - `intensity_spikes`         — single-frame GelSight LED glitches
+   - `pose_teleports_{L,R}`     — translation-velocity > 5 m/s solver flips
+   - `ot_loss_{L,R}`            — mid-episode OptiTrack track loss
+                                  (pose held stale for ≥ 0.25 s while the
+                                  cross-modal motion check shows the sensor
+                                  was actually moving)
+
+2. `respect_active_sensors`  →  per-date metadata in `tasks.json` tells us
+   which GelSight rigid bodies were actually in use that day; the predicate
+   below ignores inactive sensors when deciding "is this window useful?".
+
+3. `min_contact_fraction`  →  windows where fewer than this fraction of
+   frames have tactile contact (per the configured metric + threshold +
+   `which_sensors`) are dropped. Forces samples to be contact-rich.
+
+4. `require_motion`  →  windows where the sensor is sitting essentially
+   still (operator paused mid-manipulation) are dropped. Specifically: an
+   active sensor "passes" if at least `min_motion_fraction` of its frames
+   have per-frame translation speed ≥ `min_motion_mps`. The
+   `which_sensors_must_move` parameter says whether every active sensor
+   must pass, or just one.
+
+   This catches the failure mode that bad_frames.json *can't* — windows
+   where OT is healthy and pose is changing every frame, but the change
+   is sub-millimeter per frame so there's nothing to learn dynamics from.
+
+Coordinates note
+----------------
+All frame indices in `bad_frames.json` and the .pt files are in TRIMMED
+coordinates: the OT-uninitialized prefixes at the start of three episodes
+have been cut from the published .pt files (see `_contact_meta.trim_offset`
+inside each .pt). You don't need to do anything special — this loader and
+the metadata are already aligned.
 
 Usage
 -----
@@ -11,23 +50,31 @@ from react_window_dataset import ReactWindowDataset
 from torch.utils.data import DataLoader
 
 ds = ReactWindowDataset(
-    data_root="processed/mode1_v1/motherboard",
-    bad_frames_path="bad_frames.json",
-    tasks_json_path="tasks.json",
-    window_length=16,            # frames per window
-    stride=1,                    # within-window frame stride (1 = consecutive)
-    window_step=8,               # step between window start indices
-    contact_metric="mixed",      # which tactile metric to threshold on
-    tactile_threshold=0.4,
-    min_contact_fraction=0.5,    # ≥ 50% of window frames must have contact
-    which_sensors="any",         # "any" | "both" | "left" | "right"
-    skip_bad_frames=True,
-    respect_active_sensors=True, # mask out left modalities for right-only pilot
+    data_root        = "processed/mode1_v1/motherboard",
+    bad_frames_path  = "bad_frames.json",
+    tasks_json_path  = "tasks.json",
+    window_length    = 16,
+    stride           = 1,
+    window_step      = 8,
+    # contact filter
+    contact_metric        = "mixed",
+    tactile_threshold     = 0.4,
+    min_contact_fraction  = 0.5,
+    which_sensors         = "any",
+    # quality filters (recommended on)
+    skip_bad_frames        = True,
+    respect_active_sensors = True,
+    # motion filter (recommended on for dynamics learning)
+    require_motion              = True,
+    min_motion_mps              = 0.03,    # 30 mm/s — above "paused"
+    min_motion_fraction         = 0.5,
+    which_sensors_must_move     = "all_active",
 )
 loader = DataLoader(ds, batch_size=8, shuffle=True, num_workers=2)
 ```
 
-Each sample is a dict of `(T, ...)` tensors plus metadata.
+Each sample is a dict of `(T, ...)` tensors plus per-window metadata
+(`episode`, `episode_key`, `frame_start`, `frame_end`, `active_sensors`).
 """
 from __future__ import annotations
 
@@ -42,47 +89,81 @@ from torch.utils.data import Dataset
 CONTACT_METRICS = ("intensity", "area", "mixed")
 
 
+def _per_frame_speed_mps(pose7: np.ndarray, fps: float = 30.0) -> np.ndarray:
+    """Per-frame translation speed in m/s. Output shape == input frame count;
+    pad the first frame's speed with the second frame's (forward difference)."""
+    if pose7.shape[0] < 2:
+        return np.zeros(pose7.shape[0], dtype=np.float64)
+    d = np.linalg.norm(np.diff(pose7[:, :3], axis=0), axis=1) * fps
+    out = np.empty(pose7.shape[0], dtype=np.float64)
+    out[0] = d[0]
+    out[1:] = d
+    return out
+
+
 class ReactWindowDataset(Dataset):
     """Per-window dataset over the React recordings.
 
+    See the module docstring for what each filter catches.
+
     Parameters
     ----------
     data_root : path
-        Directory containing `<task>/<date>/episode_*.pt` files. Searched
-        recursively.
+        Directory containing `<task>/<date>/episode_*.pt` files (searched
+        recursively).
     bad_frames_path : optional path
-        `bad_frames.json` (the shipped skip-list). If None, no quality filter.
+        Path to `bad_frames.json`. If None, no quality filter is applied.
     tasks_json_path : optional path
-        `tasks.json`. Used for `respect_active_sensors` mode.
+        Path to `tasks.json`. Used for the `respect_active_sensors` mode.
+
     window_length : int
-        Number of frames per sample.
+        Frames per sample (default 16).
     stride : int
-        Frame stride within a window. `stride=1` → consecutive frames,
-        `stride=2` → every other source frame, etc. Span of a window in
-        source-frame indices = `(window_length - 1) * stride + 1`.
+        Frame stride *within* a window. `stride=1` → consecutive source
+        frames; `stride=2` → every other source frame; etc. Span of a
+        window in source-frame indices = `(window_length - 1) * stride + 1`.
     window_step : int, default `window_length // 2`
         Step between window start indices within an episode. Controls
         overlap between adjacent windows.
+
     contact_metric : {"intensity", "area", "mixed"}
         Which per-frame tactile metric to threshold on.
     tactile_threshold : float
-        Minimum value of the chosen metric to count as contact.
+        Minimum value of the chosen metric to count a frame as in-contact.
     min_contact_fraction : float in [0, 1]
-        A window is kept only if at least this fraction of its frames satisfy
-        the contact predicate.
+        Window must have ≥ this fraction of in-contact frames.
     which_sensors : {"any", "both", "left", "right"}
-        How left + right sensors combine when checking the predicate.
+        How left + right sensors combine when checking the contact
+        predicate. (Inactive sensors per `tasks.json` are always excluded.)
+
+    skip_bad_frames : bool, default True
+        Drop windows whose source-frame span overlaps any interval in
+        `intensity_spikes / pose_teleports_{L,R} / ot_loss_{L,R}`.
+    respect_active_sensors : bool, default True
+        If True (and `tasks.json` has per-date `active_sensors`), inactive
+        sensors are ignored by both the contact filter and the motion
+        filter, and the returned sample carries an `active_sensors` field
+        so downstream code can mask out the inactive modalities.
+
+    require_motion : bool, default False
+        Toggle the motion filter (off for back-compat; recommended on for
+        dynamics learning).
+    min_motion_mps : float, default 0.03
+        Per-frame translation speed (in m/s) above which a frame counts as
+        "moving" for a given sensor.
+    min_motion_fraction : float in [0, 1], default 0.5
+        An active sensor passes the motion filter if ≥ this fraction of
+        the window's frames have speed ≥ `min_motion_mps`.
+    which_sensors_must_move : {"any", "all_active"}, default "all_active"
+        Whether every active sensor must pass the motion filter (strict;
+        rejects the "left held still while right moves" pattern), or just
+        one. "all_active" is what you typically want for dynamics learning.
+
     tasks, dates : optional iterables of str
-        Filter episodes by task name and/or date string.
-    skip_bad_frames : bool
-        If True, drop windows whose source-frame span overlaps any flagged
-        interval in `bad_frames.json`.
-    respect_active_sensors : bool
-        If True (and `tasks.json` has per-date `active_sensors`), windows on
-        right-only recordings (2026-03-23 pilot) auto-fallback to right-only
-        contact predicate, and the returned sample carries an
-        `active_sensors` field so dataloaders can mask the inactive
-        modalities.
+        Restrict to specific task names / date strings.
+
+    fps : float, default 30
+        Frame rate used to convert pose deltas to m/s.
     """
 
     def __init__(
@@ -102,11 +183,18 @@ class ReactWindowDataset(Dataset):
         dates: Iterable[str] | None = None,
         skip_bad_frames: bool = True,
         respect_active_sensors: bool = True,
+        require_motion: bool = False,
+        min_motion_mps: float = 0.03,
+        min_motion_fraction: float = 0.5,
+        which_sensors_must_move: str = "all_active",
+        fps: float = 30.0,
     ):
         if contact_metric not in CONTACT_METRICS:
             raise ValueError(f"contact_metric must be one of {CONTACT_METRICS}")
         if which_sensors not in ("any", "both", "left", "right"):
             raise ValueError("which_sensors must be 'any' | 'both' | 'left' | 'right'")
+        if which_sensors_must_move not in ("any", "all_active"):
+            raise ValueError("which_sensors_must_move must be 'any' | 'all_active'")
         if window_length < 1 or stride < 1:
             raise ValueError("window_length and stride must be ≥ 1")
 
@@ -119,6 +207,12 @@ class ReactWindowDataset(Dataset):
         self.min_contact_fraction = float(min_contact_fraction)
         self.which_sensors = which_sensors
         self.respect_active_sensors = bool(respect_active_sensors)
+        self.skip_bad_frames = bool(skip_bad_frames)
+        self.require_motion = bool(require_motion)
+        self.min_motion_mps = float(min_motion_mps)
+        self.min_motion_fraction = float(min_motion_fraction)
+        self.which_sensors_must_move = which_sensors_must_move
+        self.fps = float(fps)
 
         self.bad = {}
         if bad_frames_path is not None and Path(bad_frames_path).is_file():
@@ -133,9 +227,7 @@ class ReactWindowDataset(Dataset):
                 for d, info in td.get("per_date_notes", {}).items():
                     self.per_date[d] = info
 
-        self.skip_bad_frames = bool(skip_bad_frames)
-
-        # Discover episodes
+        # ── Episode discovery ────────────────────────────────────────────
         pt_files = sorted(self.data_root.rglob("episode_*.pt"))
         if not pt_files:
             raise RuntimeError(f"No episode_*.pt under {self.data_root}")
@@ -144,28 +236,28 @@ class ReactWindowDataset(Dataset):
 
         self.episodes: list[dict] = []
         self.episode_paths: list[Path] = []
-        self.episode_keys: list[str] = []      # "<date>/<stem>" for bad_frames lookup
+        self.episode_keys: list[str] = []
         self.episode_active: list[list[str]] = []
-        self.windows: list[tuple[int, int]] = []   # (ep_idx, t_start)
+        self.windows: list[tuple[int, int]] = []
+
+        span = (self.window_length - 1) * self.stride + 1
 
-        span = (self.window_length - 1) * self.stride + 1  # source-frame span
+        # Counters for reporting how many windows each filter rejects
+        n_total_candidates = 0
+        n_drop_bad = 0
+        n_drop_contact = 0
+        n_drop_motion = 0
 
         for pt in pt_files:
             rel = pt.relative_to(self.data_root)
-            # rel.parts == (<task>, <date>, "episode_NNN.pt") OR (<date>, ...)
             if len(rel.parts) == 3:
-                task, date, _ = rel.parts
-                key = f"{date}/{pt.stem}"
+                task, date, _ = rel.parts; key = f"{date}/{pt.stem}"
             elif len(rel.parts) == 2:
-                task, date = None, rel.parts[0]
-                key = f"{date}/{pt.stem}"
+                task, date = None, rel.parts[0]; key = f"{date}/{pt.stem}"
             else:
                 task, date, key = None, None, pt.stem
-
-            if tasks is not None and task not in tasks:
-                continue
-            if dates is not None and date not in dates:
-                continue
+            if tasks is not None and task not in tasks: continue
+            if dates is not None and date not in dates: continue
 
             d = torch.load(pt, weights_only=False, map_location="cpu")
             active = ["left", "right"]
@@ -176,24 +268,18 @@ class ReactWindowDataset(Dataset):
             mR = d[f"tactile_right_{self.contact_metric}"].numpy()
             T = mL.shape[0]
 
-            # Per-frame contact predicate respecting which_sensors and active_sensors
+            # Contact predicate (respecting active sensors)
             cL = mL > self.tactile_threshold
             cR = mR > self.tactile_threshold
-            if "left" not in active:
-                cL = np.zeros_like(cL)
-            if "right" not in active:
-                cR = np.zeros_like(cR)
+            if "left"  not in active: cL[:] = False
+            if "right" not in active: cR[:] = False
             req = self.which_sensors
-            if req == "any":
-                contact_frame = cL | cR
-            elif req == "both":
-                contact_frame = cL & cR
-            elif req == "left":
-                contact_frame = cL
-            else:
-                contact_frame = cR
+            if   req == "any":   contact_frame = cL | cR
+            elif req == "both":  contact_frame = cL & cR
+            elif req == "left":  contact_frame = cL
+            else:                contact_frame = cR
 
-            # Bad-frame mask
+            # Bad-frame mask (intensity, pose_teleport, ot_loss)
             bad_mask = np.zeros(T, dtype=bool)
             if self.skip_bad_frames and key in self.bad:
                 bf = self.bad[key]
@@ -204,30 +290,58 @@ class ReactWindowDataset(Dataset):
                              + bf.get("ot_loss_R", [])):
                     bad_mask[s:e + 1] = True
 
+            # Per-frame motion predicate per sensor
+            if self.require_motion:
+                pose_L = d["sensor_left_pose"].numpy()
+                pose_R = d["sensor_right_pose"].numpy()
+                speed_L = _per_frame_speed_mps(pose_L, self.fps)
+                speed_R = _per_frame_speed_mps(pose_R, self.fps)
+                moving_L = speed_L >= self.min_motion_mps
+                moving_R = speed_R >= self.min_motion_mps
+            else:
+                moving_L = moving_R = None
+
             ep_idx = len(self.episodes)
             self.episodes.append(d)
             self.episode_paths.append(pt)
             self.episode_keys.append(key)
             self.episode_active.append(active)
 
-            # Enumerate windows
             kept = 0
             for t_start in range(0, T - span + 1, self.window_step):
+                n_total_candidates += 1
                 t_end = t_start + span - 1
                 frame_idx = np.arange(t_start, t_start + span, self.stride)
+
                 if bad_mask[t_start:t_end + 1].any():
+                    n_drop_bad += 1
                     continue
-                frac = contact_frame[frame_idx].mean()
-                if frac < self.min_contact_fraction:
+                if contact_frame[frame_idx].mean() < self.min_contact_fraction:
+                    n_drop_contact += 1
                     continue
+                if self.require_motion:
+                    passed = []
+                    for side, mov in [("left", moving_L), ("right", moving_R)]:
+                        if side not in active:
+                            continue
+                        passed.append(mov[frame_idx].mean() >= self.min_motion_fraction)
+                    if self.which_sensors_must_move == "all_active":
+                        ok = bool(passed) and all(passed)
+                    else:                       # "any"
+                        ok = any(passed)
+                    if not ok:
+                        n_drop_motion += 1
+                        continue
+
                 self.windows.append((ep_idx, t_start))
                 kept += 1
-            print(f"[ReactWindowDataset] {key}: T={T}, active={active}, "
-                  f"kept {kept} windows")
+            print(f"[ReactWindowDataset] {key}: T={T}, active={active}, kept {kept} windows")
 
         print(f"[ReactWindowDataset] total windows: {len(self.windows)} "
               f"(window_length={self.window_length}, stride={self.stride}, "
               f"window_step={self.window_step})")
+        print(f"[ReactWindowDataset] enumerated {n_total_candidates} candidates: "
+              f"-{n_drop_bad} bad_frames, -{n_drop_contact} contact, -{n_drop_motion} motion")
 
     def __len__(self) -> int:
         return len(self.windows)
@@ -237,18 +351,17 @@ class ReactWindowDataset(Dataset):
         ep = self.episodes[ep_idx]
         frame_idx = torch.arange(t_start, t_start + self.window_length * self.stride, self.stride)
         sample = {
-            "view":          ep["view"][frame_idx],            # (T, 3, 128, 128) uint8
+            "view":          ep["view"][frame_idx],
             "tactile_left":  ep["tactile_left"][frame_idx],
             "tactile_right": ep["tactile_right"][frame_idx],
-            "sensor_left_pose":  ep["sensor_left_pose"][frame_idx],   # (T, 7) f32
+            "sensor_left_pose":  ep["sensor_left_pose"][frame_idx],
             "sensor_right_pose": ep["sensor_right_pose"][frame_idx],
-            "timestamps":    ep["timestamps"][frame_idx],      # (T,) f64
+            "timestamps":    ep["timestamps"][frame_idx],
             "tactile_left_intensity":  ep["tactile_left_intensity"][frame_idx],
             "tactile_right_intensity": ep["tactile_right_intensity"][frame_idx],
             "tactile_left_mixed":   ep["tactile_left_mixed"][frame_idx],
             "tactile_right_mixed":  ep["tactile_right_mixed"][frame_idx],
         }
-        # Metadata (not batched by default DataLoader because they're scalars/strings)
         sample["episode"] = str(self.episode_paths[ep_idx])
         sample["episode_key"] = self.episode_keys[ep_idx]
         sample["frame_start"] = int(t_start)
@@ -270,6 +383,11 @@ if __name__ == "__main__":
     ap.add_argument("--min_contact_fraction", type=float, default=0.5)
     ap.add_argument("--contact_metric", default="mixed", choices=CONTACT_METRICS)
     ap.add_argument("--which_sensors", default="any", choices=["any", "both", "left", "right"])
+    ap.add_argument("--require_motion", action="store_true")
+    ap.add_argument("--min_motion_mps", type=float, default=0.03)
+    ap.add_argument("--min_motion_fraction", type=float, default=0.5)
+    ap.add_argument("--which_sensors_must_move", default="all_active",
+                    choices=["any", "all_active"])
     args = ap.parse_args()
     ds = ReactWindowDataset(
         data_root=args.data_root,
@@ -282,8 +400,12 @@ if __name__ == "__main__":
         tactile_threshold=args.tactile_threshold,
         min_contact_fraction=args.min_contact_fraction,
         which_sensors=args.which_sensors,
+        require_motion=args.require_motion,
+        min_motion_mps=args.min_motion_mps,
+        min_motion_fraction=args.min_motion_fraction,
+        which_sensors_must_move=args.which_sensors_must_move,
     )
-    print(f"len(ds) = {len(ds)}")
+    print(f"\nlen(ds) = {len(ds)}")
     if len(ds):
         sample = ds[0]
         for k, v in sample.items():