"""The up-axis conversion moves poses and cameras as ONE piece. A world-frame rotation applied to the poses but not to `T_mocap_to_cam` — or with the inverse the wrong way round — moves every projection and raises nothing. The numbers stay plausible. So the test is INVARIANCE: convert both, and every projected pixel must be unchanged. It also pins the direction. Two rotations take Y-up to Z-up with det +1; the wrong one leaves the world upside down and no handedness check notices. python scripts/test_frames.py """ from __future__ import annotations import shutil import sys import tempfile from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parents[1])) sys.path.insert(0, str(Path(__file__).resolve().parents[2])) from react_paths import force_meta, release_root # noqa: E402 import numpy as np # noqa: E402 import pyarrow.parquet as pq # noqa: E402 RESULTS: list[tuple[bool, str, str]] = [] def check(ok: bool, name: str, evidence: str) -> None: RESULTS.append((bool(ok), name, evidence)) def main() -> int: from react_toolbox.calibration import load_calibration, project_gel_to_pixel from react_toolbox.frames import (UP_AXIS_RECORDED, YUP_TO_ZUP, ZUP_TO_YUP, convert_calibration, convert_poses, to_zup) from react_toolbox.frames import require_up_axis from scipy.spatial.transform import Rotation from twm.calib_epoch import calib_dir # The calibration must come from the SAME tree as the poses below. It used # to come from calib_dir(), a separate tree that REACT_CALIB can redirect; # after the release was rotated to Z-up and that tree was not, this file # was silently testing a mismatched pair and still printing all-green. cal = load_calibration(release_root("motherboard")) require_up_axis(cal, where="the release") p = sorted(force_meta("motherboard").glob("*/*.parquet"))[0] t = pq.read_table(p, columns=["sensor_left_pose"]).to_pydict() P = np.asarray([x for x in t["sensor_left_pose"]], float) P = P[np.isfinite(P).all(1) & (np.linalg.norm(P[:, 3:], axis=1) > .5)][:400] # 0 — MEASURE the up axis from the data, do not restate it. This check # used a literal normal from an earlier run and kept asserting the old # convention after the release was converted — a constant that had # stopped describing anything. tt = pq.read_table(p).to_pydict() O = np.asarray([x for x in tt["object_pose"]], float) S = np.asarray([x for x in tt["sensor_left_pose"]], float) F = np.asarray(tt.get("force_left_normal_n", np.zeros(len(S))), float) ok_ = ((F > 2) & np.isfinite(S).all(1) & np.isfinite(O).all(1) & (np.linalg.norm(O[:, 3:], axis=1) > .5)) Ro = Rotation.from_quat(O[ok_, 3:7]).as_matrix() Rs = Rotation.from_quat(S[ok_, 3:7]).as_matrix() g = S[ok_, :3]*1000 + np.einsum("nij,j->ni", Rs, cal["gel_left"]) Cb = np.einsum("nji,nj->ni", Ro, g - O[ok_, :3]*1000) nl = np.linalg.svd(Cb - Cb.mean(0))[2][2] nw = np.einsum("nij,j->ni", Ro, nl) k = int(np.argmax(np.abs(np.median(nw, axis=0)))) nw *= np.sign(np.median(nw[:, k])) normal = np.median(nw, axis=0); normal /= np.linalg.norm(normal) measured = "xyz"[int(np.argmax(np.abs(normal)))] # 1 — the conversion is a rotation, and it sends UP to +z rather than -z det = float(np.linalg.det(YUP_TO_ZUP)) yup_normal = normal if measured == "y" else ZUP_TO_YUP @ normal up = YUP_TO_ZUP @ yup_normal check(abs(det - 1) < 1e-12 and up[2] > 0.99, "the conversion is right-handed and sends up to +z", f"det {det:+.0f}; the table normal expressed Y-up " f"{np.round(yup_normal, 3).tolist()} maps to {np.round(up, 3).tolist()}") # 2 — THE INVARIANT. The release is a matched Z-up pair; rotate it back to # the recorded Y-up, forward again with to_zup(), and every pixel must # land where the release puts it. yP = convert_poses(P, to_zup=False) ycal = convert_calibration(cal, to_zup=False) zP, zcal = to_zup(yP, ycal) worst = 0.0 n = 0 for v in ("left", "middle", "right"): for a, b in zip(P[::13], zP[::13]): ua = project_gel_to_pixel(a, cal["gel_left"], cal["cams"][v]) ub = project_gel_to_pixel(b, zcal["gel_left"], zcal["cams"][v]) if ua is None or ub is None: continue n += 1 worst = max(worst, float(np.hypot(ua[0]-ub[0], ua[1]-ub[1]))) check(n > 50 and worst < 1e-9, "converting poses AND cameras leaves every projection identical", f"{n} projections across 3 views, worst movement {worst:.2e} px") # 3 — AND HALF-APPLYING IT BREAKS THINGS. If this passes silently, the # invariance above proves nothing. # This is exactly the bug it exists to catch: Z-up poses, Y-up calibration. half = 0.0 for a in P[::13]: ua = project_gel_to_pixel(a, cal["gel_left"], cal["cams"]["middle"]) ub = project_gel_to_pixel(a, ycal["gel_left"], ycal["cams"]["middle"]) if ua is None or ub is None: continue half = max(half, float(np.hypot(ua[0]-ub[0], ua[1]-ub[1]))) check(half > 50.0, "converting the poses alone moves the projection a lot", f"poses converted, calibration left alone: up to {half:.0f} px — " f"which is why the two are converted together or not at all") # 4 — round trip back = convert_poses(zP, to_zup=False) dp = float(np.abs(back[:, :3] - yP[:, :3]).max()) da = float(np.degrees((Rotation.from_quat(back[:, 3:7]).inv() * Rotation.from_quat(yP[:, 3:7])).magnitude()).max()) check(dp < 1e-12 and da < 1e-9, "the conversion round-trips", f"worst {dp:.2e} m and {da:.2e} deg over {len(P)} poses") # 5 — the declared convention is the one the data actually has, measured check(UP_AXIS_RECORDED == measured and normal["xyz".index(measured)] > 0, "the declared convention is the one the data actually has", f"UP_AXIS_RECORDED={UP_AXIS_RECORDED!r}; measured table normal " f"{np.round(normal, 3).tolist()} -> +{measured}, " f"{np.degrees(np.arccos(abs(normal['xyz'.index(measured)]))):.1f} deg off") # 6 — the gizmo has to FIT. Its whole job is to be readable, and the axis # that points straight up is the one whose label runs off the top edge. from react_toolbox.viz import draw_world_gizmo frame = np.zeros((480, 640, 3), np.uint8) bad = [] for name, c in cal["cams"].items(): R = np.asarray(c["T_mocap_to_cam"], float)[:3, :3] for i, ax in enumerate("xyz"): d = R @ np.eye(3)[i] if float(np.hypot(d[0], d[1])) <= 0.12: continue # drawn as a dot at the origin ox = oy = 12 + 44 + 22 # draw_world_gizmo's tl origin lx = ox + float(d[0]) * (44 + 13) ly = oy + float(d[1]) * (44 + 13) # the label glyph reaches ~8 px above its anchor and ~6 below if not (10 <= lx <= 630 and 10 <= ly <= 474): bad.append(f"{name}.{ax} label at ({lx:.0f},{ly:.0f})") _ = draw_world_gizmo(frame, cal["cams"]["middle"], corner="tl", title="world (z-up)") check(not bad, "every gizmo axis label lands inside the frame", "all 3 cameras, all in-plane axes fit" if not bad else "clipped: " + "; ".join(bad)) # 7 — a calibration can be ASKED for a convention. Twelve scripts paired a # Z-up pose source with a Y-up calibration because each one picked a # directory and hoped. Asking removes the hope. from react_toolbox.frames import as_up_axis ycal2 = as_up_axis(cal, "y") zcal2 = as_up_axis(ycal2, "z") idem = as_up_axis(cal, "z") dz = max(float(np.abs(np.asarray(zcal2["cams"][v]["T_mocap_to_cam"]) - np.asarray(cal["cams"][v]["T_mocap_to_cam"])).max()) for v in cal["cams"]) di = max(float(np.abs(np.asarray(idem["cams"][v]["T_mocap_to_cam"]) - np.asarray(cal["cams"][v]["T_mocap_to_cam"])).max()) for v in cal["cams"]) dy = max(float(np.abs(np.asarray(ycal2["cams"][v]["T_mocap_to_cam"]) - np.asarray(ycal["cams"][v]["T_mocap_to_cam"])).max()) for v in cal["cams"]) check(dz < 1e-12 and di < 1e-12 and dy < 1e-12 and ycal2["up_axis"] == "y" and zcal2["up_axis"] == "z", "as_up_axis converts on demand and is a no-op when it already fits", f"z->y->z {dz:.1e}, already-z {di:.1e}, matches convert_calibration " f"{dy:.1e}; declarations {ycal2['up_axis']}/{zcal2['up_axis']}") # 8 — the raw-H5 offset. episodes.jsonl now stores it Z-up, but its whole # documented purpose is to be ADDED to a pose read out of the source # H5, which is Y-up. Handing the stored value straight to a raw # consumer puts 175 mm on the wrong axis, twice. from twm.calib_epoch import world_offset_m oz = world_offset_m("motherboard", "2026-05-19", "episode_002", up_axis="z") oy = world_offset_m("motherboard", "2026-05-19", "episode_002", up_axis="y") check(np.allclose(oz, (0.23, -0.175, 0.0), atol=1e-9) and np.allclose(oy, (0.23, 0.0, 0.175), atol=1e-9), "world_offset_m answers in the convention the caller asks for", f"z-up {tuple(round(x, 4) for x in oz)}, " f"y-up {tuple(round(x, 4) for x in oy)}") # 9 — the raw-HDF5 viewers must not be handed the converted release. # calib_dir() resolves $REACT_RELEASE BEFORE the repo's own Y-up tree, # and that directory is now Z-up. Every interactive viewer reads Y-up # poses straight out of the H5, so the moment a user exports # REACT_RELEASE -- which react_paths documents as the normal way to # point at the data -- they would silently view through a 200 px error. import os as _os from twm.calib_epoch import calib_dir as _cd _old = _os.environ.get("REACT_RELEASE") _os.environ["REACT_RELEASE"] = str(release_root()) try: try: _cd("motherboard", up_axis="y") raised = "" except Exception as ex: raised = f"{type(ex).__name__}: {str(ex)[:60]}" got_z = _cd("motherboard", up_axis="z") finally: if _old is None: _os.environ.pop("REACT_RELEASE", None) else: _os.environ["REACT_RELEASE"] = _old check(raised.startswith("ValueError") and got_z.is_dir(), "a Y-up caller is refused the Z-up release calibration", f"asking for y-up raised [{raised}]; asking for z-up returned " f"{got_z.name}/") # 10 — a column with NOTHING tracked in it must convert, not explode. # pushT never tracked an object body, so its whole object_pose column # is NaN. The valid-row mask then selects zero rows and scipy raises # "Found zero norm quaternions" on the empty array -- which is how # the pushT half of the release went unconverted long enough to ship # beside a Z-up motherboard. allnan = np.full((5, 7), np.nan) mixed = np.vstack([allnan[:2], P[:3]]) try: a1 = convert_poses(allnan, True) a2 = convert_poses(mixed, True) err = "" except Exception as ex: a1 = a2 = None err = f"{type(ex).__name__}: {ex}" ok10 = (err == "" and a1.shape == (5, 7) and np.isnan(a1).all() and np.isnan(a2[:2]).all() and np.allclose(a2[2:], convert_poses(P[:3], True))) check(ok10, "an all-NaN pose column converts to all-NaN instead of raising", "5 untracked rows pass through; a mixed array converts only its " "tracked rows and leaves the rest NaN" if ok10 else (err or "shape or values wrong")) w = max(len(x) for _, x, _ in RESULTS) print() for ok, name, ev in RESULTS: print(f" [{'ok' if ok else 'FAIL'}] {name:<{w}} {ev}") nf = sum(not x for x, _, _ in RESULTS) print(f"\nframes: {len(RESULTS)} checks, {nf} failing") return 1 if nf else 0 if __name__ == "__main__": raise SystemExit(main())