scripts/test_probe_frame_and_collision.py

"""One sensor moves, the other stays, they never touch, and depth is visible.

Four properties the first version of the probe set did not have:

  1  THE WHOLE SENSOR FRAME IS DRAWN, not a dot. A dot shows position and
     hides orientation, which makes the six ROTATION probes unreadable — they
     move the marker barely at all. The React previews draw a triad for this
     reason and so does this.

  2  PERSPECTIVE IS REAL. The axis tips are placed in 3D at a fixed
     millimetre length and then projected, so a sensor nearer the camera draws
     a larger triad. Drawing a fixed PIXEL length would assert that two
     sensors at different depths are the same size, which is the one thing a
     projection is supposed to tell you.

  3  ONE SENSOR MOVES PER PROBE, and which one is random. Every probe in the
     first version moved the left sensor, so half the rig was never exercised
     and any left-specific defect would have been invisible.

  4  THEY DO NOT COLLIDE. Each gel carries a 0.12 m-diameter exclusion circle,
     so the two centres must stay at least 0.12 m apart for every step. In the
     real data the centres sit 0.225 m apart at the median and closer than
     0.12 m on 1.67% of frames, so this rejects a little and forbids the
     physically impossible.

    python scripts/test_probe_frame_and_collision.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   # noqa: E402

import numpy as np                                              # noqa: E402

from react_toolbox.staging import staging_dir

RESULTS: list[tuple[bool, str, str]] = []
COLLISION_M = 0.12


def check(ok: bool, name: str, evidence: str) -> None:
    RESULTS.append((bool(ok), name, evidence))


def main() -> int:
    import pyarrow.parquet as pq

    import react_toolbox as T
    from react_toolbox.synth_actions import COLLISION_DIAMETER_M, sample_probe
    from react_toolbox.frames import as_up_axis
    from twm.calib_epoch import calib_dir

    stage = staging_dir()
    shutil.copytree(calib_dir("motherboard"), stage / "calibration")
    cal = as_up_axis(T.load_calibration(stage), "z")  # release poses
    cam = cal["cams"]["middle"]

    check(abs(COLLISION_DIAMETER_M - COLLISION_M) < 1e-9,
          "the collision diameter is 0.12 m",
          f"COLLISION_DIAMETER_M = {COLLISION_DIAMETER_M}")

    # 1 / 2 — the frame projects with real perspective
    if not hasattr(T, "project_gel_frame"):
        check(False, "the whole sensor frame is projected", "no project_gel_frame")
        check(False, "a nearer sensor draws a bigger triad", "not attempted")
    else:
        # DEPTH IS MEASURED, NOT ASSUMED. My first version displaced along
        # world +z and called the result "further from the camera"; world +z
        # is not the camera's view direction here, so the "far" pose came out
        # NEARER and the check failed on its own premise. `project_gel_frame`
        # returns the camera-frame depth, so the two poses are ordered by what
        # it reports rather than by which way I guessed the axis points.
        base = np.array([0.40, 0.02, 0.20, 0.0, 0.0, 0.0, 1.0])
        cands = []
        for k in range(3):
            for sgn in (+1, -1):
                q = base.copy()
                q[k] += sgn * 0.35
                r = T.project_gel_frame(q, cal["gel_left"], cam, axis_len_mm=60.0)
                if r is not None:
                    cands.append((r["depth_mm"], q))
        cands.sort()
        near, far = cands[0][1], cands[-1][1]
        depths = (cands[0][0], cands[-1][0])
        spans = []
        for p in (near, far):
            r = T.project_gel_frame(p, cal["gel_left"], cam, axis_len_mm=60.0)
            if r is None:
                spans.append(None)
                continue
            c, tips = r["centre"], [t for t in r["tips"] if t is not None]
            spans.append(max(float(np.hypot(t[0] - c[0], t[1] - c[1]))
                             for t in tips) if tips else 0.0)
        ok = all(s is not None for s in spans)
        check(ok and len(spans[0:1]) == 1,
              "the whole sensor frame is projected",
              f"centre + {len(tips)} axis tips")
        check(ok and spans[0] > spans[1] * 1.2,
              "a nearer sensor draws a bigger triad",
              f"depth {depths[0]:.0f} mm -> span {spans[0]:.1f} px, "
              f"depth {depths[1]:.0f} mm -> span {spans[1]:.1f} px"
              if ok else "projection failed")

    # 3 / 4 — one sensor moves, chosen at random, and no collision
    P = (str(force_meta("motherboard"))+"/"
         "2026-05-11/episode_003.parquet")
    t = pq.read_table(P, columns=["sensor_left_pose", "sensor_right_pose"]).to_pydict()
    poses = {s: np.asarray([x for x in t[f"sensor_{s}_pose"]], float)
             for s in ("left", "right")}

    moving = set()
    viol = []
    for seed in range(12):
        try:
            r = sample_probe(poses, cal, seed=seed, view="middle")
        except (TypeError, ValueError) as exc:
            check(False, "one sensor moves per probe, chosen at random",
                  f"sample_probe: {type(exc).__name__}: {str(exc)[:70]}")
            check(False, "the two sensors never come within 0.12 m",
                  "not attempted")
            _report()
            return 1
        moving.add(r["moving_side"])
        for p in r["probes"]:
            d = p.get("min_separation_m")
            if d is not None and d < COLLISION_M - 1e-9:
                viol.append(f"{r['moving_side']}/{p['name']}: {d:.3f} m")
    check(moving == {"left", "right"},
          "one sensor moves per probe, chosen at random",
          f"over 12 seeds the moving side was {sorted(moving)}")
    check(not viol, "the two sensors never come within 0.12 m",
          f"{len(viol)} violating probe(s)" + (f"; {viol[:2]}" if viol else ""))

    _report()
    return 1 if sum(not ok for ok, _, _ in RESULTS) else 0


def _report() -> None:
    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}")
    print(f"\nprobe frame + collision: {len(RESULTS)} checks, "
          f"{sum(not ok for ok, _, _ in RESULTS)} failing")


if __name__ == "__main__":
    raise SystemExit(main())