ReactWindowDataset: prominent contact-rich window count + stats attribute (ds.stats) + per-filter rejection breakdown in the summary print. Demo: write H.264 MP4 per picked window (was just static PNG); --no_mp4 to skip; --mp4_fps to tune.

examples/demo_react_window.py

@@ -17,12 +17,17 @@ What this script does
 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.
+4. For each picked window also writes a small MP4 clip showing the actual
+   per-frame motion (replaces the GIF outputs the old demo used to ship —
+   MP4 is ~10× smaller and renders inline on HF).
 
-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.
+Self-contained: numpy + torch + Pillow + cv2. `ffmpeg` is used to encode
+the MP4 clips; if it isn't on `$PATH` the script falls back to
+`cv2.VideoWriter`. No recording-machine code needed.
 """
 import argparse
+import shutil
+import subprocess
 import sys
 from pathlib import Path
 
@@ -108,6 +113,75 @@ def make_static_grid(ds, sample_indices, out_path: Path, *,
     print(f"  grid -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")
 
 
+def _write_mp4_h264(frames_rgb, out_path: Path, fps: float = 15.0) -> None:
+    """Pipe raw RGB frames to ffmpeg → H.264 MP4. Falls back to
+    cv2.VideoWriter(mp4v) if ffmpeg isn't on PATH."""
+    H, W = frames_rgb[0].shape[:2]
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if shutil.which("ffmpeg") is not None:
+        cmd = [
+            "ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
+            "-f", "rawvideo", "-pix_fmt", "rgb24",
+            "-s", f"{W}x{H}", "-r", f"{fps:.3f}",
+            "-i", "-",
+            "-c:v", "libx264", "-pix_fmt", "yuv420p",
+            "-preset", "medium", "-crf", "20",
+            "-movflags", "+faststart",
+            "-an", str(out_path),
+        ]
+        proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+        for f in frames_rgb:
+            assert f.shape == (H, W, 3) and f.dtype == np.uint8
+            proc.stdin.write(f.tobytes())
+        proc.stdin.close()
+        if proc.wait() != 0:
+            raise RuntimeError("ffmpeg failed")
+        return
+
+    # Fallback: cv2.VideoWriter with mp4v codec (universally portable but
+    # not as widely browser-streamable as H.264).
+    vw = cv2.VideoWriter(str(out_path),
+                         cv2.VideoWriter_fourcc(*"mp4v"),
+                         fps, (W, H))
+    for f in frames_rgb:
+        vw.write(cv2.cvtColor(f, cv2.COLOR_RGB2BGR))
+    vw.release()
+
+
+def make_window_mp4(ds, sample_idx: int, out_path: Path,
+                    *, scale: int = 3, fps: float = 15.0) -> None:
+    """Render one ReactWindowDataset window as a [view | tac_L | tac_R] MP4
+    at native source FPS (15 by default; sample_rate / playback). Each
+    composite frame is `(128*scale × 384*scale × 3)`."""
+    s = ds[sample_idx]
+    T = s["view"].shape[0]
+    frames = []
+    for t in range(T):
+        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] * scale, triplet.shape[0] * scale),
+            interpolation=cv2.INTER_NEAREST,
+        )
+        # Header strip with sample metadata so the clip is self-describing
+        H, W, _ = triplet.shape
+        header = np.full((28, W, 3), 235, np.uint8)
+        cv2.putText(
+            header,
+            f"#{sample_idx}  {s['episode_key']}  frame {s['frame_start']+t}/{s['frame_end']}  "
+            f"({t+1}/{T})  view | tactile_L | tactile_R",
+            (8, 19), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (40, 40, 40), 1, cv2.LINE_AA,
+        )
+        frames.append(np.concatenate([header, triplet], axis=0))
+
+    _write_mp4_h264(frames, out_path, fps=fps)
+    print(f"  mp4  -> {out_path.name}  ({out_path.stat().st_size / 1024:.1f} KB)")
+
+
 def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--data_root", required=True,
@@ -118,6 +192,10 @@ def main():
     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("--mp4_fps", type=float, default=15.0,
+                    help="Playback fps for the per-window MP4 clips.")
+    ap.add_argument("--no_mp4", action="store_true",
+                    help="Skip the MP4 clip rendering (only write the static PNG grid).")
     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).")
@@ -163,6 +241,15 @@ def main():
     out_dir = Path(args.out_dir)
     make_static_grid(ds, pick, out_dir / "sample_grid.png")
 
+    if not args.no_mp4:
+        print(f"\n=== Per-window MP4 clips ({len(pick)} files, H.264) ===")
+        for i, idx in enumerate(pick):
+            make_window_mp4(
+                ds, int(idx),
+                out_dir / f"sample_window_{i:02d}.mp4",
+                fps=args.mp4_fps,
+            )
+
 
 if __name__ == "__main__":
     main()

examples/react_window_dataset.py

@@ -337,11 +337,42 @@ class ReactWindowDataset(Dataset):
                 kept += 1
             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")
+        # Persist build stats on the instance so callers can inspect / log them
+        self.stats = {
+            "n_episodes":           len(self.episodes),
+            "n_candidates":         n_total_candidates,
+            "n_dropped_bad_frames": n_drop_bad,
+            "n_dropped_contact":    n_drop_contact,
+            "n_dropped_motion":     n_drop_motion,
+            "n_contact_rich_windows": len(self.windows),
+            "window_length":        self.window_length,
+            "stride":               self.stride,
+            "window_step":          self.window_step,
+            "min_contact_fraction": self.min_contact_fraction,
+            "tactile_threshold":    self.tactile_threshold,
+            "contact_metric":       self.contact_metric,
+            "which_sensors":        self.which_sensors,
+            "skip_bad_frames":      self.skip_bad_frames,
+            "require_motion":       self.require_motion,
+            "min_motion_mps":       self.min_motion_mps,
+            "min_motion_fraction":  self.min_motion_fraction,
+            "which_sensors_must_move": self.which_sensors_must_move,
+        }
+
+        # Headline summary — emphasises the contact-rich count, which is the
+        # number you'd quote in a paper or a model training log.
+        pct = 100.0 * len(self.windows) / max(1, n_total_candidates)
+        print()
+        print(f"[ReactWindowDataset] =================================")
+        print(f"[ReactWindowDataset]   Contact-rich windows sampled: {len(self.windows):,}")
+        print(f"[ReactWindowDataset]   ({pct:.1f}% of {n_total_candidates:,} sliding-window candidates)")
+        print(f"[ReactWindowDataset] =================================")
+        print(f"[ReactWindowDataset] Window spec: length={self.window_length}, stride={self.stride}, "
+              f"step={self.window_step}  (≈{self.window_length / 30:.2f}s @ 30 fps)")
+        print(f"[ReactWindowDataset] Rejected by filter:")
+        print(f"[ReactWindowDataset]   bad_frames (intensity_spikes, pose_teleports, ot_loss):  {n_drop_bad:,}")
+        print(f"[ReactWindowDataset]   contact    (< {self.min_contact_fraction:.0%} of frames in tactile contact):  {n_drop_contact:,}")
+        print(f"[ReactWindowDataset]   motion     ({'enabled' if self.require_motion else 'disabled'}):  {n_drop_motion:,}")
 
     def __len__(self) -> int:
         return len(self.windows)