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

toolbox/calib_epoch.py

@@ -41,6 +41,7 @@ dataset already publishes.
 from __future__ import annotations
 
 import json
+import re
 from functools import lru_cache
 from pathlib import Path
 
@@ -53,14 +54,65 @@ RELEASE = Path("/media/yxma/Disk1/twm/release")
 # worth naming; the directory names themselves are historical accidents.
 # Verified equal to the published `data/<task>/calibration/` for both tasks.
 CALIB_DIRS = {
-    "motherboard": REPO / "calibration" / "result backup",   # May-12 epoch
-    "pushT":       REPO / "calibration" / "result",          # June-26 epoch
+    "motherboard": REPO / "calibration" / "epoch_2026-05-12",
+    "pushT":       REPO / "calibration" / "epoch_2026-06-26",
 }
 EXPECTED_EPOCH = {"motherboard": "2026-05-12", "pushT": "2026-06-26"}
 
+# The epochs themselves, named by the date each was MEASURED.
+EPOCH_DIRS = {
+    "2026-05-12": REPO / "calibration" / "epoch_2026-05-12",
+    "2026-06-26": REPO / "calibration" / "epoch_2026-06-26",
+    "2026-09-09": REPO / "calibration" / "epoch_2026-09-09",
+}
+
+# Which epoch each RECORDING SESSION belongs to. `task -> epoch` cannot answer
+# this. The cameras were recalibrated between sessions, and a calibration is
+# measured near its sessions rather than before them: the May recordings are
+# covered by the May-12 measurement, pushT's 2026-06-18 by the June-26 one.
+# Date order therefore does not determine the answer, so a session declares
+# its epoch and nothing infers it.
+#
+# The 2026-09-09 motherboard session declares the epoch measured that same
+# day at 07:41, by the operator's decision. Recorded on: the recorder's live
+# overlay ran on the June-26 epoch during collection, and projecting each
+# GelSight centre into all three views on a mid-episode frame puts June-26 on
+# the sensors while 2026-09-09 sits 20-40 px away and May-12 30-60 px away.
+# Both solves fit their own points equally well (0.5-0.7 px RMSE) and share an
+# identical gel-to-rigid transform, so the two disagree only about where the
+# cameras were. Re-check with the projection comparison if the previews ever
+# look off.
+CALIB_SESSIONS = {
+    ("motherboard", "2026-05-10"): "2026-05-12",
+    ("motherboard", "2026-05-11"): "2026-05-12",
+    ("motherboard", "2026-05-19"): "2026-05-12",
+    ("motherboard", "2026-09-09"): "2026-09-09",
+    ("pushT",       "2026-06-18"): "2026-06-26",
+}
+
 
-def calib_dir(task: str, *, up_axis: str | None = None) -> Path:
-    """Directory of camera extrinsics valid for `task`.
+def session_epoch(task: str, date: str) -> str:
+    """The epoch a recording session declares.
+
+    Raises for an undeclared session rather than falling back to the task
+    default: the fallback is exactly how a session ships through another
+    session's extrinsics with nobody noticing.
+    """
+    try:
+        return CALIB_SESSIONS[(task, date)]
+    except KeyError:
+        known = sorted(d for t, d in CALIB_SESSIONS if t == task)
+        raise KeyError(
+            f"{task}: session {date!r} does not declare a calibration epoch. "
+            f"Declared sessions: {known}. Add it to calib_epoch.CALIB_SESSIONS "
+            f"— do not fall back to another session's extrinsics.") from None
+
+
+
+def calib_dir(task: str, *, date: str | None = None,
+              up_axis: str | None = None) -> Path:
+    """Directory of camera extrinsics valid for `task` — and for `date`,
+    when the caller knows which session it is reading (`CALIB_SESSIONS`).
 
     Looked up in this order, so the module works outside the repository it
     lives in:
@@ -115,6 +167,13 @@ def calib_dir(task: str, *, up_axis: str | None = None) -> Path:
         cand = Path(rel) / task / "calibration"
         if cand.is_dir():
             return _ok(cand)
+    if date is not None:
+        d = EPOCH_DIRS[session_epoch(task, date)]
+        if not d.is_dir():
+            raise FileNotFoundError(
+                f"calibration dir for the {session_epoch(task, date)} epoch "
+                f"({task}/{date}) is missing: {d}")
+        return _ok(d)
     try:
         d = CALIB_DIRS[task]
     except KeyError:
@@ -130,6 +189,9 @@ def calib_dir(task: str, *, up_axis: str | None = None) -> Path:
     return _ok(d)
 
 
+_DATE_PART = re.compile(r"\d{4}-\d{2}-\d{2}")
+
+
 def calib_dir_for_path(p: str | Path, *, up_axis: str = "y") -> Path:
     """Epoch dir inferred from any path containing a task-name component.
 
@@ -143,30 +205,42 @@ def calib_dir_for_path(p: str | Path, *, up_axis: str = "y") -> Path:
     failure: raises, listing the known tasks, so the caller passes explicit
     calibration paths instead of silently viewing through the wrong epoch.
     """
-    parts = set(Path(p).parts) | set(Path(p).resolve().parts)
+    all_parts = list(Path(p).parts) + list(Path(p).resolve().parts)
+    parts = set(all_parts)
     hits = [t for t in CALIB_DIRS if t in parts]
     if len(hits) == 1:
-        return calib_dir(hits[0], up_axis=up_axis)
+        # A recording path carries its session date as a component
+        # (<task>/<YYYY-MM-DD>/episode_NNN.h5). Use it: the epoch is per
+        # session, and the task default is the wrong answer for any session
+        # recorded after the rig was recalibrated.
+        dates = [q for q in all_parts if _DATE_PART.fullmatch(q)]
+        return calib_dir(hits[0], date=dates[0] if dates else None, 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)}")
 
 
-def epoch_of(task: str) -> str:
+def epoch_of(task: str, date: str | None = None) -> str:
     """The calibration date actually on disk for `task` (from the files)."""
-    p = calib_dir(task) / "T_mocap_to_cam_middle.json"
+    p = calib_dir(task, date=date) / "T_mocap_to_cam_middle.json"
     created = json.loads(p.read_text()).get("created_at") or ""
     return created[:10]
 
 
-def check_epoch(task: str) -> None:
-    """Fail loudly if the directory does not hold the epoch it should."""
-    got, want = epoch_of(task), EXPECTED_EPOCH.get(task)
+def check_epoch(task: str, date: str | None = None) -> None:
+    """Fail loudly if the directory does not hold the epoch it should.
+
+    With a `date` it is the SESSION's declared epoch that must be there;
+    without one, the task default.
+    """
+    got = epoch_of(task, date=date)
+    want = session_epoch(task, date) if date is not None else EXPECTED_EPOCH.get(task)
     if want and got != want:
+        where = f"{task}/{date}" if date is not None else task
         raise ValueError(
-            f"{task}: calibration dir holds the {got} epoch, expected {want} "
-            f"({calib_dir(task)}). Using another epoch's extrinsics puts the "
-            f"projected sensor off the sensor.")
+            f"{where}: calibration dir holds the {got} epoch, expected {want} "
+            f"({calib_dir(task, date=date)}). Using another epoch's extrinsics "
+            f"puts the projected sensor off the sensor.")
 
 
 @lru_cache(maxsize=None)
@@ -224,7 +298,7 @@ def world_offset_m(task: str, date: str, episode: str, *,
     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
+        from .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]))
@@ -234,7 +308,11 @@ def describe(task: str, date: str, episode: str) -> str:
     """One line for a status bar, so the applied correction is visible."""
     # 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)}"
+    # The session's epoch, not the task default: this line exists so a viewer
+    # can catch a wrong epoch without trusting the pipeline, and a label that
+    # names a different epoch than the one that drew the axes is worse than
+    # no label at all.
+    s = f"calib {epoch_of(task, date)}"
     if any((dx, dy, dz)):
         s += f" world+({dx:g},{dy:g},{dz:g})m"
     return s