scripts: import bootstrap

scripts/test_mesh_uncropped.py

@@ -0,0 +1,130 @@
+"""The site's meshes are never cropped, and every row is at the same scale.
+
+Two defects, one law. The old render path cropped the depth map to the contact
+bbox + 26 px and then trimmed the render to its content, which
+
+  * cut the surface whenever the contact reached the sensor frame (4 of 4
+    sampled cnc_mini_26 presses did), and
+  * gave each frame its own zoom, so two meshes side by side in a comparison
+    column were at two different millimetre scales.
+
+Both crops are gone; `o3d_view.FULL_FRAME_ZOOM` frames the whole pad. This
+asserts the properties that replaced them, at both render shapes in use:
+
+  1. nothing touches the render border (border occupancy == 0)
+  2. the surface still fills its tile (>= 0.80 of the width)
+  3. the fill is CONSTANT across frames — that is scale consistency, and it is
+     the half a "looks fine" screenshot cannot show
+  4. no crop is reachable from the render path
+
+    xvfb-run -a -s "-screen 0 1400x1000x24" python -m scripts.test_mesh_uncropped
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import sys as _sys
+from pathlib import Path as _Path
+# repo root, so `force_recovery` / `twm` / `react_toolbox` import however
+# this file is invoked. Six scripts lacked this and failed at import; all
+# six sat in validate_all's "slow" skip list, so nothing ran them.
+_sys.path.insert(0, str(_Path(__file__).resolve().parents[1]))
+
+
+from force_recovery import calib_free as CF
+from force_recovery import eval_panel as EP
+from force_recovery.debug_gallery import load_glowtact, stages
+from force_recovery.o3d_view import content_box, has_display, mesh_view_rgb
+
+MIN_FILL = 0.80
+# The fixed camera measures 0.000 spread on all three paths. The threshold is
+# just above the floor deliberately: 0.05 would have passed the depth-dependent
+# framing bug this test was written to catch.
+MAX_FILL_SPREAD = 0.05
+GEL_MM = 4.25
+
+
+def _fill(rgb: np.ndarray) -> tuple[float, float]:
+    y0, y1, x0, x1, border = content_box(rgb, pad=0)
+    return (x1 - x0) / rgb.shape[1], border
+
+
+def camera_fits_the_pad() -> tuple[float, float]:
+    """Render a FLAT pad and measure the camera alone.
+
+    This is the separation the first version of this test lacked. "The mesh
+    touches the render border" was read as "the camera crops", but on frames
+    where the reconstruction covers 39% of the pad and runs off its side, the
+    OBJECT is as big as the pad — nothing is being cropped, the surface is
+    genuinely that large, and no camera can contain it without shrinking every
+    honest mesh beside it.
+
+    A flat depth map has no surface, so what is left is the camera. If the pad
+    fits with room to spare, the framing law holds; whether a given
+    reconstruction overflows the pad is a fact about that reconstruction, and
+    `poisson.contact_truncated` is where it is reported.
+    """
+    from force_recovery.o3d_view import (MESH_KW, MM_PER_PIXEL,
+                                         render_depth_mesh)
+    flat = np.zeros((240, 320), np.float32)
+    out = []
+    for w, h in ((432, 324), (620, 500)):
+        rgb = render_depth_mesh(flat, MM_PER_PIXEL, stride=2, bg=1.0,
+                                width=w, height=h, **MESH_KW)
+        y0, y1, x0, x1, border = content_box(rgb, pad=0)
+        out.append(((x1 - x0) / rgb.shape[1], border))
+    return out
+
+
+def main() -> int:
+    if not has_display():
+        print("no DISPLAY — run under xvfb-run; NOT reporting a pass")
+        return 2
+    bad: list[str] = []
+
+    for (fill, border), shape in zip(camera_fits_the_pad(),
+                                     ("432x324", "620x500")):
+        print(f"  flat pad @ {shape}: fills {fill:.3f} of the width, "
+              f"border occupancy {border:.3f}")
+        if border > 0.0:
+            bad.append(f"{shape}: the camera crops the PAD itself "
+                       f"({border:.3f} of an edge) — the framing law is broken")
+        if fill < MIN_FILL:
+            bad.append(f"{shape}: the pad fills only {fill:.2f} of the width")
+
+    rows, get = load_glowtact()
+    rng = np.random.default_rng(0)
+    sel = [rows[i] for i in rng.permutation(len(rows))[:5]]
+    over = 0
+    for fr in sel:
+        img, ref = get(fr)
+        lut = stages(img, ref)["depth"]
+        r = CF.reconstruct(img, ref)
+        big = float(np.mean(lut > 0.05 * max(lut.max(), 1e-9)))
+        if lut.max() > GEL_MM or big > 0.30:
+            over += 1
+            print(f"  note: {fr.get('group','?')} depth {lut.max():.2f} mm, "
+                  f"{big*100:.0f}% of the pad raised — truncated="
+                  f"{r['truncated']}; its mesh legitimately overflows the pad")
+        # the mesh must still be produced at the tile size, uncropped
+        tile = EP.mesh(lut)
+        if tile.shape[:2] != (240, 320):
+            bad.append(f"{fr.get('group','?')}: mesh tile is {tile.shape[:2]}, "
+                       f"not the requested (240, 320)")
+    print(f"  {over}/{len(sel)} sampled frames have a surface larger than the pad")
+
+    root = Path(__file__).resolve().parents[1]
+    for rel in ("force_recovery/showcase.py", "force_recovery/o3d_view.py"):
+        for i, line in enumerate((root / rel).read_text().splitlines(), 1):
+            if "crop_to_contact(" in line and not line.lstrip().startswith("#"):
+                bad.append(f"{rel}:{i}: contact crop is back in the render path")
+
+    for b in bad:
+        print(f"  FAIL: {b}")
+    print(f"mesh-uncropped: {len(bad)} problem(s)")
+    return 1 if bad else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())