toolbox: projection rendering + world-frame check; gel centre fix

toolbox/calib_epoch.py

@@ -44,6 +44,8 @@ import json
 from functools import lru_cache
 from pathlib import Path
 
+import numpy as np
+
 REPO = Path(__file__).resolve().parent
 RELEASE = Path("/media/yxma/Disk1/twm/release")
 
@@ -57,7 +59,7 @@ CALIB_DIRS = {
 EXPECTED_EPOCH = {"motherboard": "2026-05-12", "pushT": "2026-06-26"}
 
 
-def calib_dir(task: str) -> Path:
+def calib_dir(task: str, *, up_axis: str | None = None) -> Path:
     """Directory of camera extrinsics valid for `task`.
 
     Looked up in this order, so the module works outside the repository it
@@ -79,14 +81,40 @@ def calib_dir(task: str) -> Path:
     slightly miscalibrated rig, which is how it shipped unnoticed once.
     """
     import os as _os
+
+    def _ok(d: Path) -> Path:
+        """Refuse a tree in the wrong convention instead of returning it.
+
+        This resolves $REACT_RELEASE before the repo's own tree, and the
+        release is now Z-up while every raw-HDF5 reader is Y-up. Returning a
+        path cannot convert anything, so the only honest options are the right
+        tree or an error -- not a 200 px picture that looks plausible.
+        """
+        if up_axis is None:
+            return d
+        if up_axis not in ("y", "z"):
+            raise ValueError(f"up axis must be 'y' or 'z', got {up_axis!r}")
+        f = d / "T_mocap_to_cam_middle.json"
+        got = "y"
+        if f.exists():
+            got = json.loads(f.read_text()).get("up_axis") or "y"
+        if got != up_axis:
+            raise ValueError(
+                f"{d} is a {got}-up calibration but the caller needs "
+                f"{up_axis}-up. Raw HDF5 poses are Y-up as recorded; the "
+                f"published release is Z-up. Point REACT_CALIB at a {up_axis}"
+                f"-up tree, or convert with react_toolbox.frames.as_up_axis "
+                f"after loading.")
+        return d
+
     env = _os.environ.get("REACT_CALIB")
     if env and Path(env).is_dir():
-        return Path(env)
+        return _ok(Path(env))
     rel = _os.environ.get("REACT_RELEASE")
     if rel:
         cand = Path(rel) / task / "calibration"
         if cand.is_dir():
-            return cand
+            return _ok(cand)
     try:
         d = CALIB_DIRS[task]
     except KeyError:
@@ -99,12 +127,17 @@ def calib_dir(task: str) -> Path:
             f"calibration dir for {task!r} missing: {d}. Set REACT_CALIB, or "
             f"REACT_RELEASE so that $REACT_RELEASE/{task}/calibration exists "
             f"(the dataset publishes it there).")
-    return d
+    return _ok(d)
 
 
-def calib_dir_for_path(p: str | Path) -> Path:
+def calib_dir_for_path(p: str | Path, *, up_axis: str = "y") -> Path:
     """Epoch dir inferred from any path containing a task-name component.
 
+    Defaults to `up_axis="y"` because every caller is an interactive viewer
+    reading poses straight out of the source HDF5, which is Y-up as recorded.
+    If $REACT_RELEASE points calib_dir at the Z-up release, this raises rather
+    than viewing through a 200 px error.
+
     For the interactive viewers, whose old default was `calibration/result`
     for every input — June-26 extrinsics under May recordings. No guess on
     failure: raises, listing the known tasks, so the caller passes explicit
@@ -113,7 +146,7 @@ def calib_dir_for_path(p: str | Path) -> Path:
     parts = set(Path(p).parts) | set(Path(p).resolve().parts)
     hits = [t for t in CALIB_DIRS if t in parts]
     if len(hits) == 1:
-        return calib_dir(hits[0])
+        return calib_dir(hits[0], up_axis=up_axis)
     raise KeyError(
         f"cannot infer task from {str(p)!r} (matches: {hits or 'none'}); pass "
         f"explicit --cam_calib/--gel_* paths. Known tasks: {sorted(CALIB_DIRS)}")
@@ -158,8 +191,15 @@ def release_episodes(task: str) -> set[str]:
     return set(_episodes(task))
 
 
-def world_offset_m(task: str, date: str, episode: str) -> tuple[float, float, float]:
-    """Offset to ADD to raw-H5 OptiTrack poses to reach the release frame.
+def world_offset_m(task: str, date: str, episode: str, *,
+                   up_axis: str) -> tuple[float, float, float]:
+    """Offset to ADD to poses to reach the release frame, in `up_axis`.
+
+    `up_axis` is REQUIRED and has no default on purpose. The value is stored
+    Z-up because the release is, but the documented use -- adding it to a pose
+    read straight out of the source H5 -- is Y-up. A default would have been
+    right for one caller and silently 175 mm wrong on the wrong axis for the
+    other, which is how this class of bug got in.
 
     Read from the release's own `episodes.jsonl` (`world_frame_offset`), never
     restated. `episode` may be `episode_002` or `2026-05-19/episode_002`.
@@ -178,14 +218,22 @@ def world_offset_m(task: str, date: str, episode: str) -> tuple[float, float, fl
         raise KeyError(
             f"{task}: {key!r} is not in {RELEASE / task / 'episodes.jsonl'}, so "
             f"its world-frame offset is unknown. Refusing to assume zero — "
-            f"2026-05-19 is offset (0.23, 0, 0.175) m and would render wrong.")
+            f"2026-05-19 is offset (0.23, -0.175, 0) m Z-up and would "
+            f"render wrong.")
     off = eps[key].get("world_frame_offset") or (0.0, 0.0, 0.0)
+    stored = eps[key].get("up_axis") or "y"
+    off = np.asarray([float(off[0]), float(off[1]), float(off[2])], float)
+    if stored != up_axis:
+        from react_toolbox.frames import YUP_TO_ZUP
+        M = np.asarray(YUP_TO_ZUP, float)
+        off = (M if up_axis == "z" else M.T) @ off
     return (float(off[0]), float(off[1]), float(off[2]))
 
 
 def describe(task: str, date: str, episode: str) -> str:
     """One line for a status bar, so the applied correction is visible."""
-    dx, dy, dz = world_offset_m(task, date, episode)
+    # a status line for the raw-H5 render paths, so: the Y-up convention
+    dx, dy, dz = world_offset_m(task, date, episode, up_axis="y")
     s = f"calib {epoch_of(task)}"
     if any((dx, dy, dz)):
         s += f" world+({dx:g},{dy:g},{dz:g})m"

toolbox/calibration.py

@@ -23,7 +23,10 @@ def load_calibration(task_root):
                   plus "gel_left"/"gel_right" center (3,) in rigid-body mm.
     """
     cdir = Path(task_root) / "calibration"
-    out = {"cams": {}}
+    # A calibration written before the Z-up conversion carries no declaration.
+    # Absent means Y-up: that is what every pre-conversion file was, and
+    # defaulting the other way would let a stale tree pass a Z-up check.
+    out = {"cams": {}, "up_axis": None}
     for cam in ("left", "middle", "right"):
         p = cdir / f"T_mocap_to_cam_{cam}.json"
         if not p.exists():
@@ -35,6 +38,7 @@ def load_calibration(task_root):
             "serial": d.get("camera_serial"),
             "rmse": d.get("rmse_mm", d.get("rmse_px")),
         }
+        out["up_axis"] = d.get("up_axis", "y")
     for side in ("left", "right"):
         p = cdir / f"T_gel_to_rigid_{side}.json"
         if p.exists():

toolbox/frames.py

@@ -1,15 +1,22 @@
 """Which way is up — declared, and converted as one piece or not at all.
 
-WHAT THE DATA ACTUALLY IS
+WHAT THE DATA IS, AND WHAT IT WAS
 
-OptiTrack records **Y-up, right-handed**. Measured on this release: the table
-normal in world coordinates is (0.053, 0.997, 0.056), i.e. 4.4 degrees off +y,
-and both the pose rotations and `T_mocap_to_cam` have determinant +1.
+The release is now **Z-up, right-handed**: the table normal in world
+coordinates is (0.053, -0.056, 0.997), 4.4 degrees off +z, and both the pose
+rotations and `T_mocap_to_cam` have determinant +1.
 
-That convention was documented nowhere. Robotics code overwhelmingly assumes
-Z-up, so a reader taking `pose[2]` as height gets a horizontal coordinate and
-nothing complains — the numbers are plausible, the plots look fine, and the
-error only shows up as a model that never learns which way gravity points.
+OptiTrack RECORDS Y-up. The release used to ship that unchanged and said so
+nowhere, which is the worse half of the problem: robotics code overwhelmingly
+assumes Z-up, and a reader taking `pose[2]` as height got a horizontal
+coordinate with nothing to complain — plausible numbers, fine-looking plots,
+and an error that surfaces only as a model that never learns which way gravity
+points.
+
+Poses and extrinsics were converted together, so every projection is
+unchanged and every rendered preview, overlay and clip stayed valid. Only the
+numbers moved. `ZUP_TO_YUP` converts back for anything that still wants the
+raw OptiTrack convention.
 
 THE CONVERSION, AND THE TRAP IN IT
 
@@ -34,7 +41,7 @@ from __future__ import annotations
 
 import numpy as np
 
-UP_AXIS_RECORDED = "y"
+UP_AXIS_RECORDED = "z"
 UP_AXIS_ROBOTICS = "z"
 
 # (x, y, z)_yup -> (x, -z, y)_zup.  det = +1, and it sends +y to +z.
@@ -74,6 +81,7 @@ def convert_calibration(cal: dict, to_zup: bool = True) -> dict:
     """
     M = _R(to_zup)
     out = {k: v for k, v in cal.items()}
+    out["up_axis"] = "z" if to_zup else "y"
     out["cams"] = {}
     for name, c in cal["cams"].items():
         T = np.asarray(c["T_mocap_to_cam"], float).copy()
@@ -89,3 +97,47 @@ def to_zup(poses7, cal: dict):
     one piece.
     """
     return convert_poses(poses7, True), convert_calibration(cal, True)
+
+
+def require_up_axis(cal: dict, expected: str = UP_AXIS_RECORDED, where: str = ""):
+    """Raise unless `cal` declares the up-axis convention `expected`.
+
+    WHY THIS EXISTS. Poses and calibration are two halves of one convention,
+    and they are read from two paths. Rotating only one half leaves every
+    self-consistency check green -- projections still recompute exactly from
+    the same wrong matrix -- while the pictures are wrong. That happened: the
+    probe test set drew its poses from the Z-up release and its calibration
+    from a Y-up tree, and every overlay was a median 153 px off.
+
+    So the halves must be paired loudly, not by convention. A file with no
+    declaration is treated as the pre-conversion Y-up it was.
+    """
+    got = cal.get("up_axis")
+    if got != expected:
+        raise ValueError(
+            f"calibration up-axis mismatch{' in ' + where if where else ''}: "
+            f"declared {got!r}, need {expected!r}. Poses and calibration must "
+            f"come from the same release. A missing declaration means a "
+            f"pre-conversion Y-up file -- convert it with "
+            f"scripts/convert_release_zup.py, or take the calibration from "
+            f"the release the poses came from.")
+    return cal
+
+
+def as_up_axis(cal: dict, want: str) -> dict:
+    """Return `cal` in the convention `want`, converting only if it must.
+
+    `require_up_axis` refuses a mismatch; this one repairs it. Use it when the
+    caller genuinely knows which convention its POSES are in -- a raw-HDF5
+    reader wants "y", a release reader wants "z" -- and should not have to care
+    which directory the calibration happened to come from.
+
+    An undeclared calibration is the pre-conversion Y-up it was, so this
+    converts it rather than trusting it.
+    """
+    if want not in ("y", "z"):
+        raise ValueError(f"up axis must be 'y' or 'z', got {want!r}")
+    got = cal.get("up_axis") or "y"
+    if got == want:
+        return cal
+    return convert_calibration(cal, to_zup=(want == "z"))

toolbox/viz.py

@@ -334,3 +334,74 @@ def draw_collision_circle(frame_rgb, sensor_pose7, gel_center_mm, cam_calib,
     if 0 <= cx < w and 0 <= cy < h and rad_px < max(w, h):
         cv2.circle(out, (cx, cy), int(round(rad_px)), color, 1, cv2.LINE_AA)
     return out
+
+def draw_world_gizmo(frame_rgb, cam_calib, corner="tl", size=44, margin=12,
+                     labels=("x", "y", "z"), title=None):
+    """World-frame orientation gizmo in a corner. Returns a copy.
+
+    Shows which way the WORLD axes point in this camera, the way a 3D viewport
+    corner axis does. Directions come from the rotation of `T_mocap_to_cam`
+    only — a gizmo is deliberately orthographic, because a perspective one
+    would change as you moved it around the image and stop being a legend.
+
+    THE PART A NAIVE VERSION GETS WRONG: these cameras look down at the table,
+    so world +z (up) points almost AT the camera and its screen projection is
+    nearly zero length. Drawn as a plain arrow it would read as "z does not
+    exist". So each axis also carries its out-of-plane sign — a filled dot for
+    pointing toward the viewer, a cross for away — the standard convention, and
+    the arrow length is the in-plane component only.
+    """
+    import cv2
+
+    out = np.ascontiguousarray(frame_rgb).copy()
+    h, w = out.shape[:2]
+    T = np.asarray(cam_calib["T_mocap_to_cam"], float)[:3, :3]
+    # Inset by the FULL reach of the drawing, not by the arrow: the label sits
+    # 13 px past the tip and its glyph another ~9. The axis pointing straight
+    # up is the one that runs off the top edge, and that is the axis this
+    # gizmo exists to show.
+    reach = size + 22
+    ox = margin + reach if "l" in corner else w - margin - reach
+    oy = margin + reach if "t" in corner else h - margin - reach
+    # title BELOW the disc: at the top corner there is no room above it and the
+    # text clipped against the frame edge.
+    if title:
+        ty = oy + size + 22
+        for c, th in (((0, 0, 0), 3), ((215, 215, 215), 1)):
+            cv2.putText(out, title, (ox - size - 6, ty),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.34, c, th, cv2.LINE_AA)
+    # a faint disc so the gizmo reads against any background
+    ov = out.copy()
+    cv2.circle(ov, (ox, oy), size + 8, (18, 22, 34), -1)
+    cv2.addWeighted(ov, 0.55, out, 0.45, 0, out)
+    cv2.circle(out, (ox, oy), size + 8, (70, 80, 100), 1, cv2.LINE_AA)
+
+    for i, col in enumerate(AXIS_BGR_RGB):
+        e = np.zeros(3); e[i] = 1.0
+        d = T @ e                        # world axis, in camera coordinates
+        # camera x right, y down, z into the scene
+        px, py, pz = float(d[0]), float(d[1]), float(d[2])
+        inplane = float(np.hypot(px, py))
+        tipx, tipy = int(round(ox + px * size)), int(round(oy + py * size))
+        if inplane > 0.12:
+            cv2.arrowedLine(out, (ox, oy), (tipx, tipy), col, 2, cv2.LINE_AA,
+                            tipLength=0.28)
+            lx = int(round(ox + px * (size + 13)))
+            ly = int(round(oy + py * (size + 13)))
+        else:
+            lx, ly = ox + 14, oy - 14
+        # out-of-plane sign: toward the viewer is -z in camera coordinates
+        if abs(pz) > 0.55:
+            if pz < 0:                    # toward the viewer
+                cv2.circle(out, (ox, oy), 6, col, 2, cv2.LINE_AA)
+                cv2.circle(out, (ox, oy), 2, col, -1, cv2.LINE_AA)
+            else:                          # away from the viewer
+                cv2.circle(out, (ox, oy), 6, col, 2, cv2.LINE_AA)
+                r = 4
+                cv2.line(out, (ox-r, oy-r), (ox+r, oy+r), col, 1, cv2.LINE_AA)
+                cv2.line(out, (ox-r, oy+r), (ox+r, oy-r), col, 1, cv2.LINE_AA)
+        for c, th in (((0, 0, 0), 3), (col, 1)):
+            cv2.putText(out, labels[i], (lx - 4, ly + 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.42, c, th, cv2.LINE_AA)
+    return out
+

toolbox/world_frame.py

@@ -69,7 +69,8 @@ def projection_fingerprint(pose7, gel_center_mm, cams) -> dict:
     return out
 
 
-def verify_world_frame(pose7, side: str, task_root, declaration) -> float:
+def verify_world_frame(pose7, side: str, task_root, declaration, *,
+                       up_axis: str | None = None) -> float:
     """Worst per-camera pixel distance from the declared fingerprint.
 
     WORST, not mean: a frame error along one camera's optical axis is
@@ -77,9 +78,17 @@ def verify_world_frame(pose7, side: str, task_root, declaration) -> float:
     dilute exactly the evidence that matters.
 
     `task_root` is the directory holding `calibration/` — the same argument
-    `load_calibration` takes.
+    `load_calibration` takes. Its calibration is converted to the convention
+    the DECLARATION names, so a working tree that still holds the recorded
+    Y-up extrinsics gives the same answer as the published Z-up ones. Pass
+    `up_axis` only to override that.
+
+    Poses in one convention with extrinsics in the other project 165 px away
+    and raise nothing, which is why this reads the convention instead of
+    assuming it.
     """
     from .calibration import load_calibration
+    from .frames import as_up_axis
 
     if not declaration or "fingerprint" not in declaration:
         raise ValueError("declaration has no fingerprint; this episode "
@@ -92,7 +101,8 @@ def verify_world_frame(pose7, side: str, task_root, declaration) -> float:
             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)
+    want = up_axis or declaration.get("up_axis") or "y"
+    cal = as_up_axis(load_calibration(task_root), want)
     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: