| |
| """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" |
|
|
| |
| |
| |
| |
| |
| |
| 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) |
| 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]: |
| |
| |
| 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) |
| 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] |
| 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, |
| ) |
|
|
| |
| |
| 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")) |
| |
| 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() |
|
|
