examples/play_react_pt.py: episode-aware viewer. Accepts a directory of segments — all same-episode segments concatenate into one playback timeline; N/P switches between episodes. Red border + red trail-plot mark on segment-boundary frames. Also supports --save_video_dir for per-episode batch MP4 export.
2b2cfc6 verified | """Interactive playback for React data — accepts a single `.pt` OR a | |
| directory of segments / episodes, concatenates same-episode segments | |
| into one continuous timeline, and lets you switch between source | |
| episodes with N / P. | |
| Usage | |
| ----- | |
| Single file (mode1_v1 episode OR a single mode2_v1 segment): | |
| python examples/play_react_pt.py \\ | |
| processed/mode2_v1/motherboard/2026-05-11/episode_012.segment_00.pt | |
| Whole task — episode-by-episode browser: | |
| python examples/play_react_pt.py \\ | |
| processed/mode2_v1/motherboard | |
| All segments of `episode_NNN` are concatenated into one playback | |
| timeline; N / P jumps to the next / previous source episode. | |
| Works with mode1_v1 too (each `.pt` is treated as a one-segment | |
| episode); N / P then jumps file-to-file. | |
| Headless export (one MP4 per episode): | |
| python examples/play_react_pt.py <root> --save_video_dir /tmp/out | |
| Controls | |
| -------- | |
| space — pause / resume | |
| → / d — next frame | |
| ← / a — previous frame | |
| 1..6 — playback speed 1× / 2× / 5× / 10× / 25× / 50× | |
| r — reset GelSight diff reference to current frame | |
| n — next episode | |
| p — previous episode | |
| q — quit | |
| """ | |
| import argparse | |
| import collections | |
| import re | |
| import sys | |
| import time | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| import torch | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| 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) | |
| SEGMENT_FNAME_RE = re.compile(r"^(episode_\d+)\.segment_(\d+)\.pt$") | |
| PLAIN_EPISODE_RE = re.compile(r"^(episode_\d+)\.pt$") | |
| def _to_hwc(t): | |
| return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy() | |
| def _view_to_bgr(view_chw): | |
| return view_chw.permute(1, 2, 0).numpy() | |
| def _tactile_to_bgr(tac_chw): | |
| 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) | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| # Episode discovery | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| def discover_episodes(root: Path) -> list[dict]: | |
| """Walk `root`, group .pt files by source episode key '<date>/episode_NNN', | |
| and return one entry per episode with its segment paths sorted. | |
| Handles both: | |
| - mode2_v1: `<root>/<date>/episode_NNN.segment_MM.pt` | |
| - mode1_v1: `<root>/<date>/episode_NNN.pt` | |
| """ | |
| pts = sorted(root.rglob("*.pt")) | |
| if not pts: | |
| raise SystemExit(f"No .pt files under {root}") | |
| episodes: dict[str, dict] = {} # key: "<date>/<ep>" → {date, ep_stem, segs: [(seg_idx, path)]} | |
| for p in pts: | |
| m_seg = SEGMENT_FNAME_RE.match(p.name) | |
| m_plain = PLAIN_EPISODE_RE.match(p.name) | |
| if m_seg: | |
| ep_stem, seg_idx = m_seg.group(1), int(m_seg.group(2)) | |
| elif m_plain: | |
| ep_stem, seg_idx = m_plain.group(1), 0 | |
| else: | |
| continue | |
| date = p.parent.name | |
| key = f"{date}/{ep_stem}" | |
| episodes.setdefault(key, {"date": date, "ep_stem": ep_stem, "segs": []}) | |
| episodes[key]["segs"].append((seg_idx, p)) | |
| out = [] | |
| for key in sorted(episodes): | |
| ep = episodes[key] | |
| ep["segs"].sort(key=lambda x: x[0]) | |
| out.append({"key": key, **ep}) | |
| return out | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| # Episode-load | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| class LoadedEpisode: | |
| """One source episode, with all its segments concatenated for playback. | |
| Stores: | |
| - keys for the 5 image-shaped tensors (view, tactile_*) concatenated | |
| - keys for the 5 per-frame scalar/vector tensors | |
| - segment_bounds[i] = (start_in_concat, end_in_concat, seg_idx, source_h5_range) | |
| for the i-th segment | |
| - p01 reference frames pulled from the *first* segment's _contact_meta | |
| """ | |
| PER_FRAME_KEYS = ( | |
| "view", "tactile_left", "tactile_right", | |
| "sensor_left_pose", "sensor_right_pose", "timestamps", | |
| "tactile_left_intensity", "tactile_right_intensity", | |
| "tactile_left_mixed", "tactile_right_mixed", | |
| ) | |
| def __init__(self, ep_meta: dict): | |
| self.key = ep_meta["key"] | |
| self.date = ep_meta["date"] | |
| self.ep_stem = ep_meta["ep_stem"] | |
| self.segment_paths = [p for _, p in ep_meta["segs"]] | |
| print(f"[player] loading episode {self.key} " | |
| f"({len(self.segment_paths)} segment{'s' if len(self.segment_paths) > 1 else ''})...") | |
| per_seg = [torch.load(p, weights_only=False, map_location="cpu") for p in self.segment_paths] | |
| cat = {} | |
| for k in self.PER_FRAME_KEYS: | |
| if k in per_seg[0]: | |
| cat[k] = torch.cat([s[k] for s in per_seg], dim=0) | |
| # Boundaries | |
| bounds = [] | |
| cursor = 0 | |
| for i, s in enumerate(per_seg): | |
| n = s["view"].shape[0] | |
| meta = s.get("_contact_meta", {}) | |
| bounds.append({ | |
| "start_in_concat": cursor, | |
| "end_in_concat": cursor + n - 1, | |
| "seg_idx": int(meta.get("source_segment_idx", i)), | |
| "source_h5_range": meta.get("source_h5_frame_range"), | |
| "n_frames": n, | |
| }) | |
| cursor += n | |
| self.data = cat | |
| self.bounds = bounds | |
| self.n_frames = cursor | |
| meta0 = per_seg[0].get("_contact_meta", {}) | |
| # p01 references from the first segment (same per-source-episode) | |
| self.ref_L = _tactile_to_bgr(meta0["ref_p01_left"]) if meta0.get("ref_p01_left") is not None else _tactile_to_bgr(per_seg[0]["tactile_left"][0]) | |
| self.ref_R = _tactile_to_bgr(meta0["ref_p01_right"]) if meta0.get("ref_p01_right") is not None else _tactile_to_bgr(per_seg[0]["tactile_right"][0]) | |
| print(f"[player] total {self.n_frames} frames ({self.n_frames / 30.0:.1f}s)") | |
| def segment_at(self, frame_idx: int) -> dict: | |
| for b in self.bounds: | |
| if b["start_in_concat"] <= frame_idx <= b["end_in_concat"]: | |
| return b | |
| return self.bounds[-1] | |
| def is_segment_start(self, frame_idx: int) -> bool: | |
| return any(frame_idx == b["start_in_concat"] for b in self.bounds[1:]) | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| # Panel renderer | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| 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 (concat 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, boundary_marks, w, h, threshold=0.4): | |
| panel = np.zeros((h, w, 3), np.uint8) | |
| cv2.putText(panel, "Contact intensity (mixed) — orange = L · blue = R · red = segment cut", | |
| (8, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.48, (200, 200, 200), 1, cv2.LINE_AA) | |
| cv2.line(panel, (8, 30), (w - 8, 30), (60, 60, 60), 1) | |
| mid_y = h - 26 | |
| max_y = 50 | |
| cv2.line(panel, (8, mid_y), (w - 8, mid_y), (80, 80, 80), 1) | |
| if not iL_trail: | |
| return panel | |
| N = len(iL_trail) | |
| 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) | |
| 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) | |
| 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) | |
| # Segment-cut markers | |
| for off in boundary_marks: | |
| if 0 <= off < N: | |
| x = int(8 + off * x_scale) | |
| cv2.line(panel, (x, 35), (x, h - 30), (0, 0, 220), 1, cv2.LINE_AA) | |
| cv2.putText(panel, f"L = {iL_trail[-1]:.2f}", (10, 50), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.42, (0, 159, 230), 1, cv2.LINE_AA) | |
| cv2.putText(panel, f"R = {iR_trail[-1]:.2f}", (10, h - 8), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.42, (178, 114, 0), 1, cv2.LINE_AA) | |
| return panel | |
| def _make_controls_panel(w, h, paused, speed, ep_idx, n_eps): | |
| 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"), | |
| ("← →", "prev / next frame"), | |
| ("1..6", "speed 1x/2x/5x/10x/25x/50x"), | |
| ("n p", "next / prev episode"), | |
| ("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 = "|| PAUSED" if paused else "> PLAYING" | |
| state_col = (0, 140, 255) if paused else (0, 220, 80) | |
| cv2.putText(panel, state, (10, h - 50), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.55, state_col, 2, cv2.LINE_AA) | |
| cv2.putText(panel, f"speed: {speed}x", (10, h - 30), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA) | |
| cv2.putText(panel, f"episode {ep_idx + 1} / {n_eps}", (10, h - 10), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA) | |
| return panel | |
| def build_panel(ep: LoadedEpisode, frame_idx: int, ref_L_bgr, ref_R_bgr, | |
| iL_trail, iR_trail, boundary_marks_local, | |
| paused: bool, speed: int, | |
| ep_idx: int, n_eps: int): | |
| view_bgr = _view_to_bgr(ep.data["view"][frame_idx]) | |
| tac_L_bgr = _tactile_to_bgr(ep.data["tactile_left"][frame_idx]) | |
| tac_R_bgr = _tactile_to_bgr(ep.data["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) | |
| 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.data["sensor_left_pose"][frame_idx].tolist() | |
| pose_R = ep.data["sensor_right_pose"][frame_idx].tolist() | |
| t_sec = float(ep.data["timestamps"][frame_idx] - ep.data["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), | |
| boundary_marks_local, *TRAIL_PANEL) | |
| controls_panel = _make_controls_panel(*CONTROLS_PANEL, paused=paused, speed=speed, | |
| ep_idx=ep_idx, n_eps=n_eps) | |
| row2 = np.hstack([ot_panel, trail_panel, controls_panel]) | |
| panel = np.vstack([row1, row2]) | |
| # Top status bar | |
| cv2.rectangle(panel, (0, 0), (PANEL_W, 22), (30, 30, 30), -1) | |
| state = "PAUSED" if paused else "PLAYING" | |
| seg = ep.segment_at(frame_idx) | |
| h5r = seg["source_h5_range"] | |
| seg_label = f"seg {seg['seg_idx']:02d}" | |
| if h5r: | |
| seg_label += f" H5[{h5r[0]}..{h5r[1]}]" | |
| status = (f"[{state}] ep {ep_idx + 1}/{n_eps} {ep.key} · " | |
| f"frame {frame_idx + 1}/{ep.n_frames} · t={t_sec:.2f}s · " | |
| f"{seg_label} · {speed}x") | |
| cv2.putText(panel, status, (10, 16), | |
| cv2.FONT_HERSHEY_SIMPLEX, 0.46, (0, 200, 255), 1, cv2.LINE_AA) | |
| # Segment-cut flash: red border for the first 2 frames of a non-first segment | |
| if ep.is_segment_start(frame_idx): | |
| cv2.rectangle(panel, (0, 22), (PANEL_W - 1, PANEL_H - 1), (0, 0, 220), 3) | |
| return panel | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| # Main | |
| # ────────────────────────────────────────────────────────────────────────────── | |
| def main(): | |
| ap = argparse.ArgumentParser(description="Interactive React .pt player.") | |
| ap.add_argument("path", help="A single .pt file OR a directory of episodes/segments.") | |
| ap.add_argument("--save_video", default=None, | |
| help="When `path` is a single .pt: write that one episode as MP4 here.") | |
| ap.add_argument("--save_video_dir", default=None, | |
| help="When `path` is a directory: write one MP4 per episode into this dir.") | |
| ap.add_argument("--fps", type=float, default=30.0) | |
| ap.add_argument("--trail_frames", type=int, default=120) | |
| args = ap.parse_args() | |
| in_path = Path(args.path) | |
| if not in_path.exists(): | |
| print(f"Not found: {in_path}", file=sys.stderr); sys.exit(1) | |
| if in_path.is_file(): | |
| # Single .pt → one-episode mode (use parent dir for discovery to enable n/p) | |
| parent_root = in_path.parent.parent # <root>/<date>/file.pt → <root> | |
| episodes = discover_episodes(parent_root) | |
| # Find the episode that contains this exact file | |
| target_path = in_path.resolve() | |
| start_idx = 0 | |
| for i, ep_meta in enumerate(episodes): | |
| if any(p.resolve() == target_path for _, p in ep_meta["segs"]): | |
| start_idx = i; break | |
| else: | |
| episodes = discover_episodes(in_path) | |
| start_idx = 0 | |
| print(f"[player] discovered {len(episodes)} episode(s) under {in_path}") | |
| headless_dir = Path(args.save_video_dir) if args.save_video_dir else None | |
| headless_single = args.save_video | |
| if headless_single and len(episodes) > 1 and in_path.is_dir(): | |
| print("--save_video accepts a single output path; for a directory pass --save_video_dir instead.", file=sys.stderr) | |
| sys.exit(1) | |
| headless = headless_single is not None or headless_dir is not None | |
| if headless: | |
| if headless_dir: | |
| headless_dir.mkdir(parents=True, exist_ok=True) | |
| for ep_idx in range(start_idx, len(episodes)): | |
| ep = LoadedEpisode(episodes[ep_idx]) | |
| out_path = (Path(headless_single) | |
| if headless_single else | |
| (headless_dir / f"{ep.date}_{ep.ep_stem}.mp4")) | |
| fourcc = cv2.VideoWriter_fourcc(*"mp4v") | |
| writer = cv2.VideoWriter(str(out_path), fourcc, args.fps, (PANEL_W, PANEL_H)) | |
| iL_trail = collections.deque(maxlen=args.trail_frames) | |
| iR_trail = collections.deque(maxlen=args.trail_frames) | |
| print(f" → {out_path}") | |
| for f in range(ep.n_frames): | |
| iL_trail.append(float(ep.data["tactile_left_mixed"][f])) | |
| iR_trail.append(float(ep.data["tactile_right_mixed"][f])) | |
| local_boundary_marks = [ | |
| args.trail_frames - 1 - (f - b["start_in_concat"]) | |
| for b in ep.bounds[1:] | |
| if b["start_in_concat"] <= f and (f - b["start_in_concat"]) < args.trail_frames | |
| ] | |
| panel = build_panel(ep, f, ep.ref_L, ep.ref_R, | |
| iL_trail, iR_trail, local_boundary_marks, | |
| paused=False, speed=1, | |
| ep_idx=ep_idx, n_eps=len(episodes)) | |
| writer.write(panel) | |
| writer.release() | |
| if headless_single: | |
| break | |
| return | |
| # Interactive | |
| paused, speed = False, 1 | |
| SPEEDS = {ord('1'): 1, ord('2'): 2, ord('3'): 5, | |
| ord('4'): 10, ord('5'): 25, ord('6'): 50} | |
| ep_idx = start_idx | |
| while 0 <= ep_idx < len(episodes): | |
| ep = LoadedEpisode(episodes[ep_idx]) | |
| WIN = "React .pt player" | |
| cv2.namedWindow(WIN, cv2.WINDOW_AUTOSIZE) | |
| cv2.createTrackbar("Frame", WIN, 0, max(1, ep.n_frames - 1), lambda v: None) | |
| ref_L, ref_R = ep.ref_L, ep.ref_R | |
| iL_trail = collections.deque(maxlen=args.trail_frames) | |
| iR_trail = collections.deque(maxlen=args.trail_frames) | |
| frame_idx = 0 | |
| last_drawn = -1 | |
| action = "stay" # 'next' | 'prev' | 'quit' | 'stay' | |
| while True: | |
| frame_idx = max(0, min(frame_idx, ep.n_frames - 1)) | |
| pos = cv2.getTrackbarPos("Frame", WIN) | |
| if pos != frame_idx and pos != last_drawn: | |
| frame_idx = pos; paused = True | |
| iL_trail.append(float(ep.data["tactile_left_mixed"][frame_idx])) | |
| iR_trail.append(float(ep.data["tactile_right_mixed"][frame_idx])) | |
| boundary_marks = [ | |
| args.trail_frames - 1 - (frame_idx - b["start_in_concat"]) | |
| for b in ep.bounds[1:] | |
| if b["start_in_concat"] <= frame_idx and (frame_idx - b["start_in_concat"]) < args.trail_frames | |
| ] | |
| panel = build_panel(ep, frame_idx, ref_L, ref_R, | |
| iL_trail, iR_trail, boundary_marks, | |
| paused=paused, speed=speed, | |
| ep_idx=ep_idx, n_eps=len(episodes)) | |
| cv2.imshow(WIN, panel) | |
| if cv2.getTrackbarPos("Frame", WIN) != frame_idx: | |
| cv2.setTrackbarPos("Frame", WIN, frame_idx) | |
| last_drawn = frame_idx | |
| key = cv2.waitKey(1) & 0xFF | |
| if key == ord('q'): action = "quit"; 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.data["tactile_left"][frame_idx]) | |
| ref_R = _tactile_to_bgr(ep.data["tactile_right"][frame_idx]) | |
| print(f" diff ref reset to frame {frame_idx}") | |
| elif key == ord('n'): | |
| action = "next"; break | |
| elif key == ord('p'): | |
| action = "prev"; break | |
| if not paused: | |
| frame_idx += speed | |
| if frame_idx >= ep.n_frames: | |
| print(f"End of episode {ep.key}.") | |
| paused = True | |
| frame_idx = ep.n_frames - 1 | |
| time.sleep(max(0.0, 1.0 / (args.fps * speed) - 0.001)) | |
| cv2.destroyAllWindows() | |
| if action == "quit": return | |
| if action == "next": | |
| ep_idx = min(ep_idx + 1, len(episodes) - 1) | |
| if ep_idx == len(episodes) - 1 and episodes[ep_idx]["key"] == ep.key: | |
| print("Already at last episode.") | |
| elif action == "prev": | |
| ep_idx = max(ep_idx - 1, 0) | |
| if ep_idx == 0 and episodes[ep_idx]["key"] == ep.key: | |
| print("Already at first episode.") | |
| else: | |
| # natural end of an episode — pause; wait for explicit action | |
| paused = True | |
| if __name__ == "__main__": | |
| main() | |