| |
| """Visualize a synchronized ZED + Homie + OptiTrack/SMPL-X data case in Rerun.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import os |
| import socket |
| import struct |
| import subprocess |
| import time |
| import xml.etree.ElementTree as ET |
| from pathlib import Path |
|
|
| import cv2 |
| import numpy as np |
| import rerun as rr |
| import rerun.blueprint as rrb |
| import yaml |
|
|
| HERE = Path(__file__).resolve().parent |
| DEFAULT_CASE = Path("/mnt/Datasets/2026-06-27-12:26:35") |
| HOMIE_NAMES = ("front_left", "front_right", "back_left", "back_right") |
| HOMIE_VIDEO = { |
| "front_left": "homie_front_left.mp4", |
| "front_right": "homie_front_right.mp4", |
| "back_left": "homie_back_left.mp4", |
| "back_right": "homie_back_right.mp4", |
| } |
| HOMIE_CAMCHAIN = { |
| "front_left": "cam0", "front_right": "cam1", |
| "back_left": "cam2", "back_right": "cam3", |
| } |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| p = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) |
| p.add_argument("case", nargs="?", type=Path, default=DEFAULT_CASE) |
| p.add_argument("--zed-calib", type=Path, default=HERE / "config/zed_poses_0622.json") |
| p.add_argument("--homie-calib", type=Path, default=HERE / "config/homie_rig_calib.json") |
| p.add_argument("--homie-camchain", type=Path, default=HERE / "config/homie-camchain.yaml") |
| p.add_argument("--zed", default="0,1,2,3,4,5,6,7", help="ZED camera indices, or empty") |
| p.add_argument("--homie", default="front_left", help="Homie camera names, or empty") |
| p.add_argument("--optitrack-calib", type=Path, default=HERE / "config/Calibration-Exported.mcal") |
| p.add_argument("--assets-dir", type=Path, |
| default=Path("/home/acerobotics/Datasets/mesh_alignmend/aligned_textured"), |
| help="room OBJ asset directory (flat *.obj or <name>/mesh.obj layout)") |
| p.add_argument("--no-room-assets", dest="no_room_assets", action="store_true", default=False, |
| help="do not load room assets") |
| p.add_argument("--room-assets", dest="no_room_assets", action="store_false", |
| help="explicitly enable room asset loading") |
| p.add_argument("--enable-room-alignment", dest="enable_room_alignment", action="store_true", default=True, |
| help="enable floor/center alignment and CLI room offsets (default)") |
| p.add_argument("--no-room-alignment", dest="enable_room_alignment", action="store_false", |
| help="disable floor/center alignment and CLI room offsets") |
| p.add_argument("--enable-room-controls", dest="enable_room_controls", action="store_true", default=True, |
| help="launch live room translation/rotation controls (default)") |
| p.add_argument("--no-room-controls", dest="enable_room_controls", action="store_false", |
| help="disable live room transform controls") |
| p.add_argument("--asset-floor-z", type=float, default=-1.62, help="floor Z in the source Z-up OBJ coordinates") |
| p.add_argument("--asset-translation", type=float, nargs=3, default=(0.12, -0.52, 0.79), metavar=("DX", "DY", "DZ"), |
| help="additional room translation in OptiTrack world meters") |
| p.add_argument("--asset-rotation-deg", type=float, nargs=3, default=(0.0, 62.0, 0.0), metavar=("RX", "RY", "RZ"), |
| help="additional room rotation about world X/Y/Z in degrees") |
| p.add_argument("--no-auto-asset-align", action="store_true", help="disable horizontal room/camera center alignment") |
| p.add_argument("--start", type=float, default=0.0, help="start time in OptiTrack seconds") |
| p.add_argument("--duration", type=float, default=None) |
| p.add_argument("--mesh-fps", type=float, default=15.0, |
| help="(unused; SMPL is logged as a single static pose at --start)") |
| p.add_argument("--no-video", action="store_true") |
| p.add_argument("--full-video", action="store_true", help="embed complete MP4 assets instead of one RGB frame per camera") |
| p.add_argument("--no-smpl", action="store_true") |
| p.add_argument("--save", type=Path, help="write an .rrd instead of spawning the viewer") |
| p.add_argument("--connect", metavar="URL", help="connect to an existing Rerun server, e.g. rerun+http://127.0.0.1:9876/proxy") |
| p.add_argument("--grpc-port", type=int, default=9876, help="Rerun data proxy port (only with --connect)") |
| p.add_argument("--web-port", type=int, default=9090, help="headless Web Viewer HTTP port") |
| p.add_argument("--control-port", type=int, default=None, help="room-alignment UI port; default web-port + 2") |
| p.add_argument("--server-memory", default="8GiB", help="Rerun proxy cache limit") |
| return p.parse_args() |
|
|
|
|
| def kill_orphaned_viewers() -> None: |
| """Terminate leftover rerun servers from previous runs of this script. |
| |
| They are detached (start_new_session), so they outlive a crashed or |
| Ctrl+C'd parent and then squat on the ports. A process serving our own |
| /tmp/multicam_optitrack_smpl_*.rrd is killed unless some ancestor is a |
| still-running visualize_case.py (i.e. an active sibling session). |
| """ |
| import signal |
|
|
| def ppid_of(pid: int) -> int: |
| try: |
| return int(Path(f"/proc/{pid}/stat").read_text().rsplit(")", 1)[1].split()[1]) |
| except (OSError, IndexError, ValueError): |
| return 0 |
|
|
| def has_live_owner(pid: int) -> bool: |
| seen = 0 |
| while pid > 1 and seen < 20: |
| try: |
| argv = Path(f"/proc/{pid}/cmdline").read_bytes().split(b"\0") |
| except OSError: |
| return False |
| if pid != os.getpid() and any(a.endswith(b"visualize_case.py") for a in argv): |
| return True |
| pid, seen = ppid_of(pid), seen + 1 |
| return False |
|
|
| for pid_dir in Path("/proc").glob("[0-9]*"): |
| pid = int(pid_dir.name) |
| if pid == os.getpid(): |
| continue |
| try: |
| argv = (pid_dir / "cmdline").read_bytes().split(b"\0") |
| except OSError: |
| continue |
| |
| |
| serves_our_rrd = any(a.startswith(b"/tmp/multicam_optitrack_smpl_") |
| and a.endswith(b".rrd") for a in argv) |
| if (serves_our_rrd and b"--serve-web" in argv |
| and not has_live_owner(pid)): |
| print(f"Stopping orphaned Rerun viewer (pid {pid})") |
| try: |
| os.kill(pid, signal.SIGTERM) |
| except OSError: |
| pass |
| time.sleep(0.5) |
|
|
|
|
| def start_headless_server(recording: Path, web_port: int, server_memory: str) -> subprocess.Popen: |
| """Start the web viewer on a completed RRD; no transient gRPC stream involved.""" |
| executable = Path(__file__).resolve().parent / ".venv/bin/rerun" |
| if not executable.is_file(): |
| raise FileNotFoundError(f"Rerun CLI not found at {executable}; install requirements in .venv") |
| with socket.socket() as check: |
| if check.connect_ex(("127.0.0.1", web_port)) == 0: |
| kill_orphaned_viewers() |
| with socket.socket() as check: |
| if check.connect_ex(("127.0.0.1", web_port)) == 0: |
| raise RuntimeError(f"Port {web_port} is already in use. Re-run with --web-port {web_port + 1}") |
| |
| proxy_port = web_port + 1 |
| with socket.socket() as check: |
| if check.connect_ex(("127.0.0.1", proxy_port)) == 0: |
| raise RuntimeError(f"Proxy port {proxy_port} is already in use. Choose another --web-port") |
| proc = subprocess.Popen( |
| [str(executable), str(recording), "--serve-web", "--bind", "127.0.0.1", |
| "--port", str(proxy_port), "--web-viewer-port", str(web_port), |
| "--server-memory-limit", server_memory], |
| start_new_session=True, |
| ) |
| deadline = time.monotonic() + 15.0 |
| while time.monotonic() < deadline: |
| if proc.poll() is not None: |
| raise RuntimeError("Rerun Web Viewer exited during startup; run .venv/bin/rerun --serve-web to inspect its error") |
| try: |
| with socket.create_connection(("127.0.0.1", web_port), timeout=0.2): |
| return proc |
| except OSError: |
| time.sleep(0.1) |
| proc.terminate() |
| raise TimeoutError(f"Rerun Web Viewer did not open port {web_port}") |
|
|
|
|
| def rotation_xyz_deg(rx: float, ry: float, rz: float) -> np.ndarray: |
| x, y, z = np.radians([rx, ry, rz]) |
| cx, sx, cy, sy, cz, sz = np.cos(x), np.sin(x), np.cos(y), np.sin(y), np.cos(z), np.sin(z) |
| Rx = np.array([[1, 0, 0], [0, cx, -sx], [0, sx, cx]]) |
| Ry = np.array([[cy, 0, sy], [0, 1, 0], [-sy, 0, cy]]) |
| Rz = np.array([[cz, -sz, 0], [sz, cz, 0], [0, 0, 1]]) |
| return Rz @ Ry @ Rx |
|
|
|
|
| def launch_alignment_ui(base_translation: np.ndarray, room_R: np.ndarray, proxy_port: int, |
| control_port: int, recording_id: str): |
| import gradio as gr |
| stream = rr.RecordingStream("multicam_optitrack_smpl", recording_id=recording_id) |
| stream.connect_grpc(f"rerun+http://127.0.0.1:{proxy_port}/proxy") |
|
|
| counter = [0] |
|
|
| def update(dx: float, dy: float, dz: float, rx: float, ry: float, rz: float) -> str: |
| delta = np.array([dx, dy, dz], float) |
| total = base_translation + delta |
| total_R = rotation_xyz_deg(rx, ry, rz) @ room_R |
| rr.log("world/room", rr.Transform3D(translation=total, mat3x3=total_R), static=True, recording=stream) |
| stream.flush() |
| counter[0] += 1 |
| return (f"已发送更新 #{counter[0]}\n\n" |
| f"总平移: [{total[0]:.3f}, {total[1]:.3f}, {total[2]:.3f}] m " |
| f"附加旋转: [{rx:.1f}, {ry:.1f}, {rz:.1f}]°\n\n" |
| f"启动参数: `--asset-translation {dx:.3f} {dy:.3f} {dz:.3f} " |
| f"--asset-rotation-deg {rx:.1f} {ry:.1f} {rz:.1f}`") |
|
|
| with gr.Blocks(title="Room alignment") as demo: |
| gr.Markdown("# 房间 Mesh 平移微调\n滑块表示叠加在自动对齐结果上的偏移（米）。松开滑块后更新 Rerun。") |
| x = gr.Slider(-5, 5, value=0, step=0.01, label="X 平移 / m") |
| y = gr.Slider(-5, 5, value=0, step=0.01, label="Y 平移 / m") |
| z = gr.Slider(-5, 5, value=0, step=0.01, label="Z 平移 / m") |
| with gr.Row(): |
| rx = gr.Slider(-180, 180, value=0, step=1, label="绕 X 旋转 / °") |
| ry = gr.Slider(-180, 180, value=0, step=1, label="绕 Y 旋转 / °") |
| rz = gr.Slider(-180, 180, value=0, step=1, label="绕 Z 旋转 / °") |
| controls = [x, y, z, rx, ry, rz] |
| status = gr.Markdown(update(0, 0, 0, 0, 0, 0)) |
| for slider in controls: |
| slider.release(update, inputs=controls, outputs=status, show_progress="hidden") |
| gr.Button("应用数值", variant="primary").click(update, inputs=controls, outputs=status, show_progress="hidden") |
| demo.launch(server_name="127.0.0.1", server_port=control_port, prevent_thread_lock=True, quiet=True) |
| return demo, stream |
|
|
|
|
| def load_obj(path: Path) -> tuple[np.ndarray, np.ndarray]: |
| vertices, faces = [], [] |
| with path.open() as f: |
| for line in f: |
| if line.startswith("v "): |
| vertices.append([float(x) for x in line.split()[1:4]]) |
| elif line.startswith("f "): |
| idx = [int(x.split("/")[0]) - 1 for x in line.split()[1:]] |
| for i in range(1, len(idx) - 1): |
| faces.append([idx[0], idx[i], idx[i + 1]]) |
| return np.asarray(vertices, np.float32), np.asarray(faces, np.uint32) |
|
|
|
|
| def obj_collection_bounds(paths: list[Path]) -> tuple[np.ndarray, np.ndarray]: |
| lo, hi = np.full(3, np.inf), np.full(3, -np.inf) |
| for path in paths: |
| with path.open(errors="ignore") as f: |
| for line in f: |
| if line.startswith("v "): |
| v = np.fromstring(line[2:], sep=" ", count=3) |
| if len(v) == 3: |
| lo, hi = np.minimum(lo, v), np.maximum(hi, v) |
| if not np.isfinite(lo).all(): |
| raise ValueError("No OBJ vertices found for room alignment") |
| return lo, hi |
|
|
|
|
| def open_pc2(path: Path) -> tuple[np.memmap, float]: |
| with path.open("rb") as f: |
| if f.read(12) != b"POINTCACHE2\0": |
| raise ValueError(f"Not a POINTCACHE2 file: {path}") |
| version, points, start, rate, frames = struct.unpack("<iiffi", f.read(20)) |
| if version != 1 or path.stat().st_size != 32 + frames * points * 12: |
| raise ValueError(f"Invalid PC2 header/size: {path}") |
| return np.memmap(path, dtype="<f4", mode="r", offset=32, shape=(frames, points, 3)), rate |
|
|
|
|
| def read_homie_poses(path: Path) -> tuple[np.ndarray, np.ndarray, np.ndarray]: |
| data = np.genfromtxt(path, delimiter=",", names=True, skip_header=1) |
| frames = data["frame"].astype(np.int64) |
| pos_m = np.column_stack([data["Homie_px"], data["Homie_py"], data["Homie_pz"]]) / 1000.0 |
| quat = np.column_stack([data["Homie_qx"], data["Homie_qy"], data["Homie_qz"], data["Homie_qw"]]) |
| return frames, pos_m, quat |
|
|
|
|
| def quat_xyzw_to_mat(q: np.ndarray) -> np.ndarray: |
| q = q / np.linalg.norm(q) |
| x, y, z, w = q |
| return np.array([ |
| [1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w)], |
| [2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w)], |
| [2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y)], |
| ]) |
|
|
|
|
| def euler_rotation(pitch: float, yaw: float, roll: float) -> np.ndarray: |
| p, y, r = np.radians([pitch, yaw, roll]) |
| cp, sp, cy, sy, cr, sr = np.cos(p), np.sin(p), np.cos(y), np.sin(y), np.cos(r), np.sin(r) |
| return np.array([[cr*cy, cr*sy*sp-sr*cp, cr*sy*cp+sr*sp], |
| [sr*cy, sr*sy*sp+cr*cp, sr*sy*cp-cr*sp], |
| [-sy, cy*sp, cy*cp]]) |
|
|
|
|
| def homie_rectification(camchain_path: Path) -> tuple[dict[str, np.ndarray], np.ndarray]: |
| cc = yaml.safe_load(camchain_path.read_text()) |
| |
| out, fov, zoom = 1024, 90.0, 0.78125 |
| focal = out / (2 * np.tan(np.radians(fov) / 2)) * zoom |
| K = np.array([[focal, 0, out/2], [0, focal, out/2], [0, 0, 1.0]]) |
| view = euler_rotation(-5.0, 0.0, 0.0) |
| result = {} |
| pairs = (("cam0", "front_left", "cam1", "front_right"), |
| ("cam2", "back_left", "cam3", "back_right")) |
| for lk, ln, rk, rn in pairs: |
| def kd(key: str): |
| c = cc[key]; fx, fy, cx, cy = c["intrinsics"] |
| return np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1.0]]), np.asarray(c["distortion_coeffs"]) |
| K0, D0 = kd(lk); K1, D1 = kd(rk) |
| T = np.asarray(cc[rk]["T_cn_cnm1"], float) |
| size = tuple(map(int, cc[lk]["resolution"])) |
| R1, R2, *_ = cv2.fisheye.stereoRectify(K0, D0, K1, D1, size, T[:3, :3], T[:3, 3], |
| flags=cv2.CALIB_ZERO_DISPARITY, newImageSize=size, |
| balance=0.0, fov_scale=1.0) |
| result[ln], result[rn] = view @ R1, view @ R2 |
| return result, K |
|
|
|
|
| def log_video(path: str, video_path: Path, origin_s: float) -> None: |
| asset = rr.AssetVideo(path=video_path) |
| rr.log(path, asset, static=True) |
| stamps = asset.read_frame_timestamps_nanos() |
| rr.send_columns(path, |
| indexes=[rr.TimeColumn("time", duration=origin_s + stamps * 1e-9)], |
| columns=rr.VideoFrameReference.columns_nanos(stamps)) |
|
|
|
|
| def log_video_frame(path: str, video_path: Path, origin_s: float, requested_time_s: float, |
| flip_vertical: bool = False) -> None: |
| """Log one JPEG frame, avoiding transfer of the complete MP4 asset.""" |
| sample_time = max(requested_time_s, origin_s) |
| cap = cv2.VideoCapture(str(video_path)) |
| cap.set(cv2.CAP_PROP_POS_MSEC, max(0.0, sample_time - origin_s) * 1000.0) |
| ok, frame = cap.read() |
| cap.release() |
| if not ok: |
| raise RuntimeError(f"Could not decode RGB frame from {video_path} at {sample_time - origin_s:.3f}s") |
| if flip_vertical: |
| frame = cv2.flip(frame, 0) |
| ok, encoded = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, 90]) |
| if not ok: |
| raise RuntimeError(f"Could not JPEG-encode frame from {video_path}") |
| rr.set_time("time", duration=sample_time) |
| rr.log(path, rr.EncodedImage(contents=encoded.tobytes(), media_type="image/jpeg")) |
|
|
|
|
| def rotation_midpoint(a: np.ndarray, b: np.ndarray) -> np.ndarray: |
| """Closest proper rotation to the equal-weight mean of two rotations.""" |
| u, _, vt = np.linalg.svd(a + b) |
| d = np.eye(3); d[-1, -1] = np.linalg.det(u @ vt) |
| return u @ d @ vt |
|
|
|
|
| def load_optitrack_cameras(path: Path) -> dict[int, dict]: |
| root = ET.fromstring(path.read_bytes().decode("utf-16")) |
| gl_to_cv = np.diag([1.0, -1.0, -1.0]) |
| cameras = {} |
| for cam in root.findall(".//Camera"): |
| props, intr, extr = cam.find("Properties"), cam.find("IntrinsicStandardCameraModel"), cam.find("Extrinsic") |
| if props is None or intr is None or extr is None: |
| continue |
| cid = int(props.attrib["CameraID"]) |
| fx, fy = float(intr.attrib["HorizontalFocalLength"]), float(intr.attrib["VerticalFocalLength"]) |
| cx, cy = float(intr.attrib["LensCenterX"]), float(intr.attrib["LensCenterY"]) |
| R = np.array([float(extr.attrib[f"OrientMatrix{i}"]) for i in range(9)]).reshape(3, 3) @ gl_to_cv |
| t = np.array([float(extr.attrib[k]) for k in ("X", "Y", "Z")]) * 1000.0 |
| T = np.eye(4); T[:3, :3], T[:3, 3] = R, t |
| cameras[cid] = {"T_c2w": T, "K": np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1.0]]), |
| "width": 2048, "height": 1088, "serial": cam.attrib.get("Serial", "")} |
| return cameras |
|
|
|
|
| def log_camera_static(path: str, T_c2w: np.ndarray, K: np.ndarray, width: int, height: int, |
| color: tuple[int, int, int]) -> None: |
| rr.log(path, rr.Transform3D(translation=T_c2w[:3, 3] / 1000.0, mat3x3=T_c2w[:3, :3]), static=True) |
| rr.log(path, rr.Pinhole(image_from_camera=K, width=width, height=height, |
| camera_xyz=rr.ViewCoordinates.RDF, image_plane_distance=0.32, |
| color=color), static=True) |
|
|
|
|
| def blueprint(zed: list[str], homie: list[str]) -> rrb.Blueprint: |
| video_views = [rrb.Spatial2DView(name=f"ZED {c}", origin=f"world/cameras/zed/cam{c}") for c in zed] |
| video_views += [rrb.Spatial2DView(name=f"Homie {c}", origin=f"world/cameras/homie/{c}") for c in homie] |
| videos = rrb.Grid(*video_views, grid_columns=2) if video_views else rrb.TextLogView() |
| return rrb.Blueprint(rrb.Horizontal( |
| rrb.Spatial3DView(name="All cameras + SMPL", origin="world", contents=["world/**"], |
| background=[41, 43, 38]), |
| videos, column_shares=[2, 1]), collapse_panels=True) |
|
|
|
|
| def main() -> None: |
| args = parse_args(); case = args.case.resolve() |
| server_proc = None |
| alignment_ui = alignment_stream = None |
| room_base_translation = room_rotation = None |
| recording_id = "multicam-optitrack-smpl-room-control" |
| web_rrd = None |
| zed_ids = [x.strip() for x in args.zed.split(",") if x.strip()] |
| homie_ids = [x.strip() for x in args.homie.split(",") if x.strip()] |
| unknown = set(homie_ids) - set(HOMIE_NAMES) |
| if unknown: raise ValueError(f"Unknown Homie cameras: {sorted(unknown)}") |
| if args.save and args.connect: |
| raise ValueError("--save and --connect are mutually exclusive") |
| rr.init("multicam_optitrack_smpl", recording_id=recording_id, spawn=False) |
| if args.save: |
| rr.save(args.save) |
| elif args.connect: |
| rr.connect_grpc(args.connect) |
| else: |
| web_rrd = Path(f"/tmp/multicam_optitrack_smpl_{os.getpid()}.rrd") |
| rr.save(web_rrd) |
| rr.log("world", rr.ViewCoordinates.RIGHT_HAND_Y_UP, static=True) |
| rr.log("world/origin", rr.TransformAxes3D(axis_length=0.5), static=True) |
|
|
| zc = json.loads(args.zed_calib.read_text())["cameras"] |
|
|
| if not args.no_room_assets and args.assets_dir.is_dir(): |
| |
| |
| axis_R = np.array([[1, 0, 0], [0, 0, 1], [0, -1, 0]], dtype=float) |
| room_R = axis_R.copy() |
| excluded_assets = {"scene.obj", "table_cook.obj"} |
| |
| |
| |
| parts = sorted(args.assets_dir.glob("*/mesh.glb")) |
| if not parts: |
| parts = sorted(args.assets_dir.glob("*/mesh.obj")) |
| if not parts: |
| parts = sorted(p for p in args.assets_dir.glob("*.obj") if p.name not in excluded_assets) |
| objects = parts |
| translation = np.zeros(3) |
| if args.enable_room_alignment: |
| room_R = rotation_xyz_deg(*args.asset_rotation_deg) @ axis_R |
| translation = np.array([0.0, -args.asset_floor_z, 0.0]) + np.asarray(args.asset_translation) |
| if args.enable_room_alignment and objects and not args.no_auto_asset_align: |
| |
| bounds_paths = [p.with_suffix(".obj") if p.suffix == ".glb" else p for p in objects] |
| lo, hi = obj_collection_bounds(bounds_paths) |
| room_center_world = room_R @ ((lo + hi) * 0.5) |
| camera_positions = np.array([np.asarray(c["T_c2w"], float)[:3, 3] / 1000.0 for c in zc.values()]) |
| camera_center = (camera_positions.min(axis=0) + camera_positions.max(axis=0)) * 0.5 |
| translation[[0, 2]] += camera_center[[0, 2]] - room_center_world[[0, 2]] |
| print(f"Auto room alignment translation: {translation.round(3).tolist()} m") |
| rr.log("world/room", rr.Transform3D(translation=translation, mat3x3=room_R), static=True) |
| if args.enable_room_controls: |
| room_base_translation, room_rotation = translation.copy(), room_R.copy() |
| palette = [(230, 92, 92), (239, 158, 64), (230, 205, 80), (86, 190, 116), |
| (65, 185, 205), (78, 135, 225), (145, 105, 210), (215, 95, 175), |
| (155, 115, 82), (120, 175, 155)] |
| for i, obj in enumerate(objects): |
| |
| |
| textured = obj.name in ("mesh.glb", "mesh.obj") |
| name = obj.parent.name if textured else obj.stem |
| if textured: |
| rr.log(f"world/room/objects/{name}", rr.Asset3D(path=obj), static=True) |
| else: |
| rr.log(f"world/room/objects/{name}", |
| rr.Asset3D(path=obj, albedo_factor=palette[i % len(palette)]), static=True) |
|
|
| zed_color = (60, 220, 90) |
| for cid in zed_ids: |
| c = zc[cid]; path = f"world/cameras/zed/cam{cid}" |
| log_camera_static(path, np.asarray(c["T_c2w"]), np.asarray(c["K"]), c["width"], c["height"], zed_color) |
|
|
| for cid, c in load_optitrack_cameras(args.optitrack_calib).items(): |
| log_camera_static(f"world/cameras/optitrack/cam{cid}", c["T_c2w"], c["K"], c["width"], c["height"], (65, 135, 255)) |
|
|
| rig = json.loads(args.homie_calib.read_text())["T_homie_cam"] |
| Rrect, Kh = homie_rectification(args.homie_camchain) |
| frames, positions, quats = read_homie_poses(case / "objects/rb_Homie.csv") |
| end = np.inf if args.duration is None else args.start + args.duration |
|
|
| def homie_cam_T(Twh: np.ndarray, cam: str) -> np.ndarray: |
| if cam == "front_left": |
| Tl = Twh @ np.asarray(rig["front_left"], float) |
| Tr = Twh @ np.asarray(rig["front_right"], float) |
| Tl[:3, :3] = Tl[:3, :3] @ Rrect["front_left"].T |
| Tr[:3, :3] = Tr[:3, :3] @ Rrect["front_right"].T |
| T = np.eye(4) |
| T[:3, 3] = (Tl[:3, 3] + Tr[:3, 3]) * 0.5 |
| T[:3, :3] = rotation_midpoint(Tl[:3, :3], Tr[:3, :3]) |
| return T |
| T = Twh @ np.asarray(rig[cam], float) |
| T[:3, :3] = T[:3, :3] @ Rrect[cam].T |
| return T |
|
|
| if args.full_video: |
| |
| keep = (frames / 60.0 >= args.start) & (frames / 60.0 <= end) |
| for frame, pos, quat in zip(frames[keep], positions[keep], quats[keep]): |
| rr.set_time("time", duration=float(frame) / 60.0) |
| Rwh = quat_xyzw_to_mat(quat) |
| rr.log("world/optitrack/homie_rigid_body", rr.Transform3D(translation=pos, mat3x3=Rwh)) |
| rr.log("world/optitrack/homie_rigid_body", rr.TransformAxes3D(axis_length=0.25)) |
| Twh = np.eye(4); Twh[:3, :3], Twh[:3, 3] = Rwh, pos * 1000.0 |
| for cam in homie_ids: |
| T = homie_cam_T(Twh, cam) |
| rr.log(f"world/cameras/homie/{cam}", rr.Transform3D(translation=T[:3, 3]/1000.0, mat3x3=T[:3, :3])) |
| else: |
| |
| |
| i = int(np.argmin(np.abs(frames / 60.0 - args.start))) |
| Rwh = quat_xyzw_to_mat(quats[i]) |
| rr.log("world/optitrack/homie_rigid_body", |
| rr.Transform3D(translation=positions[i], mat3x3=Rwh), static=True) |
| rr.log("world/optitrack/homie_rigid_body", rr.TransformAxes3D(axis_length=0.25), static=True) |
| Twh = np.eye(4); Twh[:3, :3], Twh[:3, 3] = Rwh, positions[i] * 1000.0 |
| for cam in homie_ids: |
| T = homie_cam_T(Twh, cam) |
| rr.log(f"world/cameras/homie/{cam}", |
| rr.Transform3D(translation=T[:3, 3]/1000.0, mat3x3=T[:3, :3]), static=True) |
| for cam in homie_ids: |
| rr.log(f"world/cameras/homie/{cam}", rr.Pinhole(image_from_camera=Kh, width=1024, height=1024, |
| camera_xyz=rr.ViewCoordinates.RDF, image_plane_distance=0.24, color=(255, 105, 55)), static=True) |
|
|
| if not args.no_video: |
| export = json.loads((case / "videos/export_info.json").read_text()) |
| origins = {v["file"]: float(v["start_optitrack_time_s"]) for v in export["videos"]} |
| for cid in zed_ids: |
| name = f"zed_cam{cid}.mp4"; path = f"world/cameras/zed/cam{cid}/rgb" |
| if args.full_video: log_video(path, case/"videos"/name, origins[name]) |
| else: log_video_frame(path, case/"videos"/name, origins[name], args.start, flip_vertical=True) |
| for cam in homie_ids: |
| name = HOMIE_VIDEO[cam]; path = f"world/cameras/homie/{cam}/rgb" |
| if args.full_video: log_video(path, case/"videos"/name, origins[name]) |
| else: log_video_frame(path, case/"videos"/name, origins[name], args.start) |
|
|
| if not args.no_smpl: |
| |
| |
| _, faces = load_obj(case / "viz/human/poses_template.obj") |
| verts, source_fps = open_pc2(case / "viz/human/poses_motion.pc2") |
| i = min(len(verts) - 1, max(0, int(round(args.start * source_fps)))) |
| rr.log("world/human/smplx", rr.Mesh3D(vertex_positions=verts[i], triangle_indices=faces, |
| vertex_colors=(115, 170, 255, 210)), static=True) |
| rr.send_blueprint(blueprint(zed_ids, homie_ids)) |
| print("Rerun logging complete.") |
| if web_rrd is not None: |
| rr.disconnect() |
| server_proc = start_headless_server(web_rrd, args.web_port, args.server_memory) |
| print(f"Headless Web Viewer loaded {web_rrd}.") |
| proxy_port = args.web_port + 1 |
| control_port = args.control_port |
| if control_port is None: |
| for candidate in range(args.web_port + 2, args.web_port + 22): |
| with socket.socket() as check: |
| if check.connect_ex(("127.0.0.1", candidate)) != 0: |
| control_port = candidate |
| break |
| else: |
| raise RuntimeError("No free control port found; pass --control-port") |
| if room_base_translation is not None: |
| alignment_ui, alignment_stream = launch_alignment_ui( |
| room_base_translation, room_rotation, proxy_port, control_port, recording_id) |
| print("On your LOCAL machine run:") |
| forwards = f"-L {args.web_port}:127.0.0.1:{args.web_port} -L {proxy_port}:127.0.0.1:{proxy_port}" |
| if alignment_ui is not None: |
| forwards += f" -L {control_port}:127.0.0.1:{control_port}" |
| print(f" ssh -N {forwards} acerobotics@SERVER") |
| print("Then open:") |
| print(f" http://127.0.0.1:{args.web_port}?url=rerun%3A%2F%2Flocalhost%3A{proxy_port}%2Fproxy") |
| if alignment_ui is not None: |
| print(f"Room alignment controls: http://127.0.0.1:{control_port}") |
| if server_proc is not None: |
| print("Web Viewer is ready. Keep this process running; press Ctrl+C after viewing.") |
| try: |
| server_proc.wait() |
| except KeyboardInterrupt: |
| print("\nStopping Web Viewer...") |
| if alignment_ui is not None: |
| alignment_ui.close() |
| server_proc.terminate() |
| try: |
| server_proc.wait(timeout=5) |
| except subprocess.TimeoutExpired: |
| server_proc.kill() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
