Datasets:

yxma
/

React

@@ -138,9 +138,20 @@ def main() -> int:
     ap.add_argument("--out", default=str(out_root("probe_clips")))
     args = ap.parse_args()
     out = Path(args.out)
     if out.exists():
         shutil.rmtree(out)
     (out / "clips").mkdir(parents=True)
     cal = load_calibration(SRC)
     require_up_axis(cal, where=f"{SRC}/calibration")
@@ -217,8 +228,36 @@ def _page(out: Path, recs, man) -> None:
          f"speed vs the dataset (median p{st.median(pct):.0f})"),
         (f"{min(seps):.3f} m", "closest the hands come (rule 0.12)"),
     ]
     secs = "".join(
-        f"<h2>{name}</h2><div class='grid'>" + "".join(
             f"<figure><video src='{r['clip']}' controls loop muted playsinline "
             f"poster='{r['clip'].replace('.mp4', '.jpg')}' preload='none'>"
             f"</video><figcaption>run{r['run']} &middot; "
@@ -245,6 +284,8 @@ p{color:var(--dim);max-width:78ch}a{color:var(--accent)}
 figure{margin:0;background:var(--card);border:1px solid var(--line);border-radius:10px;padding:8px}
 video{width:100%;border-radius:6px;background:#000}
 figcaption{color:var(--dim);font-size:12px;margin-top:6px}
 </style></head><body><div class="wrap">
 <h1>React probe clips</h1>
 <p>Every clip here is an animation <b>of the published test set</b> &mdash; the same

     ap.add_argument("--out", default=str(out_root("probe_clips")))
     args = ap.parse_args()
     out = Path(args.out)
+    # real/ is built by a different script and must survive this rebuild.
+    # Without this the page would show the real clips exactly once, until the
+    # next time anyone regenerated the synthetic ones -- and it would look
+    # like they had simply never been built.
+    import tempfile
+    stash = None
+    if (out / "real").is_dir():
+        stash = Path(tempfile.mkdtemp()) / "real"
+        shutil.move(str(out / "real"), str(stash))
     if out.exists():
         shutil.rmtree(out)
     (out / "clips").mkdir(parents=True)
+    if stash is not None:
+        shutil.move(str(stash), str(out / "real"))
     cal = load_calibration(SRC)
     require_up_axis(cal, where=f"{SRC}/calibration")
          f"speed vs the dataset (median p{st.median(pct):.0f})"),
         (f"{min(seps):.3f} m", "closest the hands come (rule 0.12)"),
     ]
+    # REAL counterparts, if they have been built. The synthetic probes show a
+    # commanded motion over a frozen frame; nobody performed them. Beside each
+    # one, the same signed axis as it actually occurs in the recordings, found
+    # by the criteria the probes are BUILT with (translation holds
+    # orientation, rotation holds the gel centre) rather than a looser
+    # "mostly along x".
+    real = {}
+    rj = out / "real" / "real_motion.json"
+    if rj.exists():
+        for r in json.loads(rj.read_text()):
+            real[r["name"]] = r
+    def _real_fig(name):
+        r = real.get(name)
+        if not r:
+            return ""
+        return (f"<figure class='real'><video src='{r['clip']}' controls loop "
+                f"muted playsinline preload='none' "
+                f"poster='{r['clip'].replace('.mp4', '.jpg')}'></video>"
+                f"<figcaption><b>real</b> &middot; {r['date']}/{r['episode']}"
+                f"<br>{r['amount']:.0f}"
+                f"{'mm' if r['unit'] == 'mm' else '&deg;'} &middot; "
+                f"{r['purity_kind']} {r['purity']:.2f} &middot; "
+                f"per-step {r['step_dominance']:.2f}<br>"
+                f"holds {r['counter']:.1f}"
+                f"{'&deg;' if r['counter_unit'] == 'deg' else 'mm'} &middot; "
+                f"{r['window']}f &middot; {r['side']}</figcaption></figure>")
     secs = "".join(
+        f"<h2>{name}</h2><div class='grid'>" + _real_fig(name) + "".join(
             f"<figure><video src='{r['clip']}' controls loop muted playsinline "
             f"poster='{r['clip'].replace('.mp4', '.jpg')}' preload='none'>"
             f"</video><figcaption>run{r['run']} &middot; "
 figure{margin:0;background:var(--card);border:1px solid var(--line);border-radius:10px;padding:8px}
 video{width:100%;border-radius:6px;background:#000}
 figcaption{color:var(--dim);font-size:12px;margin-top:6px}
+figure.real{border-color:var(--accent)}
+figure.real figcaption b{color:var(--accent)}
 </style></head><body><div class="wrap">
 <h1>React probe clips</h1>
 <p>Every clip here is an animation <b>of the published test set</b> &mdash; the same

scripts/build_splits.py CHANGED Viewed

@@ -23,12 +23,17 @@ def main() -> int:
     ap.add_argument("--seed", type=int, default=0)
     ap.add_argument("--test-len", type=int, default=TEST_INTERVAL_FRAMES)
     ap.add_argument("--max-train-window", type=int, default=MAX_TRAIN_WINDOW)
     ap.add_argument("--target", type=float, default=TARGET_TEST_FRACTION)
     a = ap.parse_args()
     root = Path(a.root)
     eps = [json.loads(l) for l in (root / "episodes.jsonl").read_text().splitlines() if l.strip()]
     bad = json.loads((root / "bad_frames.json").read_text())["episodes"]
     s = build_splits(eps, bad, seed=a.seed, test_len=a.test_len,
                      max_train_window=a.max_train_window, target=a.target)
     (root / "splits.json").write_text(json.dumps(s, indent=1))
     st = s["stats"]

     ap.add_argument("--seed", type=int, default=0)
     ap.add_argument("--test-len", type=int, default=TEST_INTERVAL_FRAMES)
     ap.add_argument("--max-train-window", type=int, default=MAX_TRAIN_WINDOW)
+    ap.add_argument("--hold-out", nargs="*", default=(), metavar="DATE/EPISODE",
+                    help="episodes held out WHOLE, e.g. a validation session. "
+                         "Leaving them out of the file instead makes a loader "
+                         "treat them as training data, silently.")
     ap.add_argument("--target", type=float, default=TARGET_TEST_FRACTION)
     a = ap.parse_args()
     root = Path(a.root)
     eps = [json.loads(l) for l in (root / "episodes.jsonl").read_text().splitlines() if l.strip()]
     bad = json.loads((root / "bad_frames.json").read_text())["episodes"]
     s = build_splits(eps, bad, seed=a.seed, test_len=a.test_len,
+                     hold_out=a.hold_out,
                      max_train_window=a.max_train_window, target=a.target)
     (root / "splits.json").write_text(json.dumps(s, indent=1))
     st = s["stats"]

scripts/check_session_ready.py CHANGED Viewed

@@ -48,10 +48,10 @@ def main() -> int:
     # 1 — a calibration epoch is declared for the task, and it is the right one
     try:
         from twm.calib_epoch import calib_dir, check_epoch, epoch_of
-        d = calib_dir(a.task)
         try:
-            check_epoch(a.task)
-            note(True, "calibration epoch declared", f"{epoch_of(a.task)} at {d.name}")
         except ValueError as e:
             note(False, "calibration epoch declared", str(e)[:90])
     except Exception as e:

     # 1 — a calibration epoch is declared for the task, and it is the right one
     try:
         from twm.calib_epoch import calib_dir, check_epoch, epoch_of
+        d = calib_dir(a.task, date=a.date)
         try:
+            check_epoch(a.task, a.date)
+            note(True, "calibration epoch declared", f"{epoch_of(a.task, a.date)} at {d.name}")
         except ValueError as e:
             note(False, "calibration epoch declared", str(e)[:90])
     except Exception as e:

scripts/play_react_pt.py CHANGED Viewed

@@ -3,7 +3,7 @@ directory of segments / episodes, concatenates same-episode segments
 into one continuous timeline, and lets you switch between source
 episodes with N / P.
-The viewer reuses `twm.viz.build_preview_panel`'s 1280x480 grid:
     Row 1 (y=0..240):    [left cam | middle cam | right cam | OptiTrack]
     Row 2 (y=240..480):  [gs_L_raw | gs_L_diff | gs_R_raw | gs_R_diff | Controls]
@@ -96,7 +96,7 @@ except Exception:
 # ──────────────────────────────────────────────────────────────────────────────
-# Layout constants (matches twm.viz.build_preview_panel)
 # ──────────────────────────────────────────────────────────────────────────────
 PANEL_W, PANEL_H = 1280, 480
 RS_THUMB_W, RS_THUMB_H = 320, 240     # RealSense cam cell
@@ -466,7 +466,7 @@ class LoadedEpisode:
 # ──────────────────────────────────────────────────────────────────────────────
-# Panel renderer (visualize.py-style 1280x480 grid)
 # ──────────────────────────────────────────────────────────────────────────────
 def _make_ot_panel(ot_poses, t_idx, t_sec, w, h):

 into one continuous timeline, and lets you switch between source
 episodes with N / P.
+The viewer builds its own 1280x480 grid (no status strip):
     Row 1 (y=0..240):    [left cam | middle cam | right cam | OptiTrack]
     Row 2 (y=240..480):  [gs_L_raw | gs_L_diff | gs_R_raw | gs_R_diff | Controls]
 # ──────────────────────────────────────────────────────────────────────────────
+# Layout constants for this viewer's own panel
 # ──────────────────────────────────────────────────────────────────────────────
 PANEL_W, PANEL_H = 1280, 480
 RS_THUMB_W, RS_THUMB_H = 320, 240     # RealSense cam cell
 # ──────────────────────────────────────────────────────────────────────────────
+# Panel renderer (this viewer's own 1280x480 grid)
 # ──────────────────────────────────────────────────────────────────────────────
 def _make_ot_panel(ot_poses, t_idx, t_sec, w, h):

scripts/test_conformance.py ADDED Viewed

	@@ -0,0 +1,145 @@

+"""The conformance checker must fail on every way a user gets this wrong.
+A validator that only passes is worthless. This asserts the opposite half:
+feed it each classic mistake and it has to say so, by name, with a number.
+The mistakes are not hypothetical. Every one of them happened in this repo:
+poses in one up-axis convention with extrinsics in the other (153 px, all
+self-checks green); a doc that said "quat wxyz" over scalar-last code;
+millimetres handed to a function documented in metres.
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import numpy as np                                             # noqa: E402
+from react_paths import release_root                           # noqa: E402
+RESULTS: list[tuple[bool, str, str]] = []
+def check(ok: bool, name: str, evidence: str) -> None:
+    RESULTS.append((bool(ok), name, evidence))
+def main() -> int:
+    try:
+        from react_toolbox import conformance
+    except Exception as ex:
+        check(False, "react_toolbox.conformance exists",
+              f"{type(ex).__name__}: {ex}")
+        return _report()
+    import json
+    import pyarrow.parquet as pq
+    from react_toolbox.frames import convert_poses
+    # Stage the layout a USER downloads: calibration and the declaring meta/
+    # in one tree. Locally they live apart (calibration in the release,
+    # twm.world_frame in the force export), and checking against either half
+    # alone would be testing a shape nobody receives.
+    import shutil
+    from react_toolbox.staging import staging_dir
+    from react_paths import force_meta
+    src = release_root("motherboard")
+    root = staging_dir() / "motherboard"
+    (root).mkdir(parents=True)
+    shutil.copytree(src / "calibration", root / "calibration")
+    shutil.copytree(force_meta("motherboard"), root / "meta")
+    shutil.copy(src / "episodes.jsonl", root / "episodes.jsonl")
+    key = json.loads(
+        [l for l in (root / "episodes.jsonl").read_text().splitlines()
+         if l.strip()][0])["episode"]
+    date, ep = key.split("/")
+    t = pq.read_table(str(root / "meta" / date / f"{ep}.parquet"),
+                      columns=["sensor_left_pose"]).to_pydict()
+    P = np.asarray([x for x in t["sensor_left_pose"]], float)
+    P = P[np.isfinite(P).all(1) & (np.linalg.norm(P[:, 3:], axis=1) > 0.5)]
+    def run(poses, **kw):
+        return conformance.check_poses(poses, task="motherboard", date=date,
+                                       episode=ep, side="left",
+                                       release=root, **kw)
+    # 1 — the published poses, used correctly, must pass
+    r = run(P)
+    check(r.ok and r.n_checks >= 4,
+          "the published poses pass their own conformance check",
+          f"{r.n_checks} checks, {len(r.failures)} failing; "
+          f"worst fingerprint error {r.detail.get('fingerprint_px', float('nan')):.3f} px")
+    # 2 — millimetres instead of metres
+    r = run(P * np.array([1000, 1000, 1000, 1, 1, 1, 1.0]))
+    check(not r.ok and any("unit" in f for f in r.failures),
+          "positions in millimetres are rejected",
+          f"failures: {r.failures}")
+    # 3 — quaternion read as wxyz
+    Q = P.copy()
+    Q[:, 3:7] = P[:, [6, 3, 4, 5]]
+    r = run(Q)
+    check(not r.ok, "a wxyz quaternion is rejected",
+          f"failures: {r.failures}; fingerprint "
+          f"{r.detail.get('fingerprint_px', float('nan')):.1f} px")
+    # 4 — the OTHER up-axis convention
+    r = run(convert_poses(P, to_zup=False))
+    check(not r.ok and any("frame" in f or "up" in f for f in r.failures),
+          "poses in the recorded Y-up convention are rejected",
+          f"failures: {r.failures}; fingerprint "
+          f"{r.detail.get('fingerprint_px', float('nan')):.1f} px")
+    # 5 — unnormalised quaternions
+    U = P.copy(); U[:, 3:7] *= 1.4
+    r = run(U)
+    check(not r.ok and any("quaternion" in f for f in r.failures),
+          "unnormalised quaternions are rejected",
+          f"failures: {r.failures}")
+    # 6 — the report names what each mistake would have read, so a reader can
+    #     see the check has teeth without running it themselves
+    r = run(P)
+    ctrl = r.detail.get("negative_controls") or {}
+    check(isinstance(ctrl, dict) and len(ctrl) >= 2
+          and all(v > 20 for v in ctrl.values()),
+          "a passing report still shows what each mistake would read",
+          f"negative controls (px): "
+          f"{ {k: round(v, 1) for k, v in ctrl.items()} }")
+    # 7 — a subset must be REFUSED, not silently reported as a frame error.
+    #     Measured: the first 400 rows of this episode read 10.4 px against
+    #     the episode fingerprint, which is above tolerance and looks exactly
+    #     like a broken world frame.
+    r = run(P[:400])
+    check(not r.ok and "row-coverage" in r.failures,
+          "a subset of rows is refused rather than misread as a frame error",
+          f"failures: {r.failures}; fingerprint would have read "
+          f"{r.detail.get('fingerprint_px', float('nan')):.1f} px")
+    # 8 — but a subset the caller identifies is checked row-wise, and passes
+    idx = np.arange(400)
+    r = run(P[idx], rows=idx)
+    check(r.ok, "an identified subset is checked row-wise and passes",
+          f"worst position difference "
+          f"{r.detail.get('max_position_diff_m', float('nan')):.2e} m")
+    return _report()
+def _report() -> int:
+    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}")
+    n = sum(not x for x, _, _ in RESULTS)
+    print(f"\nconformance: {len(RESULTS)} checks, {n} failing")
+    return 1 if n else 0
+if __name__ == "__main__":
+    raise SystemExit(main())