| |
| """Render a force review video from one MCAP, replicating the official |
| FusionX Tactile Foxglove panel (touchtronixrobotics.fusionx-tactile-panel |
| v0.2.4 .foxe) and the fusionx_foxglove_annotated.json layout. |
| |
| Layout (1920x1080): |
| top 71.5%: [ FusionX Tactile panel | head camera / wrist lh + rh ] |
| bottom 28.5%: semantic state timeline (contact / target / subtask) |
| The layout's 3D hand-pose panels are not reproduced. |
| |
| Tactile rendering matches the extension exactly: per-finger 4x3 pixel grids |
| (LH little-ring-middle-index at columns 1/5/9/13, RH index..little at |
| 5/9/13/17, thumb at row 6), colour hsl(240*(1-v/vmax), 90%, 50%) with a |
| fixed 0-20 N scale in force-pixels mode (0-255 in raw mode), sample-and-hold |
| of the latest message like the live panel (no interpolation). |
| |
| All streams are aligned on MCAP log_time, so tactile, cameras, and |
| annotations share one clock (fixes the per-stream offset in visualize.py). |
| |
| Usage: visualize_force.py <recording_dir> [--mode auto|force-pixels|raw] |
| [--start S] [--duration S] [--fps N] [--out PATH] |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import colorsys |
| import json |
| import subprocess |
| import sys |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
| from mcap.reader import make_reader |
|
|
| FINGERS = ("thumb", "index", "middle", "ring", "little") |
| HEAD_TOPIC = "/camera/head/rgb/h264" |
| WRIST_TOPICS = {"lh": "/camera/wrist/lh/h264", "rh": "/camera/wrist/rh/h264"} |
| MONO_TOPICS = {"lh": "/camera/head/mono_left/h264", "rh": "/camera/head/mono_right/h264"} |
| TACTILE_TOPICS = {"lh": "/glove/lh/tactile", "rh": "/glove/rh/tactile"} |
| STATE_TOPIC = "/annotations/semantic/state" |
|
|
| CANVAS_W, CANVAS_H = 1920, 1080 |
| TOP_H = 772 |
| HEAD_H = 574 |
| PANEL_W = CANVAS_W // 2 |
|
|
|
|
| def hex_bgr(h: str) -> tuple[int, int, int]: |
| h = h.lstrip("#") |
| return (int(h[4:6], 16), int(h[2:4], 16), int(h[0:2], 16)) |
|
|
|
|
| |
| PANEL_BG = hex_bgr("#0b1118") |
| SVG_BG = hex_bgr("#111821") |
| CELL_STROKE = hex_bgr("#263241") |
| INK = hex_bgr("#edf2f7") |
| MUTED = hex_bgr("#78889b") |
| FAINT = hex_bgr("#aab4c3") |
| SCALE_INK = hex_bgr("#d9e2ec") |
| BEND_TRACK = hex_bgr("#202b38") |
| BEND_FILL = hex_bgr("#00c800") |
| BEND_INK = hex_bgr("#c8c8c8") |
| BTN_ACTIVE = hex_bgr("#2563eb") |
| BTN_IDLE = hex_bgr("#202b38") |
| BTN_BORDER = hex_bgr("#3b4858") |
| CAM_BG = hex_bgr("#0e0e0e") |
|
|
| |
| |
| |
| TRACK_COLORS = [hex_bgr(c) for c in ( |
| "#3987e5", "#d95926", "#199e70", "#c98500", |
| "#d55181", "#008300", "#9085e9", "#e66767", |
| )] |
|
|
| FONT = cv2.FONT_HERSHEY_SIMPLEX |
|
|
|
|
| def heat_color(value: float, vmax: float) -> tuple[int, int, int]: |
| |
| hue = 240.0 * (1.0 - min(max(value / vmax, 0.0), 1.0)) |
| r, g, b = colorsys.hls_to_rgb(hue / 360.0, 0.5, 0.9) |
| return (int(b * 255), int(g * 255), int(r * 255)) |
|
|
|
|
| def put_text(img, text, x, y, px, color, weight=1): |
| scale = px / 22.0 |
| cv2.putText(img, text, (int(x), int(y)), FONT, scale, color, weight, cv2.LINE_AA) |
|
|
|
|
| def text_w(text, px, weight=1): |
| return cv2.getTextSize(text, FONT, px / 22.0, weight)[0][0] |
|
|
|
|
| |
| |
| |
|
|
| def decode_varint(buf: bytes, i: int) -> tuple[int, int]: |
| x = 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, n = 0, 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) |
| if fn == field_no: |
| return buf[i : i + ln] |
| i += ln |
| 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 parse_tactile(obj: dict) -> dict: |
| adc = np.zeros((5, 12), np.float32) |
| for i, name in enumerate(FINGERS): |
| row = (obj.get("finger_pressure") or {}).get(name) or [] |
| adc[i, : min(12, len(row))] = row[:12] |
| force = None |
| pix = obj.get("finger_force_N_pixels") |
| if pix: |
| force = np.zeros((5, 12), np.float32) |
| for i in range(min(5, len(pix))): |
| force[i, : min(12, len(pix[i]))] = pix[i][:12] |
| palm = np.zeros(60, np.float32) |
| raw_palm = obj.get("palm_pressure") or [] |
| palm[: min(60, len(raw_palm))] = raw_palm[:60] |
| bend = np.zeros(5, np.float32) |
| raw_bend = obj.get("finger_bend") or [] |
| bend[: min(5, len(raw_bend))] = raw_bend[:5] |
| return {"adc": adc, "force": force, "palm": palm, "bend": bend, |
| "sample_idx": int(obj.get("sample_idx", -1))} |
|
|
|
|
| def parse_state(obj: dict) -> tuple[str | None, str | None, str | None]: |
| aa = obj.get("atomic_actions") or [] |
| st = obj.get("subtasks") or [] |
| contact = aa[0].get("contact_state_start") if aa else None |
| target = aa[0].get("target_object") if aa else None |
| subtask = st[0].get("description") if st else None |
| return contact, target, subtask |
|
|
|
|
| def extract(mcap: Path, tmp_dir: Path) -> dict: |
| with open(mcap, "rb") as f: |
| summary = make_reader(f).get_summary() |
| available = {ch.topic for ch in (summary.channels or {}).values()} if summary else set() |
|
|
| cams = {"head": (HEAD_TOPIC, "Head Camera")} |
| for side in ("lh", "rh"): |
| if WRIST_TOPICS[side] in available: |
| cams[f"wrist_{side}"] = (WRIST_TOPICS[side], f"Wrist {side.upper()}") |
| elif MONO_TOPICS[side] in available: |
| cams[f"wrist_{side}"] = (MONO_TOPICS[side], f"Head mono {'L' if side == 'lh' else 'R'}") |
| topic_to_cam = {t: k for k, (t, _) in cams.items()} |
|
|
| writers = {k: (tmp_dir / f"_{k}.h264").open("wb") for k in cams} |
| cam_times = {k: [] for k in cams} |
| tactile = {h: {"t": [], "samples": []} for h in ("lh", "rh")} |
| states = [] |
|
|
| topics = [t for t, _ in cams.values()] + list(TACTILE_TOPICS.values()) |
| if STATE_TOPIC in available: |
| topics.append(STATE_TOPIC) |
|
|
| print(f"reading {mcap.name} ...", flush=True) |
| with open(mcap, "rb") as f: |
| for _sch, ch, msg in make_reader(f).iter_messages(topics=topics): |
| t = msg.log_time / 1e9 |
| if ch.topic in topic_to_cam: |
| payload = proto_bytes_field(msg.data, 3) |
| if payload: |
| key = topic_to_cam[ch.topic] |
| writers[key].write(payload) |
| cam_times[key].append(t) |
| elif ch.topic == STATE_TOPIC: |
| states.append((t, *parse_state(json.loads(msg.data)))) |
| else: |
| hand = "lh" if ch.topic == TACTILE_TOPICS["lh"] else "rh" |
| tactile[hand]["t"].append(t) |
| tactile[hand]["samples"].append(parse_tactile(json.loads(msg.data))) |
| for w in writers.values(): |
| w.close() |
|
|
| out = {"cams": {}, "tactile": {}, "states": states} |
| for k, (topic, label) in cams.items(): |
| raw = tmp_dir / f"_{k}.h264" |
| mp4 = tmp_dir / f"_{k}.mp4" |
| subprocess.run( |
| ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error", |
| "-fflags", "+genpts", "-r", "30", "-f", "h264", "-i", str(raw), |
| "-c", "copy", str(mp4)], |
| check=True, |
| ) |
| raw.unlink() |
| out["cams"][k] = {"mp4": mp4, "times": np.asarray(cam_times[k]), "label": label} |
| print(f" {label:12s} {len(cam_times[k])} frames", flush=True) |
| for h in ("lh", "rh"): |
| has_force = any(s["force"] is not None for s in tactile[h]["samples"]) |
| out["tactile"][h] = { |
| "t": np.asarray(tactile[h]["t"]), |
| "samples": tactile[h]["samples"], |
| "has_force": has_force, |
| } |
| print(f" {h} tactile {len(tactile[h]['t'])} samples force {'yes' if has_force else 'no'}", flush=True) |
| print(f" state {len(states)} messages", flush=True) |
| return out |
|
|
|
|
| |
| |
| |
|
|
| def sensor_cells(hand: str, sample: dict, mode: str): |
| long_names = ["little", "ring", "middle", "index"] if hand == "lh" else ["index", "middle", "ring", "little"] |
| anchors = {n: (1, (1 if hand == "lh" else 5) + 4 * k) for k, n in enumerate(long_names)} |
| anchors["thumb"] = (6, 17 if hand == "lh" else 1) |
| cells = [] |
| for fi, name in enumerate(FINGERS): |
| row0, col0 = anchors[name] |
| values = sample["force"][fi] if mode == "force-pixels" else sample["adc"][fi] |
| for n, v in enumerate(values): |
| cells.append((row0 + n // 3, col0 + n % 3, float(v))) |
| if mode == "raw": |
| base = 1 if hand == "lh" else 5 |
| for r, v in enumerate(sample["palm"]): |
| cells.append((6 + r // 15, base + r % 15, float(v))) |
| return cells |
|
|
|
|
| def draw_heatmap(img, x0, y0, bw, bh, hand: str, sample: dict | None, mode: str): |
| sc = min(bw / 28.0, bh / 12.0) |
| ox = x0 + (bw - 28 * sc) / 2 |
| oy = y0 + (bh - 12 * sc) / 2 |
| cv2.rectangle(img, (int(ox), int(oy)), (int(ox + 28 * sc), int(oy + 12 * sc)), SVG_BG, -1) |
| if sample is None: |
| msg = f"Waiting for {TACTILE_TOPICS[hand]}" |
| put_text(img, msg, ox + 14 * sc - text_w(msg, 15) / 2, oy + 6 * sc, 15, FAINT) |
| return |
| if mode == "force-pixels" and sample["force"] is None: |
| msg = "Pixel force unavailable in this recording" |
| put_text(img, msg, ox + 14 * sc - text_w(msg, 15) / 2, oy + 6 * sc, 15, FAINT) |
| return |
|
|
| vmax = 255.0 if mode == "raw" else 20.0 |
| shift = 7 if hand == "lh" else 0 |
| for row, col, v in sensor_cells(hand, sample, mode): |
| cx, cy = ox + (col + shift) * sc, oy + row * sc |
| p0, p1 = (int(cx), int(cy)), (int(cx + 0.9 * sc), int(cy + 0.9 * sc)) |
| cv2.rectangle(img, p0, p1, heat_color(v, vmax), -1) |
| cv2.rectangle(img, p0, p1, CELL_STROKE, 1) |
| |
| sx = ox + (4.5 if hand == "lh" else 22.5) * sc |
| for n in range(11): |
| sy = oy + (1 + 0.8 * n) * sc |
| r, g, b = colorsys.hls_to_rgb(n / 10.0 * 240.0 / 360.0, 0.5, 0.9) |
| cv2.rectangle(img, (int(sx), int(sy)), (int(sx + sc), int(sy + 0.82 * sc)), |
| (int(b * 255), int(g * 255), int(r * 255)), -1) |
| tx = ox + (0.5 if hand == "lh" else 24.0) * sc |
| put_text(img, "255 ADC" if mode == "raw" else "20 N", tx, oy + 1.6 * sc, 0.65 * sc, SCALE_INK) |
| put_text(img, "0", tx, oy + 9.3 * sc, 0.65 * sc, SCALE_INK) |
| if mode == "raw": |
| px = ox + ((15.5 if hand == "lh" else 12.5) + shift) * sc |
| put_text(img, "palm", px - text_w("palm", 0.65 * sc) / 2, oy + 11 * sc, 0.65 * sc, SCALE_INK) |
|
|
|
|
| def draw_bend(img, x0, y0, bw, bh, hand: str, sample: dict): |
| sc = min(bw / 28.0, bh / 10.0) |
| ox = x0 + (bw - 28 * sc) / 2 |
| oy = y0 + (bh - 10 * sc) / 2 |
| cv2.rectangle(img, (int(ox), int(oy)), (int(ox + 28 * sc), int(oy + 10 * sc)), SVG_BG, -1) |
| for t, name in enumerate(FINGERS): |
| c = (25.5 - 4 * t) if hand == "lh" else (2.5 + 4 * t) |
| bx = ox + (c - 1) * sc |
| h = min(max(float(sample["bend"][t]) / 255.0, 0.0), 1.0) * 7.5 * sc |
| cv2.rectangle(img, (int(bx), int(oy + 2 * sc)), (int(bx + 2 * sc), int(oy + 9.5 * sc)), BEND_TRACK, -1) |
| if h > 0: |
| cv2.rectangle(img, (int(bx), int(oy + 9.5 * sc - h)), (int(bx + 2 * sc), int(oy + 9.5 * sc)), BEND_FILL, -1) |
| letter = name[0].upper() |
| put_text(img, letter, ox + c * sc - text_w(letter, 0.8 * sc) / 2, oy + 1.35 * sc, 0.8 * sc, BEND_INK) |
|
|
|
|
| def draw_tactile_panel(img, x0, y0, w, h, samples: dict, mode: str, t_sec: float): |
| cv2.rectangle(img, (x0, y0), (x0 + w, y0 + h), PANEL_BG, -1) |
| pad = 12 |
| put_text(img, "FusionX Tactile", x0 + pad, y0 + 26, 17, INK, 2) |
| stamp = f"t = {t_sec:6.2f} s" |
| put_text(img, stamp, x0 + w - pad - text_w(stamp, 14), y0 + 26, 14, MUTED) |
| |
| by = y0 + 38 |
| bw = (w - 2 * pad - 8) // 2 |
| for i, (m, label) in enumerate((("raw", "Raw ADC"), ("force-pixels", "Pixel Force"))): |
| bx = x0 + pad + i * (bw + 8) |
| cv2.rectangle(img, (bx, by), (bx + bw, by + 30), BTN_ACTIVE if m == mode else BTN_IDLE, -1) |
| cv2.rectangle(img, (bx, by), (bx + bw, by + 30), BTN_BORDER, 1) |
| put_text(img, label, bx + (bw - text_w(label, 14)) / 2, by + 20, 14, INK) |
|
|
| sec_y = by + 42 |
| sec_h = h - (sec_y - y0) - 8 |
| half = w // 2 |
| cv2.line(img, (x0 + half, sec_y), (x0 + half, y0 + h - 8), BTN_BORDER, 1) |
| for i, hand in enumerate(("lh", "rh")): |
| hx = x0 + i * half + (8 if i else pad) |
| hw = half - pad - 8 |
| title = f"{'Left' if hand == 'lh' else 'Right'} Hand" |
| put_text(img, title, hx + (hw - text_w(title, 15, 2)) / 2, sec_y + 18, 15, INK, 2) |
| heat_h = int(hw * 12 / 28) |
| bend_h = int(hw * 10 / 28) |
| avail = sec_h - 28 - 24 - 14 |
| if heat_h + bend_h > avail: |
| k = avail / (heat_h + bend_h) |
| heat_h, bend_h = int(heat_h * k), int(bend_h * k) |
| draw_heatmap(img, hx, sec_y + 28, hw, heat_h, hand, samples[hand], mode) |
| if samples[hand] is not None: |
| draw_bend(img, hx, sec_y + 38 + heat_h, hw, bend_h, hand, samples[hand]) |
| foot = f"{TACTILE_TOPICS[hand]} sample {samples[hand]['sample_idx']}" |
| else: |
| foot = TACTILE_TOPICS[hand] |
| put_text(img, foot, hx + hw - text_w(foot, 12), y0 + h - 16, 12, MUTED) |
|
|
|
|
| |
| |
| |
|
|
| TRACKS = (("contact", 1), ("target", 2), ("subtask", 3)) |
|
|
|
|
| def build_segments(states, t0, t1): |
| """Per track: list of (start, end, value) merged over consecutive equal values.""" |
| tracks = [] |
| for _, idx in TRACKS: |
| segs = [] |
| for t, *vals in states: |
| v = vals[idx - 1] |
| if segs and segs[-1][2] == v: |
| segs[-1][1] = t |
| else: |
| if segs: |
| segs[-1][1] = t |
| segs.append([t, t1, v]) |
| tracks.append([(max(s, t0), min(e, t1), v) for s, e, v in segs |
| if v is not None and e > t0 and s < t1]) |
| return tracks |
|
|
|
|
| def render_timeline_bg(w, h, tracks, t0, t1): |
| img = np.full((h, w, 3), PANEL_BG, np.uint8) |
| label_w, right = 90, 16 |
| span = max(t1 - t0, 1e-9) |
|
|
| def tx(t): |
| return label_w + (t - t0) / span * (w - label_w - right) |
|
|
| color_maps = [] |
| row_h = (h - 34) // len(TRACKS) |
| for ti, (name, _) in enumerate(TRACKS): |
| cmap = {} |
| color_maps.append(cmap) |
| y = 10 + ti * row_h |
| put_text(img, name, 12, y + row_h // 2 + 5, 14, FAINT) |
| bar_y, bar_h = y + 6, row_h - 18 |
| cv2.rectangle(img, (label_w, bar_y), (w - right, bar_y + bar_h), SVG_BG, -1) |
| for s, e, v in tracks[ti]: |
| if v not in cmap: |
| cmap[v] = TRACK_COLORS[len(cmap) % len(TRACK_COLORS)] |
| x0, x1 = int(tx(s)), int(tx(e)) |
| cv2.rectangle(img, (x0, bar_y), (max(x1 - 2, x0 + 1), bar_y + bar_h), cmap[v], -1) |
| label = str(v) |
| if text_w(label, 13) < x1 - x0 - 10: |
| put_text(img, label, x0 + 6, bar_y + bar_h // 2 + 5, 13, INK, 1) |
| axis_y = h - 18 |
| step = max(10, int(round(span / 8 / 10)) * 10) |
| t = 0 |
| while t <= span: |
| x = int(tx(t0 + t)) |
| cv2.line(img, (x, axis_y - 4), (x, axis_y), MUTED, 1) |
| put_text(img, f"{t:d}s", x + 3, axis_y + 12, 12, MUTED) |
| t += step |
| return img, tx |
|
|
|
|
| |
| |
| |
|
|
| class CamReader: |
| def __init__(self, mp4: Path, times: np.ndarray, label: str): |
| self.cap = cv2.VideoCapture(str(mp4)) |
| self.times = times |
| self.label = label |
| self.idx = -1 |
| self.frame = None |
|
|
| def at(self, t: float): |
| while self.idx + 1 < len(self.times) and self.times[self.idx + 1] <= t: |
| ok, frame = self.cap.read() |
| if not ok: |
| break |
| self.idx += 1 |
| self.frame = frame |
| return self.frame |
|
|
| def release(self): |
| self.cap.release() |
|
|
|
|
| def blit_camera(canvas, x0, y0, bw, bh, frame, label): |
| cv2.rectangle(canvas, (x0, y0), (x0 + bw, y0 + bh), CAM_BG, -1) |
| if frame is not None: |
| fh, fw = frame.shape[:2] |
| s = min(bw / fw, bh / fh) |
| nw, nh = int(fw * s), int(fh * s) |
| ox, oy = x0 + (bw - nw) // 2, y0 + (bh - nh) // 2 |
| canvas[oy : oy + nh, ox : ox + nw] = cv2.resize(frame, (nw, nh), interpolation=cv2.INTER_AREA) |
| else: |
| put_text(canvas, "waiting", x0 + bw / 2 - text_w("waiting", 16) / 2, y0 + bh / 2, 16, MUTED) |
| tw = text_w(label, 14) |
| cv2.rectangle(canvas, (x0 + 8, y0 + 8), (x0 + 20 + tw, y0 + 32), (0, 0, 0), -1) |
| put_text(canvas, label, x0 + 14, y0 + 25, 14, INK) |
|
|
|
|
| |
| |
| |
|
|
| def ffmpeg_writer(dest: Path, w: int, h: int, fps: float) -> subprocess.Popen: |
| return subprocess.Popen( |
| ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error", |
| "-f", "rawvideo", "-pix_fmt", "bgr24", "-s", f"{w}x{h}", "-r", str(fps), "-i", "-", |
| "-c:v", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-crf", "20", |
| "-movflags", "+faststart", str(dest)], |
| stdin=subprocess.PIPE, |
| ) |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("recording_dir", nargs="?", default=".") |
| ap.add_argument("--mode", choices=("auto", "force-pixels", "raw"), default="auto") |
| ap.add_argument("--start", type=float, default=0.0, help="offset into recording, seconds") |
| ap.add_argument("--duration", type=float, default=None, help="seconds to render") |
| ap.add_argument("--fps", type=float, default=30.0) |
| ap.add_argument("--out", type=Path, default=None) |
| args = ap.parse_args() |
|
|
| root = Path(args.recording_dir).resolve() |
| root = root.parent if root.is_file() else root |
| mcaps = sorted(root.glob("*.mcap")) |
| if not mcaps: |
| sys.exit(f"no .mcap found in {root}") |
| out_dir = root / "output" |
| out_dir.mkdir(exist_ok=True) |
| dest = args.out or out_dir / "force_video.mp4" |
|
|
| streams = extract(mcaps[0], out_dir) |
|
|
| firsts = [c["times"][0] for c in streams["cams"].values() if len(c["times"])] |
| lasts = [c["times"][-1] for c in streams["cams"].values() if len(c["times"])] |
| for h in ("lh", "rh"): |
| t = streams["tactile"][h]["t"] |
| if t.size: |
| firsts.append(t[0]) |
| lasts.append(t[-1]) |
| t0, t1 = min(firsts), max(lasts) |
| t0 += args.start |
| if args.duration is not None: |
| t1 = min(t1, t0 + args.duration) |
| n_frames = max(1, int(round((t1 - t0) * args.fps))) |
|
|
| if args.mode == "auto": |
| mode = "force-pixels" if any(streams["tactile"][h]["has_force"] for h in ("lh", "rh")) else "raw" |
| else: |
| mode = args.mode |
| print(f"rendering {n_frames} frames ({(t1 - t0):.1f}s) mode={mode} -> {dest.name}", flush=True) |
|
|
| cams = {k: CamReader(c["mp4"], c["times"], c["label"]) for k, c in streams["cams"].items()} |
| tl_h = CANVAS_H - TOP_H |
| if streams["states"]: |
| seg_tracks = build_segments(streams["states"], t0, t1) |
| timeline_bg, tl_tx = render_timeline_bg(CANVAS_W, tl_h, seg_tracks, t0, t1) |
| else: |
| timeline_bg, tl_tx = np.full((tl_h, CANVAS_W, 3), PANEL_BG, np.uint8), None |
| put_text(timeline_bg, "no semantic annotations in this recording", |
| CANVAS_W / 2 - text_w("no semantic annotations in this recording", 15) / 2, |
| tl_h / 2, 15, MUTED) |
|
|
| proc = ffmpeg_writer(dest, CANVAS_W, CANVAS_H, args.fps) |
| canvas = np.zeros((CANVAS_H, CANVAS_W, 3), np.uint8) |
| wrist_w, wrist_h = PANEL_W // 2, TOP_H - HEAD_H |
| tac = streams["tactile"] |
| for i in range(n_frames): |
| t = t0 + i / args.fps |
| samples = {} |
| for h in ("lh", "rh"): |
| j = int(np.searchsorted(tac[h]["t"], t, "right")) - 1 |
| samples[h] = tac[h]["samples"][j] if j >= 0 else None |
| draw_tactile_panel(canvas, 0, 0, PANEL_W, TOP_H, samples, mode, t - t0) |
| blit_camera(canvas, PANEL_W, 0, PANEL_W, HEAD_H, cams["head"].at(t), cams["head"].label) |
| for k, key in enumerate(("wrist_lh", "wrist_rh")): |
| if key in cams: |
| blit_camera(canvas, PANEL_W + k * wrist_w, HEAD_H, wrist_w, wrist_h, |
| cams[key].at(t), cams[key].label) |
| else: |
| blit_camera(canvas, PANEL_W + k * wrist_w, HEAD_H, wrist_w, wrist_h, None, key) |
| canvas[TOP_H:] = timeline_bg |
| if tl_tx is not None: |
| x = int(tl_tx(t)) |
| cv2.line(canvas, (x, TOP_H + 4), (x, CANVAS_H - 20), INK, 2) |
| proc.stdin.write(canvas.tobytes()) |
| if i % 900 == 0: |
| print(f" frame {i}/{n_frames}", flush=True) |
| proc.stdin.close() |
| if proc.wait() != 0: |
| raise RuntimeError("ffmpeg encode failed") |
| for c in cams.values(): |
| c.release() |
| for k in streams["cams"]: |
| streams["cams"][k]["mp4"].unlink(missing_ok=True) |
| print(f"wrote {dest} {dest.stat().st_size / 1e6:.1f} MB", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
