visualize.py

#!/usr/bin/env python3
"""Decode head/wrist RGB and render tactile review videos from one MCAP.

Usage: visualize.py <recording_dir> [--remap-only]
<recording_dir> is a folder containing the .mcap (defaults to the current
directory); outputs go to <recording_dir>/output.
"""

from __future__ import annotations

import json
import shutil
import subprocess
import sys
from pathlib import Path

import cv2
import numpy as np
from mcap.reader import make_reader


def _resolve_root() -> Path:
    args = [a for a in sys.argv[1:] if not a.startswith("--")]
    root = Path(args[0]).resolve() if args else Path.cwd()
    return root.parent if root.is_file() else root


ROOT = _resolve_root()
_mcaps = sorted(ROOT.glob("*.mcap"))
MCAP = _mcaps[0] if _mcaps else ROOT / "recording_000.mcap"
OUT = ROOT / "output"
FPS = 30.0
FINGERS = ("thumb", "index", "middle", "ring", "little")


def detect_n_frames() -> int:
    for qa in (ROOT / "qa_result.json", ROOT / "labels" / "qa_result.json"):
        if qa.exists():
            obj = json.loads(qa.read_text())
            n = int(obj.get("summary", {}).get("frame_count") or 0)
            if n > 0:
                return n
    for sem in (
        ROOT / "semantic_annotation_result.json",
        ROOT / "labels" / "semantic_annotation_result.json",
    ):
        if sem.exists():
            obj = json.loads(sem.read_text())
            dur = float(obj.get("video_duration_sec") or 0.0)
            if dur > 0:
                return max(1, int(round(dur * FPS)))
    return 0


N_FRAMES = detect_n_frames()

HEAD_TOPIC = "/camera/head/rgb/h264"
WRIST_LH_TOPIC = "/camera/wrist/lh/h264"
WRIST_RH_TOPIC = "/camera/wrist/rh/h264"
MONO_L_TOPIC = "/camera/head/mono_left/h264"
MONO_R_TOPIC = "/camera/head/mono_right/h264"
LH_TACTILE = "/glove/lh/tactile"
RH_TACTILE = "/glove/rh/tactile"

# Review-dashboard tactile panel: official FusionX anatomical layout
# LH long fingers L->R = little, ring, middle, index; thumb lower-right
# RH long fingers L->R = index, middle, ring, little; thumb lower-left
# Palm shares the long-finger column grid (official cols: LH 1-15, RH 5-19),
# so each palm cell sits directly under its finger column at the same pitch.
# Bend bars are centered under their finger pads (thumb bar under thumb pad).
PANEL_W, PANEL_H = 800, 1080
FORCE_W, FORCE_H = 800, 720
BG = (12, 12, 12)
PAD_BG = (28, 24, 22)
CELL = 22
PAD_GAP = 8


def decode_varint(buf: bytes, i: int) -> tuple[int, int]:
    x = 0
    s = 0
    while True:
        b = buf[i]
        i += 1
        x |= (b & 0x7F) << s
        if not (b & 0x80):
            return x, i
        s += 7


def proto_bytes_field(buf: bytes, field_no: int) -> bytes:
    i = 0
    n = len(buf)
    while i < n:
        key, i = decode_varint(buf, i)
        fn, wt = key >> 3, key & 7
        if wt == 2:
            ln, i = decode_varint(buf, i)
            chunk = buf[i : i + ln]
            i += ln
            if fn == field_no:
                return chunk
        elif wt == 0:
            _, i = decode_varint(buf, i)
        elif wt == 1:
            i += 8
        elif wt == 5:
            i += 4
        else:
            raise ValueError(f"bad wire type {wt}")
    return b""


def red_heat(normalized: float) -> tuple[int, int, int]:
    n = float(np.clip(normalized, 0.0, 1.0))
    n = n**0.75
    return (int(10 + 20 * (1 - n)), int(8 + 40 * n), int(18 + 237 * n))


def _rounded_rect(img: np.ndarray, x0: int, y0: int, x1: int, y1: int, color, radius: int = 10, filled: bool = True) -> None:
    thickness = -1 if filled else 1
    cv2.rectangle(img, (x0 + radius, y0), (x1 - radius, y1), color, thickness)
    cv2.rectangle(img, (x0, y0 + radius), (x1, y1 - radius), color, thickness)
    for cx, cy in ((x0 + radius, y0 + radius), (x1 - radius, y0 + radius), (x0 + radius, y1 - radius), (x1 - radius, y1 - radius)):
        cv2.circle(img, (cx, cy), radius, color, thickness, cv2.LINE_AA)


def finger_pad_size() -> tuple[int, int]:
    return 3 * CELL + 12, 4 * CELL + 12


def draw_finger_pad(img: np.ndarray, x: int, y: int, values: np.ndarray, vmax: float) -> None:
    pad_w, pad_h = finger_pad_size()
    _rounded_rect(img, x, y, x + pad_w, y + pad_h, PAD_BG, 6, True)
    for i, value in enumerate(values):
        r, c = divmod(int(i), 3)  # row0 = tip, col0 = left  (FusionX pixel1-3)
        cx = x + 6 + c * CELL
        cy = y + 6 + r * CELL
        cv2.rectangle(img, (cx + 1, cy + 1), (cx + CELL - 2, cy + CELL - 2), red_heat(value / max(vmax, 1e-6)), -1)
    _rounded_rect(img, x, y, x + pad_w, y + pad_h, (80, 74, 70), 6, False)


def draw_palm_pad(img: np.ndarray, x: int, y: int, palm: np.ndarray, vmax: float) -> tuple[int, int]:
    # x = left edge of the leftmost long-finger pad; palm column c reuses that
    # pad grid: virtual column c -> pad c//4, in-pad column c%4 (c%4 == 3 = gap)
    pad_w, _ = finger_pad_size()
    w, h = 4 * pad_w + 3 * PAD_GAP, 4 * CELL + 12
    _rounded_rect(img, x, y, x + w, y + h, PAD_BG, 6, True)
    for i, value in enumerate(palm):
        r, c = divmod(int(i), 15)  # row0 nearest fingers, col0 = leftmost long finger
        cx = x + 6 + (c // 4) * (pad_w + PAD_GAP) + (c % 4) * CELL
        cy = y + 6 + r * CELL
        cv2.rectangle(
            img,
            (cx + 1, cy + 1),
            (cx + CELL - 2, cy + CELL - 2),
            red_heat(value / max(vmax, 1e-6)),
            -1,
        )
    _rounded_rect(img, x, y, x + w, y + h, (80, 74, 70), 6, False)
    return w, h


def hand_spec(hand: str) -> dict:
    if hand == "lh":
        return {
            "long": (("little", "L"), ("ring", "R"), ("middle", "M"), ("index", "I")),
            "thumb": ("thumb", "T"),
            "thumb_side": "right",
            "bend": (("little", "L"), ("ring", "R"), ("middle", "M"), ("index", "I"), ("thumb", "T")),
        }
    return {
        "long": (("index", "I"), ("middle", "M"), ("ring", "R"), ("little", "L")),
        "thumb": ("thumb", "T"),
        "thumb_side": "left",
        "bend": (("thumb", "T"), ("index", "I"), ("middle", "M"), ("ring", "R"), ("little", "L")),
    }


def draw_hand_block(
    img: np.ndarray,
    y0: int,
    hand: str,
    title: str,
    finger: np.ndarray,
    palm: np.ndarray | None,
    bend: np.ndarray,
    vmax: float,
) -> int:
    spec = hand_spec(hand)
    pad_w, pad_h = finger_pad_size()
    cv2.putText(img, title, (20, y0 + 26), cv2.FONT_HERSHEY_SIMPLEX, 0.62, (230, 230, 230), 2, cv2.LINE_AA)

    long_w = 4 * pad_w + 3 * PAD_GAP
    block_w = long_w + PAD_GAP + pad_w
    x_block = (img.shape[1] - block_w) // 2
    y_long = y0 + 40

    long_xs = []
    for k, (name, letter) in enumerate(spec["long"]):
        x = x_block + (pad_w + PAD_GAP if spec["thumb_side"] == "left" else 0) + k * (pad_w + PAD_GAP)
        long_xs.append(x)
        draw_finger_pad(img, x, y_long, finger[FINGERS.index(name)], vmax)
        cv2.putText(img, letter, (x + pad_w // 2 - 7, y_long + pad_h + 22), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (200, 200, 200), 2, cv2.LINE_AA)

    y_palm = y_long + pad_h + 30
    if palm is not None:
        palm_x = long_xs[0]  # official layout: palm spans exactly the long-finger columns
        pw, ph = draw_palm_pad(img, palm_x, y_palm, palm, vmax)
        cv2.putText(img, "palm", (palm_x + pw // 2 - 22, y_palm + ph + 18), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (160, 160, 160), 1, cv2.LINE_AA)
        y_thumb = y_palm
    else:
        y_thumb = y_palm

    thumb_name, thumb_letter = spec["thumb"]
    thumb_x = x_block if spec["thumb_side"] == "left" else x_block + long_w + PAD_GAP
    draw_finger_pad(img, thumb_x, y_thumb, finger[FINGERS.index(thumb_name)], vmax)
    cv2.putText(
        img,
        thumb_letter,
        (thumb_x + pad_w // 2 - 7, y_thumb + pad_h + 22),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.55,
        (200, 200, 200),
        2,
        cv2.LINE_AA,
    )

    # Bend bars: official Foxglove order (LH L-R-M-I-T, RH T-I-M-R-L),
    # each bar centered under its finger pad like the official panel
    y_bar = max(y_long + pad_h, y_thumb + pad_h) + 50
    track_h = 70
    bar_cxs = [x + pad_w // 2 for x in long_xs]
    thumb_cx = thumb_x + pad_w // 2
    bar_cxs = [thumb_cx, *bar_cxs] if spec["thumb_side"] == "left" else [*bar_cxs, thumb_cx]
    for k, (name, letter) in enumerate(spec["bend"]):
        cx = bar_cxs[k]
        bx = cx - 8
        cv2.rectangle(img, (bx, y_bar), (bx + 16, y_bar + track_h), (40, 36, 34), -1)
        h = int(max(0.0, min(1.0, float(bend[FINGERS.index(name)]) / 255.0)) * track_h)
        cv2.rectangle(img, (bx, y_bar + track_h - h), (bx + 16, y_bar + track_h), (0, 200, 0), -1)
        cv2.putText(img, letter, (cx - 6, y_bar - 8), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (180, 180, 180), 1, cv2.LINE_AA)
    return y_bar + track_h + 16


def draw_review_hand(
    hand: str, finger: np.ndarray, palm: np.ndarray | None, bend: np.ndarray, vmax: float, t_sec: float
) -> np.ndarray:
    img = np.full((FORCE_H, FORCE_W, 3), BG, dtype=np.uint8)
    title = f"{'LH' if hand == 'lh' else 'RH'} glove (tactile + bend)   t={t_sec:5.2f}s"
    draw_hand_block(img, 8, hand, title, finger, palm, bend, vmax)
    return img


def draw_review_panel(
    lh_f: np.ndarray,
    lh_p: np.ndarray | None,
    lh_b: np.ndarray,
    rh_f: np.ndarray,
    rh_p: np.ndarray | None,
    rh_b: np.ndarray,
    vmax: float,
    t_sec: float,
) -> np.ndarray:
    img = np.full((PANEL_H, PANEL_W, 3), BG, dtype=np.uint8)
    cv2.putText(img, f"t = {t_sec:6.2f}s", (PANEL_W - 200, 26), cv2.FONT_HERSHEY_SIMPLEX, 0.50, (170, 170, 170), 1, cv2.LINE_AA)
    y = draw_hand_block(img, 10, "lh", "LH glove (tactile + bend)", lh_f, lh_p, lh_b, vmax)
    draw_hand_block(img, y + 8, "rh", "RH glove (tactile + bend)", rh_f, rh_p, rh_b, vmax)
    return img


def list_mcap_topics() -> set[str]:
    with open(MCAP, "rb") as f:
        summary = make_reader(f).get_summary()
    if not summary or not summary.channels:
        return set()
    return {ch.topic for ch in summary.channels.values()}


def extract_streams() -> dict:
    available = list_mcap_topics()
    side_l_topic = WRIST_LH_TOPIC if WRIST_LH_TOPIC in available else MONO_L_TOPIC
    side_r_topic = WRIST_RH_TOPIC if WRIST_RH_TOPIC in available else MONO_R_TOPIC
    side_l_key = "wrist_lh" if side_l_topic == WRIST_LH_TOPIC else "mono_left"
    side_r_key = "wrist_rh" if side_r_topic == WRIST_RH_TOPIC else "mono_right"
    raw_paths = {
        "head": OUT / "_head.h264",
        side_l_key: OUT / f"_{side_l_key}.h264",
        side_r_key: OUT / f"_{side_r_key}.h264",
    }
    writers = {k: p.open("wb") for k, p in raw_paths.items()}
    topic_to_key = {
        HEAD_TOPIC: "head",
        side_l_topic: side_l_key,
        side_r_topic: side_r_key,
    }
    tactile = {h: {"t": [], "finger": [], "palm": [], "bend": [], "force": [], "has_force": False} for h in ("lh", "rh")}
    t0 = None
    counts = {k: 0 for k in raw_paths}
    print("reading MCAP (video + tactile) ...", flush=True)
    print(f"  cameras: head + {side_l_key} + {side_r_key}", flush=True)
    with open(MCAP, "rb") as f:
        reader = make_reader(f)
        for _sch, ch, msg in reader.iter_messages(
            topics=[HEAD_TOPIC, side_l_topic, side_r_topic, LH_TACTILE, RH_TACTILE]
        ):
            if ch.topic in topic_to_key:
                payload = proto_bytes_field(msg.data, 3)
                if payload:
                    writers[topic_to_key[ch.topic]].write(payload)
                    counts[topic_to_key[ch.topic]] += 1
                continue
            obj = json.loads(msg.data)
            parsed = _parse_tactile(obj)
            if t0 is None:
                t0 = parsed["t"]
            _append_tactile(tactile, parsed, t0)
    for w in writers.values():
        w.close()
    print(f"  video frames {counts}", flush=True)
    out = {"raw": raw_paths, "t0": t0}
    out.update(_pack_tactile(tactile))
    return out


def _named_finger(named: dict) -> np.ndarray:
    finger = np.zeros((5, 12), dtype=np.float32)
    for i, name in enumerate(FINGERS):
        row = named.get(name) or []
        finger[i, : min(12, len(row))] = row[:12]
    return finger


def _parse_tactile(obj: dict) -> dict:
    named = obj.get("finger_pressure") or {}
    adc = _named_finger(named)
    force = None
    pix = obj.get("finger_force_N_pixels")
    if pix:
        force = np.zeros((5, 12), dtype=np.float32)
        for i in range(min(5, len(pix))):
            row = pix[i]
            force[i, : min(12, len(row))] = row[:12]
    palm = np.zeros(60, dtype=np.float32)
    raw_palm = obj.get("palm_pressure") or []
    palm[: min(60, len(raw_palm))] = raw_palm[:60]
    bend = np.zeros(5, dtype=np.float32)
    raw_bend = obj.get("finger_bend") or []
    bend[: min(5, len(raw_bend))] = raw_bend[:5]
    return {
        "hand": obj["hand"],
        "t": float(obj["timestamp"]),
        "adc": adc,
        "force": force,
        "palm": palm,
        "bend": bend,
    }


def _append_tactile(tactile: dict, parsed: dict, t0: float) -> None:
    hand = parsed["hand"]
    tactile[hand]["t"].append(parsed["t"] - t0)
    tactile[hand]["finger"].append(parsed["adc"])
    tactile[hand]["palm"].append(parsed["palm"])
    tactile[hand]["bend"].append(parsed["bend"])
    if parsed["force"] is not None:
        tactile[hand]["force"].append(parsed["force"])
        tactile[hand]["has_force"] = True
    else:
        tactile[hand]["force"].append(np.zeros((5, 12), dtype=np.float32))


def _pack_tactile(tactile: dict) -> dict:
    out = {}
    for h in ("lh", "rh"):
        out[h] = {
            "t": np.asarray(tactile[h]["t"], dtype=np.float64),
            "adc": np.asarray(tactile[h]["finger"], dtype=np.float32),
            "force": np.asarray(tactile[h]["force"], dtype=np.float32),
            "palm": np.asarray(tactile[h]["palm"], dtype=np.float32),
            "bend": np.asarray(tactile[h]["bend"], dtype=np.float32),
            "has_force": bool(tactile[h]["has_force"]),
        }
        adc_max = float(out[h]["adc"].max()) if out[h]["adc"].size else 0.0
        force_max = float(out[h]["force"].max()) if out[h]["has_force"] and out[h]["force"].size else 0.0
        print(
            f"  {h} tactile {out[h]['t'].shape[0]}  "
            f"ADC max {adc_max:.0f}  "
            f"force {'yes' if out[h]['has_force'] else 'no'} {force_max:.2f} N  "
            f"palm max {float(out[h]['palm'].max()) if out[h]['palm'].size else 0:.0f}  "
            f"bend max {float(out[h]['bend'].max()) if out[h]['bend'].size else 0:.0f}",
            flush=True,
        )
    return out


def extract_tactile() -> dict:
    tactile = {h: {"t": [], "finger": [], "palm": [], "bend": [], "force": [], "has_force": False} for h in ("lh", "rh")}
    t0 = None
    print("reading MCAP tactile ...", flush=True)
    with open(MCAP, "rb") as f:
        reader = make_reader(f)
        for _sch, _ch, msg in reader.iter_messages(topics=[LH_TACTILE, RH_TACTILE]):
            parsed = _parse_tactile(json.loads(msg.data))
            if t0 is None:
                t0 = parsed["t"]
            _append_tactile(tactile, parsed, t0)
    out = {"t0": t0}
    out.update(_pack_tactile(tactile))
    return out


def _interp_nd(t: np.ndarray, values: np.ndarray, grid: np.ndarray) -> np.ndarray:
    flat = values.reshape(len(t), -1)
    out = np.empty((len(grid), flat.shape[1]), dtype=np.float32)
    for c in range(flat.shape[1]):
        out[:, c] = np.interp(grid, t, flat[:, c])
    return out.reshape((len(grid),) + values.shape[1:])


def resample_hand(hand: dict, n: int = N_FRAMES, fps: float = FPS) -> dict:
    t = hand["t"]
    grid = np.arange(n, dtype=np.float64) / fps
    empty = {
        "adc": np.zeros((n, 5, 12), np.float32),
        "force": np.zeros((n, 5, 12), np.float32),
        "palm": np.zeros((n, 60), np.float32),
        "bend": np.zeros((n, 5), np.float32),
        "has_force": bool(hand.get("has_force")),
    }
    if t.size == 0:
        return empty
    return {
        "adc": _interp_nd(t, hand["adc"], grid),
        "force": _interp_nd(t, hand["force"], grid) if hand.get("has_force") else empty["force"],
        "palm": _interp_nd(t, hand["palm"], grid),
        "bend": _interp_nd(t, hand["bend"], grid),
        "has_force": bool(hand.get("has_force")),
    }


def _ffmpeg_raw(dest: Path, w: int, h: int) -> subprocess.Popen:
    proc = subprocess.Popen(
        [
            "ffmpeg",
            "-y",
            "-hide_banner",
            "-loglevel",
            "error",
            "-f",
            "rawvideo",
            "-pix_fmt",
            "bgr24",
            "-s",
            f"{w}x{h}",
            "-r",
            str(int(FPS)),
            "-i",
            "-",
            "-c:v",
            "libx264",
            "-preset",
            "veryfast",
            "-pix_fmt",
            "yuv420p",
            "-crf",
            "20",
            "-movflags",
            "+faststart",
            str(dest),
        ],
        stdin=subprocess.PIPE,
    )
    assert proc.stdin is not None
    return proc


def render_force_video(hand: str, series: dict, dest: Path, mode: str, vmax: float) -> None:
    proc = _ffmpeg_raw(dest, FORCE_W, FORCE_H)
    finger = series["force"] if mode == "force-pixels" else series["adc"]
    palm = None if mode == "force-pixels" else series["palm"]
    bend = series["bend"]
    n = finger.shape[0]
    for i in range(n):
        frame = draw_review_hand(hand, finger[i], None if palm is None else palm[i], bend[i], vmax, i / FPS)
        proc.stdin.write(frame.tobytes())
        if i % 900 == 0:
            print(f"  {hand} {mode} {i}/{n}", flush=True)
    proc.stdin.close()
    if proc.wait() != 0:
        raise RuntimeError(f"ffmpeg failed for {dest}")


def render_review_panel(lh: dict, rh: dict, dest: Path, mode: str, vmax: float) -> None:
    proc = _ffmpeg_raw(dest, PANEL_W, PANEL_H)
    lf = lh["force"] if mode == "force-pixels" else lh["adc"]
    rf = rh["force"] if mode == "force-pixels" else rh["adc"]
    lp = None if mode == "force-pixels" else lh["palm"]
    rp = None if mode == "force-pixels" else rh["palm"]
    n = lf.shape[0]
    for i in range(n):
        frame = draw_review_panel(
            lf[i],
            None if lp is None else lp[i],
            lh["bend"][i],
            rf[i],
            None if rp is None else rp[i],
            rh["bend"][i],
            vmax,
            i / FPS,
        )
        proc.stdin.write(frame.tobytes())
        if i % 900 == 0:
            print(f"  review panel {i}/{n}", flush=True)
    proc.stdin.close()
    if proc.wait() != 0:
        raise RuntimeError(f"ffmpeg failed for {dest}")


def _label_filter(src: str, tag: str, label: str, w: int, h: int) -> str:
    font = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
    return (
        f"{src}fps=30,tpad=stop_mode=clone:stop=-1,setpts=PTS-STARTPTS,"
        f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
        f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,setsar=1,"
        f"drawtext=fontfile={font}:text='{label}':x=16:y=16:fontsize=26:fontcolor=white:box=1:boxcolor=black@0.45[{tag}]"
    )


def compose_summary(
    cameras: list[tuple[Path, str]],
    tactile: Path,
    dest: Path,
    n_frames: int,
) -> None:
    left_w, right_w, height = 1120, 800, 1080
    head_h, small_h, small_w = 360, 360, 560
    slots = list(cameras[1:5])
    while len(slots) < 4:
        slots.append((None, f"EXO {len(slots) - 1}" if len(slots) >= 2 else "unavailable"))
    # keep screenshot labels for the last two placeholders
    if slots[2][0] is None:
        slots[2] = (None, "EXO 1")
    if slots[3][0] is None:
        slots[3] = (None, "EXO 2")
    filt_parts = [_label_filter("[0:v]", "h", cameras[0][1], left_w, head_h)]
    inputs = ["-i", str(cameras[0][0])]
    next_i = 1
    for k, (path, label) in enumerate(slots, start=1):
        tag = f"c{k}"
        if path is None:
            filt_parts.append(
                f"color=c=0x0e0e0e:s={small_w}x{small_h}:r=30,"
                f"drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf:"
                f"text='{label}':x=16:y=16:fontsize=26:fontcolor=white:box=1:boxcolor=black@0.45,"
                f"drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf:"
                f"text='unavailable':x=(w-text_w)/2:y=(h-text_h)/2:fontsize=28:fontcolor=0x666666[{tag}]"
            )
        else:
            filt_parts.append(_label_filter(f"[{next_i}:v]", tag, label, small_w, small_h))
            inputs += ["-i", str(path)]
            next_i += 1
    inputs += ["-i", str(tactile)]
    filt_parts.append(f"[{next_i}:v]fps=30,scale={right_w}:{height},setsar=1[t]")
    layout = f"0_0|0_{head_h}|{small_w}_{head_h}|0_{head_h + small_h}|{small_w}_{head_h + small_h}|{left_w}_0"
    filt = ";".join(filt_parts) + f";[h][c1][c2][c3][c4][t]xstack=inputs=6:layout={layout}[v]"
    cmd = [
        "ffmpeg",
        "-y",
        "-hide_banner",
        "-loglevel",
        "error",
        *inputs,
        "-filter_complex",
        filt,
        "-map",
        "[v]",
        "-c:v",
        "libx264",
        "-preset",
        "veryfast",
        "-pix_fmt",
        "yuv420p",
        "-crf",
        "20",
        "-t",
        f"{n_frames / FPS:.3f}",
        "-movflags",
        "+faststart",
        str(dest),
    ]
    subprocess.run(cmd, check=True)


def reset_output() -> None:
    if OUT.exists():
        shutil.rmtree(OUT)
    OUT.mkdir(parents=True)


def main() -> None:
    if not MCAP.exists():
        raise SystemExit(f"no .mcap found in {ROOT}\nusage: visualize.py <recording_dir> [--remap-only]")
    remap_only = "--remap-only" in sys.argv
    videos = {
        "head": OUT / "head_rgb.mp4",
        "force_lh": OUT / "force_lh.mp4",
        "force_rh": OUT / "force_rh.mp4",
        "tactile": OUT / "tactile_panel.mp4",
        "summary": OUT / "summary.mp4",
    }
    if remap_only:
        side_keys = [k for k in ("wrist_lh", "wrist_rh", "mono_left", "mono_right") if (OUT / f"{k}.mp4").exists()]
        if not videos["head"].exists() or len(side_keys) < 2:
            raise FileNotFoundError("camera videos missing; run without --remap-only")
        videos[side_keys[0]] = OUT / f"{side_keys[0]}.mp4"
        videos[side_keys[1]] = OUT / f"{side_keys[1]}.mp4"
        streams = extract_tactile()
        streams["side_keys"] = (side_keys[0], side_keys[1])
    else:
        reset_output()
        streams = extract_streams()
        side_keys = [k for k in streams["raw"] if k != "head"]
        for key in side_keys:
            videos[key] = OUT / f"{key}.mp4"
        print("encoding camera videos ...", flush=True)
        jobs = []
        for key in ["head", *side_keys]:
            raw = streams["raw"][key]
            if raw.stat().st_size == 0:
                raise RuntimeError(f"empty camera stream: {key}")
            jobs.append(
                subprocess.Popen(
                    [
                        "ffmpeg",
                        "-y",
                        "-hide_banner",
                        "-loglevel",
                        "error",
                        "-fflags",
                        "+genpts",
                        "-r",
                        str(int(FPS)),
                        "-i",
                        str(raw),
                        "-c:v",
                        "libx264",
                        "-preset",
                        "veryfast",
                        "-pix_fmt",
                        "yuv420p",
                        "-crf",
                        "23",
                        "-movflags",
                        "+faststart",
                        str(videos[key]),
                    ]
                )
            )
        for p in jobs:
            if p.wait() != 0:
                raise RuntimeError("ffmpeg camera encode failed")
        for raw in streams["raw"].values():
            raw.unlink(missing_ok=True)
        streams["side_keys"] = tuple(side_keys)

    n_frames = N_FRAMES
    if n_frames <= 0:
        dur = 0.0
        for h in ("lh", "rh"):
            t = streams[h]["t"]
            if t.size:
                dur = max(dur, float(t[-1]))
        n_frames = max(1, int(round(dur * FPS)))
    print(f"episode frames {n_frames} ({n_frames / FPS:.1f}s)", flush=True)

    print("resampling tactile to 30 Hz ...", flush=True)
    lh = resample_hand(streams["lh"], n=n_frames)
    rh = resample_hand(streams["rh"], n=n_frames)
    mode = "force-pixels" if (lh["has_force"] or rh["has_force"]) else "raw"
    if mode == "force-pixels":
        vmax = 20.0
    else:
        vmax = float(max(np.percentile(np.concatenate([lh["adc"].ravel(), rh["adc"].ravel()]), 99.5), 32.0))
    print(f"  review mode {mode}  vmax {vmax:.1f}", flush=True)

    print("rendering review tactile videos ...", flush=True)
    render_force_video("lh", lh, videos["force_lh"], mode, vmax)
    render_force_video("rh", rh, videos["force_rh"], mode, vmax)
    render_review_panel(lh, rh, videos["tactile"], mode, vmax)

    print("composing summary ...", flush=True)
    side_keys = list(streams.get("side_keys") or ("wrist_lh", "wrist_rh"))
    label_map = {
        "wrist_lh": "WRIST LH",
        "wrist_rh": "WRIST RH",
        "mono_left": "HEAD MONO L",
        "mono_right": "HEAD MONO R",
    }
    cameras = [("head", "HEAD RGB")] + [(k, label_map.get(k, k.upper())) for k in side_keys]
    camera_paths = [(videos["head"] if k == "head" else videos[k], lab) for k, lab in cameras]
    compose_summary(camera_paths, videos["tactile"], videos["summary"], n_frames)
    print("wrote", OUT)
    for p in sorted(OUT.iterdir()):
        print(f"  {p.name:16s} {p.stat().st_size / 1e6:8.1f} MB")


if __name__ == "__main__":
    main()