| """Which world frame a pose array is in — read it, and check it. |
| |
| The 2026-05-19 motherboard session redefined the OptiTrack origin: its raw |
| poses sit (0.23, 0, 0.175) m from every other date. The published poses have |
| the correction baked in, so all 32 episodes share one frame — but that fact |
| used to live in one free-text sentence inside `calibration.json`, which a |
| machine cannot read, which states a difference without a direction, and which |
| nothing can check. |
| |
| Each episode's parquet now carries the declaration, and a FINGERPRINT: the |
| median pixel the gel centre projects to in each camera, computed from the |
| poses that ship. Recompute it from whatever poses you hold and compare. |
| |
| dec = read_world_frame("episode_002.parquet") |
| err = verify_world_frame(my_poses, "left", "motherboard", dec) |
| assert err < 6.0 |
| |
| Measured discriminating power on 2026-05-19/episode_002: |
| |
| missing world offset 222.9 px |
| y/z axes swapped 227.2 px |
| metres read as mm 1741-2782 px |
| 1 degree of yaw 1.7-3.2 px |
| |
| against a calibration rmse of 4.75 mm — about 3 px at this depth. So it |
| catches every frame error this rig can plausibly suffer, including ones nobody |
| has thought of, which a check for one known offset cannot. |
| """ |
| from __future__ import annotations |
|
|
| import json |
|
|
| import numpy as np |
|
|
| VIEWS = ("left", "middle", "right") |
|
|
|
|
| def read_world_frame(parquet_path): |
| """The declaration embedded in an episode's parquet, or None.""" |
| import pyarrow.parquet as pq |
| md = pq.read_schema(str(parquet_path)).metadata or {} |
| raw = md.get(b"twm.world_frame") |
| return json.loads(raw.decode()) if raw is not None else None |
|
|
|
|
| def projection_fingerprint(pose7, gel_center_mm, cams) -> dict: |
| """Median projected gel-centre pixel per camera. |
| |
| Median, not mean: a handful of tracking dropouts move a mean by tens of |
| pixels and leave a median untouched, and a signature that drifts with the |
| noise cannot be compared against a stored one. |
| """ |
| from .calibration import project_gel_to_pixel |
|
|
| p = np.asarray(pose7, float) |
| ok = np.isfinite(p).all(1) & (np.linalg.norm(p[:, 3:], axis=1) > 0.5) |
| p = p[ok] |
| if len(p) < 10: |
| raise ValueError(f"only {len(p)} valid poses — cannot fingerprint") |
| out = {} |
| for v in VIEWS: |
| if v not in cams: |
| continue |
| uv = [project_gel_to_pixel(q, gel_center_mm, cams[v]) for q in p] |
| uv = np.asarray([x for x in uv if x is not None], float) |
| if len(uv) < 10: |
| continue |
| out[v] = [float(np.median(uv[:, 0])), float(np.median(uv[:, 1]))] |
| return out |
|
|
|
|
| def verify_world_frame(pose7, side: str, task_root, declaration) -> float: |
| """Worst per-camera pixel distance from the declared fingerprint. |
| |
| WORST, not mean: a frame error along one camera's optical axis is |
| invisible to that camera and obvious to the others, so averaging would |
| dilute exactly the evidence that matters. |
| |
| `task_root` is the directory holding `calibration/` — the same argument |
| `load_calibration` takes. |
| """ |
| from .calibration import load_calibration |
|
|
| if not declaration or "fingerprint" not in declaration: |
| raise ValueError("declaration has no fingerprint; this episode " |
| "predates the world-frame metadata") |
| stored = declaration["fingerprint"].get(side) |
| if not isinstance(stored, dict): |
| raise ValueError( |
| f"no fingerprint for side {side!r}. Pass the whole declaration; " |
| f"this function selects the side. (The sides and the cameras " |
| f"share the names left/right, so selecting by hand is easy to " |
| f"get wrong — an earlier version of this check did, and returned " |
| f"0.0 for every input as a result.)") |
| cal = load_calibration(task_root) |
| got = projection_fingerprint(pose7, cal[f"gel_{side}"], cal["cams"]) |
| common = [v for v in VIEWS if v in got and v in stored] |
| if not common: |
| raise ValueError("no camera in common between the fingerprint and " |
| "this calibration") |
| return max(float(np.hypot(got[v][0] - stored[v][0], |
| got[v][1] - stored[v][1])) for v in common) |
|
|
