"""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. 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: 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 import cv2 import numpy as np import torch from PIL import Image # Same-directory import. sys.path.insert(0, str(Path(__file__).parent)) from react_window_dataset import ReactWindowDataset 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 _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, 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] T = s["view"].shape[0] pick = np.linspace(0, T - 1, n_cols).astype(int) cells = [] for t in pick: 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 canvas_h = 60 + len(rows) * (H_row + label_h + pad_y) 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) cell_w = W_row // n_cols for r, idx in enumerate(sample_indices): s = ds[idx] y0 = 60 + r * (H_row + label_h + pad_y) 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} · {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) cv2.putText(canvas, "view | tactile_left | tactile_right", (10, y0 + 76), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (130, 130, 130), 1, cv2.LINE_AA) 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" 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, 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("--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).") args = ap.parse_args() print("=== Building dataset (all four quality filters on) ===") ds = ReactWindowDataset( 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.01, min_motion_fraction = 0.25, which_sensors_must_move = "all_active", ) if len(ds) == 0: print("No windows passed the filters. Try lowering `min_contact_fraction` " "or disabling `require_motion`.") return 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 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()