Upload Calibration

Room-scale/calibration/README.md

@@ -0,0 +1,140 @@
+# Camera Calibration
+
+Calibration files for the capture rig used in all released takes:
+
+- **8 static ZED cameras** (`zed_cam0`–`zed_cam7`, 1920×1080)
+- **4 egocentric fisheye cameras** on the head-mounted "Homie" rig
+  (`front_left`, `front_right`, `back_left`, `back_right`, 1088×1280)
+- **OptiTrack Motive** motion-capture system (rigid-body / skeleton tracking)
+
+**World frame:** everything shares the OptiTrack Motive world frame — **Y-up,
+millimeters** — identical to the Motive CSV exports (`raw/mocap_raw/*.csv`,
+`raw/object_mocap_raw/rb_*.csv`) in each take. Camera axes follow the OpenCV
+convention (+Z forward, +X right, +Y down).
+
+**Take layout:** released takes use `raw/{egocentric_raw,exocentric_raw,mocap_raw,object_mocap_raw}`
+(formerly `homie/`, `zed/`, `motive/`, `objects/`), `timeline/` (formerly
+`preprocess/` + the top-level sync CSVs), `motions/` (formerly `viz/`), and
+`videos_and_annotations/` (formerly `videos/`, plus the projection renders).
+Raw frame dumps (`homie/frames`, `zed/frames`) and `.svo2` recordings are not
+shipped.
+
+## Files
+
+| File | Content |
+|------|---------|
+| `zed_intrinsics.json` | Per-ZED intrinsics: `K` (3×3), `dist` (8-coeff OpenCV rational model `[k1,k2,p1,p2,k3,k4,k5,k6]`), image size. Keys `"0"`–`"7"` = `zed_cam0`–`zed_cam7`. |
+| `zed_poses_0622.json` | Per-ZED extrinsics `T_c2w` (4×4 camera→world, mm) plus a copy of K/dist. Calibrated 2026-06-22 with an AprilTag board tracked by OptiTrack; valid for every released take. `meta` documents the method and residuals. |
+| `homie-camchain.yaml` | Homie fisheye intrinsics + cam-to-cam chain (kalibr format): pinhole + `equidistant` (Kannala–Brandt, use `cv2.fisheye`), `intrinsics = [fx, fy, cx, cy]`. **Note: `T_cn_cnm1` translations here are in meters** (kalibr convention), unlike the mm world frame. |
+| `homie_rig_calib.json` | Hand–eye result `T_homie_cam` (4×4 camera→rig, mm) mapping each fisheye camera into the frame of the OptiTrack rigid body named "Homie", plus per-camera residual time delays `delays_s` (~2 ms). |
+| `Calibration-Exported.mcal` | OptiTrack Motive calibration export (poses of the 12 IR mocap cameras, same world frame). Only needed if you want the mocap cameras themselves. |
+
+### Camera name mappings
+
+ZED index ↔ device serial (index = ascending serial order;
+`videos_and_annotations/zed_camN.mp4` in each take):
+
+| index | serial | | index | serial |
+|-------|-----------|-|-------|-----------|
+| cam0 | 302899467 | | cam4 | 306087165 |
+| cam1 | 303008978 | | cam5 | 306714077 |
+| cam2 | 304203361 | | cam6 | 306854655 |
+| cam3 | 304866636 | | cam7 | 308314642 |
+
+Homie camera ↔ camchain key ↔ raw frame folder (capture-pipeline
+`homie/frames/<folder>`, not shipped in released takes):
+
+| camera | camchain key | raw frame folder |
+|--------------|--------|------|
+| front_left | cam0 | cam2 |
+| front_right | cam1 | cam1 |
+| back_left | cam2 | cam0 |
+| back_right | cam3 | cam3 |
+
+(The released `videos_and_annotations/homie_*.mp4` are already named by
+camera, so the folder mapping only matters if you work with raw frame dumps.
+Note these mp4s are the **rectified 1024×1024 pinhole** views, not the raw
+1088×1280 fisheye frames — see `--rectified` below.)
+
+## How to use
+
+### Project a 3D point into a ZED video
+
+```python
+import json, numpy as np, cv2
+
+cams = json.load(open("zed_poses_0622.json"))["cameras"]
+c = cams["3"]                                  # zed_cam3
+T_w2c = np.linalg.inv(np.array(c["T_c2w"]))    # world -> camera
+K, dist = np.array(c["K"]), np.array(c["dist"])
+
+p_w = np.array([x_mm, y_mm, z_mm, 1.0])        # OptiTrack world point, mm
+p_c = (T_w2c @ p_w)[:3]
+uv, _ = cv2.projectPoints(p_c.reshape(1, 1, 3), np.zeros(3), np.zeros(3), K, dist)
+```
+
+Any point from `raw/object_mocap_raw/rb_*.csv`, the Motive take CSV
+(`raw/mocap_raw/*.csv`), or the SMPL-X track can be projected this way — they
+are all already in the same world frame.
+
+### Per-frame Homie (egocentric) camera poses
+
+The rig moves, so its camera poses are per-frame:
+`T_world_cam(t) = T_world_homie(t + delay_cam) @ T_homie_cam`, where
+`T_world_homie(t)` is the "Homie" rigid-body pose from the take's Motive CSV
+and `T_homie_cam` comes from `homie_rig_calib.json`.
+
+`scripts/homie_extrinsics.py` does all of this (rigid-body interpolation,
+per-camera delays, fisheye intrinsics) and writes one JSON with intrinsics +
+per-frame `world→cam` matrices. Point it at a take directory:
+
+```bash
+python scripts/homie_extrinsics.py /mnt/sync_data/<take> --out <take>/homie_poses.json
+```
+
+It reads the take's `raw/mocap_raw/*.csv` and `timeline/sync_timeline.csv`
+(present in every take; the frame list comes from the sync CSV, so the
+missing raw frame dumps don't matter). Intrinsics come from the take's own
+`calibration_cache` when present, else the shared `homie-camchain.yaml`.
+The old capture-pipeline invocation (`<take>/homie/frames`) still works.
+
+By default the output matches the **raw fisheye** frames — project with
+`cv2.fisheye.projectPoints` and the `equidistant` coefficients. To work with
+the released `videos_and_annotations/homie_*.mp4` (rectified 1024×1024
+pinhole views) pass `--rectified`; video frame `i` corresponds to
+`sync_timeline.csv` record `i`.
+
+### Full-scene sanity check (Rerun viewer)
+
+`scripts/visualize/` is a self-contained viewer that loads every calibration
+file in this folder, places all camera frustums in the OptiTrack world, and
+overlays the synchronized RGB streams and the SMPL-X body mesh:
+
+```bash
+cd scripts/visualize
+pip install -r requirements.txt
+python visualize_case.py <take-dir> --no-room-assets
+```
+
+(`--no-room-assets` because the optional room-mesh assets are not shipped
+here; see its `README.md` for viewing over SSH and more options.)
+
+## Synchronization
+
+Streams inside a take are already synchronized: `videos_and_annotations/*.mp4`
+are the synced exports, `timeline/sync_timeline.csv` maps frame indices across
+ZED / Homie / OptiTrack (Homie↔OptiTrack clock offset already folded in;
+`timeline/homie_time_offset.json` records it), and `timeline/timestamps.csv`
+holds per-frame timestamps. The `delays_s` in `homie_rig_calib.json` are small
+residual per-camera offsets (~2 ms) that `homie_extrinsics.py` applies
+automatically.
+
+## Accuracy / provenance
+
+- ZED extrinsics (2026-06-22): AprilTag board (4×4 grid, 125 mm tags) tracked
+  by OptiTrack; 20 258 board poses, 3 882 IR-verified; median marker
+  consistency ≈ 39 mm, IR reprojection median ≈ 7.5 px (see `meta` in
+  `zed_poses_0622.json`).
+- Homie hand–eye (2026-06-25, take `2026-06-25-19:49:06`): 1 563 board views,
+  reprojection median 1.64 px / p90 2.54 px (see `meta` in
+  `homie_rig_calib.json`).

Room-scale/calibration/homie-camchain.yaml

@@ -0,0 +1,47 @@
+cam0:
+  cam_overlaps: [1, 2, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05761959903731187, 0.0029356256212510054, -0.006634361165985679, 0.0017843379743501806]
+  distortion_model: equidistant
+  intrinsics: [395.00109559502636, 394.7747916429034, 536.1617651628547, 673.6553587142616]
+  resolution: [1088, 1280]
+  rostopic: /cam2/image_raw
+cam1:
+  T_cn_cnm1:
+  - [-0.8757267034226962, -0.4334105804454474, -0.21273929977874914, -0.03558586437354394]
+  - [0.430325390635062, -0.5008877925235563, -0.7509537119394611, -0.1266418904865405]
+  - [0.21891276593016093, -0.7491773408605029, 0.625148392666883, -0.06172188622562206]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 2, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05447515001895322, -0.004585362477944007, -0.0014068764700961882, 0.0007025151712548356]
+  distortion_model: equidistant
+  intrinsics: [393.55340406395106, 393.28715684686443, 542.2206853120093, 657.4503753501341]
+  resolution: [1088, 1280]
+  rostopic: /cam1/image_raw
+cam2:
+  T_cn_cnm1:
+  - [-0.5375188088397032, 0.24936962591266637, 0.8055360450133361, 0.12970697966945538]
+  - [-0.25669503412415545, 0.8615487000157906, -0.4379971426357756, -0.07346810254112937]
+  - [-0.8032317160069996, -0.4422088049477103, -0.39908668635670197, -0.22362519911425208]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 1, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05836168773666623, 0.0007872549620501365, -0.00629456849079218, 0.002390768156079088]
+  distortion_model: equidistant
+  intrinsics: [395.4542533845256, 395.5537951778382, 545.8560606598916, 657.9798005111777]
+  resolution: [1088, 1280]
+  rostopic: /cam0/image_raw
+cam3:
+  T_cn_cnm1:
+  - [-0.6251662803454691, 0.4297032782530559, -0.6515536927817833, -0.10028190094522217]
+  - [-0.43520354339784484, 0.5010539057936366, 0.7480259750188444, 0.11509551220532377]
+  - [0.6478927362866185, 0.75119909221691, -0.1262336172321775, -0.17129991531294733]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 1, 2]
+  camera_model: pinhole
+  distortion_coeffs: [-0.056216443478993725, -0.005317845099511976, -6.621165624969179e-05, 0.00011839559082425627]
+  distortion_model: equidistant
+  intrinsics: [395.72395165269614, 395.26038160815466, 538.9967644789181, 641.4500725845512]
+  resolution: [1088, 1280]
+  rostopic: /cam3/image_raw

Room-scale/calibration/homie_rig_calib.json

@@ -0,0 +1,121 @@
+{
+ "T_homie_cam": {
+  "front_left": [
+   [
+    -0.3549473773367149,
+    0.7731296300861267,
+    0.5256262307045535,
+    93.11548227007071
+   ],
+   [
+    -0.7610144640058892,
+    0.08762696025357442,
+    -0.6427896245355453,
+    -57.96410434109294
+   ],
+   [
+    -0.5430187334665505,
+    -0.6281656556352053,
+    0.5572598713210704,
+    132.95426611968767
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "front_right": [
+   [
+    -0.13452028496833032,
+    -0.9345983032879102,
+    -0.32928757101263073,
+    -49.311461444736125
+   ],
+   [
+    0.7693416456168276,
+    0.11092852405914028,
+    -0.6291329707380244,
+    -58.8735087137323
+   ],
+   [
+    0.6245139912376908,
+    -0.33796578827067636,
+    0.7041032599746637,
+    155.1038195428959
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "back_left": [
+   [
+    -0.427519343994489,
+    -0.6254046380017881,
+    0.6527604838502205,
+    104.87394699848096
+   ],
+   [
+    -0.8917437243280575,
+    0.17322360831466832,
+    -0.418075007198435,
+    -17.983993816986075
+   ],
+   [
+    0.14839252215676835,
+    -0.7608302177807467,
+    -0.6317571044948007,
+    -60.001207100533925
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "back_right": [
+   [
+    -0.4364460688534747,
+    0.35727935820319107,
+    -0.8257519537877362,
+    -119.74332013301124
+   ],
+   [
+    0.8997196441230979,
+    0.16881707394472178,
+    -0.4024988913323215,
+    -15.546167795409245
+   ],
+   [
+    -0.004403516930124807,
+    -0.9186143128357285,
+    -0.3951308052936245,
+    -23.633891937619335
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ]
+ },
+ "delays_s": {
+  "front_left": 0.002258018664379698,
+  "front_right": 0.0020811559852302918,
+  "back_left": 0.0024979296001485622,
+  "back_right": 0.002134785077434174
+ },
+ "meta": {
+  "source_take": "2026-06-25-19:49:06",
+  "reproj_px_median": 1.6397870960141963,
+  "reproj_px_p90": 2.540545231473632,
+  "n_board_views": 1563,
+  "generated_at": "2026-06-25T20:33:10"
+ }
+}

Room-scale/calibration/scripts/homie_extrinsics.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python3
+"""
+homie_extrinsics.py — per-frame camera poses for the 4-fisheye Homie rig.
+
+Input : a take directory in the released layout, e.g.
+            python homie_extrinsics.py /mnt/sync_data/<take>
+        detected by the presence of `raw/egocentric_raw/`; it reads the Motive
+        export from `raw/mocap_raw/*.csv` and the frame<->time mapping from
+        `timeline/sync_timeline.csv`. The raw fisheye frame dumps are not
+        shipped in this layout — that's fine: the frame list comes from
+        sync_timeline.csv, images are only needed for --debug.
+        Backwards compatible: a capture-pipeline `homie/frames/` folder still
+        works (Motive at `motive/*.csv`, sync at `sync_timeline.csv`,
+        intrinsics at `homie/calibration_cache/*/camchain.yaml`).
+
+        NOTE the released `videos_and_annotations/homie_*.mp4` are the
+        RECTIFIED 1024x1024 pinhole views (old cam_frames/), not the raw
+        1088x1280 fisheye frames — pass --rectified to get poses+intrinsics
+        that match those videos (video frame i = sync_timeline record i).
+Output: one JSON file
+        {
+          "intrinsics": { "<cam_id>": {model, fx, fy, cx, cy, dist:[k1..k4], width, height} },
+          "extrinsics": { "<frame.jpg>": { "<cam_id>": [[4x4 world->cam, mm]] } }
+        }
+        World frame = OptiTrack/Motive global frame (mm). A 3D world point p projects with
+        the camera's Kannala-Brandt model after  p_cam = (world->cam) @ [p; 1].
+
+Pose model:  T_world_cam(t) = T_world_homie(t + dt_cam) @ T_homie_cam
+In the current multi-marker capture pipeline sync_timeline.csv already folds in the
+Homie<->OptiTrack clock offset, so the residual global delay is ~0 and the 4 cameras are
+mutually synced (<2 ms).  Both delays are still configurable via --global-delay / --delay.
+
+The rig extrinsics T_homie_cam are a fixed calibration loaded from an external JSON
+(--calib, default homie_rig_calib.json found next to this script or in its parent folder)
+produced by calibrate_handeye.py; future takes need only OptiTrack tracking of the "Homie"
+rigid body — no calibration board.  Recompute the calibration with calibrate_handeye.py
+if the Homie marker set / rigid-body frame changes.  Fisheye intrinsics fall back to the
+shared homie-camchain.yaml when a take ships no per-take calibration_cache.
+"""
+import os, csv, glob, json, argparse
+import numpy as np
+import cv2
+from scipy.spatial.transform import Rotation as R, Slerp
+
+# cam_id -> (raw frame sub-folder, camchain key).  Order = camchain cam0..cam3 / debug 2x2 grid.
+CAMS = {
+    "front_left":  ("cam2", "cam0"),
+    "front_right": ("cam1", "cam1"),
+    "back_left":   ("cam0", "cam2"),
+    "back_right":  ("cam3", "cam3"),
+}
+ORDER = ["front_left", "front_right", "back_left", "back_right"]
+
+# The rig calibration (T_homie_cam + per-camera time delays) is NOT hard-coded: it is loaded
+# from an external JSON produced by calibrate_handeye.py (default homie_rig_calib.json next to
+# this script).  Re-run calibrate_handeye.py whenever the Homie marker set / rigid-body frame
+# changes; homie_extrinsics.py then just picks up the new file.
+def _default_file(name):
+    """Locate a calibration file next to this script, else in its parent folder."""
+    here = os.path.dirname(os.path.abspath(__file__))
+    for d in (here, os.path.dirname(here)):
+        p = os.path.join(d, name)
+        if os.path.isfile(p):
+            return p
+    return os.path.join(here, name)
+
+DEFAULT_CALIB = _default_file("homie_rig_calib.json")
+
+# Last-resort Homie camchain (intrinsics), used only when a take has no per-take
+# homie/calibration_cache/*/camchain.yaml (e.g. it was rectified straight from a repo
+# camchain and never got a cache). Prefer the take's own calibration — see _resolve_camchain.
+DEFAULT_CAMCHAIN = _default_file("homie-camchain.yaml")
+
+def load_calib(path):
+    """Load {cam_id: T_homie_cam 4x4 (np)} and {cam_id: delay_s} from a calibration JSON."""
+    c = json.load(open(path))
+    X = {cam: np.array(c["T_homie_cam"][cam], float) for cam in ORDER}
+    delays = {cam: float(c.get("delays_s", {}).get(cam, 0.0)) for cam in ORDER}
+    return X, delays, c.get("meta", {})
+
+# -------------------------------------------------------------------------- helpers
+def inv_T(T):
+    Ri = T[:3, :3].T
+    out = np.eye(4); out[:3, :3] = Ri; out[:3, 3] = -Ri @ T[:3, 3]
+    return out
+
+def load_intrinsics(camchain_path):
+    import yaml
+    cc = yaml.safe_load(open(camchain_path))      # keyed by camchain entry name cam0..cam3
+    by_key = {}
+    for key, c in cc.items():
+        fx, fy, cx, cy = c["intrinsics"]
+        by_key[key] = dict(model="kannala_brandt", fx=fx, fy=fy, cx=cx, cy=cy,
+                           dist=list(c["distortion_coeffs"]),
+                           width=int(c["resolution"][0]), height=int(c["resolution"][1]))
+    return cc, by_key
+
+def camchain_K_D(cc, key):
+    c = cc[key]
+    fx, fy, cx, cy = c["intrinsics"]
+    K = np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1]], float)
+    return K, np.array(c["distortion_coeffs"], float)
+
+class RigidBody:
+    """Per-frame OptiTrack rigid-body pose with time interpolation (SLERP + linear)."""
+    def __init__(self, t, quats_xyzw, pos_mm):
+        self.t = np.asarray(t); self.slerp = Slerp(self.t, R.from_quat(quats_xyzw))
+        self.pos = np.asarray(pos_mm)
+    def pose_at(self, tq):
+        tq = float(np.clip(tq, self.t[0], self.t[-1]))
+        T = np.eye(4); T[:3, :3] = self.slerp([tq]).as_matrix()[0]
+        T[:3, 3] = [np.interp(tq, self.t, self.pos[:, i]) for i in range(3)]
+        return T
+
+def parse_motive(csv_path):
+    r = list(csv.reader(open(csv_path)))
+    typ, name, rp, ax = r[2], r[3], r[6], r[7]
+    data = r[8:]
+    times = np.array([float(row[1]) for row in data if row[0] not in ("", "Frame")])
+    cols = {}
+    for i, (t, n, p, a) in enumerate(zip(typ, name, rp, ax)):
+        if t == "Rigid Body":
+            cols.setdefault(n, {})[(p, a)] = i
+    bodies = {}
+    for n, c in cols.items():
+        try:
+            qc = [c[("Rotation", a)] for a in "XYZW"]; pc = [c[("Position", a)] for a in "XYZ"]
+        except KeyError:
+            continue
+        q, p, tt = [], [], []
+        for row, tm in zip(data, times):
+            if all(row[k] not in ("", None) for k in qc + pc):
+                q.append([float(row[k]) for k in qc]); p.append([float(row[k]) for k in pc]); tt.append(tm)
+        if len(tt) >= 2:
+            bodies[n] = RigidBody(tt, q, p)
+    return bodies
+
+def parse_sync(sync_csv):
+    s = list(csv.reader(open(sync_csv)))
+    h = {n: i for i, n in enumerate(s[0])}
+    recs = []
+    for row in s[1:]:
+        fl, of = row[h["homie_front_left"]], row[h["optitrack_frame_idx"]]
+        if not fl or not of:
+            continue
+        diff = float(row[h["homie_diff_ms"]]) if row[h["homie_diff_ms"]] else 0.0
+        recs.append((os.path.basename(fl).replace(".jpg", ""), int(of) / 60.0 + diff / 1000.0))
+    return recs
+
+def project_fisheye(pts_world, T_cam_world, K, D):
+    rvec, _ = cv2.Rodrigues(T_cam_world[:3, :3]); tvec = T_cam_world[:3, 3]
+    proj, _ = cv2.fisheye.projectPoints(pts_world.reshape(-1, 1, 3).astype(np.float64), rvec, tvec, K, D)
+    cam = (T_cam_world[:3, :3] @ pts_world.T).T + T_cam_world[:3, 3]
+    return proj.reshape(-1, 2), cam[:, 2] > 1.0      # pixels, in-front mask
+
+def project_pinhole(pts_world, T_cam_world, K):
+    cam = (T_cam_world[:3, :3] @ pts_world.T).T + T_cam_world[:3, 3]
+    uv = (K @ cam.T).T
+    return uv[:, :2] / uv[:, 2:3], cam[:, 2] > 1.0   # pixels, in-front mask
+
+# -------------------------------------------------------------------------- rectified (pinhole) views
+# cam_frames/ are stereo-rectified pinhole views (see video-sync .../core/rectify.py).
+# Each rectified camera is the physical fisheye camera rotated by a fixed R_rect about its
+# optical centre; the intrinsic becomes a plain pinhole K_rect (no distortion).
+RECTIFY = dict(fov_deg=90.0, out=1024, zoom=0.78125, pitch=-5.0, yaw=0.0, roll=0.0)  # from rectify_report.json
+# stereo pairs as (camchain_key, cam_id): pair0 = front, pair1 = back; member0 -> R1, member1 -> R2
+RECT_PAIRS = [(("cam0", "front_left"), ("cam1", "front_right")),
+              (("cam2", "back_left"),  ("cam3", "back_right"))]
+
+def _euler(pitch, yaw, roll):       # matches rectify.py _euler_to_rotation_matrix
+    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 rectify_params(cc):
+    """({cam_id: R_rect (3x3, physical->rectified)}, K_rect (3x3 pinhole)), matching cam_frames/."""
+    cfg = RECTIFY
+    R_view = _euler(cfg["pitch"], cfg["yaw"], cfg["roll"])
+    W = cfg["out"]; fx = W / (2*np.tan(np.radians(cfg["fov_deg"])/2)) * cfg["zoom"]
+    Krect = np.array([[fx, 0, W/2.0], [0, fx, W/2.0], [0, 0, 1.0]])
+    Rr = {}
+    for (lk, lcam), (rk, rcam) in RECT_PAIRS:
+        K0, D0 = camchain_K_D(cc, lk); K1, D1 = camchain_K_D(cc, rk)
+        size = (int(cc[lk]["resolution"][0]), int(cc[lk]["resolution"][1]))
+        T = np.array(cc[rk]["T_cn_cnm1"], float)
+        R1, R2, *_ = cv2.fisheye.stereoRectify(
+            K0, D0.reshape(4, 1), K1, D1.reshape(4, 1), size, T[:3, :3], T[:3, 3],
+            flags=cv2.CALIB_ZERO_DISPARITY, newImageSize=size, balance=0.0, fov_scale=1.0)
+        Rr[lcam] = R_view @ R1
+        Rr[rcam] = R_view @ R2
+    return Rr, Krect
+
+# -------------------------------------------------------------------------- main
+def _resolve_camchain(homie_dir):
+    """Locate the Homie camchain (intrinsics) for a take, tolerating a missing cache.
+
+    Preference order (so takes rectified without a per-take calibration_cache still work
+    instead of crashing with IndexError):
+      1. the take's own homie/calibration_cache/*/camchain.yaml (normal case);
+      2. the camchain the take was rectified with, recorded in
+         homie/cam_frames/rectify_report.json ("calibration_json_path") — per-take correct;
+      3. the repo default DEFAULT_CAMCHAIN (current Homie unit).
+    """
+    hits = sorted(glob.glob(os.path.join(homie_dir, "calibration_cache", "*", "camchain.yaml")))
+    if hits:
+        return hits[0]
+    report = os.path.join(homie_dir, "cam_frames", "rectify_report.json")
+    if os.path.isfile(report):
+        try:
+            cc = (json.load(open(report)) or {}).get("calibration_json_path")
+        except Exception:
+            cc = None
+        if cc and os.path.isfile(cc):
+            print(f"[camchain] {homie_dir}: no calibration_cache; using rectify_report camchain {cc}", flush=True)
+            return cc
+    if os.path.isfile(DEFAULT_CAMCHAIN):
+        print(f"[camchain] {homie_dir}: no calibration_cache/rectify_report; using default {DEFAULT_CAMCHAIN}", flush=True)
+        return DEFAULT_CAMCHAIN
+    raise FileNotFoundError(
+        f"No Homie camchain for take at {homie_dir}: none under calibration_cache/*/camchain.yaml, "
+        f"no usable calibration_json_path in cam_frames/rectify_report.json, and no default at "
+        f"{DEFAULT_CAMCHAIN}.")
+
+def resolve_paths(path):
+    """Accept either a take directory in the released layout
+    (<take>/raw/egocentric_raw + <take>/timeline/sync_timeline.csv) or, for
+    backwards compatibility, a capture-pipeline homie/frames/ folder."""
+    path = os.path.abspath(path)
+    if os.path.isdir(os.path.join(path, "raw", "egocentric_raw")):
+        take_dir = path
+        homie_dir = os.path.join(take_dir, "raw", "egocentric_raw")
+        frames_dir = os.path.join(homie_dir, "frames")  # raw frame dumps are not shipped; only used by --debug
+        motive_glob = os.path.join(take_dir, "raw", "mocap_raw", "*.csv")
+        sync = os.path.join(take_dir, "timeline", "sync_timeline.csv")
+        toff = os.path.join(take_dir, "timeline", "homie_time_offset.json")
+    else:
+        frames_dir = path
+        homie_dir = os.path.dirname(frames_dir)
+        take_dir = os.path.dirname(homie_dir)
+        motive_glob = os.path.join(take_dir, "motive", "*.csv")
+        sync = os.path.join(take_dir, "sync_timeline.csv")
+        toff = os.path.join(take_dir, "homie_time_offset.json")
+    camchain = _resolve_camchain(homie_dir)
+    csvs = [f for f in glob.glob(motive_glob)
+            if "frames" not in os.path.basename(f) and "Manus" not in f]
+    return dict(frames=frames_dir, take=take_dir, camchain=camchain,
+                motive=csvs[0], sync=sync, time_offset=toff)
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("frames_dir",
+                    help="a take directory (released layout with raw/egocentric_raw + timeline/), "
+                         "or a capture-pipeline homie/frames/ folder (old layout)")
+    ap.add_argument("--calib", default=DEFAULT_CALIB,
+                    help="rig calibration JSON from calibrate_handeye.py (T_homie_cam + delays); "
+                         "default homie_rig_calib.json next to this script")
+    ap.add_argument("--delay", nargs=4, type=float, default=None,
+                    metavar=("cam0", "cam1", "cam2", "cam3"),
+                    help="extra per-camera delay in seconds added on top of the calibration delays "
+                         "(cam0..cam3 = front_left,front_right,back_left,back_right)")
+    ap.add_argument("--global-delay", type=float, default=None,
+                    help="extra global delay (s) added to every camera on top of the calibration")
+    ap.add_argument("--out", default="homie_poses.json", help="output JSON path")
+    ap.add_argument("--rectified", action="store_true",
+                    help="output poses+intrinsics for the rectified pinhole views (homie/cam_frames/) "
+                         "instead of the raw fisheye frames")
+    ap.add_argument("--debug", metavar="VIDEO.mp4", default=None,
+                    help="render a 2x2 reprojection-overlay video")
+    ap.add_argument("--debug-step", type=int, default=3, help="use every Nth frame in --debug")
+    ap.add_argument("--objects", default=None,
+                    help="comma-separated rigid-body names to overlay in --debug "
+                         "(default: every OptiTrack rigid body except 'Homie')")
+    args = ap.parse_args()
+
+    P = resolve_paths(args.frames_dir)
+    cc, intr_json = load_intrinsics(P["camchain"])
+    bodies = parse_motive(P["motive"])
+    homie = bodies["Homie"]
+    recs = parse_sync(P["sync"])
+
+    X, base_delay, meta = load_calib(args.calib)
+    g = args.global_delay or 0.0
+    dt = {cam: base_delay[cam] + g + (args.delay[i] if args.delay else 0.0)
+          for i, cam in enumerate(ORDER)}
+    print(f"calib: {os.path.basename(args.calib)} (source {meta.get('source_take','?')}, "
+          f"reproj {meta.get('reproj_px_median','?')} px) ; per-camera dt (ms) = "
+          f"{ {c: round(dt[c]*1000,1) for c in ORDER} }")
+
+    # ---- rectified (pinhole) views: fold in the fixed per-camera rectification rotation ----
+    rect = rectify_params(cc) if args.rectified else None
+    if rect:
+        Rr, Krect = rect
+        print(f"rectified pinhole views: fx=fy={Krect[0,0]:.1f}, cx=cy={Krect[0,2]:.1f}, "
+              f"{RECTIFY['out']}x{RECTIFY['out']}, no distortion")
+
+    # ---- per-frame world->cam ----
+    extr = {}
+    for stem, t in recs:
+        per_cam = {}
+        for cam in ORDER:
+            Tcw = inv_T(homie.pose_at(t + dt[cam]) @ X[cam])     # world -> physical cam
+            if rect:
+                R4 = np.eye(4); R4[:3, :3] = Rr[cam]
+                Tcw = R4 @ Tcw                                    # world -> rectified cam
+            per_cam[cam] = Tcw.tolist()
+        extr[stem + ".jpg"] = per_cam
+
+    if rect:
+        Rr, Krect = rect
+        intrinsics = {cam: dict(model="pinhole", fx=Krect[0, 0], fy=Krect[1, 1],
+                                cx=Krect[0, 2], cy=Krect[1, 2], dist=[0.0, 0.0, 0.0, 0.0],
+                                width=RECTIFY["out"], height=RECTIFY["out"]) for cam in ORDER}
+    else:
+        intrinsics = {cam: intr_json[CAMS[cam][1]] for cam in ORDER}
+    out = {"intrinsics": intrinsics, "extrinsics": extr}
+    json.dump(out, open(args.out, "w"))
+    kind = "rectified pinhole" if rect else "raw fisheye"
+    print(f"wrote {args.out}: {len(extr)} frames x {len(ORDER)} cameras ({kind})")
+
+    if args.debug:
+        sel = [s.strip() for s in args.objects.split(",")] if args.objects else None
+        render_debug(args.debug, P, cc, bodies, homie, recs, X, dt, args.debug_step, rect, sel)
+
+# distinct BGR colors for auto-assigned overlay objects ("Calibration Board" pinned to red)
+_PALETTE = [(0, 165, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255),
+            (255, 128, 0), (128, 0, 255), (0, 255, 128), (200, 200, 0)]
+
+def render_debug(out_mp4, P, cc, bodies, homie, recs, X, dt, step, rect=None, objects=None):
+    # default: every rigid body except the camera rig itself; optionally a user-given subset
+    names = objects if objects else [n for n in bodies if n != "Homie"]
+    missing = [n for n in names if n not in bodies]
+    if missing:
+        print(f"  warning: requested objects not in motive: {missing}")
+    names = [n for n in names if n in bodies]
+    COLORS, i = {}, 0
+    for n in names:
+        if n == "Calibration Board":
+            COLORS[n] = (0, 0, 255)
+        else:
+            COLORS[n] = _PALETTE[i % len(_PALETTE)]; i += 1
+    objs = {n: bodies[n] for n in names}
+    print(f"  overlaying objects: {names}")
+    KD = {cam: camchain_K_D(cc, CAMS[cam][1]) for cam in ORDER}
+    rect_dir = os.path.join(os.path.dirname(P["frames"]), "cam_frames")   # rectified images
+    tile = 512
+    vw = cv2.VideoWriter(out_mp4, cv2.VideoWriter_fourcc(*"mp4v"), 15, (2 * tile, 2 * tile))
+    axes = np.array([[0, 0, 0], [150, 0, 0], [0, 150, 0], [0, 0, 150]], float)
+    for stem, t in recs[::step]:
+        cells = []
+        for cam in ORDER:
+            folder, key = CAMS[cam]; K, D = KD[cam]
+            if rect:
+                img = cv2.imread(os.path.join(rect_dir, cam, stem + ".jpg"))
+                if img is None:
+                    img = np.zeros((RECTIFY["out"], RECTIFY["out"], 3), np.uint8)
+            else:
+                img = cv2.imread(os.path.join(P["frames"], folder, stem + ".jpg"))
+                if img is None:
+                    img = np.zeros((1280, 1088, 3), np.uint8)
+            Tcw = inv_T(homie.pose_at(t + dt[cam]) @ X[cam])
+            if rect:
+                R4 = np.eye(4); R4[:3, :3] = rect[0][cam]; Tcw = R4 @ Tcw
+            for name, rb in objs.items():
+                To = rb.pose_at(t + dt[cam])
+                wp = (To[:3, :3] @ axes.T).T + To[:3, 3]
+                if rect:
+                    ap, infront = project_pinhole(wp, Tcw, rect[1])
+                else:
+                    ap, infront = project_fisheye(wp, Tcw, K, D)
+                o = ap[0]
+                if not infront[0] or not (0 <= o[0] < img.shape[1] and 0 <= o[1] < img.shape[0]):
+                    continue
+                for j, c in zip([1, 2, 3], [(0, 0, 255), (0, 255, 0), (255, 0, 0)]):
+                    if infront[j]:
+                        cv2.line(img, tuple(o.astype(int)), tuple(ap[j].astype(int)), c, 2)
+                cv2.circle(img, tuple(o.astype(int)), 6, COLORS[name], 2)
+                cv2.putText(img, name, tuple((o + [8, -8]).astype(int)),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, COLORS[name], 2)
+            cell = cv2.resize(img, (tile, tile))
+            cv2.putText(cell, cam, (10, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
+            cells.append(cell)
+        grid = np.vstack([np.hstack([cells[0], cells[1]]), np.hstack([cells[2], cells[3]])])
+        vw.write(grid)
+    vw.release()
+    print(f"wrote {out_mp4}")
+
+if __name__ == "__main__":
+    main()

Room-scale/calibration/scripts/visualize/README.md

@@ -0,0 +1,74 @@
+# ZED + Homie + OptiTrack/SMPL Rerun viewer
+
+This tool shows all calibrated camera poses in the OptiTrack Y-up world, places the synchronized RGB stream on every camera frustum, and animates the pre-baked SMPL-X mesh.
+
+By default only one JPEG frame per camera is transferred and placed on its frustum. Pass `--full-video` only when complete video playback is needed.
+
+The default view includes all eight ZED cameras, twelve calibrated OptiTrack IR cameras, and one virtual forehead Homie camera. The Homie camera uses the front-left RGB image and the midpoint pose of the calibrated front-left/right optical cameras.
+
+The individual room object meshes are the opaque, colorful primary geometry, except `table_cook.obj`, which is intentionally excluded. When present, `scene.obj` is also loaded as a translucent neutral context layer to fill geometry missing from the individual parts. Pass `--no-room-assets` to disable all room geometry.
+
+Floor and horizontal center alignment are enabled by default. Add a measured correction with `--asset-translation DX DY DZ` (meters), use `--no-auto-asset-align` to disable only the center heuristic, or `--no-room-alignment` to disable all alignment and CLI offsets.
+
+Persist a manual rotation with `--asset-rotation-deg RX RY RZ`; angles are degrees about world X/Y/Z and compose as `Rz @ Ry @ Rx`.
+
+The Gradio translation/rotation panel starts by default on `web-port + 2`. Use `--no-room-controls` to disable it. Its offsets are applied on top of the automatic alignment result.
+
+When room assets are enabled, the accumulated default correction is `--asset-translation 0.12 -0.52 0.79 --asset-rotation-deg 0 62 0`. Camera frustums use moderately compact image-plane distances: 0.32 m for ZED/OptiTrack and 0.24 m for Homie.
+
+## Install
+
+```bash
+cd /home/acerobotics/visualize
+python -m venv .venv
+.venv/bin/pip install -r requirements.txt
+```
+
+## Run
+
+The server is headless, so run the logger there:
+
+```bash
+.venv/bin/python visualize_case.py /mnt/Datasets/2026-06-27-12:26:35
+```
+
+It first writes a temporary `.rrd`, then starts a persistent Web Viewer for that file on server port 9090. On your **local** machine, create an SSH tunnel (replace the host if needed):
+
+```bash
+ssh -N \
+  -L 9090:127.0.0.1:9090 \
+  acerobotics@AceRobotics-Server01
+```
+
+The data proxy uses the next port, so for `--web-port 9091`, forward both 9091 and 9092. Open the exact URL printed by the script.
+
+If 9090 is occupied by an older server, add `--web-port 9091` and tunnel/open port 9091 instead.
+
+Keep both the SSH tunnel and the server-side logger running while viewing. After logging completes, the logger deliberately stays alive to host the recording; press `Ctrl+C` when finished.
+
+To use a separately managed Rerun server instead, start it with `.venv/bin/rerun --serve-web`, then pass `--connect rerun+http://127.0.0.1:9876/proxy` to the logger.
+
+Useful options:
+
+```bash
+# Quick 10-second check with fewer cameras and a 10 Hz body mesh
+.venv/bin/python visualize_case.py DATA_CASE --zed 0,1 --homie front_left,front_right --duration 10 --mesh-fps 10
+
+# Save a recording instead of opening the viewer
+.venv/bin/python visualize_case.py DATA_CASE --save output.rrd
+
+# Camera-only or mesh-only variants
+.venv/bin/python visualize_case.py DATA_CASE --no-smpl
+.venv/bin/python visualize_case.py DATA_CASE --no-video
+.venv/bin/python visualize_case.py DATA_CASE --full-video
+```
+
+The default calibration snapshots in `config/` correspond to the rig calibration used by this case. Override them with `--zed-calib`, `--homie-calib`, and `--homie-camchain` for a case recorded with different hardware calibration.
+
+Notes:
+
+- The full 225-second case is large. `--mesh-fps 15` is the default compromise; use 5–10 Hz for fast inspection or 60 Hz for every SMPL frame.
+- Default web mode writes a temporary RRD under `/tmp`; use `--save PATH.rrd` if you want to keep the recording permanently.
+- Single-frame mode is the default and needs little proxy memory. Full-video mode can be several GiB; adjust `--server-memory` according to server RAM.
+- ZED images contain lens distortion while Rerun's 3D textured pinhole plane is an ideal pinhole. The supplied calibrated intrinsic matrix provides the correct camera pose and a close frustum; exact distortion-aware reprojection belongs in a separate 2D overlay.
+- Homie videos are the case's 1024×1024 rectified pinhole views, so their image planes use the same rectification as the exported RGB.

Room-scale/calibration/scripts/visualize/config/homie-camchain.yaml

@@ -0,0 +1,47 @@
+cam0:
+  cam_overlaps: [1, 2, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05761959903731187, 0.0029356256212510054, -0.006634361165985679, 0.0017843379743501806]
+  distortion_model: equidistant
+  intrinsics: [395.00109559502636, 394.7747916429034, 536.1617651628547, 673.6553587142616]
+  resolution: [1088, 1280]
+  rostopic: /cam2/image_raw
+cam1:
+  T_cn_cnm1:
+  - [-0.8757267034226962, -0.4334105804454474, -0.21273929977874914, -0.03558586437354394]
+  - [0.430325390635062, -0.5008877925235563, -0.7509537119394611, -0.1266418904865405]
+  - [0.21891276593016093, -0.7491773408605029, 0.625148392666883, -0.06172188622562206]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 2, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05447515001895322, -0.004585362477944007, -0.0014068764700961882, 0.0007025151712548356]
+  distortion_model: equidistant
+  intrinsics: [393.55340406395106, 393.28715684686443, 542.2206853120093, 657.4503753501341]
+  resolution: [1088, 1280]
+  rostopic: /cam1/image_raw
+cam2:
+  T_cn_cnm1:
+  - [-0.5375188088397032, 0.24936962591266637, 0.8055360450133361, 0.12970697966945538]
+  - [-0.25669503412415545, 0.8615487000157906, -0.4379971426357756, -0.07346810254112937]
+  - [-0.8032317160069996, -0.4422088049477103, -0.39908668635670197, -0.22362519911425208]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 1, 3]
+  camera_model: pinhole
+  distortion_coeffs: [-0.05836168773666623, 0.0007872549620501365, -0.00629456849079218, 0.002390768156079088]
+  distortion_model: equidistant
+  intrinsics: [395.4542533845256, 395.5537951778382, 545.8560606598916, 657.9798005111777]
+  resolution: [1088, 1280]
+  rostopic: /cam0/image_raw
+cam3:
+  T_cn_cnm1:
+  - [-0.6251662803454691, 0.4297032782530559, -0.6515536927817833, -0.10028190094522217]
+  - [-0.43520354339784484, 0.5010539057936366, 0.7480259750188444, 0.11509551220532377]
+  - [0.6478927362866185, 0.75119909221691, -0.1262336172321775, -0.17129991531294733]
+  - [0.0, 0.0, 0.0, 1.0]
+  cam_overlaps: [0, 1, 2]
+  camera_model: pinhole
+  distortion_coeffs: [-0.056216443478993725, -0.005317845099511976, -6.621165624969179e-05, 0.00011839559082425627]
+  distortion_model: equidistant
+  intrinsics: [395.72395165269614, 395.26038160815466, 538.9967644789181, 641.4500725845512]
+  resolution: [1088, 1280]
+  rostopic: /cam3/image_raw

Room-scale/calibration/scripts/visualize/config/homie_rig_calib.json

@@ -0,0 +1,121 @@
+{
+ "T_homie_cam": {
+  "front_left": [
+   [
+    -0.3549473773367149,
+    0.7731296300861267,
+    0.5256262307045535,
+    93.11548227007071
+   ],
+   [
+    -0.7610144640058892,
+    0.08762696025357442,
+    -0.6427896245355453,
+    -57.96410434109294
+   ],
+   [
+    -0.5430187334665505,
+    -0.6281656556352053,
+    0.5572598713210704,
+    132.95426611968767
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "front_right": [
+   [
+    -0.13452028496833032,
+    -0.9345983032879102,
+    -0.32928757101263073,
+    -49.311461444736125
+   ],
+   [
+    0.7693416456168276,
+    0.11092852405914028,
+    -0.6291329707380244,
+    -58.8735087137323
+   ],
+   [
+    0.6245139912376908,
+    -0.33796578827067636,
+    0.7041032599746637,
+    155.1038195428959
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "back_left": [
+   [
+    -0.427519343994489,
+    -0.6254046380017881,
+    0.6527604838502205,
+    104.87394699848096
+   ],
+   [
+    -0.8917437243280575,
+    0.17322360831466832,
+    -0.418075007198435,
+    -17.983993816986075
+   ],
+   [
+    0.14839252215676835,
+    -0.7608302177807467,
+    -0.6317571044948007,
+    -60.001207100533925
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ],
+  "back_right": [
+   [
+    -0.4364460688534747,
+    0.35727935820319107,
+    -0.8257519537877362,
+    -119.74332013301124
+   ],
+   [
+    0.8997196441230979,
+    0.16881707394472178,
+    -0.4024988913323215,
+    -15.546167795409245
+   ],
+   [
+    -0.004403516930124807,
+    -0.9186143128357285,
+    -0.3951308052936245,
+    -23.633891937619335
+   ],
+   [
+    0.0,
+    0.0,
+    0.0,
+    1.0
+   ]
+  ]
+ },
+ "delays_s": {
+  "front_left": 0.002258018664379698,
+  "front_right": 0.0020811559852302918,
+  "back_left": 0.0024979296001485622,
+  "back_right": 0.002134785077434174
+ },
+ "meta": {
+  "source_take": "2026-06-25-19:49:06",
+  "reproj_px_median": 1.6397870960141963,
+  "reproj_px_p90": 2.540545231473632,
+  "n_board_views": 1563,
+  "generated_at": "2026-06-25T20:33:10"
+ }
+}

Room-scale/calibration/scripts/visualize/config/zed_poses_0622.json

@@ -0,0 +1,939 @@
+{
+  "meta": {
+    "world_frame": "OptiTrack Motive world (Y-up, mm), identical to the Motive CSV export and the .mcal extrinsics",
+    "convention": "T_c2w: camera\u2192world, X_w = R@X_c + t (OpenCV camera axes: +Z forward, +X right, +Y down). Units: mm.",
+    "board": {
+      "tag_size_mm": 125.0,
+      "tag_gap_mm": 25.0,
+      "grid": 4,
+      "dict": "DICT_6X6_100"
+    },
+    "board_pose_source": "markers",
+    "n_ir_verified_poses": 3882,
+    "n_board_poses": 20258,
+    "ir_reproj_median_px": 7.548271327933806,
+    "marker_dist_p50_mm": 39.12134911198805,
+    "marker_offsets_board_mm": [
+      [
+        -288.62159175255556,
+        -291.06153400015074,
+        25.133356793384934
+      ],
+      [
+        -290.1209460605521,
+        294.3529408890757,
+        26.390675068946763
+      ],
+      [
+        298.1737594059931,
+        -290.8108225513729,
+        25.0169032934206
+      ],
+      [
+        299.03794657445195,
+        297.11916556598663,
+        22.719542171416467
+      ]
+    ],
+    "inputs": {
+      "mcal": "Calibration-Exported.mcal",
+      "zed_intrinsics": "zed_intrinsics.json",
+      "optitrack_dir": "/home/acerobotics/Videos/Calibration_Board_0610_OTE",
+      "zed_dir": "/home/acerobotics/Videos/Calibration_Board_0610_ZED/frames_synsplice_tmp",
+      "timestamps": "/home/acerobotics/Videos/Calibration_Board_0610_ZED/timestamps_opt.csv",
+      "optitrack_csv": "/home/acerobotics/Videos/Calibration_Board_0610/Calibration_Board_0610.csv",
+      "output": "zed_poses_in_optitrack.json",
+      "zed_cameras": "None",
+      "max_frames": "20000",
+      "workers": "None",
+      "subpix": "False",
+      "ir_gamma": "3.0",
+      "min_markers": "2",
+      "min_cams": "3",
+      "max_reproj_cam": "25.0",
+      "max_reproj_frame": "12.0",
+      "max_angle_gap": "360.0",
+      "marker_tol": "150.0",
+      "keep_unverified": "False",
+      "max_board_speed": "50.0",
+      "board_pose_source": "markers",
+      "marker_fit_tol": "10.0",
+      "max_sync_diff_ms": "8.0",
+      "max_reproj_zed": "4.0",
+      "max_corner_radius": "700.0",
+      "huber_delta": "5.0",
+      "trim_ratio": "3.0",
+      "test_fraction": "0.2",
+      "joint_rounds": "3",
+      "ir_weight": "0.1",
+      "marker_weight": "2.0",
+      "refine_offsets": "True"
+    }
+  },
+  "cameras": {
+    "0": {
+      "K": [
+        [
+          736.311,
+          0.0,
+          967.372
+        ],
+        [
+          0.0,
+          735.838,
+          488.696
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1236,
+        0.0684,
+        0.0003,
+        -0.0002,
+        -0.0415,
+        0.1238,
+        0.1235,
+        -0.0557
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.8264854337212932,
+          0.17858117294725595,
+          0.5338825643484792,
+          -4498.1092102048615
+        ],
+        [
+          0.04814999502482596,
+          0.9224529420283858,
+          -0.3830954812083858,
+          1740.7154835801487
+        ],
+        [
+          -0.5608951825659008,
+          0.34232927776040095,
+          0.7537952372908755,
+          -3855.1695492073027
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.8264854337212932,
+          0.04814999502482596,
+          -0.5608951825659008,
+          1471.4602715227556
+        ],
+        [
+          0.17858117294725595,
+          0.9224529420283858,
+          0.34232927776040095,
+          517.2869071643931
+        ],
+        [
+          0.5338825643484792,
+          -0.3830954812083858,
+          0.7537952372908755,
+          5974.330760833986
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.3961210670788421,
+        -0.5978077312089015,
+        0.0712224620681941
+      ],
+      "tvec_w2c_mm": [
+        1471.4602715227556,
+        517.2869071643931,
+        5974.330760833986
+      ],
+      "position_mm": [
+        -4498.1092102048615,
+        1740.7154835801487,
+        -3855.1695492073027
+      ],
+      "reproj": {
+        "train_mean_px": 1.7207454360764707,
+        "train_median_px": 1.4519597739379129,
+        "test_mean_px": 2.354627349748447,
+        "test_median_px": 2.098143603810553,
+        "n_train_frames": 180,
+        "n_trimmed": 6,
+        "n_test_frames": 47,
+        "n_train_corners": 6052
+      }
+    },
+    "1": {
+      "K": [
+        [
+          737.293,
+          0.0,
+          941.367
+        ],
+        [
+          0.0,
+          736.89,
+          540.694
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1276,
+        0.068,
+        0.0003,
+        -0.0002,
+        -0.0468,
+        0.1284,
+        0.1239,
+        -0.0618
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.1273677302838765,
+          0.5611442706308235,
+          0.817859748869288,
+          -3086.3578269629165
+        ],
+        [
+          0.02898380564134284,
+          0.8263289974884052,
+          -0.5624413986544308,
+          1595.3929826393905
+        ],
+        [
+          -0.9914319947897983,
+          -0.04793219636119889,
+          -0.1215117453545661,
+          4665.762385022123
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.1273677302838765,
+          0.02898380564134284,
+          -0.9914319947897983,
+          4186.443157203164
+        ],
+        [
+          0.5611442706308235,
+          0.8263289974884052,
+          -0.04793219636119889,
+          637.2127665859709
+        ],
+        [
+          0.817859748869288,
+          -0.5624413986544308,
+          -0.1215117453545661,
+          3988.4678286535363
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.4694560197186951,
+        -1.6508604641127633,
+        0.48556164327500106
+      ],
+      "tvec_w2c_mm": [
+        4186.443157203164,
+        637.2127665859709,
+        3988.4678286535363
+      ],
+      "position_mm": [
+        -3086.3578269629165,
+        1595.3929826393905,
+        4665.762385022123
+      ],
+      "reproj": {
+        "train_mean_px": 2.9123992347237126,
+        "train_median_px": 2.2898165257514562,
+        "test_mean_px": 4.850453175326985,
+        "test_median_px": 2.715830090531422,
+        "n_train_frames": 627,
+        "n_trimmed": 0,
+        "n_test_frames": 157,
+        "n_train_corners": 18876
+      }
+    },
+    "2": {
+      "K": [
+        [
+          737.587,
+          0.0,
+          959.519
+        ],
+        [
+          0.0,
+          737.055,
+          522.671
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0308,
+        0.0122,
+        0.0004,
+        -0.0001,
+        -0.0083,
+        0.0405,
+        0.0504,
+        -0.0177
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.7645834671851738,
+          -0.23262169861846244,
+          -0.6010817473846294,
+          1695.871702374565
+        ],
+        [
+          -0.07546393812269152,
+          0.893872536651561,
+          -0.44192429471926337,
+          2080.0126065963896
+        ],
+        [
+          0.6400916463680125,
+          0.38324800528112996,
+          0.6658856138241177,
+          -3191.0268291764323
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.7645834671851738,
+          -0.07546393812269152,
+          0.6400916463680125,
+          902.8800932278815
+        ],
+        [
+          -0.23262169861846244,
+          0.893872536651561,
+          0.38324800528112996,
+          -241.8149217997485
+        ],
+        [
+          -0.6010817473846294,
+          -0.44192429471926337,
+          0.6658856138241177,
+          4063.4244892561123
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.46639607911242775,
+        0.7015242808618536,
+        -0.088827222262893
+      ],
+      "tvec_w2c_mm": [
+        902.8800932278815,
+        -241.8149217997485,
+        4063.4244892561123
+      ],
+      "position_mm": [
+        1695.871702374565,
+        2080.0126065963896,
+        -3191.0268291764323
+      ],
+      "reproj": {
+        "train_mean_px": 2.0529125582436367,
+        "train_median_px": 1.7389845200626883,
+        "test_mean_px": 2.336579099817837,
+        "test_median_px": 1.8515414087232207,
+        "n_train_frames": 687,
+        "n_trimmed": 24,
+        "n_test_frames": 170,
+        "n_train_corners": 34480
+      }
+    },
+    "3": {
+      "K": [
+        [
+          737.212,
+          0.0,
+          944.628
+        ],
+        [
+          0.0,
+          736.787,
+          527.42
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1187,
+        0.0765,
+        0.0006,
+        -0.0003,
+        -0.0486,
+        0.119,
+        0.1331,
+        -0.0638
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.24288073954002531,
+          -0.7002303881280003,
+          -0.6713317733450432,
+          621.9878572989348
+        ],
+        [
+          -0.1923931548658246,
+          0.7130788333718614,
+          -0.6741687113459065,
+          1734.8587761666608
+        ],
+        [
+          0.9507858961518441,
+          -0.0345829573509181,
+          -0.30791264790456296,
+          4748.038734726321
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.24288073954002531,
+          -0.1923931548658246,
+          0.9507858961518441,
+          -4029.524439401385
+        ],
+        [
+          -0.7002303881280003,
+          0.7130788333718614,
+          -0.0345829573509181,
+          -637.3550523829739
+        ],
+        [
+          -0.6713317733450432,
+          -0.6741687113459065,
+          -0.30791264790456296,
+          3049.128895898004
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.7053996802643994,
+        1.789034978135712,
+        -0.5600941230037197
+      ],
+      "tvec_w2c_mm": [
+        -4029.524439401385,
+        -637.3550523829739,
+        3049.128895898004
+      ],
+      "position_mm": [
+        621.9878572989348,
+        1734.8587761666608,
+        4748.038734726321
+      ],
+      "reproj": {
+        "train_mean_px": 2.5048194609653915,
+        "train_median_px": 1.9828813362491196,
+        "test_mean_px": 5.296709982790022,
+        "test_median_px": 2.9605944943266476,
+        "n_train_frames": 1009,
+        "n_trimmed": 130,
+        "n_test_frames": 253,
+        "n_train_corners": 36684
+      }
+    },
+    "4": {
+      "K": [
+        [
+          737.465,
+          0.0,
+          945.476
+        ],
+        [
+          0.0,
+          737.047,
+          517.935
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1174,
+        0.0709,
+        0.0004,
+        -0.0003,
+        -0.0456,
+        0.1168,
+        0.1266,
+        -0.0605
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.1623058952295233,
+          -0.17889022485241673,
+          -0.9703891404101731,
+          3713.19484829117
+        ],
+        [
+          0.0006797727246361657,
+          0.9834084206660851,
+          -0.1814040133847063,
+          1718.4154601049672
+        ],
+        [
+          0.9867402567458093,
+          -0.030102584860567147,
+          -0.1594913793969019,
+          2041.3929037594426
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.1623058952295233,
+          0.0006797727246361657,
+          0.9867402567458093,
+          -1412.8192759204858
+        ],
+        [
+          -0.17889022485241673,
+          0.9834084206660851,
+          -0.030102584860567147,
+          -964.1987692191888
+        ],
+        [
+          -0.9703891404101731,
+          -0.1814040133847063,
+          -0.1594913793969019,
+          4240.55598824576
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.133619850909165,
+        1.7284128828711223,
+        -0.15858486293258514
+      ],
+      "tvec_w2c_mm": [
+        -1412.8192759204858,
+        -964.1987692191888,
+        4240.55598824576
+      ],
+      "position_mm": [
+        3713.19484829117,
+        1718.4154601049672,
+        2041.3929037594426
+      ],
+      "reproj": {
+        "train_mean_px": 1.4613748493136391,
+        "train_median_px": 1.1594095402838214,
+        "test_mean_px": 1.6130319002559326,
+        "test_median_px": 1.1533180102645888,
+        "n_train_frames": 188,
+        "n_trimmed": 16,
+        "n_test_frames": 46,
+        "n_train_corners": 5512
+      }
+    },
+    "5": {
+      "K": [
+        [
+          737.302,
+          0.0,
+          952.888
+        ],
+        [
+          0.0,
+          736.73,
+          526.617
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0332,
+        0.0126,
+        0.0007,
+        -0.0004,
+        -0.0085,
+        0.0437,
+        0.0496,
+        -0.0174
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.9973782763362055,
+          0.07213843493199729,
+          -0.005711400719771116,
+          -1000.5730935999982
+        ],
+        [
+          0.061071558275041855,
+          0.7967711654402801,
+          -0.6011871378304732,
+          2267.0088850087623
+        ],
+        [
+          -0.03881801981654879,
+          -0.5999597954267437,
+          -0.7990878582540357,
+          4730.89176951348
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.9973782763362055,
+          0.061071558275041855,
+          -0.03881801981654879,
+          -952.7557822150793
+        ],
+        [
+          0.07213843493199729,
+          0.7967711654402801,
+          -0.5999597954267437,
+          1104.2373238588418
+        ],
+        [
+          -0.005711400719771116,
+          -0.6011871378304732,
+          -0.7990878582540357,
+          5137.580080859871
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.10977643993672742,
+        -2.9611351907523313,
+        0.9898479160566382
+      ],
+      "tvec_w2c_mm": [
+        -952.7557822150793,
+        1104.2373238588418,
+        5137.580080859871
+      ],
+      "position_mm": [
+        -1000.5730935999982,
+        2267.0088850087623,
+        4730.89176951348
+      ],
+      "reproj": {
+        "train_mean_px": 2.24573616833002,
+        "train_median_px": 1.8089978412962404,
+        "test_mean_px": 4.230362441587578,
+        "test_median_px": 2.9070329441325065,
+        "n_train_frames": 1428,
+        "n_trimmed": 180,
+        "n_test_frames": 359,
+        "n_train_corners": 70192
+      }
+    },
+    "6": {
+      "K": [
+        [
+          739.387,
+          0.0,
+          961.24
+        ],
+        [
+          0.0,
+          738.941,
+          549.495
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0276,
+        0.0066,
+        0.0002,
+        -0.0001,
+        -0.0067,
+        0.0367,
+        0.0447,
+        -0.0162
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.9916450051259756,
+          -0.02103931769764785,
+          -0.12726952077980477,
+          -822.905107559007
+        ],
+        [
+          -0.059829073356569874,
+          0.7990615505095611,
+          -0.5982650921444025,
+          2137.051918522988
+        ],
+        [
+          0.11428326994795826,
+          0.6008810078610188,
+          0.791126632469119,
+          600.3222048177358
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.9916450051259756,
+          -0.059829073356569874,
+          0.11428326994795826,
+          875.2807910147145
+        ],
+        [
+          -0.02103931769764785,
+          0.7990615505095611,
+          0.6008810078610188,
+          -2085.671592999592
+        ],
+        [
+          -0.12726952077980477,
+          -0.5982650921444025,
+          0.791126632469119,
+          698.8619399723472
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.6452000755181322,
+        0.12996738163803703,
+        0.020870812389210323
+      ],
+      "tvec_w2c_mm": [
+        875.2807910147145,
+        -2085.671592999592,
+        698.8619399723472
+      ],
+      "position_mm": [
+        -822.905107559007,
+        2137.051918522988,
+        600.3222048177358
+      ],
+      "reproj": {
+        "train_mean_px": 2.500777328745501,
+        "train_median_px": 2.07068963345984,
+        "test_mean_px": 4.627448446658975,
+        "test_median_px": 3.2401133841767678,
+        "n_train_frames": 1100,
+        "n_trimmed": 70,
+        "n_test_frames": 275,
+        "n_train_corners": 45168
+      }
+    },
+    "7": {
+      "K": [
+        [
+          733.987,
+          0.0,
+          934.021
+        ],
+        [
+          0.0,
+          733.457,
+          520.834
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1232,
+        0.0888,
+        0.0004,
+        -0.0,
+        -0.0489,
+        0.1256,
+        0.1456,
+        -0.0637
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.04408698598699251,
+          -0.35887400401534364,
+          -0.9323442427068329,
+          -951.4227472070256
+        ],
+        [
+          -0.007197501376451948,
+          0.9333415246765598,
+          -0.3589175313193418,
+          2244.2097397499574
+        ],
+        [
+          0.9990017685872827,
+          -0.009113043203552273,
+          -0.04373121085736698,
+          -957.9700582817479
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.04408698598699251,
+          -0.007197501376451948,
+          0.9990017685872827,
+          931.2211238442036
+        ],
+        [
+          -0.35887400401534364,
+          0.9333415246765598,
+          -0.009113043203552273,
+          -2444.785053522505
+        ],
+        [
+          -0.9323442427068329,
+          -0.3589175313193418,
+          -0.04373121085736698,
+          -123.46049179867488
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.28912213588998953,
+        1.5963056590146754,
+        -0.2906694025938897
+      ],
+      "tvec_w2c_mm": [
+        931.2211238442036,
+        -2444.785053522505,
+        -123.46049179867488
+      ],
+      "position_mm": [
+        -951.4227472070256,
+        2244.2097397499574,
+        -957.9700582817479
+      ],
+      "reproj": {
+        "train_mean_px": 3.475393358339814,
+        "train_median_px": 2.9746573817404833,
+        "test_mean_px": 5.838131593355678,
+        "test_median_px": 4.266213525838221,
+        "n_train_frames": 440,
+        "n_trimmed": 7,
+        "n_test_frames": 111,
+        "n_train_corners": 24092
+      }
+    }
+  }
+}

Room-scale/calibration/scripts/visualize/requirements.txt

@@ -0,0 +1,5 @@
+rerun-sdk>=0.26,<0.30
+numpy>=1.26
+opencv-python-headless>=4.9
+PyYAML>=6.0
+gradio>=5.0,<7

Room-scale/calibration/scripts/visualize/visualize_case.py

@@ -0,0 +1,567 @@
+#!/usr/bin/env python3
+"""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
+        # exact-argument match so shells whose command text merely quotes
+        # these strings are never touched
+        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}")
+    # Rerun's web app still fetches data through this proxy. Keep it predictable for SSH.
+    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())
+    # Matches the parameters recorded in this case's rectify_report.json.
+    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]),  # matches calibration_sz.png backdrop
+        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():
+        # Source meshes are globally placed in a Z-up reconstruction. Convert
+        # (x,y,z)_src -> (x,z,-y)_world and lift their source floor to Y=0.
+        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"}
+        # New layout: aligned_textured/<name>/mesh.glb (textures embedded;
+        # Asset3D cannot resolve an OBJ's external .mtl/.png). Fall back to
+        # <name>/mesh.obj, then to the legacy flat *.obj layout.
+        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 parser reads OBJ text; GLB entries use their sibling OBJ
+            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):
+            # <name>/mesh.glb|obj carries its own texture: log untinted.
+            # Legacy untextured flat OBJs keep the palette tint.
+            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:
+        # animated rig: poses follow the timeline alongside the videos
+        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:
+        # static snapshot at --start, consistent with the static human and the
+        # single logged video frames
+        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:
+        # Static single pose at --start: the Homie rig does not follow the
+        # human, so animating the SMPL mesh only inflates the recording.
+        _, 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:  # first free port from web_port+2
+            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()

Room-scale/calibration/zed_intrinsics.json

@@ -0,0 +1,258 @@
+{
+     "0": {
+        "K": [
+            [
+                736.3110,
+                0.0,
+                967.3720
+            ],
+            [
+                0.0,
+                735.8380,
+                488.6960
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.1236,
+            0.0684,
+            0.0003,
+            -0.0002,
+            -0.0415,
+            0.1238,
+            0.1235,
+            -0.0557
+        ],
+        "focal": 2.2089,
+        "width": 1920,
+        "height": 1080
+    },
+    "1": {
+        "K": [
+            [
+                737.2930,
+                0.0,
+                941.3670
+            ],
+            [
+                0.0,
+                736.8900,
+                540.6940
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+            ],
+        "dist": [
+            0.1276,
+            0.0680,
+            0.0003,
+            -0.0002,
+            -0.0468,
+            0.1284,
+            0.1239,
+            -0.0618
+        ],
+        "focal": 2.2119,
+        "width": 1920,
+        "height": 1080
+    },
+    "2": {
+        "K": [
+            [
+                737.5870,
+                0.0,
+                959.5190
+            ],
+            [
+                0.0,
+                737.0550,
+                522.6710
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.0308,
+            0.0122,
+            0.0004,
+            -0.0001,
+            -0.0083,
+            0.0405,
+            0.0504,
+            -0.0177
+        ],
+        "focal": 2.2128,
+        "width": 1920,
+        "height": 1080
+    },
+    "3": {
+        "K": [
+            [
+                737.2120,
+                0.0,
+                944.6280
+            ],
+            [
+                0.0,
+                736.7870,
+                527.4200
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.1187,
+            0.0765,
+            0.0006,
+            -0.0003,
+            -0.0486,
+            0.1190,
+            0.1331,
+            -0.0638
+        ],
+        "focal": 2.2116,
+        "width": 1920,
+        "height": 1080
+    },
+    "4": {
+        "K": [
+            [
+                737.4650,
+                0.0,
+                945.4760
+            ],
+            [
+                0.0,
+                737.0470,
+                517.9350
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.1174,
+            0.0709,
+            0.0004,
+            -0.0003,
+            -0.0456,
+            0.1168,
+            0.1266,
+            -0.0605
+        ],
+        "focal": 2.2124,
+        "width": 1920,
+        "height": 1080
+    },
+    "5": {
+        "K": [
+            [
+                737.3020,
+                0.0,
+                952.8880
+            ],
+            [
+                0.0,
+                736.7300,
+                526.6170
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.0332,
+            0.0126,
+            0.0007,
+            -0.0004,
+            -0.0085,
+            0.0437,
+            0.0496,
+            -0.0174
+        ],
+        "focal": 2.2119,
+        "width": 1920,
+        "height": 1080
+    },
+    "6": {
+        "K": [
+            [
+                739.3870,
+                0.0,
+                961.2400
+            ],
+            [
+                0.0,
+                738.9410,
+                549.4950
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.0276,
+            0.0066,
+            0.0002,
+            -0.0001,
+            -0.0067,
+            0.0367,
+            0.0447,
+            -0.0162
+        ],
+        "focal": 2.2182,
+        "width": 1920,
+        "height": 1080
+    },
+    "7": {
+        "K": [
+            [
+                733.9870,
+                0.0,
+                934.0210
+            ],
+            [
+                0.0,
+                733.4570,
+                520.8340
+            ],
+            [
+                0.0,
+                0.0,
+                1.0
+            ]
+        ],
+        "dist": [
+            0.1232,
+            0.0888,
+            0.0004,
+            -0.0000,
+            -0.0489,
+            0.1256,
+            0.1456,
+            -0.0637
+        ],
+        "focal": 2.2020,
+        "width": 1920,
+        "height": 1080
+    }
+}

Room-scale/calibration/zed_poses_0622.json

@@ -0,0 +1,939 @@
+{
+  "meta": {
+    "world_frame": "OptiTrack Motive world (Y-up, mm), identical to the Motive CSV export and the .mcal extrinsics",
+    "convention": "T_c2w: camera\u2192world, X_w = R@X_c + t (OpenCV camera axes: +Z forward, +X right, +Y down). Units: mm.",
+    "board": {
+      "tag_size_mm": 125.0,
+      "tag_gap_mm": 25.0,
+      "grid": 4,
+      "dict": "DICT_6X6_100"
+    },
+    "board_pose_source": "markers",
+    "n_ir_verified_poses": 3882,
+    "n_board_poses": 20258,
+    "ir_reproj_median_px": 7.548271327933806,
+    "marker_dist_p50_mm": 39.12134911198805,
+    "marker_offsets_board_mm": [
+      [
+        -288.62159175255556,
+        -291.06153400015074,
+        25.133356793384934
+      ],
+      [
+        -290.1209460605521,
+        294.3529408890757,
+        26.390675068946763
+      ],
+      [
+        298.1737594059931,
+        -290.8108225513729,
+        25.0169032934206
+      ],
+      [
+        299.03794657445195,
+        297.11916556598663,
+        22.719542171416467
+      ]
+    ],
+    "inputs": {
+      "mcal": "Calibration-Exported.mcal",
+      "zed_intrinsics": "zed_intrinsics.json",
+      "optitrack_dir": "/home/acerobotics/Videos/Calibration_Board_0610_OTE",
+      "zed_dir": "/home/acerobotics/Videos/Calibration_Board_0610_ZED/frames_synsplice_tmp",
+      "timestamps": "/home/acerobotics/Videos/Calibration_Board_0610_ZED/timestamps_opt.csv",
+      "optitrack_csv": "/home/acerobotics/Videos/Calibration_Board_0610/Calibration_Board_0610.csv",
+      "output": "zed_poses_in_optitrack.json",
+      "zed_cameras": "None",
+      "max_frames": "20000",
+      "workers": "None",
+      "subpix": "False",
+      "ir_gamma": "3.0",
+      "min_markers": "2",
+      "min_cams": "3",
+      "max_reproj_cam": "25.0",
+      "max_reproj_frame": "12.0",
+      "max_angle_gap": "360.0",
+      "marker_tol": "150.0",
+      "keep_unverified": "False",
+      "max_board_speed": "50.0",
+      "board_pose_source": "markers",
+      "marker_fit_tol": "10.0",
+      "max_sync_diff_ms": "8.0",
+      "max_reproj_zed": "4.0",
+      "max_corner_radius": "700.0",
+      "huber_delta": "5.0",
+      "trim_ratio": "3.0",
+      "test_fraction": "0.2",
+      "joint_rounds": "3",
+      "ir_weight": "0.1",
+      "marker_weight": "2.0",
+      "refine_offsets": "True"
+    }
+  },
+  "cameras": {
+    "0": {
+      "K": [
+        [
+          736.311,
+          0.0,
+          967.372
+        ],
+        [
+          0.0,
+          735.838,
+          488.696
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1236,
+        0.0684,
+        0.0003,
+        -0.0002,
+        -0.0415,
+        0.1238,
+        0.1235,
+        -0.0557
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.8264854337212932,
+          0.17858117294725595,
+          0.5338825643484792,
+          -4498.1092102048615
+        ],
+        [
+          0.04814999502482596,
+          0.9224529420283858,
+          -0.3830954812083858,
+          1740.7154835801487
+        ],
+        [
+          -0.5608951825659008,
+          0.34232927776040095,
+          0.7537952372908755,
+          -3855.1695492073027
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.8264854337212932,
+          0.04814999502482596,
+          -0.5608951825659008,
+          1471.4602715227556
+        ],
+        [
+          0.17858117294725595,
+          0.9224529420283858,
+          0.34232927776040095,
+          517.2869071643931
+        ],
+        [
+          0.5338825643484792,
+          -0.3830954812083858,
+          0.7537952372908755,
+          5974.330760833986
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.3961210670788421,
+        -0.5978077312089015,
+        0.0712224620681941
+      ],
+      "tvec_w2c_mm": [
+        1471.4602715227556,
+        517.2869071643931,
+        5974.330760833986
+      ],
+      "position_mm": [
+        -4498.1092102048615,
+        1740.7154835801487,
+        -3855.1695492073027
+      ],
+      "reproj": {
+        "train_mean_px": 1.7207454360764707,
+        "train_median_px": 1.4519597739379129,
+        "test_mean_px": 2.354627349748447,
+        "test_median_px": 2.098143603810553,
+        "n_train_frames": 180,
+        "n_trimmed": 6,
+        "n_test_frames": 47,
+        "n_train_corners": 6052
+      }
+    },
+    "1": {
+      "K": [
+        [
+          737.293,
+          0.0,
+          941.367
+        ],
+        [
+          0.0,
+          736.89,
+          540.694
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1276,
+        0.068,
+        0.0003,
+        -0.0002,
+        -0.0468,
+        0.1284,
+        0.1239,
+        -0.0618
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.1273677302838765,
+          0.5611442706308235,
+          0.817859748869288,
+          -3086.3578269629165
+        ],
+        [
+          0.02898380564134284,
+          0.8263289974884052,
+          -0.5624413986544308,
+          1595.3929826393905
+        ],
+        [
+          -0.9914319947897983,
+          -0.04793219636119889,
+          -0.1215117453545661,
+          4665.762385022123
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.1273677302838765,
+          0.02898380564134284,
+          -0.9914319947897983,
+          4186.443157203164
+        ],
+        [
+          0.5611442706308235,
+          0.8263289974884052,
+          -0.04793219636119889,
+          637.2127665859709
+        ],
+        [
+          0.817859748869288,
+          -0.5624413986544308,
+          -0.1215117453545661,
+          3988.4678286535363
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.4694560197186951,
+        -1.6508604641127633,
+        0.48556164327500106
+      ],
+      "tvec_w2c_mm": [
+        4186.443157203164,
+        637.2127665859709,
+        3988.4678286535363
+      ],
+      "position_mm": [
+        -3086.3578269629165,
+        1595.3929826393905,
+        4665.762385022123
+      ],
+      "reproj": {
+        "train_mean_px": 2.9123992347237126,
+        "train_median_px": 2.2898165257514562,
+        "test_mean_px": 4.850453175326985,
+        "test_median_px": 2.715830090531422,
+        "n_train_frames": 627,
+        "n_trimmed": 0,
+        "n_test_frames": 157,
+        "n_train_corners": 18876
+      }
+    },
+    "2": {
+      "K": [
+        [
+          737.587,
+          0.0,
+          959.519
+        ],
+        [
+          0.0,
+          737.055,
+          522.671
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0308,
+        0.0122,
+        0.0004,
+        -0.0001,
+        -0.0083,
+        0.0405,
+        0.0504,
+        -0.0177
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.7645834671851738,
+          -0.23262169861846244,
+          -0.6010817473846294,
+          1695.871702374565
+        ],
+        [
+          -0.07546393812269152,
+          0.893872536651561,
+          -0.44192429471926337,
+          2080.0126065963896
+        ],
+        [
+          0.6400916463680125,
+          0.38324800528112996,
+          0.6658856138241177,
+          -3191.0268291764323
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.7645834671851738,
+          -0.07546393812269152,
+          0.6400916463680125,
+          902.8800932278815
+        ],
+        [
+          -0.23262169861846244,
+          0.893872536651561,
+          0.38324800528112996,
+          -241.8149217997485
+        ],
+        [
+          -0.6010817473846294,
+          -0.44192429471926337,
+          0.6658856138241177,
+          4063.4244892561123
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.46639607911242775,
+        0.7015242808618536,
+        -0.088827222262893
+      ],
+      "tvec_w2c_mm": [
+        902.8800932278815,
+        -241.8149217997485,
+        4063.4244892561123
+      ],
+      "position_mm": [
+        1695.871702374565,
+        2080.0126065963896,
+        -3191.0268291764323
+      ],
+      "reproj": {
+        "train_mean_px": 2.0529125582436367,
+        "train_median_px": 1.7389845200626883,
+        "test_mean_px": 2.336579099817837,
+        "test_median_px": 1.8515414087232207,
+        "n_train_frames": 687,
+        "n_trimmed": 24,
+        "n_test_frames": 170,
+        "n_train_corners": 34480
+      }
+    },
+    "3": {
+      "K": [
+        [
+          737.212,
+          0.0,
+          944.628
+        ],
+        [
+          0.0,
+          736.787,
+          527.42
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1187,
+        0.0765,
+        0.0006,
+        -0.0003,
+        -0.0486,
+        0.119,
+        0.1331,
+        -0.0638
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.24288073954002531,
+          -0.7002303881280003,
+          -0.6713317733450432,
+          621.9878572989348
+        ],
+        [
+          -0.1923931548658246,
+          0.7130788333718614,
+          -0.6741687113459065,
+          1734.8587761666608
+        ],
+        [
+          0.9507858961518441,
+          -0.0345829573509181,
+          -0.30791264790456296,
+          4748.038734726321
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.24288073954002531,
+          -0.1923931548658246,
+          0.9507858961518441,
+          -4029.524439401385
+        ],
+        [
+          -0.7002303881280003,
+          0.7130788333718614,
+          -0.0345829573509181,
+          -637.3550523829739
+        ],
+        [
+          -0.6713317733450432,
+          -0.6741687113459065,
+          -0.30791264790456296,
+          3049.128895898004
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.7053996802643994,
+        1.789034978135712,
+        -0.5600941230037197
+      ],
+      "tvec_w2c_mm": [
+        -4029.524439401385,
+        -637.3550523829739,
+        3049.128895898004
+      ],
+      "position_mm": [
+        621.9878572989348,
+        1734.8587761666608,
+        4748.038734726321
+      ],
+      "reproj": {
+        "train_mean_px": 2.5048194609653915,
+        "train_median_px": 1.9828813362491196,
+        "test_mean_px": 5.296709982790022,
+        "test_median_px": 2.9605944943266476,
+        "n_train_frames": 1009,
+        "n_trimmed": 130,
+        "n_test_frames": 253,
+        "n_train_corners": 36684
+      }
+    },
+    "4": {
+      "K": [
+        [
+          737.465,
+          0.0,
+          945.476
+        ],
+        [
+          0.0,
+          737.047,
+          517.935
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1174,
+        0.0709,
+        0.0004,
+        -0.0003,
+        -0.0456,
+        0.1168,
+        0.1266,
+        -0.0605
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.1623058952295233,
+          -0.17889022485241673,
+          -0.9703891404101731,
+          3713.19484829117
+        ],
+        [
+          0.0006797727246361657,
+          0.9834084206660851,
+          -0.1814040133847063,
+          1718.4154601049672
+        ],
+        [
+          0.9867402567458093,
+          -0.030102584860567147,
+          -0.1594913793969019,
+          2041.3929037594426
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.1623058952295233,
+          0.0006797727246361657,
+          0.9867402567458093,
+          -1412.8192759204858
+        ],
+        [
+          -0.17889022485241673,
+          0.9834084206660851,
+          -0.030102584860567147,
+          -964.1987692191888
+        ],
+        [
+          -0.9703891404101731,
+          -0.1814040133847063,
+          -0.1594913793969019,
+          4240.55598824576
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.133619850909165,
+        1.7284128828711223,
+        -0.15858486293258514
+      ],
+      "tvec_w2c_mm": [
+        -1412.8192759204858,
+        -964.1987692191888,
+        4240.55598824576
+      ],
+      "position_mm": [
+        3713.19484829117,
+        1718.4154601049672,
+        2041.3929037594426
+      ],
+      "reproj": {
+        "train_mean_px": 1.4613748493136391,
+        "train_median_px": 1.1594095402838214,
+        "test_mean_px": 1.6130319002559326,
+        "test_median_px": 1.1533180102645888,
+        "n_train_frames": 188,
+        "n_trimmed": 16,
+        "n_test_frames": 46,
+        "n_train_corners": 5512
+      }
+    },
+    "5": {
+      "K": [
+        [
+          737.302,
+          0.0,
+          952.888
+        ],
+        [
+          0.0,
+          736.73,
+          526.617
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0332,
+        0.0126,
+        0.0007,
+        -0.0004,
+        -0.0085,
+        0.0437,
+        0.0496,
+        -0.0174
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.9973782763362055,
+          0.07213843493199729,
+          -0.005711400719771116,
+          -1000.5730935999982
+        ],
+        [
+          0.061071558275041855,
+          0.7967711654402801,
+          -0.6011871378304732,
+          2267.0088850087623
+        ],
+        [
+          -0.03881801981654879,
+          -0.5999597954267437,
+          -0.7990878582540357,
+          4730.89176951348
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.9973782763362055,
+          0.061071558275041855,
+          -0.03881801981654879,
+          -952.7557822150793
+        ],
+        [
+          0.07213843493199729,
+          0.7967711654402801,
+          -0.5999597954267437,
+          1104.2373238588418
+        ],
+        [
+          -0.005711400719771116,
+          -0.6011871378304732,
+          -0.7990878582540357,
+          5137.580080859871
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.10977643993672742,
+        -2.9611351907523313,
+        0.9898479160566382
+      ],
+      "tvec_w2c_mm": [
+        -952.7557822150793,
+        1104.2373238588418,
+        5137.580080859871
+      ],
+      "position_mm": [
+        -1000.5730935999982,
+        2267.0088850087623,
+        4730.89176951348
+      ],
+      "reproj": {
+        "train_mean_px": 2.24573616833002,
+        "train_median_px": 1.8089978412962404,
+        "test_mean_px": 4.230362441587578,
+        "test_median_px": 2.9070329441325065,
+        "n_train_frames": 1428,
+        "n_trimmed": 180,
+        "n_test_frames": 359,
+        "n_train_corners": 70192
+      }
+    },
+    "6": {
+      "K": [
+        [
+          739.387,
+          0.0,
+          961.24
+        ],
+        [
+          0.0,
+          738.941,
+          549.495
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.0276,
+        0.0066,
+        0.0002,
+        -0.0001,
+        -0.0067,
+        0.0367,
+        0.0447,
+        -0.0162
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          0.9916450051259756,
+          -0.02103931769764785,
+          -0.12726952077980477,
+          -822.905107559007
+        ],
+        [
+          -0.059829073356569874,
+          0.7990615505095611,
+          -0.5982650921444025,
+          2137.051918522988
+        ],
+        [
+          0.11428326994795826,
+          0.6008810078610188,
+          0.791126632469119,
+          600.3222048177358
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          0.9916450051259756,
+          -0.059829073356569874,
+          0.11428326994795826,
+          875.2807910147145
+        ],
+        [
+          -0.02103931769764785,
+          0.7990615505095611,
+          0.6008810078610188,
+          -2085.671592999592
+        ],
+        [
+          -0.12726952077980477,
+          -0.5982650921444025,
+          0.791126632469119,
+          698.8619399723472
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.6452000755181322,
+        0.12996738163803703,
+        0.020870812389210323
+      ],
+      "tvec_w2c_mm": [
+        875.2807910147145,
+        -2085.671592999592,
+        698.8619399723472
+      ],
+      "position_mm": [
+        -822.905107559007,
+        2137.051918522988,
+        600.3222048177358
+      ],
+      "reproj": {
+        "train_mean_px": 2.500777328745501,
+        "train_median_px": 2.07068963345984,
+        "test_mean_px": 4.627448446658975,
+        "test_median_px": 3.2401133841767678,
+        "n_train_frames": 1100,
+        "n_trimmed": 70,
+        "n_test_frames": 275,
+        "n_train_corners": 45168
+      }
+    },
+    "7": {
+      "K": [
+        [
+          733.987,
+          0.0,
+          934.021
+        ],
+        [
+          0.0,
+          733.457,
+          520.834
+        ],
+        [
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "dist": [
+        0.1232,
+        0.0888,
+        0.0004,
+        -0.0,
+        -0.0489,
+        0.1256,
+        0.1456,
+        -0.0637
+      ],
+      "width": 1920,
+      "height": 1080,
+      "T_c2w": [
+        [
+          -0.04408698598699251,
+          -0.35887400401534364,
+          -0.9323442427068329,
+          -951.4227472070256
+        ],
+        [
+          -0.007197501376451948,
+          0.9333415246765598,
+          -0.3589175313193418,
+          2244.2097397499574
+        ],
+        [
+          0.9990017685872827,
+          -0.009113043203552273,
+          -0.04373121085736698,
+          -957.9700582817479
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "T_w2c": [
+        [
+          -0.04408698598699251,
+          -0.007197501376451948,
+          0.9990017685872827,
+          931.2211238442036
+        ],
+        [
+          -0.35887400401534364,
+          0.9333415246765598,
+          -0.009113043203552273,
+          -2444.785053522505
+        ],
+        [
+          -0.9323442427068329,
+          -0.3589175313193418,
+          -0.04373121085736698,
+          -123.46049179867488
+        ],
+        [
+          0.0,
+          0.0,
+          0.0,
+          1.0
+        ]
+      ],
+      "rvec_w2c": [
+        -0.28912213588998953,
+        1.5963056590146754,
+        -0.2906694025938897
+      ],
+      "tvec_w2c_mm": [
+        931.2211238442036,
+        -2444.785053522505,
+        -123.46049179867488
+      ],
+      "position_mm": [
+        -951.4227472070256,
+        2244.2097397499574,
+        -957.9700582817479
+      ],
+      "reproj": {
+        "train_mean_px": 3.475393358339814,
+        "train_median_px": 2.9746573817404833,
+        "test_mean_px": 5.838131593355678,
+        "test_median_px": 4.266213525838221,
+        "n_train_frames": 440,
+        "n_trimmed": 7,
+        "n_test_frames": 111,
+        "n_train_corners": 24092
+      }
+    }
+  }
+}