scripts/test_synth_actions.py

"""Synthetic probe trajectories: axis-aligned, dataset-paced, in view.

Twelve controlled action sequences — six pure translations along +/-x, +/-y,
+/-z and six pure rotations about the same axes — for probing a world model
where no ground-truth future image exists. They are judged by eye against the
GT sensor-pose projection overlaid on the start frame.

The requirements that are checkable, and are checked:

  1  SIX DIRECTIONS, ONE AXIS EACH. A trajectory that drifts off its axis is
     not a controlled probe.
  2  DATASET-PACED. Per-step magnitude must sit inside the measured
     distribution, not merely "look reasonable". Measured over 480,008 rows:
     |dp| p25 0.971, p50 2.813, p90 10.158 mm/step; |dtheta| p25 0.320,
     p50 0.699, p90 2.296 deg/step.
  3  HORIZON > 1.5 s. At 30 Hz that is 45 steps.
  4  UNIFORM SPEED, so a failure is attributable to direction and magnitude
     rather than to an acceleration profile nothing else in the set shares.
  5  IN VIEW BY DEFAULT. The projected pose must stay inside the image for
     every step, or the probe leaves the distribution the model was trained
     on and its output is uninterpretable. `allow_leaving_view=True` exists
     for deliberate OOD probes and is NOT the default.
  6  ACTIONS AND START FRAMES ARE INDEPENDENT. The action set is generated
     without reference to any frame; a start frame is then accepted or
     rejected against it. Coupling them would make "which frames survive" a
     property of the generator rather than of the geometry.
  7  THE MODEL INPUT IS SEVERAL CONSECUTIVE FRAMES, so the sampler returns a
     context window, not one image.

    python scripts/test_synth_actions.py
"""
from __future__ import annotations

import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

import numpy as np                                              # noqa: E402

RESULTS: list[tuple[bool, str, str]] = []
# measured over the release, 30 Hz rows
DP_P25, DP_P50, DP_P90 = 0.971, 2.813, 10.158        # mm / step
DA_P25, DA_P50, DA_P90 = 0.320, 0.699, 2.296         # deg / step


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


def main() -> int:
    from react_toolbox.synth_actions import (DA_PCT, DP_PCT, _speed_percentile,
                                             gel_centre_world,
                                             make_rotation_set,
                                             make_translation_set)
    from scipy.spatial.transform import Rotation

    start = np.array([0.40, 0.02, 0.30, 0.0, 0.0, 0.0, 1.0])

    # the real measured gel offset: 65.7 mm from the rigid-body origin, which
    # is exactly why the pivot matters
    GEL = np.array([-42.6, -36.6, -34.2])
    tr = make_translation_set(start, seed=0)
    ro = make_rotation_set(start, GEL, seed=0)
    check(len(tr) == 6 and len(ro) == 6, "six directions in each set",
          f"{len(tr)} translations, {len(ro)} rotations")

    # 1 — one axis each, and the six cover +/- on all three
    axes = set()
    off = []
    for t in tr:
        d = t["poses"][-1, :3] - t["poses"][0, :3]
        a = int(np.argmax(np.abs(d)))
        axes.add((a, int(np.sign(d[a]))))
        lateral = np.linalg.norm(np.delete(d, a))
        if lateral > 1e-9:
            off.append(f"{t['name']}: {lateral*1000:.3f} mm off-axis")
    check(len(axes) == 6 and not off, "each translation moves on one axis",
          f"{len(axes)} distinct (axis, sign)" + (f"; {off[:2]}" if off else ""))

    # 2 — per-step magnitude inside the measured distribution
    bad = []
    for t in tr:
        s = np.linalg.norm(np.diff(t["poses"][:, :3], axis=0), axis=1) * 1000
        if not (DP_P25 <= s.mean() <= DP_P90):
            bad.append(f"{t['name']}: {s.mean():.2f} mm/step")
    for r in ro:
        q = Rotation.from_quat(r["poses"][:, 3:7])
        s = np.degrees((q[:-1].inv() * q[1:]).magnitude())
        if not (DA_P25 <= s.mean() <= DA_P90):
            bad.append(f"{r['name']}: {s.mean():.3f} deg/step")
    check(not bad, "per-step magnitude is inside the dataset distribution",
          f"{12-len(bad)}/12 within p25-p90" + (f"; {bad[:3]}" if bad else ""))

    # 3 / 4 — horizon and uniform speed
    short = [x["name"] for x in tr + ro if x["n_steps"] < 45]
    check(not short, "horizon exceeds 1.5 s (45 steps at 30 Hz)",
          f"shortest {min(x['n_steps'] for x in tr+ro)} steps"
          + (f"; too short: {short}" if short else ""))

    jitter = []
    for t in tr:
        s = np.linalg.norm(np.diff(t["poses"][:, :3], axis=0), axis=1)
        if s.std() / max(s.mean(), 1e-12) > 1e-6:
            jitter.append(f"{t['name']}: cv {s.std()/s.mean():.2e}")
    check(not jitter, "speed is uniform",
          f"{6-len(jitter)}/6 constant-speed" + (f"; {jitter[:2]}" if jitter else ""))

    # 5 — amplitude ranges as specified
    amps = [np.linalg.norm(t["poses"][-1, :3] - t["poses"][0, :3]) for t in tr]
    ang = []
    for r in ro:
        q = Rotation.from_quat(r["poses"][[0, -1], 3:7])
        ang.append(np.degrees((q[0].inv() * q[1]).magnitude()))
    check(all(0.1 - 1e-9 <= a <= 0.4 + 1e-9 for a in amps)
          and all(18 - 1e-6 <= a <= 90 + 1e-6 for a in ang),
          "amplitudes are within the requested ranges",
          f"translation {min(amps):.3f}-{max(amps):.3f} m, "
          f"rotation {min(ang):.1f}-{max(ang):.1f} deg")


    # 6 — SPEED IS SAMPLED, NOT DERIVED. The first version computed
    #     n = amplitude / p50, so every probe long enough to clear the 1.5 s
    #     floor ran at EXACTLY the median: 48 of 60 published probes sat
    #     within 1% of 2.813 mm/step and not one exceeded p50. A p25-p90
    #     range check passes on a constant, which is why it did.
    from react_toolbox.synth_actions import SPEED_PCT_RANGE
    pc_t, pc_r = [], []
    for sd in range(24):
        pc_t += [t["speed_percentile"] for t in make_translation_set(start, seed=sd)]
        pc_r += [r["speed_percentile"] for r in make_rotation_set(start, GEL, seed=sd)]
    pc_t, pc_r = np.array(pc_t), np.array(pc_r)
    lo, hi = SPEED_PCT_RANGE
    spread_ok = (np.percentile(pc_t, 90) - np.percentile(pc_t, 10) > 15
                 and np.percentile(pc_r, 90) - np.percentile(pc_r, 10) > 15)
    clumped = max(np.mean(np.abs(pc_t - np.median(pc_t)) < 1.0),
                  np.mean(np.abs(pc_r - np.median(pc_r)) < 1.0))
    check(spread_ok and clumped < 0.25, "speed is drawn at random, not pinned to p50",
          f"translation p10-p90 {np.percentile(pc_t,10):.0f}-{np.percentile(pc_t,90):.0f}, "
          f"rotation {np.percentile(pc_r,10):.0f}-{np.percentile(pc_r,90):.0f}; "
          f"{clumped*100:.0f}% within 1 pct-pt of the median")

    # 7 — AND NOT SUPER SLOW. The floor is the amplitude the 1.5 s horizon
    #     forces: 0.1 m over 45 steps is 2.22 mm/step, the dataset's p42.
    #     Nothing may be slower than that, and the bulk must clear `lo`.
    floor_t = _speed_percentile(0.100 * 1000 / 45, DP_PCT)
    floor_r = _speed_percentile(18.0 / 45, DA_PCT)
    check(pc_t.min() >= floor_t - 0.5 and pc_r.min() >= floor_r - 0.5
          and np.median(pc_t) >= lo and np.median(pc_r) >= lo,
          "no probe is slower than the horizon forces",
          f"slowest translation p{pc_t.min():.0f} (floor p{floor_t:.0f}), "
          f"rotation p{pc_r.min():.0f} (floor p{floor_r:.0f}); "
          f"medians p{np.median(pc_t):.0f}/p{np.median(pc_r):.0f} vs requested >= p{lo:.0f}")

    # 8 — A ROTATION PROBE ROTATES IN PLACE. The pose is the RIGID BODY's,
    #     the drawn frame is the GEL's, and the gel sits 65.7 mm off the
    #     rigid origin — so holding the rigid position fixed swings the gel
    #     through an arc of up to 52.8 mm. On screen a "pure rotation" then
    #     translates, which is what a viewer sees and calls a bug. The pivot
    #     must be the gel centre, the thing the picture actually shows.
    swing = []
    for r in ro:
        g = gel_centre_world(r["poses"], GEL)
        swing.append((r["name"], float(np.max(np.linalg.norm(g - g[0], axis=1)))))
    worst = max(swing, key=lambda x: x[1])
    turned = []
    for r in ro:
        q = Rotation.from_quat(r["poses"][[0, -1], 3:7])
        turned.append(np.degrees((q[0].inv() * q[1]).magnitude()))
    check(worst[1] < 1.0 and min(turned) > 17.0,
          "a rotation probe pivots about the gel, not the marker origin",
          f"gel centre moves at most {worst[1]:.2f} mm ({worst[0]}) while "
          f"turning {min(turned):.0f}-{max(turned):.0f} deg")

    _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"\nsynth actions: {len(RESULTS)} checks, "
          f"{sum(not ok for ok, _, _ in RESULTS)} failing")


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