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

toolbox/__init__.py

@@ -22,5 +22,14 @@ __all__ = [
     "next_state_action", "delta_pose_action", "integrate_delta",
     "diff_heatmap", "contact_overlay", "reference_compare", "depth_view", "height_to_pointcloud",
     "load_calibration", "project_gel_to_pixel",
+    "draw_projection", "force_radius_px",
+    "read_world_frame", "verify_world_frame", "projection_fingerprint",
 ]
 __version__ = "0.1.0"
+
+# Projection debugging. `draw_projection` renders what `project_gel_to_pixel`
+# computed, so a user can see whether it lands on the sensor; the world-frame
+# helpers let them check the same thing without looking.
+from .viz import draw_projection, force_radius_px          # noqa: F401
+from .world_frame import (projection_fingerprint,           # noqa: F401
+                          read_world_frame, verify_world_frame)

toolbox/calibration.py

@@ -38,12 +38,46 @@ def load_calibration(task_root):
     for side in ("left", "right"):
         p = cdir / f"T_gel_to_rigid_{side}.json"
         if p.exists():
-            d = json.loads(p.read_text())
-            T = np.array(d.get("T_gel_to_rigid", d.get("T")), np.float64)
-            out[f"gel_{side}"] = T[:3, 3] if T.shape == (4, 4) else np.array(d.get("gel_center_mm", [0, 0, 0]))
+            out[f"gel_{side}"] = _gel_center(p)
     return out
 
 
+def _gel_center(path) -> np.ndarray:
+    """The measured gel centre in rigid-body millimetres. RAISES if absent.
+
+    This read three keys that do not exist in any published file —
+    `T_gel_to_rigid`, `T`, `gel_center_mm` — and fell through to a default of
+    `[0, 0, 0]`. The real key is `gel_center_in_rigid_mm`, and it is present in
+    all four published files of both tasks.
+
+    Zero is the worst possible default here because it is a VALID-LOOKING
+    offset: it says "the gel centre is the rigid-body origin", so nothing
+    downstream can tell it from a real answer. Every projection the toolbox
+    produced was of the rigid body, off by the real offset — measured on
+    motherboard/2026-05-11/episode_003, median over the episode: 35.8 px
+    (left camera), 20.8 (middle), 28.0 (right), against a calibration rmse of
+    4.75 mm ~ 3 px. Seven to twelve times the rig's own error, and still
+    shaped like a slightly miscalibrated rig rather than like a bug.
+
+    So: no fallback. A calibration file that cannot say where the gel is stops
+    the caller, because a projection of the wrong point is worse than none.
+    """
+    d = json.loads(Path(path).read_text())
+    for key in ("gel_center_in_rigid_mm", "gel_center_mm"):
+        if key in d:
+            return np.asarray(d[key], np.float64)
+    T = d.get("T_gel_to_rigid", d.get("T"))
+    if T is not None:
+        T = np.asarray(T, np.float64)
+        if T.shape == (4, 4):
+            return T[:3, 3]
+    raise KeyError(
+        f"{path}: no gel centre. Looked for gel_center_in_rigid_mm, "
+        f"gel_center_mm, T_gel_to_rigid, T. Refusing to assume [0,0,0] — "
+        f"that is a valid-looking offset and would silently project the "
+        f"rigid-body origin instead of the gel.")
+
+
 def pose7_to_matrix(pose7):
     """[x,y,z, qx,qy,qz,qw] (m, scalar-last) -> 4x4 (mm translation)."""
     p = np.asarray(pose7, np.float64)

toolbox/quickstart.md

@@ -40,6 +40,22 @@ ov  = T.contact_overlay(frames[100], ref)
 cal = T.load_calibration("data/motherboard")                # after snapshot_download of calibration/
 uv  = T.project_gel_to_pixel(meta["sensor_left_pose"][100], cal["gel_left"], cal["cams"]["middle"])
 
+# 5b) SEE it land — a coordinate cannot tell you whether it is on the sensor,
+#     and every projection defect this dataset has shipped was obvious in a
+#     picture and invisible in a number (21-36 px, 35-73 px, 155-223 px, all
+#     of them shaped like a slightly miscalibrated rig).
+img = T.draw_projection(cam_frame, meta["sensor_left_pose"][100],
+                        cal["gel_left"], cal["cams"]["middle"],
+                        force_n=meta["force_left_normal_n"][100],
+                        target_pose7=meta["force_left_target_pose"][100])
+
+# 5c) or check it without looking: every episode's parquet declares the world
+#     frame its poses are in, and carries a projection fingerprint you can
+#     recompute. A pose array in the wrong frame misses it by 150+ px.
+dec = T.read_world_frame(episode_parquet)     # {"world_frame", "raw_h5_offset_m", "fingerprint"}
+err = T.verify_world_frame(meta["sensor_left_pose"], "left", "motherboard", dec)
+assert err < 6.0, f"poses are not in the declared frame: {err:.1f} px off"
+
 # 6) derive actions from handheld poses
 act   = T.next_state_action(meta["sensor_left_pose"])       # next-frame absolute state
 delta = T.delta_pose_action(meta["sensor_left_pose"])       # frame-to-frame delta

toolbox/viz.py

@@ -60,3 +60,96 @@ def height_to_pointcloud(height_map, stride=4, z_scale=1.0):
     h = height_map[::stride, ::stride]
     ys, xs = np.mgrid[0:h.shape[0], 0:h.shape[1]]
     return np.stack([xs.ravel(), ys.ravel(), (h * z_scale).ravel()], axis=1).astype(np.float32)
+
+
+# ── camera-view projection, for checking your own geometry ──────────────────
+# Force -> disc radius. Area is linear in force: human size judgement of a
+# filled disc tracks its area, so radius ∝ F would exaggerate large forces
+# roughly quadratically. Same law the published preview videos use.
+F_FULL_N, R_MIN_PX, R_MAX_PX = 8.0, 3.0, 22.0
+TARGET_GAIN = 40.0          # drawn gap exaggeration; see draw_projection
+
+
+def force_radius_px(force_n):
+    """THE force -> pixel-radius law, so a legend cannot drift from a disc."""
+    f = max(float(force_n), 0.0)
+    return R_MIN_PX + (R_MAX_PX - R_MIN_PX) * (min(f, F_FULL_N) / F_FULL_N) ** 0.5
+
+
+def draw_projection(frame_rgb, sensor_pose7, gel_center_mm, cam_calib,
+                    force_n=None, target_pose7=None, gain=TARGET_GAIN,
+                    label=None):
+    """Draw where the sensor projects into this camera view. Returns a copy.
+
+    WHY THE TOOLBOX DRAWS AT ALL
+
+    A coordinate is a weak debugging aid for a geometry problem. Knowing that
+    `project_gel_to_pixel` returned (366, 188) says nothing about whether that
+    is ON the sensor, and every projection defect this dataset has shipped was
+    obvious in a picture and invisible in a number:
+
+        wrong calibration epoch            35-73 px
+        gel centre defaulted to the origin 21-36 px
+        world offset not applied          155-223 px
+
+    All three look like a slightly miscalibrated rig, which is exactly why
+    they survived. Render one frame and they stop looking like that.
+
+    Draws, when given: the gel centre (dot), the pressing normal (line), the
+    press force (translucent disc, area linear in newtons) and the DexForce
+    virtual target (ring joined to the dot).
+
+    ONE PROJECTION. Every element goes through `calibration.project_gel_to_pixel`
+    — the same call you use — so the picture cannot disagree with the number
+    you got from the library.
+
+    `gain` exaggerates the drawn target OFFSET only, and is printed on the
+    image. At true scale it is invisible: force/k is millimetres while the
+    view spans a metre, measured p50 0.00 px and max 1.41 px on a real
+    episode, against a force disc of radius up to 22 px. An unlabelled
+    exaggeration is a false statement about a distance.
+    """
+    import cv2
+
+    from .calibration import project_gel_to_pixel
+
+    out = np.ascontiguousarray(frame_rgb).copy()
+    uv = project_gel_to_pixel(sensor_pose7, gel_center_mm, cam_calib)
+    if uv is None:                      # behind the camera: draw nothing.
+        return out                      # A wrapped coordinate is not a position.
+    u, v = int(round(uv[0])), int(round(uv[1]))
+    h, w = out.shape[:2]
+    if not (0 <= u < w and 0 <= v < h):
+        return out
+
+    if force_n is not None and float(force_n) > 0.02:
+        r = int(round(force_radius_px(force_n)))
+        layer = out.copy()
+        cv2.circle(layer, (u, v), r, (255, 120, 60), -1, cv2.LINE_AA)
+        cv2.addWeighted(layer, 0.42, out, 0.58, 0, out)
+        cv2.circle(out, (u, v), r, (255, 120, 60), 1, cv2.LINE_AA)
+        cv2.putText(out, f"{float(force_n):.1f}N", (u + r + 4, v - r - 4),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.42, (255, 120, 60), 1,
+                    cv2.LINE_AA)
+
+    if target_pose7 is not None:
+        t = np.asarray(target_pose7, np.float64).copy()
+        o = np.asarray(sensor_pose7, np.float64)
+        if not np.allclose(t[:3], o[:3]):        # force 0 -> target IS pose
+            t[:3] = o[:3] + gain * (t[:3] - o[:3])   # exaggerate in WORLD mm,
+            tuv = project_gel_to_pixel(t, gel_center_mm, cam_calib)  # then project
+            if tuv is not None:
+                tu, tv = int(round(tuv[0])), int(round(tuv[1]))
+                cv2.line(out, (u, v), (tu, tv), (220, 0, 255), 1, cv2.LINE_AA)
+                cv2.circle(out, (tu, tv), 5, (220, 0, 255), 1, cv2.LINE_AA)
+                cv2.putText(out, f"target x{gain:g}", (tu + 7, tv + 4),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.36, (220, 0, 255), 1,
+                            cv2.LINE_AA)
+
+    cv2.circle(out, (u, v), 3, (255, 255, 255), -1, cv2.LINE_AA)
+    cv2.circle(out, (u, v), 5, (0, 200, 255), 1, cv2.LINE_AA)
+    if label:
+        cv2.putText(out, str(label), (u + 8, v + 4),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.42, (0, 200, 255), 1,
+                    cv2.LINE_AA)
+    return out

toolbox/world_frame.py

@@ -0,0 +1,102 @@
+"""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)