From c377c144742ded8d7ee6c16d3f0c2c30313718a2 Mon Sep 17 00:00:00 2001 From: ykcheungab Date: Fri, 25 Sep 2026 15:44:44 +0800 Subject: [PATCH] 1. added blender deformation probe for marker size picking and optimization 2. added unwarp map export in current cli, don't need to generate by precompute in sensor running --- .gitignore | 8 + README.md | 193 ++ blender/scripts/probe_deform.py | 449 ++++ blender/scripts/probe_falloff.py | 270 +++ blender/scripts/probe_render.py | 1049 +++++++++ blender/scripts/test_probe_falloff.py | 538 +++++ .../r01/patch_texture_produce.png | Bin 834246 -> 238838 bytes docs/probe-findings.md | 382 +++ docs/probe-method.md | 323 +++ docs/probe-pipeline.md | 763 ++++++ pyproject.toml | 7 + sensors/finger-xynova/r01/design.yaml | 76 + .../finger-xynova/r01/source/geometry.blend | Bin 2319240 -> 2314397 bytes sensors/finger/r01/profiles/compute.yaml | 30 + sensors/finger/r01/source/geometry.blend | Bin 688142 -> 688113 bytes src/orisys_sensor_design/cli.py | 1120 +++++++++ src/orisys_sensor_design/compare.py | 668 ++++++ src/orisys_sensor_design/deform.py | 770 ++++++ src/orisys_sensor_design/floorcal.py | 290 +++ src/orisys_sensor_design/flow.py | 2055 ++++++++++++++++ src/orisys_sensor_design/optimise.py | 813 +++++++ src/orisys_sensor_design/probe_plot.py | 636 +++++ src/orisys_sensor_design/render.py | 487 ++++ src/orisys_sensor_design/sensitivity.py | 2063 +++++++++++++++++ tests/test_compare.py | 289 +++ tests/test_deform.py | 625 +++++ tests/test_flow.py | 869 +++++++ tests/test_noise_model.py | 399 ++++ tests/test_optimise.py | 503 ++++ tests/test_preview.py | 5 +- tests/test_probe_plot.py | 272 +++ tests/test_render.py | 801 +++++++ tests/test_sensitivity.py | 971 ++++++++ tools/build_uv_map.py | 309 +++ 34 files changed, 18032 insertions(+), 1 deletion(-) create mode 100644 blender/scripts/probe_deform.py create mode 100644 blender/scripts/probe_falloff.py create mode 100644 blender/scripts/probe_render.py create mode 100644 blender/scripts/test_probe_falloff.py create mode 100644 docs/probe-findings.md create mode 100644 docs/probe-method.md create mode 100644 docs/probe-pipeline.md create mode 100644 src/orisys_sensor_design/compare.py create mode 100644 src/orisys_sensor_design/deform.py create mode 100644 src/orisys_sensor_design/floorcal.py create mode 100644 src/orisys_sensor_design/flow.py create mode 100644 src/orisys_sensor_design/optimise.py create mode 100644 src/orisys_sensor_design/probe_plot.py create mode 100644 src/orisys_sensor_design/render.py create mode 100644 src/orisys_sensor_design/sensitivity.py create mode 100644 tests/test_compare.py create mode 100644 tests/test_deform.py create mode 100644 tests/test_flow.py create mode 100644 tests/test_noise_model.py create mode 100644 tests/test_optimise.py create mode 100644 tests/test_probe_plot.py create mode 100644 tests/test_render.py create mode 100644 tests/test_sensitivity.py create mode 100644 tools/build_uv_map.py diff --git a/.gitignore b/.gitignore index cbe7c9c..dc6f5a3 100644 --- a/.gitignore +++ b/.gitignore @@ -13,6 +13,14 @@ build/textures/**/_texture_job.json # Printability reports are regenerated output, not design input. Use # `orisys-design inspect --out ` to keep one deliberately. build/textures/**/texture_report.json +# The probe sensitivity bench writes ~90 MB of derived measurement artifacts +# (31 rendered frames, per-frame flow arrays, JSON reports) plus per-run job +# files. They are regenerated output like texture_report.json, not design input, +# so only a deliberate `optimise` winner should be promoted by hand. +build/probe/ +# Local verification/scratch: pytest basetemps, sweep logs and the lead's independent +# deform/sensitivity auditors. Regenerate with the commands in docs/probe-method.md. +build/_* .pytest_cache/ # Blender diff --git a/README.md b/README.md index 2e1e04a..4af2cd1 100644 --- a/README.md +++ b/README.md @@ -367,6 +367,199 @@ Collection check: blender -b sensors/finger/r01/source/geometry.blend -P blender/scripts/validate.py -- sensors/finger/r01 ``` +## Probe sensitivity bench + +`orisys-design deform|render|track|sensitivity|optimise` answers *"which marker +pattern gives the best tracking sensitivity on this sensor?"* It deforms the +sensing surface through a **known** displacement, renders what `cam_sensor` +actually sees, measures DIS optical flow against the zero-displacement reference, +and reports a ranked, auditable score. The full interface contract is in +[`docs/probe-pipeline.md`](docs/probe-pipeline.md). + +```powershell +python -m pip install -e .[probe] # numpy + opencv-python + +# 1) deform 31 frames (1 reference + 3 axes x 10 steps) +orisys-design deform sensors/finger-xynova/r01 +# 2) render what the camera sees for each frame +orisys-design render sensors/finger-xynova/r01 +# 3) DIS flow against the reference +orisys-design track sensors/finger-xynova/r01 +# 4) score and rank (writes sensitivity_report.json) +orisys-design sensitivity sensors/finger-xynova/r01 --skip-deform --skip-render --skip-track +# 5) search patch-pattern parameters +orisys-design optimise sensors/finger-xynova/r01 --dry-run +# 6) compare different settings and plot the measured optical flow +orisys-design compare sensors/finger-xynova/r01 +``` + +### Visualising the flow and comparing settings + +`orisys-design compare` runs one marker pattern under several estimator settings and +writes three figures plus `settings_comparison.json` into +`build/probe///comparison/`: + +| figure | what it shows | +|---|---| +| `settings_flow.png` | one panel per setting: the rendered marker around the probe with the measured flow as arrows, the ROI, the cell grid and the **effective window** drawn on it, and the applied vs measured displacement. Below each panel, the measured `\|flow\|` field on a shared colour scale. | +| `settings_tuning.png` | score vs the camera-space cell, and vs the cell/window ratio, one series per setting. | +| `settings_response.png` | two panels. **Signal**: response vs applied displacement per setting, with each curve's *own* noise floor drawn as a line and the ideal 1:1 line. **Retention**: `gain(σ)/gain(clean)` vs injected noise σ, so a pattern that looks strong but collapses under noise is visible at a glance. | + +Only the settings that need re-running do: `nx` regenerates the texture, `radius_mm` +regenerates the deformation and frames, and `dis_mode` reuses the *same frames* (the +variant directory holds a manifest with absolute frame paths), so the decisive +estimator comparison costs seconds rather than a re-render. + +```powershell +# the shipped setting vs the full-resolution estimator, on identical frames +orisys-design compare sensors/finger-xynova/r01 --grid 31,56,80 --dis-modes 1,0 +# a different rubber radius changes the optimum, so compare for stability +orisys-design compare sensors/finger-xynova/r01 --radii 0.5,1.0,1.5 +``` + +`orisys-design sensitivity` chains all of steps 1–4 itself, so a single run is +usually enough; the `--skip-*` flags let you re-score without re-rendering. All +artifacts land in `build/probe///`. + +### How the deformation is defined + +The vertices in the `probe` vertex group move rigidly by a displacement expressed +in a **probe-average orthonormal frame** — x and y are shear, z is the surface +normal, i.e. normal force. The 0.01 mm steps run from 0 to 0.10 mm per axis. +Vertices outside the group follow Blender's proportional-editing falloff +(`smooth`/`linear`/`sharp`/`constant`) out to `radius_mm`, representing the outer +rubber. + +The falloff is computed explicitly in millimetres rather than through +`bpy.ops.transform.translate(use_proportional_edit=True)`: that operator is +viewport-modal and its radius is screen-space, so it is neither available nor +reproducible under `blender -b`. The `.blend` is never written — the whole +pipeline is read-only towards it. + +`deform_report.json` reports how many vertices actually moved. That matters: on +the Xynova revision the median mesh edge is 0.63 mm, so the default 0.5 mm radius +reaches only 5 of 2502 vertices outside the group, producing a sharp 6-vertex +island rather than a smooth bulge. Raise `--radius-mm` to ~1.0 mm (17 vertices) +or 1.5 mm (30 vertices) for a rounded indentation. + +### Reading the report + +`render_manifest.json` records the render settings actually applied. Two are +forced for correctness: the view transform must be `Standard` (the scene ships +with AgX, a filmic tonemapper that silently rewrites every marker value) and +denoising is off (it smears the pattern the tracker is meant to measure). The +render also asserts that re-rendering the reference frame produces identical +bytes, because a non-reproducible render invalidates every later number. + +`sensitivity_report.json` carries, per axis and per scale, the measured `gain` +(measured mm of flow per mm of applied displacement), the `snr` against the +null-frame floor, cross-axis leakage, and `resolvable_step_mm`. + +**Be careful reading small steps.** The Xynova design camera renders 500x500, which +is **13.25 px/mm** at the probe, so 0.01 mm is only **0.13 px**. That is a *per-pixel* +precision limit, not an estimator limit: because the response is averaged over the +probe ROI (~139 px), the measured zero-input floor is only **0.029 px** and a single +0.01 mm step (0.13 px) clears it about 4.5x over. The report therefore states +`resolvable_step_mm` per axis, reports the floor and the step separately in pixels, +and evaluates the process scale (250x250 by default) alongside the render scale so you +can see what the runtime can actually resolve. Do not assume a sub-pixel step is +unmeasurable — check the floor. + +Sensitivity here is a **relative ranking under a fixed estimator and camera**, not a +force calibration, and it must be read under a **stated noise model** — see the section +above. The optimizer's winner is the best of a bounded deterministic candidate grid, and +is not a proven global optimum. + +### The measured gain is confounded with the ROI size + +This is the most important caveat in the tool, and it is measured rather than +theoretical. On Xynova the probe patch plus its falloff taper spans only about +**13 px**, i.e. 1-2 DIS patches (8 px), so DIS regularizes toward the static +background and the coherent motion is measured at roughly **0.67x** of the applied +displacement. Injecting a synthetic rigid translation of the same 1.3248 px recovers +**17%** at a patch radius of 6.6 px (equal to the ROI), **51%** at r 10, **81%** at +r 20 and **95%** at r 40. So the absolute gain depends strongly on `radius_mm`: +compare patterns only while the radius, ROI and scale are held fixed. +`orisys-design optimise` varies `nx`/`ny`/`seed` and never the radius for exactly this +reason. + +Attribution matters too: the deficit is **not** aliasing, noise or a diluted average. +The real flow's radial profile is flat inside the ROI, and the texture-level +known-answer recovers a 2 px shift as 2.0000 px. Only strongly *periodic* synthetic +textures alias (a 3.11 px checker turns a 2 px shift into 8.17 px); the shipped random +per-cell pattern does not. + +### The noise floor was wrong, and it changed the answer + +**Read [`docs/probe-findings.md`](docs/probe-findings.md) for the conclusions and +recommendations.** The short version is below. + +**This section replaces an earlier claim that nx=31 is the best pattern and that "the +marker cell must match the estimator's effective window". That claim is retracted.** It +was driven by the noise floor, and the floor was not a valid noise model. + +`floor_px` is measured as `reference` vs a re-render at **seed + 1** — Cycles +antialiasing jitter. On this data it differs by ~5 grey levels RMS on half the pixels and +scales with edge contrast. It is not sensor noise, and three checks show it cannot rank +patterns: + +1. **Its trend reverses** under additive noise. p95 |flow| over the ROI, same DIS config: + + | pattern | render-seed | injected σ=2 | σ=4 | + |---|---|---|---| + | nx=80 | 0.0292 | **0.0161** | 0.0278 | + | nx=31 | 0.0376 | **0.0084** | 0.0182 | + | nx=56 | 0.0134 | 0.0102 | 0.0203 | + +2. **It understates the real floor.** Measured on idle dd02 footage + (`data/dd02-0703/190.mp4`, 1280x720) with the same estimator: + **0.2267 px** p95 |flow| over the ROI, dominant marker period **25.5 px**, i.e. + **0.0089 floor per period**. Short baseline (consecutive frames) equals long baseline + (vs frame 0) — ratio 0.98 — so this is frame-independent white noise, not drift, and + the clip is genuinely idle. Every simulated floor per cell is well below it, and the + **coarse patterns are understated most** (nx=56 by ~6x, nx=31 by ~4x, nx=80 by ~2x) — + exactly the bias that made nx=31 and nx=56 look best. + +3. **Signal is not noise-invariant either**, so gain must be quoted under a stated model. + At +0.10 mm on the x axis, retention is `gain(σ)/gain(clean)`: + + | pattern | σ=4 | σ=16 | + |---|---|---| + | nx=80 dm1 | **99%** | **84%** | + | nx=56 dm1 | 96% | 71% | + | nx=31 dm1 | 72% | 59% | + +**What the calibrated model supports:** at the render scale, `radius_mm=0.5`, `dis_mode=1`, +nx=80 has the **highest clean response on both axes** (x 9.10 vs 4.74 px/mm; y 11.69 vs +10.90) and the **best noise retention** (84–99% vs 59–73%), so on this evidence the +shipped 80x80 is competitive or better, not worse. What is *not* yet re-ranked: the +process (250x250) scale and the `radius_mm=1.5` block, where the score ordering differs. + +Every report now carries `noise_models` (per-axis gain, floor and `response_retention` per +σ, measured under one model) and `noise_calibration` (the real idle numbers above), and +`settings_response.png` has a retention panel so a pattern that looks strong but collapses +under noise is visible. + +### What the bench measures + +The marker grid is defined **across the camera image**, so a cell is +`render_width / nx` pixels, not a millimetre quantity: at 500x500 the shipped 80x80 grid +has a **6.25 px** cell and nx=31 has **16.13 px**. `dis_mode=1` is OpenCV's +`setFinestScale(1)`, so DIS computes flow at half resolution and upscales, giving an +effective window of `patch_px * 2**dis_mode` = **16 px**. Those are the right quantities to +watch — but the earlier reading of them as *the* explanation of the ranking was an artefact +of the floor above, so treat the ratio as a useful diagnostic, not a validated law. + +The measured gain is also **confounded with the ROI size**: the probe patch plus its +falloff taper spans only ~13 px (1-2 DIS patches), so DIS regularizes toward the static +background. Injecting a synthetic rigid translation of the same 1.3248 px recovers ~17% at +a patch radius of 6.6 px (equal to the ROI), 51% at r 10, 81% at r 20 and 95% at r 40. +Compare patterns only with the radius, ROI and scale held fixed — which is why +`orisys-design optimise` varies `nx`/`ny`/`seed` and never the radius. + + + + ## Profiles - **`compute`** — `sensing_surface` + `cam_sensor` relative to `origin_sensor`. Writes diff --git a/blender/scripts/probe_deform.py b/blender/scripts/probe_deform.py new file mode 100644 index 0000000..52ae11d --- /dev/null +++ b/blender/scripts/probe_deform.py @@ -0,0 +1,449 @@ +"""Blender headless probe deformation (mm, object-local). + + blender -b sensors/finger-xynova/r01/source/geometry.blend \\ + -P blender/scripts/probe_deform.py -- \\ + --job + +Reads the job written by ``orisys_sensor_design.deform``, resolves the mesh and +vertex group, builds the probe-average orthonormal basis, computes the +proportional falloff ONCE from the probe members' ORIGINAL positions (so the +weight vector is constant across every frame), then writes:: + + probe_frames.npz the deformation/rendering contract + deform_report.json measured probe statistics + honesty warnings + +THE .BLEND IS NEVER WRITTEN. No ``bpy.ops.wm.save_mainfile`` / +``save_as_mainfile`` call exists in this script; the source file is opened +read-only and only read from. The script does leave Edit mode if the opened file +happens to be in it, but that changes the in-memory session only. + +WHY NOT bpy.ops.transform.translate(use_proportional_edit=True) +-------------------------------------------------------------- +That operator is viewport-modal. It needs a 3D-view region for the pivot and its +``tool_settings.proportional_size`` is interpreted in SCREEN SPACE (pixels) +relative to that region. Under ``blender -b`` there is no 3D-view region and no +screen-space scale, so the affected vertex set would depend on GUI state and +zoom and could not be reproduced headlessly. Every displacement here is computed +explicitly in millimetres by ``probe_falloff.py``:: + + delta_i = weight_i * (axis_vector * step_mm) (mm, object-local) + +``weight_i = 1.0`` for the probe members, otherwise the falloff curve of +``d_i / radius_mm`` where ``d_i`` is the distance from the vertex's ORIGINAL +position to the nearest probe vertex. Do not "fix" this back to the operator. + +Exit codes: 0 success, 1 scene/geometry error, 2 config/job error. +""" + +# pyright: reportMissingImports=false + +from __future__ import annotations + +import argparse +import hashlib +import json +import sys +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import bpy +import numpy as np + +# Blender -P does not consistently include the script directory on sys.path. +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +from probe_falloff import ( # noqa: E402 + FALLOFF_MODES, + affected_bands, + edge_lengths_mm, + falloff_weights, + flatness_mm, + orthonormal_basis, + percentile, +) + +JOB_SCHEMA = "orisys-sensor-design/probe-deform-job-v1" +REPORT_SCHEMA = "orisys-sensor-design/probe-deform-report-v1" +FRAMES_NPZ_FILENAME = "probe_frames.npz" +DEFORM_REPORT_FILENAME = "deform_report.json" + +AXIS_ROWS = {"x": 0, "y": 1, "z": 2} +VALID_AXES = (None, "x", "y", "z") + + +class ConfigError(Exception): + """Bad or incomplete job file (exit 2).""" + + +class SceneError(Exception): + """Blend contents do not match the job (exit 1).""" + + +def _argv_after_double_dash() -> list[str]: + if "--" not in sys.argv: + return [] + return sys.argv[sys.argv.index("--") + 1 :] + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(prog="probe_deform.py") + parser.add_argument( + "--job", + type=Path, + required=True, + help="Absolute path to the _deform_job.json written by orisys-design deform", + ) + return parser.parse_args(argv) + + +def load_job(path: Path) -> dict[str, Any]: + """Load and structurally validate the deform job (raises ConfigError).""" + if not path.is_file(): + raise ConfigError(f"Deform job not found: {path}") + try: + job = json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as exc: + raise ConfigError(f"Deform job is not readable JSON: {path}: {exc}") from exc + if not isinstance(job, dict): + raise ConfigError(f"Deform job must be a JSON object: {path}") + if job.get("schema") != JOB_SCHEMA: + raise ConfigError( + f"Deform job schema must be {JOB_SCHEMA!r}, got {job.get('schema')!r}" + ) + + for key in ("source_blend", "output_dir", "settings", "frames", "artifacts"): + if key not in job: + raise ConfigError(f"Deform job is missing {key!r}") + + objects = job.get("objects") + if not isinstance(objects, dict) or not objects.get("mesh") or not objects.get("group"): + raise ConfigError("Deform job 'objects' must name a mesh and a vertex group") + + settings = job["settings"] + if not isinstance(settings, dict): + raise ConfigError("Deform job 'settings' must be a mapping") + for key in ("radius_mm", "falloff", "step_mm", "max_mm", "axes"): + if key not in settings: + raise ConfigError(f"Deform job settings is missing {key!r}") + if not isinstance(settings["axes"], list) or not settings["axes"]: + raise ConfigError("Deform job settings.axes must be a non-empty list") + radius = float(settings["radius_mm"]) + if not radius > 0.0: + raise ConfigError(f"Deform job settings.radius_mm must be > 0, got {radius!r}") + falloff = str(settings["falloff"]) + if falloff not in FALLOFF_MODES: + raise ConfigError( + f"Deform job settings.falloff must be one of " + f"{', '.join(FALLOFF_MODES)}, got {falloff!r}" + ) + step = float(settings["step_mm"]) + max_mm = float(settings["max_mm"]) + if not step > 0.0 or not max_mm > 0.0: + raise ConfigError("Deform job settings.step_mm/max_mm must be > 0") + + frames = job["frames"] + if not isinstance(frames, list) or not frames: + raise ConfigError("Deform job 'frames' must be a non-empty list") + for position, frame in enumerate(frames): + if not isinstance(frame, dict): + raise ConfigError(f"frames[{position}] must be a mapping") + for key in ("index", "name", "axis", "step_mm"): + if key not in frame: + raise ConfigError(f"frames[{position}] is missing {key!r}") + if frame["index"] != position: + raise ConfigError( + f"frames[{position}].index must be {position}, got {frame['index']!r}" + ) + if not isinstance(frame["name"], str) or not frame["name"]: + raise ConfigError(f"frames[{position}].name must be a non-empty string") + if frame["axis"] not in VALID_AXES: + raise ConfigError( + f"frames[{position}].axis must be null/x/y/z, got {frame['axis']!r}" + ) + if float(frame["step_mm"]) < 0.0: + raise ConfigError(f"frames[{position}].step_mm must be >= 0") + if frames[0]["axis"] is not None or float(frames[0]["step_mm"]) != 0.0: + raise ConfigError("frames[0] must be the zero-displacement reference") + + artifacts = job["artifacts"] + if not isinstance(artifacts, dict) or not artifacts.get("frames") or not artifacts.get("report"): + raise ConfigError("Deform job 'artifacts' must name 'frames' and 'report'") + + source_blend = Path(str(job["source_blend"])) + if not source_blend.is_file(): + raise ConfigError(f"Deform job source_blend not found: {source_blend}") + return job + + +def _sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _require_mesh(name: str): + obj = bpy.data.objects.get(name) + if obj is None: + raise SceneError(f"Object not found: {name!r}") + if obj.type != "MESH": + raise SceneError(f"Object {name!r} has type {obj.type!r}, expected 'MESH'") + if obj.data is None or len(obj.data.vertices) == 0: + raise SceneError(f"Mesh object {name!r} has no vertices") + return obj + + +def _ensure_object_mode(obj) -> None: + """Leave Edit mode if the opened file is in it (in-memory only, never saved).""" + if obj.mode == "OBJECT": + return + try: + view_layer = bpy.context.view_layer + if view_layer.objects.active is not obj: + view_layer.objects.active = obj + bpy.ops.object.mode_set(mode="OBJECT") + except Exception as exc: # pragma: no cover - depends on the opened file + raise SceneError(f"Could not leave {obj.mode!r} mode for {obj.name!r}: {exc}") from exc + + +def _probe_members(obj, group_name: str) -> tuple[list[int], list[float]]: + group = obj.vertex_groups.get(group_name) + if group is None: + available = ", ".join(sorted(g.name for g in obj.vertex_groups)) or "" + raise SceneError( + f"Vertex group {group_name!r} not found on {obj.name!r} (have: {available})" + ) + members: list[int] = [] + group_weights: list[float] = [] + for vertex in obj.data.vertices: + for assignment in vertex.groups: + if assignment.group == group.index: + members.append(int(vertex.index)) + group_weights.append(float(assignment.weight)) + break + if not members: + raise SceneError(f"Vertex group {group_name!r} on {obj.name!r} is empty") + return members, group_weights + + +def _write_frames_npz( + path: Path, + *, + base_vertices: np.ndarray, + vertices: np.ndarray, + frame_names: list[str], + frame_axes: list[str], + frame_steps_mm: list[float], + weights: np.ndarray, + origin: np.ndarray, + basis: np.ndarray, + probe_indices: np.ndarray, +) -> None: + if len(vertices) != len(frame_names): + raise SceneError( + f"frame count mismatch: {len(vertices)} vertex sets, {len(frame_names)} names" + ) + path.parent.mkdir(parents=True, exist_ok=True) + np.savez( + path, + base_vertices=np.asarray(base_vertices, dtype=np.float64), + vertices=np.asarray(vertices, dtype=np.float64), + frame_names=np.array(frame_names), + frame_axes=np.array(frame_axes, dtype=" int: + args = parse_args(_argv_after_double_dash()) + try: + job = load_job(args.job.resolve()) + except ConfigError as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 2 + + try: + mesh_name = str(job["objects"]["mesh"]) + group_name = str(job["objects"]["group"]) + obj = _require_mesh(mesh_name) + _ensure_object_mode(obj) + + settings = job["settings"] + radius_mm = float(settings["radius_mm"]) + falloff = str(settings["falloff"]) + members, group_weights = _probe_members(obj, group_name) + + mesh = obj.data + base_vertices = np.array( + [vertex.co[:] for vertex in mesh.vertices], dtype=np.float64 + ) + normals = np.array( + [vertex.normal[:] for vertex in mesh.vertices], dtype=np.float64 + ) + member_array = np.asarray(sorted(members), dtype=np.int64) + origin, basis, basis_report = orthonormal_basis( + normals[member_array], origin=base_vertices[member_array].mean(axis=0) + ) + if not basis_report["orthonormal"]: + raise SceneError( + "probe-average basis is not orthonormal within " + f"{1e-6:g} (error {basis_report['orthonormality_error']:.3g})" + ) + + # Weights come from the ORIGINAL coordinates, computed exactly once, so + # every frame shares one falloff vector (Blender proportional-edit + # semantics: distance is measured from the selected vertices' start). + weights = falloff_weights(base_vertices, member_array, radius_mm, falloff) + + edges = np.array( + [edge.vertices[:] for edge in mesh.edges], dtype=np.int64 + ).reshape(-1, 2) + edge_lengths = edge_lengths_mm(base_vertices, edges) + if edge_lengths.size == 0: + raise SceneError(f"Mesh object {mesh_name!r} has no edges to measure") + edge_p50_mm = percentile(edge_lengths, 50.0) + except SceneError as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 1 + except Exception as exc: + print(f"ERROR: probe deformation failed: {exc}", file=sys.stderr) + return 1 + + frames = job["frames"] + frame_count = len(frames) + vertices = np.empty((frame_count, base_vertices.shape[0], 3), dtype=np.float64) + frame_deltas: list[float] = [] + frame_moved: list[int] = [] + for position, frame in enumerate(frames): + axis = frame["axis"] + if axis is None: + vector = np.zeros(3, dtype=np.float64) + else: + vector = basis[AXIS_ROWS[axis]] * float(frame["step_mm"]) + vertices[position] = base_vertices + weights[:, None] * vector[None, :] + delta = vertices[position] - base_vertices + frame_deltas.append(float(np.linalg.norm(delta, axis=1).max())) + # Contract: vertices displaced by a non-zero amount IN THIS FRAME. + # 0 for the reference, 6 + partial (11 on Xynova) for any non-zero step. + frame_moved.append(int(np.count_nonzero(np.any(delta != 0.0, axis=1)))) + + if not np.array_equal(vertices[0], base_vertices): + print( + "ERROR: reference frame differs from the base vertices", + file=sys.stderr, + ) + return 1 + + members_at_one = int((weights >= 1.0).sum()) + partial = int(((weights > 0.0) & (weights < 1.0)).sum()) + unaffected = int((weights == 0.0).sum()) + warnings: list[str] = [] + if partial < 4 * len(member_array): + warnings.append( + f"radius {radius_mm:g} mm reaches only {partial} vertices outside the " + f"probe group (threshold {4 * len(member_array)} = 4 * " + f"{len(member_array)} members); the deformation is local to the probe " + "neighbourhood" + ) + if radius_mm < edge_p50_mm: + warnings.append( + f"radius {radius_mm:g} mm is below the mesh median edge length " + f"{edge_p50_mm:.6f} mm; affected vertices may be isolated" + ) + if any(abs(weight - 1.0) > 1e-9 for weight in group_weights): + warnings.append( + f"probe group weights are not all 1.0 ({group_weights}); the contract " + "displaces probe members by the full vector regardless" + ) + scale = [float(value) for value in obj.matrix_world.to_scale()] + if max(abs(value - 1.0) for value in scale) > 1e-4: + warnings.append( + f"mesh object scale {scale} is not 1; displacement units are " + "object-local, not world millimetres" + ) + + source_blend = Path(str(job["source_blend"])) + report = { + "schema": REPORT_SCHEMA, + "generated_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat(), + "source_blend": { + "path": str(source_blend.resolve()), + "sha256": _sha256_file(source_blend), + }, + "mesh": mesh_name, + "group": group_name, + "probe_indices": [int(index) for index in member_array], + "origin": [round(float(value), 9) for value in origin], + "basis": [[round(float(value), 9) for value in row] for row in basis], + "basis_orthonormal": bool(basis_report["orthonormal"]), + "normal_angle_max_deg": round(float(basis_report["normal_angle_max_deg"]), 3), + "flatness_mm": round(flatness_mm(base_vertices[member_array], origin, basis[2]), 6), + "radius_mm": radius_mm, + "falloff": falloff, + "vertex_count": int(base_vertices.shape[0]), + "edge_p50_mm": round(edge_p50_mm, 6), + "weights": { + "min": float(weights.min()), + "max": float(weights.max()), + "members_at_one": members_at_one, + "partial": partial, + "unaffected": unaffected, + }, + "affect_bands": affected_bands(weights), + "frames": [ + { + "index": int(frame["index"]), + "name": str(frame["name"]), + "axis": frame["axis"], + "step_mm": float(frame["step_mm"]), + "max_delta_mm": round(frame_deltas[position], 9), + # Vertices with a non-zero displacement in this frame: 0 for the + # reference, 6 + partial (= 11 on Xynova) for any non-zero step. + "moved_vertices": frame_moved[position], + } + for position, frame in enumerate(frames) + ], + "warnings": warnings, + } + + artifacts = job["artifacts"] + frames_path = Path(str(artifacts["frames"])) + report_path = Path(str(artifacts["report"])) + try: + _write_frames_npz( + frames_path, + base_vertices=base_vertices, + vertices=vertices, + frame_names=[str(frame["name"]) for frame in frames], + frame_axes=["null" if frame["axis"] is None else str(frame["axis"]) for frame in frames], + frame_steps_mm=[float(frame["step_mm"]) for frame in frames], + weights=weights, + origin=origin, + basis=basis, + probe_indices=member_array.astype(np.int32), + ) + report_path.parent.mkdir(parents=True, exist_ok=True) + report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") + except (OSError, SceneError) as exc: + print(f"ERROR: could not write deform artifacts: {exc}", file=sys.stderr) + return 1 + + print( + f"Probe deform complete: {frame_count} frames, {base_vertices.shape[0]} vertices, " + f"{members_at_one} probe members, {partial} partial, {unaffected} unaffected" + ) + for warning in warnings: + print(f"WARNING: {warning}", file=sys.stderr) + print(f" {frames_path}") + print(f" {report_path}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/blender/scripts/probe_falloff.py b/blender/scripts/probe_falloff.py new file mode 100644 index 0000000..4d39762 --- /dev/null +++ b/blender/scripts/probe_falloff.py @@ -0,0 +1,270 @@ +"""bpy-FREE probe geometry maths: proportional falloff, basis, edge stats. + +Why the falloff is computed here instead of with an operator +------------------------------------------------------------ +``bpy.ops.transform.translate(use_proportional_edit=True)`` is deliberately NOT +used anywhere in this pipeline. That operator is viewport-modal: it needs a 3D +view region to define the pivot and, crucially, its +``tool_settings.proportional_size`` is interpreted in SCREEN SPACE (pixels) +relative to that region. Under ``blender -b`` there is no 3D-view region and no +screen-space scale, so the same script would affect a different vertex set +depending on GUI state or zoom -- and could not be reproduced at all headlessly. +The falloff is therefore computed explicitly, in millimetres, by this module. + +Semantics replicate Blender's proportional editing with the probe members as the +selection: + +* ``d`` = distance from the **original** position of a vertex to the nearest + probe vertex; +* ``t = d / radius_mm``; +* ``w = curve(t)``, with ``w = 0`` whenever ``t >= 1`` and ``w = 1`` for probe + members. + +Because ``d`` is measured from the original (base) coordinates, the weight +vector is constant across every frame of the sweep -- exactly Blender's +behaviour, where the proportional falloff is computed once from the selected +vertices' starting positions. + +Only numpy is required, so the normal pytest suite imports this module without +bpy (the same pattern as ``blender/scripts/patch_geometry.py``). +""" + +from __future__ import annotations + +from typing import Any, Sequence + +import numpy as np + +#: Blender proportional-edit falloff modes accepted by the pipeline contract. +FALLOFF_MODES = ("smooth", "linear", "sharp", "constant") +DEFAULT_FALLOFF = "smooth" + +#: Contract failure threshold for the probe-average basis ("not orthonormal +#: within 1e-6" must fail loudly). The measured Xynova basis is orthonormal to +#: ~2.2e-16. +ORTHONORMAL_TOLERANCE = 1e-6 + +#: Weight histogram bands, lowest-inclusive/highest-exclusive except "1.0". +#: Empty bands are omitted so the report only prints what actually moves. +_WEIGHT_BANDS = ( + ("1.0", 1.0, 1.0), + ("0.5-1.0", 0.5, 1.0), + ("0.3-0.5", 0.3, 0.5), + ("0.1-0.3", 0.1, 0.3), + ("0.05-0.1", 0.05, 0.1), + ("0.0-0.05", 0.0, 0.05), +) + + +def smooth_weight(t: float) -> float: + """Blender's "Smooth" proportional curve: 1 at t=0, 0 at t>=1.""" + return 1.0 - (3.0 * t * t - 2.0 * t * t * t) + + +def linear_weight(t: float) -> float: + """Blender's "Linear" proportional curve: 1 - t.""" + return 1.0 - t + + +def sharp_weight(t: float) -> float: + """Blender's "Sharp" proportional curve: (1 - t)^2.""" + return (1.0 - t) ** 2 + + +def constant_weight(t: float) -> float: + """Blender's "Constant" proportional curve: 1 everywhere inside radius.""" + return 1.0 + + +_FALLOFF_CURVES = { + "smooth": smooth_weight, + "linear": linear_weight, + "sharp": sharp_weight, + "constant": constant_weight, +} + + +def falloff_weight(t: float, mode: str = DEFAULT_FALLOFF) -> float: + """Return the scalar falloff weight for a normalised distance ``t``. + + ``t <= 0`` gives 1.0 and ``t >= 1`` gives 0.0 for every mode. + """ + if mode not in _FALLOFF_CURVES: + allowed = ", ".join(FALLOFF_MODES) + raise ValueError(f"Unknown falloff mode {mode!r} (allowed: {allowed})") + t = float(t) + if t <= 0.0: + return 1.0 + if t >= 1.0: + return 0.0 + return float(_FALLOFF_CURVES[mode](t)) + + +def _curve_values(t: np.ndarray, mode: str) -> np.ndarray: + clipped = np.clip(t, 0.0, 1.0) + if mode == "smooth": + values = 1.0 - (3.0 * clipped**2 - 2.0 * clipped**3) + elif mode == "linear": + values = 1.0 - clipped + elif mode == "sharp": + values = (1.0 - clipped) ** 2 + else: + values = np.ones_like(clipped) + return np.where(t >= 1.0, 0.0, values) + + +def falloff_weights( + coords: np.ndarray, + member_indices: Sequence[int], + radius_mm: float, + mode: str = DEFAULT_FALLOFF, +) -> np.ndarray: + """Return one falloff weight per vertex, measured from ORIGINAL positions. + + ``coords`` is ``(V, 3)`` object-local millimetres, ``member_indices`` are the + probe vertices (weight forced to exactly 1.0), ``radius_mm`` is the + proportional radius in millimetres. The result is constant across frames: + callers must pass the undeformed base coordinates every time. + """ + if mode not in _FALLOFF_CURVES: + allowed = ", ".join(FALLOFF_MODES) + raise ValueError(f"Unknown falloff mode {mode!r} (allowed: {allowed})") + coords = np.asarray(coords, dtype=np.float64) + if coords.ndim != 2 or coords.shape[1] != 3: + raise ValueError(f"coords must have shape (V, 3), got {coords.shape}") + members = np.asarray(list(member_indices), dtype=np.int64) + if members.size == 0: + raise ValueError("member_indices must not be empty") + if members.min() < 0 or members.max() >= coords.shape[0]: + raise ValueError("member_indices contains an out-of-range vertex index") + radius_mm = float(radius_mm) + if not radius_mm > 0.0: + raise ValueError(f"radius_mm must be > 0, got {radius_mm!r}") + + deltas = coords[:, None, :] - coords[members][None, :, :] + distance = np.sqrt((deltas**2).sum(axis=-1)).min(axis=1) + weights = _curve_values(distance / radius_mm, mode) + weights[members] = 1.0 + return weights + + +def affected_bands(weights: np.ndarray) -> dict[str, int]: + """Histogram moved vertices by weight band; empty bands are omitted. + + Matches the ``affect_bands`` block of ``deform_report.json``: the measured + Xynova default (radius 0.5 mm, smooth) is exactly + ``{"1.0": 6, "0.3-0.5": 1, "0.05-0.1": 4}``. + """ + values = np.asarray(weights, dtype=np.float64).ravel() + bands: dict[str, int] = {} + for label, low, high in _WEIGHT_BANDS: + if label == "1.0": + mask = values >= 1.0 + elif label == "0.0-0.05": + mask = (values > 0.0) & (values < high) + else: + mask = (values >= low) & (values < high) + count = int(mask.sum()) + if count: + bands[label] = count + return bands + + +def orthonormality_error(basis: np.ndarray) -> float: + """Return max ``|basis @ basis.T - I|`` (0.0 for a perfect frame).""" + matrix = np.asarray(basis, dtype=np.float64) + if matrix.shape != (3, 3): + raise ValueError(f"basis must have shape (3, 3), got {matrix.shape}") + return float(np.abs(matrix @ matrix.T - np.eye(3)).max()) + + +def orthonormal_basis( + normals: np.ndarray, + origin: Sequence[float] | None = None, +) -> tuple[np.ndarray | None, np.ndarray, dict[str, Any]]: + """Build the probe-average orthonormal basis from probe vertex normals. + + Returns ``(origin, basis, report)``: + + * ``basis`` rows are ``x``, ``y``, ``z`` in that order, object-local; + * ``z`` is the average of the unit normals (equal weight per vertex, so it + is area-independent), ``x = normalize(cross((0,0,1), z))`` falling back to + ``(1, 0, 0)`` when that is degenerate, ``y = cross(z, x)``; + * ``origin`` is the probe centroid in object-local mm. Normals carry no + position, so the caller must pass it (usually + ``base[member_indices].mean(axis=0)``); when omitted, ``None`` is returned + unchanged and ``report["origin_given"]`` is ``False``. + + ``report`` carries ``member_count``, ``normal_angle_max_deg``, + ``orthonormality_error``, ``orthonormal`` and ``x_fallback``. + """ + normals = np.asarray(normals, dtype=np.float64) + if normals.ndim != 2 or normals.shape[1] != 3 or normals.shape[0] == 0: + raise ValueError(f"normals must have shape (P, 3), got {normals.shape}") + lengths = np.linalg.norm(normals, axis=1) + if not np.all(lengths > 0.0): + raise ValueError("probe vertex normals must be non-zero") + unit = normals / lengths[:, None] + + mean_normal = unit.mean(axis=0) + mean_length = float(np.linalg.norm(mean_normal)) + if mean_length <= 1e-12: + raise ValueError("probe vertex normals cancel out; no surface normal") + z = mean_normal / mean_length + + x = np.cross(np.array([0.0, 0.0, 1.0]), z) + x_length = float(np.linalg.norm(x)) + x_fallback = x_length < 1e-9 + x = np.array([1.0, 0.0, 0.0]) if x_fallback else x / x_length + y = np.cross(z, x) + + basis = np.vstack([x, y, z]) + angles = np.degrees(np.arccos(np.clip(unit @ z, -1.0, 1.0))) + error = orthonormality_error(basis) + report: dict[str, Any] = { + "member_count": int(normals.shape[0]), + "normal_angle_max_deg": float(angles.max()), + "orthonormality_error": error, + "orthonormal": error <= ORTHONORMAL_TOLERANCE, + "x_fallback": bool(x_fallback), + "origin_given": origin is not None, + } + origin_out = None if origin is None else np.asarray(origin, dtype=np.float64) + return origin_out, basis, report + + +def flatness_mm(coords: np.ndarray, origin: Sequence[float], normal: Sequence[float]) -> float: + """Peak-to-valley deviation of ``coords`` along the unit ``normal``, in mm. + + This is the contract's ``flatness_mm``: for the measured Xynova probe it is + 0.007611 mm (signed offsets along z span -0.00066..+0.00427 and + -0.00334..+0.00369). + """ + axis = np.asarray(normal, dtype=np.float64) + axis_length = float(np.linalg.norm(axis)) + if axis_length <= 0.0: + raise ValueError("normal must be non-zero") + offsets = (np.asarray(coords, dtype=np.float64) - np.asarray(origin, dtype=np.float64)) @ ( + axis / axis_length + ) + return float(offsets.max() - offsets.min()) + + +def edge_lengths_mm(coords: np.ndarray, edges: np.ndarray) -> np.ndarray: + """Return the length of every mesh edge, in object-local millimetres.""" + coords = np.asarray(coords, dtype=np.float64) + edges = np.asarray(edges, dtype=np.int64).reshape(-1, 2) + if edges.size == 0: + return np.zeros(0, dtype=np.float64) + return np.linalg.norm(coords[edges[:, 0]] - coords[edges[:, 1]], axis=1) + + +def percentile(values: np.ndarray, q: float) -> float: + """Linear-interpolated percentile of a non-empty 1-D array (numpy default).""" + values = np.asarray(values, dtype=np.float64).ravel() + if values.size == 0: + raise ValueError("percentile of an empty array is undefined") + q = float(q) + if not 0.0 <= q <= 100.0: + raise ValueError(f"percentile q must be in [0, 100], got {q!r}") + return float(np.percentile(values, q)) diff --git a/blender/scripts/probe_render.py b/blender/scripts/probe_render.py new file mode 100644 index 0000000..0b6c12b --- /dev/null +++ b/blender/scripts/probe_render.py @@ -0,0 +1,1049 @@ +"""Blender headless probe rendering. + + blender -b sensors/finger-xynova/r01/source/geometry.blend \\ + -P blender/scripts/probe_render.py -- \\ + --job + +Reads the job written by ``orisys_sensor_design.render``, loads the +``probe_frames.npz`` produced by the deform stage, installs ONE emission +material bound to the marker texture over the configured UV map, and renders +every frame of the plan to ``frames/.png`` plus a second reference render +at a different seed (``frames/reference_null.png``) that the tracker uses to +measure its zero-input floor. + +THE .BLEND IS NEVER WRITTEN. No ``bpy.ops.wm.save_mainfile`` / +``save_as_mainfile`` call exists in this script; every scene change is in memory +only. + +WHY THE VIEW TRANSFORM IS FORCED AND CHECKED +-------------------------------------------- +The shipping .blend has ``view_transform = 'AgX'`` and ``cycles.samples = 1024`` +with denoising on. AgX is a filmic tonemapper: it silently rewrites every marker +pixel, which corrupts every flow number downstream. This script therefore forces +``view_transform='Standard'``, ``look='None'``, ``exposure=0.0``, +``use_denoising=False``, ``use_adaptive_sampling=False``, ``samples`` from the +job, a fixed ``cycles.seed``, ``interpolation='Closest'`` and dithering off, then +reads the resolved view transform back and REFUSES with exit code 2 if it is not +``Standard``. + +DETERMINISM +----------- +Cycles CPU floating-point accumulation order is not fixed, so a boundary pixel +can tip by one 8-bit step even with an identical scene and seed. That is thread +scheduling, not irreproducibility, and because it is content-dependent a strict +byte gate silently disqualifies some marker patterns and biases a pattern +search. + +So: after every render this script still strips ONLY the known-volatile ``tEXt`` +chunks (``Date``, ``Time``, ``RenderTime``, ``cycles.ViewLayer.*_time``) and +keeps every image-defining chunk byte-for-byte. ``reference_deterministic`` is +then decided from the DECODED PIXELS of two frame-0 renders in the same session: +identical shape, ``max |delta| <= 1`` per 8-bit channel, and a differing-pixel +fraction ``<= 0.05%``. The measured ``max_abs_delta`` and ``differing_fraction`` +are recorded in the manifest either way, and a tolerance breach still fails with +exit 1. Raw file bytes are never the comparison: PNG compression and metadata +are not the measurement. + +MEASUREMENTS +------------ +Two pixel scales are recorded, separately, because confusing them would corrupt +the scorer's units: + +* ``mesh_px_per_mm`` is mesh-wide: p05/p50/p95/min/max of (projected mesh edge + length in px) / (3D edge length in mm) over every mesh edge of the reference + frame, projected with ``bpy_extras.object_utils.world_to_camera_view``. For the + shipping revision that reproduces the contract's 13.430 / 10.499 / 38.594. +* ``probe_px_per_mm`` is probe-local and is the gain the scorer must use: + ``|centroid_px(step) - centroid_px(0)| / step_mm`` per axis (each axis using + its largest step), summarised by the median over axes. It is anisotropic: on + this sensor ``z`` (surface-normal motion) is much smaller than x/y because + normal motion is largely out of the image plane. That is recorded, not fixed. + +``probe_roi_px`` is the reference probe centroid projected to pixels (u=column, +v=row, origin top-left) plus ``radius_mm * probe_px_per_mm.p50``. Each frame +entry carries ``centroid_px`` for THAT frame's deformed probe centroid. + +Exit codes: 0 success, 1 scene/geometry error, 2 config/job error, +3 missing/empty required artifact. +""" + +# pyright: reportMissingImports=false + +from __future__ import annotations + +import argparse +import hashlib +import json +import re +import struct +import sys +import time +import zlib +from datetime import datetime, timezone +from pathlib import Path + +import bpy +import numpy as np +from bpy_extras.object_utils import world_to_camera_view +from mathutils import Vector + +JOB_SCHEMA = "orisys-sensor-design/probe-render-job-v1" +MANIFEST_SCHEMA = "orisys-sensor-design/probe-render-manifest-v1" +MANIFEST_FILENAME = "render_manifest.json" +FRAMES_DIRNAME = "frames" +NULL_FRAME_NAME = "reference_null" +REQUIRED_VIEW_TRANSFORM = "Standard" +DEFAULT_INTERPOLATE = "Closest" +DEFAULT_ENGINE = "CYCLES" +DEFAULT_SAMPLES = 16 +DEFAULT_SEED = 0 + +_PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n" +#: Volatile PNG text chunks Blender adds per render. They carry wall-clock or +#: render timings and are the ONLY reason two identical renders differ on disk. +#: The set is explicit on purpose: a new volatile chunk must fail the +#: determinism check loudly, not be silently averaged away. +_VOLATILE_TEXT_KEYS = frozenset({"Date", "Time", "RenderTime"}) +_VOLATILE_TEXT_PATTERN = re.compile(r"^cycles\.ViewLayer\..*_time$") + +#: Determinism gate. Cycles CPU thread-order rounding can move a boundary pixel +#: by one 8-bit step; anything beyond that, or on more than 0.05 % of pixels, is +#: real nondeterminism and must stop the run. +DETERMINISM_MAX_ABS_DELTA = 1 +DETERMINISM_MAX_DIFFERING_FRACTION = 0.0005 + +MESH_PX_PER_MM_BASIS = "per-mesh-edge projected px / 3D mm, all {count} edges" +PROBE_PX_PER_MM_BASIS = ( + "probe-local: |centroid_px(step) - centroid_px(0)| / step_mm, " + "per axis at its largest step" +) + +_REQUIRED_NPZ_KEYS = ( + "base_vertices", + "vertices", + "frame_names", + "frame_axes", + "frame_steps_mm", + "weights", + "origin", + "basis", + "probe_indices", +) + + +class ConfigError(ValueError): + """Invalid job/flags (exit code 2).""" + + +class SceneError(RuntimeError): + """Missing, inconsistent or unusable scene data (exit code 1).""" + + +class ArtifactError(RuntimeError): + """A required artifact is missing or empty (exit code 3).""" + + +# ---------------------------------------------------------------------- +# CLI +# ---------------------------------------------------------------------- +def _argv_after_double_dash(): + if "--" not in sys.argv: + return [] + return sys.argv[sys.argv.index("--") + 1 :] + + +def parse_args(argv): + parser = argparse.ArgumentParser(prog="probe_render.py") + parser.add_argument( + "--job", + type=Path, + required=True, + help="JSON render job written by orisys-design render", + ) + parser.add_argument("--width", type=int, default=None, help="Override render width") + parser.add_argument("--height", type=int, default=None, help="Override render height") + parser.add_argument("--samples", type=int, default=None, help="Override Cycles samples") + parser.add_argument("--seed", type=int, default=None, help="Override Cycles seed") + parser.add_argument("--uv-map", dest="uv_map", default=None, help="Override mesh UV map") + parser.add_argument( + "--texture", type=Path, default=None, help="Override marker texture PNG" + ) + return parser.parse_args(argv) + + +def _load_job(path): + if not path.is_file(): + raise ConfigError(f"Render job not found: {path}") + try: + data = json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as exc: + raise ConfigError(f"Render job is not valid JSON: {path}: {exc}") from exc + if not isinstance(data, dict): + raise ConfigError(f"Render job must be a JSON object: {path}") + return data + + +def _as_int(value, label): + if isinstance(value, bool) or not isinstance(value, int): + raise ConfigError(f"{label}: must be an integer (got {value!r})") + return int(value) + + +def _as_positive_int(value, label): + number = _as_int(value, label) + if number <= 0: + raise ConfigError(f"{label}: must be a positive integer (got {value!r})") + return number + + +def _as_name(value, label): + if not isinstance(value, str) or not value.strip(): + raise ConfigError(f"{label}: must be a non-empty name (got {value!r})") + return value.strip() + + +def _utc_now(): + return datetime.now(timezone.utc).replace(microsecond=0).isoformat() + + +def _sha256(path): + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _require_non_empty(path, label): + candidate = Path(path) + if not candidate.is_file(): + raise ArtifactError(f"{label} not found: {candidate}") + if candidate.stat().st_size == 0: + raise ArtifactError(f"{label} is empty: {candidate}") + return candidate + + +# ---------------------------------------------------------------------- +# PNG metadata +# ---------------------------------------------------------------------- +def strip_volatile_text_chunks(path): + """Drop only the volatile ``tEXt`` chunks; keep every image chunk verbatim. + + Returns the number of dropped chunks. The file stays a valid PNG and its + IHDR/IDAT/IEND bytes are untouched, so the pixel data is exactly what Cycles + produced. + """ + data = Path(path).read_bytes() + if data[:8] != _PNG_SIGNATURE: + raise SceneError(f"renderer wrote a file that is not a PNG: {path}") + out = bytearray(_PNG_SIGNATURE) + pos = 8 + dropped = 0 + while pos + 8 <= len(data): + (length,) = struct.unpack(">I", data[pos : pos + 4]) + ctype = data[pos + 4 : pos + 8] + end = pos + 12 + length + if end > len(data): + raise SceneError(f"truncated PNG: {path}") + if ctype == b"tEXt": + key = data[pos + 8 : pos + 8 + length].split(b"\0", 1)[0].decode("latin-1") + if key in _VOLATILE_TEXT_KEYS or _VOLATILE_TEXT_PATTERN.match(key): + dropped += 1 + pos = end + continue + out += data[pos:end] + pos = end + if dropped: + Path(path).write_bytes(bytes(out)) + return dropped + + +# ---------------------------------------------------------------------- +# PNG pixel comparison (the determinism gate) +# ---------------------------------------------------------------------- +def png_dimensions(path): + """Return ``(width, height)`` from a PNG's IHDR, without decoding pixels.""" + data = Path(path).read_bytes() + if data[:8] != _PNG_SIGNATURE: + raise SceneError(f"not a PNG: {path}") + if data[12:16] != b"IHDR": + raise SceneError(f"PNG does not start with IHDR: {path}") + width, height = struct.unpack(">II", data[16:24]) + return int(width), int(height) + + +def decode_png_rgba8(path): + """Decode an 8-bit RGBA, non-interlaced PNG to a ``(H, W, 4)`` uint8 array. + + Only the format this pipeline writes is accepted; anything else fails loudly + rather than being compared under a false assumption. Decoding here (rather + than through Blender's image API) keeps the comparison exact: no colour + management, no float round-trip. + """ + data = Path(path).read_bytes() + if data[:8] != _PNG_SIGNATURE: + raise SceneError(f"not a PNG: {path}") + header = None + idat = bytearray() + pos = 8 + while pos + 8 <= len(data): + (length,) = struct.unpack(">I", data[pos : pos + 4]) + ctype = data[pos + 4 : pos + 8] + end = pos + 12 + length + if end > len(data): + raise SceneError(f"truncated PNG: {path}") + if ctype == b"IHDR": + header = struct.unpack(">IIBBBBB", data[pos + 8 : pos + 8 + length]) + elif ctype == b"IDAT": + idat += data[pos + 8 : pos + 8 + length] + elif ctype == b"IEND": + break + pos = end + if header is None: + raise SceneError(f"PNG has no IHDR: {path}") + width, height, depth, color_type, compression, filter_method, interlace = header + if (depth, color_type, interlace) != (8, 6, 0): + raise SceneError( + "pixel comparison expects an 8-bit RGBA non-interlaced PNG, got " + f"depth={depth} color_type={color_type} interlace={interlace}: {path}" + ) + if compression != 0 or filter_method != 0: + raise SceneError(f"unsupported PNG compression/filter method: {path}") + try: + raw = zlib.decompress(bytes(idat)) + except zlib.error as exc: + raise SceneError(f"cannot decompress PNG pixel data: {path}: {exc}") from exc + stride = width * 4 + if len(raw) != height * (stride + 1): + raise SceneError( + f"PNG pixel data is {len(raw)} bytes, expected {height * (stride + 1)}: {path}" + ) + + pixels = np.empty((height, width, 4), dtype=np.uint8) + previous = bytearray(stride) + cursor = 0 + for y in range(height): + filter_type = raw[cursor] + cursor += 1 + line = bytearray(raw[cursor : cursor + stride]) + cursor += stride + if filter_type == 0: + pass + elif filter_type == 1: + for i in range(4, stride): + line[i] = (line[i] + line[i - 4]) & 0xFF + elif filter_type == 2: + for i in range(stride): + line[i] = (line[i] + previous[i]) & 0xFF + elif filter_type == 3: + for i in range(stride): + left = line[i - 4] if i >= 4 else 0 + line[i] = (line[i] + ((left + previous[i]) >> 1)) & 0xFF + elif filter_type == 4: + for i in range(stride): + a = line[i - 4] if i >= 4 else 0 + b = previous[i] + c = previous[i - 4] if i >= 4 else 0 + p = a + b - c + pa = abs(p - a) + pb = abs(p - b) + pc = abs(p - c) + if pa <= pb and pa <= pc: + pred = a + elif pb <= pc: + pred = b + else: + pred = c + line[i] = (line[i] + pred) & 0xFF + else: + raise SceneError(f"unknown PNG filter type {filter_type}: {path}") + pixels[y] = np.frombuffer(bytes(line), dtype=np.uint8).reshape(width, 4) + previous = line + return pixels + + +def compare_reference_renders(path_a, path_b): + """Measure how far two frame-0 renders differ, in decoded pixels. + + Returns a result dict with ``passed``, ``max_abs_delta``, + ``differing_pixels``, ``total_pixels``, ``differing_fraction`` and the + tolerances applied. A byte-identical pair short-circuits to zero deltas; any + other pair is decoded and compared channel by channel. Shape mismatch, or any + unreadable/unsupported PNG, raises :class:`SceneError`. + """ + bytes_a = Path(path_a).read_bytes() + bytes_b = Path(path_b).read_bytes() + shape_a = png_dimensions(path_a) + shape_b = png_dimensions(path_b) + if shape_a != shape_b: + raise SceneError( + f"frame-0 renders have different shapes: {shape_a} vs {shape_b} " + f"({path_a}, {path_b})" + ) + height, width = shape_a[1], shape_a[0] + total_pixels = height * width + + if bytes_a == bytes_b: + max_abs_delta = 0 + differing_pixels = 0 + else: + pixels_a = decode_png_rgba8(path_a) + pixels_b = decode_png_rgba8(path_b) + if pixels_a.shape != pixels_b.shape: + raise SceneError( + f"decoded frame-0 renders have different shapes: " + f"{pixels_a.shape} vs {pixels_b.shape}" + ) + delta = np.abs(pixels_a.astype(np.int16) - pixels_b.astype(np.int16)) + max_abs_delta = int(delta.max()) if delta.size else 0 + differing_pixels = int((delta.max(axis=2) > 0).sum()) + + differing_fraction = differing_pixels / total_pixels if total_pixels else 0.0 + passed = ( + max_abs_delta <= DETERMINISM_MAX_ABS_DELTA + and differing_fraction <= DETERMINISM_MAX_DIFFERING_FRACTION + ) + return { + "passed": bool(passed), + "max_abs_delta": max_abs_delta, + "differing_pixels": differing_pixels, + "total_pixels": int(total_pixels), + "differing_fraction": float(differing_fraction), + "max_abs_delta_tolerance": DETERMINISM_MAX_ABS_DELTA, + "differing_fraction_tolerance": DETERMINISM_MAX_DIFFERING_FRACTION, + "shape": [int(width), int(height)], + } + + +# ---------------------------------------------------------------------- +# Scene lookup +# ---------------------------------------------------------------------- +def _require_object(name, object_type, label): + obj = bpy.data.objects.get(name) + if obj is None: + raise SceneError(f"Scene has no {label} named {name!r}") + if obj.type != object_type: + raise SceneError( + f"Object {name!r} is {obj.type}, expected {object_type} for the {label}" + ) + return obj + + +def _require_uv_layer(obj, name): + for layer in obj.data.uv_layers: + if layer.name == name: + if len(layer.data) == 0: + raise SceneError(f"UV map {name!r} on {obj.name!r} has no loop data") + return layer + available = ", ".join(sorted(layer.name for layer in obj.data.uv_layers)) or "none" + raise SceneError( + f"Mesh {obj.name!r} has no UV map named {name!r} (available: {available})" + ) + + +class Projector: + """World coordinates -> render pixels (u=column, v=row, origin top-left).""" + + def __init__(self, scene, camera, width, height): + self.scene = scene + self.camera = camera + self.width = float(width) + self.height = float(height) + + def project(self, world_co): + u, v, depth = world_to_camera_view( + self.scene, self.camera, Vector((float(world_co[0]), float(world_co[1]), float(world_co[2]))) + ) + return (u * self.width, (1.0 - v) * self.height, depth) + + def project_many(self, world_coords): + return np.array([self.project(p)[:2] for p in world_coords], dtype=np.float64) + + +def _mesh_px_per_mm_stats(reference_coords, edges, projector, matrix_world): + """Mesh-wide sampling scale: projected-edge px / 3D-edge mm over every edge. + + This describes how the whole surface is sampled by the camera. It is NOT the + gain that converts the probe's measured flow into millimetres; see + :func:`_probe_px_per_mm` for that. Measured on the reference frame from the + actual projection; never assumed. + """ + if len(edges) == 0: + raise SceneError("Mesh has no edges; cannot measure the projection scale") + world = np.array( + [(matrix_world @ Vector(tuple(c))).to_tuple() for c in reference_coords], + dtype=np.float64, + ) + px = projector.project_many(world) + d3 = np.linalg.norm(reference_coords[edges[:, 0]] - reference_coords[edges[:, 1]], axis=1) + d2 = np.linalg.norm(px[edges[:, 0]] - px[edges[:, 1]], axis=1) + usable = d3 > 0.0 + if not np.any(usable): + raise SceneError("Every mesh edge has zero length; cannot measure the projection scale") + ratios = d2[usable] / d3[usable] + stats = { + "min": float(ratios.min()), + "p05": float(np.percentile(ratios, 5)), + "p50": float(np.percentile(ratios, 50)), + "p95": float(np.percentile(ratios, 95)), + "max": float(ratios.max()), + } + stats["basis"] = MESH_PX_PER_MM_BASIS.format(count=int(len(edges))) + if not all(np.isfinite(value) for key, value in stats.items() if key != "basis"): + raise SceneError(f"Non-finite projection scale measured: {stats}") + return stats + + +def _probe_px_per_mm(frames, centroids): + """Probe-local scale per axis: |centroid_px(step) - centroid_px(0)| / step_mm. + + This is the gain the scorer must use to convert the probe's measured flow to + millimetres. It is anisotropic; on this sensor ``z`` (surface-normal motion) + is much smaller than x/y because normal motion is largely out of the image + plane. That is a real property, recorded rather than corrected. + + Each axis uses its largest step, which is the most numerically robust finite + difference of the same locally-linear map (all 6 probe vertices move by the + same vector, so the centroid tracks it exactly). + """ + reference = np.asarray(centroids[0], dtype=np.float64) + per_axis: dict[str, float] = {} + for axis in ("x", "y", "z"): + positions = [i for i, frame in enumerate(frames) if frame["axis"] == axis] + if not positions: + continue + best = max(positions, key=lambda i: frames[i]["step_mm"]) + step_mm = float(frames[best]["step_mm"]) + if step_mm <= 0.0: + raise SceneError(f"axis {axis!r} has no positive step; cannot measure its scale") + delta = np.asarray(centroids[best], dtype=np.float64) - reference + per_axis[axis] = float(np.linalg.norm(delta) / step_mm) + if not per_axis: + raise SceneError("Frame plan has no axis frames; cannot measure the probe-local scale") + + stats: dict[str, object] = {"p50": float(np.median(list(per_axis.values())))} + for axis in ("x", "y", "z"): + if axis in per_axis: + stats[axis] = per_axis[axis] + stats["basis"] = PROBE_PX_PER_MM_BASIS + if not all(np.isfinite(value) for value in per_axis.values()): + raise SceneError(f"Non-finite probe-local scale measured: {per_axis}") + return stats + + +# ---------------------------------------------------------------------- +# Config resolution +# ---------------------------------------------------------------------- +def _resolve_config(job, args): + schema = job.get("schema") + if schema != JOB_SCHEMA: + raise ConfigError(f"Job schema is {schema!r}, expected {JOB_SCHEMA!r}") + + settings = job.get("settings") + if not isinstance(settings, dict): + raise ConfigError("Job 'settings' must be a mapping") + objects = job.get("objects") + if not isinstance(objects, dict): + raise ConfigError("Job 'objects' must be a mapping") + artifacts = job.get("artifacts") + if not isinstance(artifacts, dict): + raise ConfigError("Job 'artifacts' must be a mapping") + + output_dir = job.get("output_dir") + if not isinstance(output_dir, str) or not output_dir: + raise ConfigError("Job 'output_dir' must be a non-empty path") + frames_npz = artifacts.get("frames_npz") + if not isinstance(frames_npz, str) or not frames_npz: + raise ConfigError("Job 'artifacts.frames_npz' must be a non-empty path") + + raw_frames = job.get("frames") + if not isinstance(raw_frames, list) or not raw_frames: + raise ConfigError("Job 'frames' must be a non-empty list") + frames = [] + for position, entry in enumerate(raw_frames): + if not isinstance(entry, dict): + raise ConfigError(f"Job frames[{position}] must be a mapping") + frame = { + "index": _as_int(entry.get("index"), f"frames[{position}].index"), + "name": _as_name(entry.get("name"), f"frames[{position}].name"), + "axis": entry.get("axis"), + "step_mm": entry.get("step_mm"), + } + if frame["axis"] is not None: + frame["axis"] = _as_name(frame["axis"], f"frames[{position}].axis") + if not isinstance(frame["step_mm"], (int, float)) or isinstance(frame["step_mm"], bool): + raise ConfigError( + f"frames[{position}].step_mm must be a number (got {frame['step_mm']!r})" + ) + frame["step_mm"] = float(frame["step_mm"]) + frames.append(frame) + + names = [frame["name"] for frame in frames] + if len(set(names)) != len(names): + raise ConfigError("Job 'frames' contains duplicate names") + if frames[0]["index"] != 0: + raise ConfigError(f"Job frames[0].index must be 0 (got {frames[0]['index']})") + + null_raw = job.get("null_frame") or {} + if not isinstance(null_raw, dict): + raise ConfigError("Job 'null_frame' must be a mapping") + null_name = _as_name(null_raw.get("name", NULL_FRAME_NAME), "null_frame.name") + + # --- the hard, non-negotiable render settings --- + requested_view_transform = _as_name( + settings.get("view_transform", REQUIRED_VIEW_TRANSFORM), "settings.view_transform" + ) + if requested_view_transform != REQUIRED_VIEW_TRANSFORM: + raise ConfigError( + "settings.view_transform must be " + f"{REQUIRED_VIEW_TRANSFORM!r} (got {requested_view_transform!r}); AgX/Filmic " + "silently rewrites marker pixel values and invalidates the measurement" + ) + + config = { + "output_dir": Path(output_dir).resolve(), + "frames_npz": Path(frames_npz).resolve(), + "source_blend": Path(str(job.get("source_blend", ""))).resolve(), + "mesh": _as_name(objects.get("mesh"), "objects.mesh"), + "camera": _as_name(objects.get("camera"), "objects.camera"), + "frames": frames, + "null_name": null_name, + "null_seed": _as_int( + null_raw.get("seed", _as_int(settings.get("seed", DEFAULT_SEED), "settings.seed") + 1), + "null_frame.seed", + ), + "uv_map": _as_name(args.uv_map or settings.get("uv_map"), "settings.uv_map"), + "texture": Path(args.texture or settings.get("texture") or "").expanduser().resolve(), + "width": _as_positive_int( + args.width if args.width is not None else settings.get("width"), "settings.width" + ), + "height": _as_positive_int( + args.height if args.height is not None else settings.get("height"), "settings.height" + ), + "engine": _as_name(settings.get("engine", DEFAULT_ENGINE), "settings.engine"), + "samples": _as_positive_int( + args.samples if args.samples is not None else settings.get("samples", DEFAULT_SAMPLES), + "settings.samples", + ), + "denoise": settings.get("denoise", False), + "view_transform": requested_view_transform, + "interpolate": _as_name( + settings.get("interpolate", DEFAULT_INTERPOLATE), "settings.interpolate" + ), + "seed": _as_int( + args.seed if args.seed is not None else settings.get("seed", DEFAULT_SEED), + "settings.seed", + ), + "radius_mm": settings.get("radius_mm"), + } + if not isinstance(config["denoise"], bool): + raise ConfigError(f"settings.denoise must be true or false (got {config['denoise']!r})") + if not isinstance(config["radius_mm"], (int, float)) or isinstance(config["radius_mm"], bool): + raise ConfigError( + "settings.radius_mm must be a positive number (got " + f"{config['radius_mm']!r}); probe_roi_px.radius = radius_mm * px_per_mm" + ) + config["radius_mm"] = float(config["radius_mm"]) + if config["radius_mm"] <= 0.0: + raise ConfigError(f"settings.radius_mm must be > 0 (got {config['radius_mm']!r})") + if args.texture is None and (not str(config["texture"]) or str(config["texture"]) == "."): + raise ConfigError("settings.texture must be a non-empty path") + return config + + +# ---------------------------------------------------------------------- +# Scene preparation +# ---------------------------------------------------------------------- +def _apply_scene_settings(scene, config): + """Force the contract's render settings and refuse a non-Standard transform.""" + try: + scene.view_settings.view_transform = REQUIRED_VIEW_TRANSFORM + except TypeError as exc: + raise ConfigError( + f"This Blender build cannot resolve view transform {REQUIRED_VIEW_TRANSFORM!r}: {exc}" + ) from exc + try: + scene.view_settings.look = "None" + except TypeError: + # Blender 4.x renames looks; the transform is what matters and 'None' is + # valid there. A build without 'None' keeps its default look, recorded + # as applied in the manifest. + pass + scene.view_settings.exposure = 0.0 + resolved_view_transform = scene.view_settings.view_transform + if resolved_view_transform != REQUIRED_VIEW_TRANSFORM: + raise ConfigError( + "resolved view transform is " + f"{resolved_view_transform!r}, expected {REQUIRED_VIEW_TRANSFORM!r}; refusing to " + "render marker values through a filmic transform" + ) + + scene.render.engine = config["engine"] + scene.render.resolution_x = config["width"] + scene.render.resolution_y = config["height"] + scene.render.resolution_percentage = 100 + scene.render.film_transparent = False + scene.render.use_file_extension = True + # 8-bit output must not be dithered: dithering is random and makes the + # saved bytes irreproducible. + scene.render.dither_intensity = 0.0 + scene.render.image_settings.file_format = "PNG" + scene.render.image_settings.color_mode = "RGBA" + # Stamp metadata is pure noise for a measurement; volatile cycles timing + # chunks are stripped after each render regardless. + for attribute in dir(scene.render): + if attribute.startswith("use_stamp_"): + try: + setattr(scene.render, attribute, False) + except (AttributeError, TypeError): + pass + + cycles = getattr(scene, "cycles", None) + if cycles is not None: + cycles.samples = config["samples"] + # Denoising and adaptive sampling both change pixel values and would + # make the sweep depend on a stochastic estimator. + cycles.use_denoising = False + cycles.use_adaptive_sampling = False + cycles.seed = config["seed"] + if hasattr(cycles, "use_animated_seed"): + cycles.use_animated_seed = False + elif config["engine"] == "CYCLES": + raise SceneError("Scene has no Cycles settings while the engine is CYCLES") + + return { + "engine": config["engine"], + "samples": config["samples"], + "denoise": False, + "view_transform": resolved_view_transform, + "look": scene.view_settings.look, + "exposure": float(scene.view_settings.exposure), + "interpolate": config["interpolate"], + "seed": config["seed"], + } + + +def _install_marker_material(mesh_obj, image, uv_map, interpolate): + """Install ONE emission material driven by the marker image over ``uv_map``.""" + material = bpy.data.materials.new("probe_marker_emission") + material.use_nodes = True + node_tree = material.node_tree + for node in list(node_tree.nodes): + node_tree.nodes.remove(node) + output = node_tree.nodes.new("ShaderNodeOutputMaterial") + emission = node_tree.nodes.new("ShaderNodeEmission") + texture = node_tree.nodes.new("ShaderNodeTexImage") + uv_node = node_tree.nodes.new("ShaderNodeUVMap") + uv_node.uv_map = uv_map + texture.image = image + try: + texture.interpolation = interpolate + except TypeError as exc: + raise ConfigError(f"settings.interpolate {interpolate!r} is not a valid mode") from exc + emission.inputs["Strength"].default_value = 1.0 + node_tree.links.new(uv_node.outputs["UV"], texture.inputs["Vector"]) + node_tree.links.new(texture.outputs["Color"], emission.inputs["Color"]) + node_tree.links.new(emission.outputs["Emission"], output.inputs["Surface"]) + + mesh = mesh_obj.data + mesh.materials.clear() + mesh.materials.append(material) + for polygon in mesh.polygons: + polygon.material_index = 0 + return material + + +def _write_vertices(mesh, coords): + flat = np.ascontiguousarray(coords, dtype=np.float32).ravel() + mesh.vertices.foreach_set("co", flat) + mesh.update() + + +def _render_to(scene, path): + Path(path).parent.mkdir(parents=True, exist_ok=True) + scene.render.filepath = str(path) + bpy.ops.render.render(write_still=True) + strip_volatile_text_chunks(path) + return Path(path) + + +# ---------------------------------------------------------------------- +# Main +# ---------------------------------------------------------------------- +def main(): + args = parse_args(_argv_after_double_dash()) + try: + job = _load_job(args.job) + config = _resolve_config(job, args) + except (ConfigError, json.JSONDecodeError, OSError) as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 2 + + scene = bpy.context.scene + try: + settings_applied = _apply_scene_settings(scene, config) + except (ConfigError, SceneError) as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 2 if isinstance(exc, ConfigError) else 1 + + try: + npz_path = _require_non_empty(config["frames_npz"], "probe_frames.npz") + texture_path = _require_non_empty(config["texture"], "marker texture") + mesh_obj = _require_object(config["mesh"], "MESH", "mesh") + camera_obj = _require_object(config["camera"], "CAMERA", "camera") + _require_uv_layer(mesh_obj, config["uv_map"]) + except (ArtifactError, SceneError) as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 3 if isinstance(exc, ArtifactError) else 1 + + started = time.time() + mesh = mesh_obj.data + try: + with np.load(str(npz_path), allow_pickle=False) as data: + missing = [key for key in _REQUIRED_NPZ_KEYS if key not in data.files] + if missing: + raise SceneError( + f"{npz_path} is missing key(s) {', '.join(missing)} " + f"(present: {', '.join(sorted(data.files))})" + ) + base_vertices = np.asarray(data["base_vertices"], dtype=np.float64) + vertices = np.asarray(data["vertices"], dtype=np.float64) + npz_names = [str(name) for name in np.asarray(data["frame_names"]).tolist()] + probe_indices = np.asarray(data["probe_indices"], dtype=np.int64).ravel() + except SceneError: + raise + except Exception as exc: # noqa: BLE001 - surface any npz read failure + print(f"ERROR: cannot read {npz_path}: {exc}", file=sys.stderr) + return 3 + + plan_names = [frame["name"] for frame in config["frames"]] + try: + if vertices.ndim != 3 or vertices.shape[2] != 3: + raise SceneError(f"probe_frames.npz 'vertices' must be (F, V, 3), got {vertices.shape}") + if base_vertices.ndim != 2 or base_vertices.shape[1] != 3: + raise SceneError( + f"probe_frames.npz 'base_vertices' must be (V, 3), got {base_vertices.shape}" + ) + if len(vertices) != len(npz_names): + raise SceneError( + f"probe_frames.npz has {len(vertices)} frames but {len(npz_names)} frame names" + ) + if len(npz_names) != len(plan_names): + raise SceneError( + f"probe_frames.npz has {len(npz_names)} frames but the job plan has " + f"{len(plan_names)}" + ) + mismatched = [ + (index, plan, npz) + for index, (plan, npz) in enumerate(zip(plan_names, npz_names)) + if plan != npz + ] + if mismatched: + index, plan, npz = mismatched[0] + raise SceneError( + f"frame order disagrees at index {index}: job plan {plan!r} vs " + f"probe_frames.npz {npz!r}" + ) + if vertices.shape[1] != len(mesh.vertices): + raise SceneError( + f"probe_frames.npz has {vertices.shape[1]} vertices but mesh {mesh_obj.name!r} " + f"has {len(mesh.vertices)}" + ) + if base_vertices.shape[0] != len(mesh.vertices): + raise SceneError( + f"probe_frames.npz 'base_vertices' has {base_vertices.shape[0]} rows but mesh " + f"{mesh_obj.name!r} has {len(mesh.vertices)} vertices" + ) + if probe_indices.size == 0: + raise SceneError("probe_frames.npz 'probe_indices' is empty") + if probe_indices.min() < 0 or probe_indices.max() >= len(mesh.vertices): + raise SceneError( + f"probe_frames.npz 'probe_indices' out of range 0..{len(mesh.vertices) - 1}" + ) + except SceneError as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 1 + + try: + image = bpy.data.images.load(str(texture_path), check_existing=False) + except RuntimeError as exc: + print(f"ERROR: cannot load marker texture {texture_path}: {exc}", file=sys.stderr) + return 3 + if image.size[0] <= 0 or image.size[1] <= 0: + print(f"ERROR: marker texture has no pixels: {texture_path}", file=sys.stderr) + return 3 + image.colorspace_settings.name = "sRGB" + + output_dir = config["output_dir"] + frames_dir = output_dir / FRAMES_DIRNAME + frames_dir.mkdir(parents=True, exist_ok=True) + _install_marker_material(mesh_obj, image, config["uv_map"], config["interpolate"]) + + projector = Projector(scene, camera_obj, config["width"], config["height"]) + matrix_world = mesh_obj.matrix_world + edges = np.array( + [tuple(edge.vertices) for edge in mesh.edges], dtype=np.int64 + ).reshape(-1, 2) + + def project_local(local_co): + return projector.project(matrix_world @ Vector(tuple(float(x) for x in local_co))) + + try: + mesh_px_per_mm = _mesh_px_per_mm_stats(vertices[0], edges, projector, matrix_world) + # Every probe vertex moves by the same vector, so the centroid of each + # frame's probe members is exactly origin + applied displacement. + centroids = [ + (float(project_local(vertices[i][probe_indices].mean(axis=0))[0]), + float(project_local(vertices[i][probe_indices].mean(axis=0))[1])) + for i in range(len(config["frames"])) + ] + probe_px_per_mm = _probe_px_per_mm(config["frames"], centroids) + except SceneError as exc: + print(f"ERROR: {exc}", file=sys.stderr) + return 1 + + roi_u, roi_v = centroids[0] + roi_radius = config["radius_mm"] * float(probe_px_per_mm["p50"]) + + # --- frames, in plan order --- + frame_entries = [] + determinism = None + reference_png_sha = None + for position, frame in enumerate(config["frames"]): + centroid = centroids[position] + _write_vertices(mesh, vertices[position]) + png = _render_to(scene, frames_dir / f"{frame['name']}.png") + digest = _sha256(png) + if position == 0: + reference_png_sha = digest + # Same session, same seed, same scene: the DECODED PIXELS must agree + # within one 8-bit step on at most 0.05% of pixels. Raw file bytes are + # not the comparison; Cycles thread ordering can flip a boundary pixel. + repeat = _render_to(scene, output_dir / "checks" / f"{frame['name']}_repeat.png") + determinism = compare_reference_renders(png, repeat) + if not determinism["passed"]: + print( + "ERROR: frame 0 rendered twice with the same seed is not reproducible: " + f"max_abs_delta={determinism['max_abs_delta']} " + f"(tolerance {determinism['max_abs_delta_tolerance']}), " + f"differing_fraction={determinism['differing_fraction']:.8f} " + f"(tolerance {determinism['differing_fraction_tolerance']}), " + f"differing_pixels={determinism['differing_pixels']}/" + f"{determinism['total_pixels']}; every later number would be invalid", + file=sys.stderr, + ) + return 1 + frame_entries.append( + { + "index": frame["index"], + "name": frame["name"], + "axis": frame["axis"], + "step_mm": frame["step_mm"], + "png": f"{FRAMES_DIRNAME}/{frame['name']}.png", + "sha256": digest, + "width": config["width"], + "height": config["height"], + "centroid_px": [centroid[0], centroid[1]], + } + ) + print( + f"[{position + 1}/{len(config['frames'])}] {frame['name']} -> {png.name} " + f"({png.stat().st_size} bytes, centroid {centroid[0]:.4f},{centroid[1]:.4f})", + flush=True, + ) + + if reference_png_sha is None: + print("ERROR: the job plan has no reference frame", file=sys.stderr) + return 1 + if abs(centroids[0][0] - roi_u) > 1e-9 or abs(centroids[0][1] - roi_v) > 1e-9: + print( + f"ERROR: reference centroid_px {centroids[0]} does not match probe_roi_px " + f"centre ({roi_u}, {roi_v})", + file=sys.stderr, + ) + return 1 + + # --- null frame: the reference again at a different seed --- + _write_vertices(mesh, vertices[0]) + cycles = getattr(scene, "cycles", None) + if cycles is not None: + cycles.seed = config["null_seed"] + null_png = _render_to(scene, frames_dir / f"{config['null_name']}.png") + null_sha = _sha256(null_png) + print( + f"null frame {config['null_name']} seed={config['null_seed']} -> {null_png.name} " + f"({null_png.stat().st_size} bytes)", + flush=True, + ) + + if config["source_blend"].is_file(): + source_sha = _sha256(config["source_blend"]) + else: + source_sha = "" + manifest = { + "schema": MANIFEST_SCHEMA, + "generated_at": _utc_now(), + "source_blend": { + "path": str(config["source_blend"]), + "sha256": source_sha, + }, + "texture": { + "path": str(texture_path), + "sha256": _sha256(texture_path), + }, + "uv_map": config["uv_map"], + "width": config["width"], + "height": config["height"], + "settings_applied": settings_applied, + "mesh_px_per_mm": mesh_px_per_mm, + "probe_px_per_mm": probe_px_per_mm, + "probe_roi_px": { + "u": float(roi_u), + "v": float(roi_v), + "radius": float(roi_radius), + }, + "reference_index": 0, + "reference_deterministic": bool(determinism["passed"]), + "reference_determinism": determinism, + "frames": frame_entries, + "null": { + "name": config["null_name"], + "seed": config["null_seed"], + "png": f"{FRAMES_DIRNAME}/{config['null_name']}.png", + "sha256": null_sha, + }, + } + manifest_path = output_dir / MANIFEST_FILENAME + manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + + print( + f"Render complete: {len(frame_entries)} frames + 1 null in " + f"{time.time() - started:.1f}s" + ) + print( + " mesh_px_per_mm min/p05/p50/p95/max " + f"{mesh_px_per_mm['min']:.4f} / {mesh_px_per_mm['p05']:.4f} / " + f"{mesh_px_per_mm['p50']:.4f} / {mesh_px_per_mm['p95']:.4f} / " + f"{mesh_px_per_mm['max']:.4f}" + ) + print( + " probe_px_per_mm p50/x/y/z " + f"{probe_px_per_mm['p50']:.4f} / {float(probe_px_per_mm.get('x', float('nan'))):.4f} / " + f"{float(probe_px_per_mm.get('y', float('nan'))):.4f} / " + f"{float(probe_px_per_mm.get('z', float('nan'))):.4f}" + ) + print(f" probe_roi_px u/v/radius {roi_u:.4f} / {roi_v:.4f} / {roi_radius:.4f}") + print( + f" reference_deterministic {determinism['passed']} " + f"(max_abs_delta {determinism['max_abs_delta']}/" + f"{determinism['max_abs_delta_tolerance']}, differing_fraction " + f"{determinism['differing_fraction']:.8f}/" + f"{determinism['differing_fraction_tolerance']})" + ) + print(f" reference sha256 {reference_png_sha}") + print(f" manifest {manifest_path}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/blender/scripts/test_probe_falloff.py b/blender/scripts/test_probe_falloff.py new file mode 100644 index 0000000..3d6b16a --- /dev/null +++ b/blender/scripts/test_probe_falloff.py @@ -0,0 +1,538 @@ +"""Tests for the bpy-free probe falloff and basis helpers. + +The Xynova regression fixture below is the measured set of nearest-probe-vertex +distances (mm) for the 2502 non-probe vertices of ``sensing_surface`` in +``sensors/finger-xynova/r01/source/geometry.blend`` (sha256 +``1C8A050B8490B6832D3A9F269DFEF3DAFBF94DBFE3E943B3956BE1104A50D9C9``). It was +dumped once from Blender and is embedded as base64 float32 because pytest cannot +import bpy: the measured distribution has to travel with the test. The values +are sorted ascending, so the first entries are the ones the radius can reach. +""" + +from __future__ import annotations + +import base64 + +import numpy as np +import pytest + +from probe_falloff import ( + FALLOFF_MODES, + affected_bands, + edge_lengths_mm, + falloff_weight, + falloff_weights, + flatness_mm, + linear_weight, + orthonormal_basis, + orthonormality_error, + percentile, + sharp_weight, + smooth_weight, +) + +#: Sorted nearest-probe distances, mm, for the 2502 non-probe vertices. +_NONPROBE_DISTANCES_F32_B64 = ( + "SRaSPkIO1T5RDtU+nmLVPrFi1T44xks/DpdUPxiXVD8n71Q/pu9UPzvEYj8SxmI/h6BoP4egaD+vtWg/cAh7P40Iez8uv4E/" + "Yb+BP0dMmD90TJg/RHKYP2Hjnj+a454/lSefP8wnnz8YDaI/Yg2iPzz8vD+i/Lw/T+HLP9Hhyz/g59I/T+jSPyNF0z+XRdM/" + "FlnZP0tP3z9sUN8/PRrkPzSD5j/ag+Y/yC/nP4ai5z8Yxec/+uTrP3Oj7z+oo+8/GJfxP0AY+j/4GPo/R3b6P82K+z99JAJA" + "oiQCQPgiA0BSIwNAAmADQF5gA0D4kwNAfB0HQHQtCUDJLQlA0pAJQFMwEUCLMBFA7lYSQAobE0C7rxRAG7AUQIchFUDjIRVA" + "4+cbQCR2HECkdhxAKMUcQH7FHEDdoB9AWKEfQCN/I0BZfyNAxJcjQIZtJEDkbSRAqQcmQJwZKEBCGihAHX8pQCqILUDEli1A" + "PpctQF0BL0DMAS9AWDw0QPFnNUCQaDVADas1QH2rNUBnzjVA4s41QFZJNkDwSTZA4t43QCLfN0AO6zdAXOs3QGraOUCirztA" + "hrM7QKTMO0D11TtAMHo9QJhXPkBUPD9AkAJAQJc5QECyO0FARjxBQP28QUCVvUFAOTlDQPKOQ0Aej0NAW71EQD+zRkDzx0ZA" + "RO9HQL3vR0BtUEhApz9KQH+FTEAQhkxAmf1MQDP+TECNVE1AF+hNQBOuTkDReVBARclQQCMhUUDdZ1JAKGhSQBeKUkA+glVA" + "6ZJXQH3KV0AUy1dAr1NYQEZUWEDbSVpA+OlaQInqWkCQIltA6D5bQLlSW0DTbVtAEY5cQDS7XECjul1AbNtdQPz/XUA7jF5A" + "o75eQBHdXkBgDV9A2ThfQBp7YECne2BAvy5iQBlPYkARuGJAqeFiQAkIY0DACGNAqaNjQEGkY0AmmWRA1ZlkQPBjZUC2hmVA" + "6O9lQGbwZUDWaGZARX1mQMSwZkDZgGdArahnQKysZ0CTHGhAoCloQL8AaUAG82tAqRNtQC9XbUBEfW1A38ZtQCPmbUDi521A" + "j2FuQCpibkBatG5AeLRuQHXrbkAs7G5Ab3lvQHpRckA/hXJA4wl0QMoqdEAYT3RA0E51QKTtdkB3DXdAomN3QDbHd0AkPnhA" + "zT54QMkkeUAKiXlApLx5QCMqekD4KnpAmOp7QFwNfED2fnxAj398QOnyfEDWo31AIMt9QIxrf0B/YoBAbm6AQN9xgECcuoBA" + "4LqAQOLFgECZ34BA8wiBQMIVgUAcFoFA6TuBQPipgUDkuoFAucGBQALSgUDp4IFA5+GBQKP0gUADHoJARDaCQBg5gkBxQoJA" + "BFOCQAdTgkBpaYJA3a+CQD2wgkAQF4NAqi+DQDh0g0AthINA4omDQLeRhECuqoRAjdiEQMHYhECp2YRAdxGFQFwehUANI4VA" + "aSOFQFckhUAqM4VA7zyFQIluhUB+gIVA0hOGQEAUhkDSWIZAC4aGQCmfhkAd9IZALQSHQKZPh0CnY4dA9X6HQB6IiEAL64hA" + "TQSJQFFXiUCgaYlAXnGJQJyCiUAZz4lAbOiJQM4FikD3GIpAwxmKQF4Yi0DOGItA/zSLQCV1i0CGt4tAxNCLQIcCjEASEoxA" + "jSyMQMssjEC+54xAjf2MQBo9jUBZPY1Au0+NQG/jjUC+8I1A//ONQI0CjkCJOo5Aik+OQGF0jkCkdI5AQLmOQAbIjkBK0o5A" + "JeWOQEj+jkAgaY9AnAqQQAkSkEA/JpBAfvKQQCMEkUAZCZFAkhuRQGRZkUCbQZJA1kGSQKtukkAXcJJAHoKSQBeJkkByvJJA" + "tcCSQK/HkkB1zJJAaFWTQHMflUB3MJVArjGVQCsylUDnT5VAf2KVQJF0lUCchpVAtvSVQOv+lUATCJZAdAuWQOwVlkCBHpZA" + "gDmWQO5BlkCUT5ZANlOWQINplkAJbJZA/oCWQLSJlkB2n5ZASQmXQIRDl0BhW5dAI4iXQIuIl0COnZdAq++XQED/l0Dzi5hA" + "DqSYQH20mEDmuJhAYMaYQH0ImUCyHJlAwGGZQHy8mUDRzJlACwGaQEkBmkDXK5pAaz2aQHc/mkDLP5pAyFeaQHKHmkAKoJpA" + "pwybQCUgm0BmHpxApR6cQD1XnECxb5xAOJicQGmpnEB41pxAYR+dQHIxnUALl51AwqmdQEy9nkD1y55AIc2eQHLknkDgAJ9A" + "NBmfQB4gn0BpMZ9AcXWfQPinn0AyqJ9AuUCgQFJKoEAQTKBA91+gQECpoEA4u6BAIfSgQC35oECfBKFAEg6hQGaWoUDHraFA" + "066hQGy/oUBywqFAcSSiQJ44okC/rKJAj7GjQJXJo0D10aNAb+WjQOvwo0BEEqRAxiGkQNlApEBhUaRAJVKkQH9ipEAbsqRA" + "aMqkQNPppEB5vaVAj82lQI0GpkBDGaZA3IGmQJWDpkAqk6ZAcIKnQHe5p0DJuadAyxyoQPg0qEBeWKhA72ioQPm/qEBKxqhA" + "OdioQKgCqUCnSalALlupQAKzqUBMs6lA3dGpQAQXqkBFHqpAZyqqQJ0sqkCiM6pAQ0CqQHBXqkCcbapARIGqQPeVqkA0napA" + "n7OqQOLlqkBo9apAYVurQHhvq0Cwb6tAdYarQIabq0CHrKtANtOrQCHrq0ClEKxA3yGsQDScrEBLs6xASLWsQJ7IrEBz3axA" + "COesQB/3rEDxAq1AKQOtQAXHrUAG/K1ATA2uQKEhrkDvOK5AL5auQNGorkAZh69AX9CvQFTir0AB6K9A7vKvQBP9r0CBFLBA" + "rVuwQNJqsEDVnrBA0vuwQLIEsUCtDLFAnBaxQKXfsUA577FA+iiyQHhAskDI/bJAzg6zQAEBtECHArRAtgq0QMATtEAPFrRA" + "wRy0QA0itEBEMbRArTS0QM9EtECen7RAG6q0QCi3tED+vbRAqMe0QPNStUAyU7VATom1QGmatUCTrLVAAbS1QMq4tUCEubVA" + "RMe1QHastkA3vbZAvy23QPctt0CPMbdA1EC3QFpEt0DYVrdAzVu3QChzt0CAjrdAJJ+3QExPuEAfYLhAlna4QJKNuEDh+7hA" + "gQu5QNxjuUDUdblAMaK5QOZLukAVTLpAXFq6QIdxukCAc7pASIS6QDuku0BjtLtA5Ba8QBsovEDyzbxA/dy8QHRGvUCwmr1A" + "sbG9QEzJvUCd3b1Az++9QMP5vUCfBL5Acwq+QLIOvkB0Ir5AySe+QMcovkAROL5AyDy+QF12vkCai75AY62+QBTNvkAg2r5A" + "NuC+QJDvvkABUr9AWV6/QK5nv0AKb79AIre/QNnHv0CfEMBAICPAQKY5wEBNScBA7XnAQN+PwEApG8FA7zHBQLV2wUBt5MFA" + "wufBQFL2wUA8+sFA7v3BQPsKwkDRysJAEcvCQA44w0AzSMNAAWPDQG2aw0BsrcNAv7DDQGy8w0AST8RASmDEQNiKxEAii8RA" + "49jEQFLvxEAzQcVAfFDFQMOPxUAxpsVAYzTGQPfHxkBLMcdA1UHHQOhTx0COZMdAcH3HQKV9x0DHhMdAWYfHQM+Yx0DamsdA" + "icPHQOTZx0AQ6MdAiPzHQAz/x0D6EchA4szIQAfjyEAV+shAdQzJQMCKyUCXmclApDHKQPJHykAkrspAKr3KQMHyykD3AstA" + "CZDLQC+Qy0AN08xAKdbMQJPjzEAN5cxAS+zMQHL6zEBSJc9ADzXPQAKiz0DDr89AzcXPQPYF0EBUHtBAlR7QQHxq0ECmf9BA" + "n47QQOQR0UA6JdFA8UfRQL9M0UC2WtFAYWDRQOR30UDYxtFACcfRQFDn0UBu+9FALP/RQGYR0kDrU9JATGjSQHK/0kAn09JA" + "NtXSQL7n0kC+RtNAgVjTQGhj00AIeNNARK3TQErh00Cm8NNAVQPUQBUY1EDnktRAIJPUQMax1ECzxtRAlSnVQLU61UCtbdVA" + "rYLVQD8F1kDUGtZA62HWQDly1kCdC9dAwCDXQIqv10AmwNdADATYQKFy2EA23NhAe/HYQLwb2UDkKtlAfYDZQMmV2UBHNdpA" + "tkraQCqp2kAZvNpAbdzaQDXe2kCf7NpAb/PaQAIc20BYL9tAuEXbQIjo20BN/NtAM/7bQHwO3ECHDt1AtiPdQCcr3UDgLN1A" + "WkDdQOJB3UBWSt1AnErdQCKt3kDtvN5Ar9DeQO3d3kAZ3t5As9/eQLxq30DKf99ACFPgQPln4EBqqOBAfb3gQKrW4EBC3uBA" + "5+rgQImH4UCuh+FA97PhQFPw4UBSBeJA9xnjQGkp40CbQuNAf1fjQCWt40CNvuNA0cHjQE7Y40CtCORA7xrkQCpG5ECsRuRA" + "/VfkQFtZ5ECYn+RAb7TkQILs5ECM/+RAwxHlQBcj5UBFOeVAaDnlQBHm5UBm+eVAugfmQGoc5kAqeuZA+3zmQAyL5kBtkOZA" + "siLnQEU250CRNudA4UrnQDl750DJj+dAfdXnQIrb50Ao6edALxnoQE0o6EALi+hA4pPoQH6b6ECup+hAWvroQMsO6UDKXOlA" + "o3DpQEfb6UABL+pA6ULqQM9L6kAITOpAO4XqQIeZ6kB8repANMHqQJRL60CIW+tAknXrQIiF60B+zOtAsszrQDvt60A/AexA" + "iKTtQFqz7UDIvu1ATs7tQOPS7UBi4u1ADVfuQDZX7kDXuu5AfLvuQA/L7kBzze5AstHvQLbc70DB5e9Alu/vQLPf8EC38/BA" + "SibxQBY68UB1qPFAKt/xQEzf8UDD9fFAwgnyQHrV8kC+5PJAvBPzQKQn80B43vNAXzn0QExN9EBqbfRAlG30QLmA9EB/m/RA" + "Ra/0QKNm9UCFevVARCD2QKqb9kBkr/ZAFr72QEvP9kBp6PZABPr2QB4N90DyHfdA3x/3QBIg90DbLvdAmof3QIaZ90ABqvdA" + "frX3QP/I90Cy2PdAXOz3QN4Z+EBeKvhAVIX4QHOP+ECnj/hAhZf4QGIe+UD9MflAucD5QBzL+UC60PlAjd35QKpQ+kArX/pA" + "S236QMOA+kAdg/pAu5X6QGf8+kC5/fpA5/36QKsP+0CiRvtAO1n7QOrF+0BN2ftAeBP8QGUc/EAqJvxAGCz8QGvn/EBX6PxA" + "Fvb8QCL7/ECpKP1A8Tv9QA3E/UDl1v1AHRf+QLUp/kDTX/5A+F/+QOuV/kB/pf5AF6n+QFu4/kCZL/9A+T7/QLU7AEEoRQBB" + "0cgAQUTSAEH1FQFBPy8BQbY4AUGVewFBFYMBQR6tAUGRtgFBLOQBQUXkAUGZLQJBETcCQb9cAkERZgJBG5QCQTSUAkHEsAJB" + "NLoCQUDrAkGgNgNBC0ADQQNJA0E5vgNBTr4DQSm/A0GUyANBO9UDQUHeA0F/OgRBykMEQXBKBEHIUwRBSWAEQRGmBEEKqwRB" + "3awEQUCtBEFaswRBBbUEQWjYBEG14QRBvusEQTT0BEFd+wRBXAMFQbkNBUG+XQVBz10FQUFjBUE1aQVB02sFQYFyBUFCnwVB" + "GKcFQdupBUEGswVBMP0FQVEFBkFwBgZBAA4GQVNDBkGESgZBrJQGQdudBkHKngZBcqYGQdTFBkGbzgZBhi0HQQgwB0FmNgdB" + "LjkHQbZkB0ERmwdB7aMHQaDPB0G42AdBzQoIQbETCEHCJAhB3CQIQcBzCEHTfAhB8HwIQdmFCEFxzQhBi80IQbscCUG7JQlB" + "XikJQR1mCUEJbwlB8rcJQUq/CUGL6wlBo+sJQZJTCkF5XApBTH4KQTmHCkECzApB6NQKQcZFC0GwTgtBvXoLQdJ6C0ENewtB" + "KqkLQfTAC0HRyQtB2+4LQXX3C0F/PQxBZ0YMQYNIDEF8TwxBvIoMQZe7DEFzxAxBRzsNQSVEDUFjSA1B7lANQbG8DUGExQ1B" + "XdwNQTnkDUH/8Q1Bu/oNQYEBDkHNAQ5BeQkOQYUJDkGJOw5B5D8OQZZCDkGtSA5BLlMOQUhTDkEcZg5BF2wOQTJuDkFRdQ5B" + "BMUOQcHNDkEg9Q5BM/UOQZH9DkHIBQ9BgEYPQTNMD0EmTw9B3lAPQedUD0FGWA9BALsPQUnDD0Hd1Q9BjN4PQfcHEEEICBBB" + "cGIQQRlrEEGVkRBB7JkQQW7yEEED+xBBkP0QQTN3EUGXfxFBMIYRQeWHEUHzhxFBvY4RQb4ZEkEgHhJB4SASQaUmEkGyYxJB" + "HmwSQZ66EkEVwxJB8lETQV9XE0FWWhNBqsgTQQrRE0HP6BNBwAIUQSMLFEEjDBRB8hIUQSg/FEGVRxRBJnAUQT1wFEGltRRB" + "DL4UQb4LFUHTCxVBWiwVQbg0FUGcUBVBulgVQVajFUG0qxVBkcAVQQcUFkEZFBZBvRoWQRojFkGIVxZBZF4WQXuSFkHCkhZB" + "hpoWQQ+bFkHHpxZBkwsXQeITF0GKFxdBoxkXQREfF0EXIRdBRl0XQexkF0FbhRdBj4UXQaSFF0GejRdB3KwXQRDfF0HN5hdB" + "QQAYQX0IGEFqHRhBkCQYQdpbGEFxfBhBp4QYQcSPGEGHlxhBLPoYQVwCGUHNYRlBp2kZQe15GUEOghlBLPwZQUcEGkEISBpB" + "508aQYOBGkGTiRpBpJoaQZKhGkFdChtBYhIbQRw4G0EJQBtBMEYbQSuXG0EnnxtB4O0bQXj0G0FkKBxB+ykcQVowHEHmMRxB" + "7aEcQeWpHEGrGB1BmCAdQbZZHUGYYR1B9Y0dQeCVHUH8AR5B5AkeQf90HkHkfB5BMIkeQc+QHkF0kh5BGZkeQUnnHkEp7x5B" + "CFkfQdtgH0FDth9B0r0fQWTKH0E50h9BKwUgQbY7IEGoPSBBg0MgQcVEIEG0WSBB4mAgQaRxIEGneCBBpXkgQbx5IEGIrCBB" + "NK0gQf20IEGBuiBBzcEgQRz5IEGM/iBBagUhQZ4JIUGzCSFBHh8hQd8mIUG7UyFBE1shQaaRIUFlmSFB4qEhQXP+IUGO/iFB" + "HAUiQc0MIkHLFyJBMR8iQbZ5IkFhgSJBA/AiQaz3IkHQ+CJBSQAjQTE1I0HSOyNBB0sjQW1VI0F9VSNBnGgjQTZwI0EL5CNB" + "U+kjQVDqI0Gi6yNBsvAjQcrwI0HgYiRBamokQQXVJEHM1SRBAd8kQY/lJEF35iRBE+0kQZNsJUEOdCVB29ElQVHZJUHESCZB" + "PlAmQYSJJkHpkCZBcL0mQefEJkHg5yZBPu4mQcAvJ0ExNydBSJ4nQe2fJ0F4pSdBX6cnQVQOKEHAFShBK1AoQUN7KEGfgihB" + "57goQQLAKEH35ihBXO4oQcZRKUEiWSlBkGopQVtxKUFAgilB7ogpQRqgKUH3pilB+bspQVHDKUGJ8ClBI/cpQQgXKkHsHSpB" + "9SUqQUItKkH9jypBQpcqQZzCKkGTySpBTfoqQZYBK0FEZStBfGwrQdtsK0H5lCtBAZwrQS7RK0Fl2CtBj+UrQfPrK0F6/itB" + "ngQsQQ0iLEGfPixBzUUsQa1ZLEEagCxBKYcsQTauLEFctSxBXs4sQXDOLEH41ixBiCAtQaonLUFUdi1BYX0tQSmWLUFCnS1B" + "hG0uQZR0LkFxjS5BeZQuQdrmLkHi7S5BP/AuQVHwLkGFVC9BplovQd1dL0HiZC9BAZgvQfaeL0Ef0i9BIdkvQYTzL0FUQzBB" + "WkowQduIMEEjlTBB6pswQW+xMEFruDBBiLwwQbYcMUGzIzFBsj0xQc5DMUGQhTFBiYwxQT2fMUHvpTFBaOwxQVjzMUGNUTJB" + "elgyQXSdMkEunjJB1qMyQaekMkFWtTJBQLwyQeroMkFv7zJBkvAyQdr2MkEuGDNBER8zQYVxM0EVeDNBhnozQWGBM0FTszNB" + "rdwzQYDjM0HuKjRBiTE0QfI+NEHHRTRBtaE0QXmoNEHSqDRB5q40QUkFNUFDBzVBDww1Qd4NNUFZajVBF3E1QX7RNUEz2DVB" + "TPg1Qez+NUGZqDZBQK82QW3wNkET9zZBD483QaiVN0HVvzdBxcI3QaXVN0GA2zdBr+U3QVDsN0G2XDhBjGI4QZhiOEFTYzhB" + "EIk4QZqPOEGR0DhBL9c4QfVAOUGKRzlBkE45QaNTOUFWcTlBqnc5QaCtOUExtDlBhRY6QRYdOkGuXTpBul06QQx8OkGagjpB" + "rt46QTXlOkHcPjtBYkU7QfqcO0F6oztBz8E7QdfHO0GT1ztBrd07QXL5O0G1/DtB4f87QbICPEHkBDxBDzA8QdgzPEELOjxB" + "uVQ8QSxbPEEVZDxBvGk8QVGvPEG8tTxBXso8QZHQPEGVCT1BAhA9QehjPUFIaj1BjHw9QVyCPUHijT1BGZQ9QZ++PUEAxT1B" + "MRo+QYggPkFscD5BonY+QUJ3PkGWfT5B1Ik+QW7WPkG33D5B7GM/QSJqP0HGnT9B/6M/QdFaQEEKYUBB5mhAQYJuQEHZdEBB" + "CntAQWRLQUGdUUFBdFJBQeRXQUHoX0FBDGZBQem+QUEdxUFBmSpCQY4uQkG8NEJBnTVCQZc7QkERmkJBRaBCQVUBQ0F7B0NB" + "7D1DQU9kQ0FxakNBeMNDQaPJQ0EJ0kNBFdJDQVwfREF6JURBd3hEQSR8REGMfkRBP89EQVfVREFv7kRBnfJEQSb0REG1E0VB" + "ZxZFQVsZRUEtHEVBLCRFQUIqRUHMd0VB2H1FQUyBRUEgh0VB9KhFQfyoRUGhykVBodBFQQb2RUEUHUZBoSJGQRYjRkF1KEZB" + "115GQVlkRkGPb0ZBkHVGQXvCRkFwyEZBJu1GQf3yRkFSFkdBSBxHQZNXR0FYw0dBO8lHQfzSR0Ha2EdB5XtIQcKBSEEuxkhB" + "CsxIQVYMSUGqEUlBy0RJQZlKSUFZuUlBN79JQQwfSkGyJEpB8C9KQck1SkEzo0pBBqlKQW7nSkEA7UpBRRJLQRwYS0GKVktB" + "6XxLQbeCS0HX4ktBpOhLQQxETEHUSUxBl6BMQVumTEH2+ExBuv5MQcoOTUHnE01BzE1NQYRTTUGWn01BSaVNQeLuTUGX9E1B" + "wgdOQboiTkGsJU5BGyhOQV80TkG1OU5BMTxOQeJBTkGgWk5BCmBOQSaITkHQjU5BtdFOQUnTTkEo105B59hOQREeT0GtI09B" + "BidPQRMnT0EITk9BOFNPQehoT0F9bk9BZ3tPQeeAT0GpAFBBMQZQQYZKUEEEUFBBJ59QQa2kUEHL21BB19tQQV8xUUHaNlFB" + "4klRQV1PUUEiv1FBkAVSQQQLUkEdIlJBmidSQQsuUkGOM1JBx4xSQRrDUkGXyFJBc89SQbbUUkHGD1NBQRVTQY5SU0EEWFNB" + "j2tTQYiCU0H+h1NBtYxTQe6RU0Gp4FNBFuZTQUbxU0G69lNBSVtUQbxgVEFKwFRBu8VUQbTsVEExIFVBmiVVQe96VUFagFVB" + "tdBVQRrWVUEVIlZBbydWQZtvVkH4dFZB+7lWQVS/VkHIAVdBGQdXQYpHV0HbTFdB2V1XQSVeV0HVYldBKmNXQaiBV0Hli1dB" + "LpFXQSakV0FAqVdBd89XQbfUV0GHJVhBoCpYQaNIWEGKTVhBKlZYQWhbWEGu1VhB2NpYQYLfWEG15FhBP3BZQWZ1WUGWp1lB" + "vaxZQRDrWUHjDVpBBhNaQdppWkHraVpB/nxaQa6BWkG2jVpB25JaQT69WkFTwlpBiXpbQad/W0FD/ltBUf5bQeQqXEHLL1xB" + "VGFcQW5mXEGmz1xBv9RcQXA5XUGDPl1B7J1dQf2iXUEJ811BjfddQfL8XUEEAl5BglZeQZFbXkGYkV5Bj6peQZ6vXkFq+V5B" + "cP5eQWM2X0GkQ19BqkhfQemJX0Hjjl9B5MxfQeDRX0Ey1V9BxddfQT0NYEEzEmBBiUtgQYFQYEF3iGBBZY1gQY2PYEE1lGBB" + "bKBgQSalYEGvxGBBmclgQSTzYEHf92BB/TxhQdxBYUFSfWFBEn5hQWp/YUEWgmFBerhhQVO9YUGRMmJBTjdiQSM8YkHvQGJB" + "Ys1iQSTSYkHeBWNBpwpjQQNxY0HFdWNBAupjQcXuY0GTxmRBJ8tkQcTRZEGM1mRBJixlQTChZUE9oWVBzLBlQY+1ZUE462VB" + "XRpmQR0fZkHVfmZBj4NmQZXdZkFR4mZB1RZnQeAWZ0F1NmdBLDtnQX2JZ0E1jmdBo8lnQdTWZ0F922dBrx5oQVQjaEHHYWhB" + "b2ZoQc2gaEFspWhBfNxoQRrhaEGHFWlBHhppQUkiaUGJTGlBIFFpQS+CaUHHhmlBPbdpQcu7aUFRyWlBqc1pQabpaUEB7mlB" + "giFqQQsmakHYR2pBPkxqQclcakEFYWpBqY9qQS+UakHF2WpBJd5qQZ8Ga0EZC2tB44trQVaQa0H2kmtBWJdrQRkdbEErIWxB" + "NCRsQZMkbEGdKGxBp2ZsQRZrbEHuR21BWkxtQVZibUGRZm1B5iluQU8ubkES7m5BoABvQQUFb0G7B29BqQtvQTZlb0GgaW9B" + "wmxvQUPEb0GdyG9BIh1wQXchcEHBb3BBHnRwQUa8cEGewHBBk9JwQaHScEHP8XBB0wJxQSUHcUG5Q3FBFUhxQcB/cUEMhHFB" + "nLdxQem7cUEV7HFBV/BxQab9cUHiHXJBIyJyQeQqckHvKnJBsk1yQfNRckEsqnJBba5yQacGc0HmCnNB/UZzQY5Hc0GYZ3NB" + "wmtzQZiic0GopnNB+tFzQR3Wc0FfO3RBaD90QU1LdEFqT3RBHoV0QTHYdEFE3HRBtfd0Qcr7dEEjy3VBOM91Qdb+dUG3AnZB" + "/qh2QQ2tdkHaT3dBlnZ3QbWEd0HCiHdBA+53QRLyd0HVUnhB3lZ4QVqyeEFntnhB6At5QesPeUHjXnlB6WJ5QVKreUFPr3lB" + "WPF5QVv1eUFfGXpBMDF6QS81ekFCa3pBQW96QU6gekFGpHpBE9F6QQvVekFu/npBYgJ7QRspe0ELLXtBzVF7QbhVe0Eon3tB" + "NqB7QRSke0Hz7ntBzvJ7QQECfEEQAnxBmUJ8QW5GfEG0U3xBXFd8QaeQfEFUlHxBu5V8QUaZfEE+oHxBEqR8QZcDfUFHB31B" + "aA19QTURfUFVPn1BWT59QZ6OfUFkkn1BoqJ9QVmmfUF45X1B7+h9QbdhfkFtZX5Bg+1+QZ/wfkFpNH9BIjh/QTcHgEETCYBB" + "1FOAQdpxgEGyc4BBeKSAQVKmgEGT1IBBataAQc8BgUGlA4FB2CuBQa4tgUFsUoFBQFSBQZB1gUFod4FBZpWBQTqXgUHKrIFB" + "BrKBQdezgUGxxYFBs8uBQYTNgUHK4oFBmOSBQbT3gUGB+YFB4QqCQbEMgkG1HIJBfx6CQZAtgkFXL4JBxU2CQZBPgkFOboJB" + "EHCCQXuRgkE8k4JB6LmCQaa7gkFL6oJBCeyCQeUkg0GeJoNBZ1SDQe2Yg0HxmINBrp+DQVChg0G5KYRBuymEQb40hEEINoRB" + "kbyEQUO+hEH4I4VBVSWFQZYlhUGjJYVBilSFQThWhUFhgoVBDoSFQSKthUHNroVBgNSFQSnWhUE5+IVB4/mFQVwYhkEIGoZB" + "ETWGQbc2hkF7ToZBIlCGQdxkhkGCZoZBl3iGQT16hkEfioZBwIuGQd2ZhkGAm4ZBPqGGQaG1hkE+t4ZBJL6GQf7OhkGV0IZB" + "P3aHQa93h0GGfIdB/X2HQaKoh0EdqodBw8GHQR3Dh0HM64dBS+2HQRL4h0FEQYhBxUKIQSmjiEGrpIhBygiJQY4LiUERDYlB" + "ATKJQQMyiUGvdIlBMXaJQb6niUFBqYlBDbaJQRC2iUHp2IlBatqJQYoHikEHCYpBLTOKQao0ikGIW4pBBV2KQUuAikHKgYpB" + "RKGKQcCiikGBvopB/L+KQSzYikGq2YpBeu6KQfDvikGnAYtBHAOLQR8Si0GWE4tBVCCLQcohi0G9LItBMC6LQbtBi0EuQ4tB" + "S1SLQbdVi0FGZ4tBtGiLQS59i0GZfotBMYSLQaOYi0EOmotBV7yLQcO9i0F16otB2OuLQRlLjEFmTIxBpMqMQVSMjUHlo45B" + "j6+OQRzNjkEezY5BDEWPQQxFj0EVxI9BX8WPQW7Sj0G2049Bt5aQQRyYkEFd25BBfdyQQcMUkUHjFZFBb2GRQZRikUHQvJFB" + "9b2RQTghkkFcIpJB/YiSQSSKkkHE7pJB6O+SQTL9kkFBH5NBZyCTQVNNk0F2TpNBX3iTQYN5k0ECoJNBJ6GTQfvDk0EbxZNB" + "/uOTQSDlk0HZ/5NB+gCUQa4XlEHSGJRBtSuUQdYslEEgPJRBQD2UQSdJlEFDSZRBYkqUQY9TlEGtVJRBbFuUQY9clEFcYZRB" + "fWKUQSpplEFIapRB92qUQflqlEFLbpRBZG+UQcVzlEHedJRBLnyUQUZ9lEE8ipRBUIuUQY+glEGhoZRBOMGUQUfClEEax5RB" + "Z9eUQWfXlEFrBZVBaAaVQR6JlUFs25VBBkWaQc1FmkGtkJpBdJGaQbXWmkHW5ppBoOeaQewJm0GnLZtBdEibQTlJm0EIsJtB" + "0rCbQQHMm0EtGJxB9xicQdd7nEGgfJxBnoycQW2qnEE3q5xBHdacQeXWnEFW/pxBHv+cQbsinUGCI51BDUOdQdZDnUEOX51B" + "1l+dQZF2nUFXd51BuomdQYOKnUFfi51B55WdQZSWnUGllp1BVZedQcuYnUGSmZ1BiJydQSOdnUFGnZ1B3Z2dQQGknUHKpJ1B" + "/qSdQcKlnUG1q51BeaydQUOtnUEHrp1BW66dQRivnUFTsJ1BFrGdQS+ynUFQsp1B9rKdQRaznUHH0Z1BcNKdQWgbnkG0lZ9B" + "7bCfQe6wn0HsBaBBHwagQT0IoEE/CKBBP4agQVGGoEGobaFBZW+kQQGepEH90aRBbeGkQd3hpEEB/aRBKk2lQZhNpUHntqVB" + "UrelQYK8pUHVGaZBPRqmQU1HpkG8R6ZBbXGmQdpxpkGpl6ZBE5imQbCwpkEEsaZBh7KmQd+ypkGLs6ZB8LOmQa25pkEZuqZB" + "G72mQYS9pkG+zaZBJc6mQT7XpkGu16ZBseKmQRrjpkEm8KZBkPCmQTL5pkGb+aZBNgSnQaAEp0FuDqdB1w6nQZcTp0EDFKdB" + "jx6nQf0ep0E6H6dBqB+nQeMkp0FNJadBZiWnQdMlp0EeKKdBcyinQYgop0HaKKdBhMOnQfUEqUGCrqlBh9upQfDnqUFa7qlB" + "0xaqQaUkqkHNZapB0WWqQZV3qkFZ1KpBd9uqQT/lqkHPQ6tBvk2rQeC2q0FXuqtBWB2sQcQerEHPfaxBtoOsQUDarEEL4qxB" + "f/KsQeAgrUEYKq1BOTCtQTY0rUGMWa1Bn1mtQRZnrUE7cq1BJHetQah4rUERfK1BdJytQYycrUGXpa1BlK6tQXK2rUGJuK1B" + "TdStQcjWrUFd2K1B6eWtQd7mrUEz+a1B4v2tQWYErkEFBa5BchGuQQwUrkGwFq5B6xauQSkXrkGWG65B3xuuQfkbrkFcHK5B" +) + +#: Signed offsets of the 6 measured probe vertices from their centroid along the +#: basis z axis (mm). Peak-to-valley is the contract's flatness_mm = 0.007611. +_MEASURED_PROBE_OFFSETS_Z = ( + -0.0006562, + 0.0042672, + -0.0033438, + 0.0036863, + -0.0033205, + -0.0006329, +) + + +def _measured_nonprobe_distances() -> np.ndarray: + raw = base64.b64decode(_NONPROBE_DISTANCES_F32_B64) + return np.frombuffer(raw, dtype=" tuple[np.ndarray, np.ndarray]: + """Return (coords, member_indices) reproducing the measured radii exactly. + + The 6 probe members sit at the origin; each non-probe vertex sits on the +x + axis at its measured nearest-probe distance, so the minimum distance to a + member equals the measured value. + """ + distances = _measured_nonprobe_distances() + members = np.zeros((6, 3), dtype=np.float64) + others = np.stack( + [distances, np.zeros_like(distances), np.zeros_like(distances)], axis=1 + ) + coords = np.vstack([members, others]) + return coords, np.arange(6, dtype=np.int64) + + +# ------------------------------------------------------------- curves + + +def test_curve_endpoints() -> None: + assert smooth_weight(0.0) == 1.0 + assert smooth_weight(1.0) == 0.0 + assert linear_weight(0.0) == 1.0 + assert linear_weight(1.0) == 0.0 + assert sharp_weight(0.0) == 1.0 + assert sharp_weight(1.0) == 0.0 + assert smooth_weight(0.25) == pytest.approx(1.0 - (3 * 0.25**2 - 2 * 0.25**3)) + + +def test_curve_monotonic_decreasing() -> None: + samples = np.linspace(0.0, 1.0, 101) + smooth = np.array([smooth_weight(t) for t in samples]) + linear = np.array([linear_weight(t) for t in samples]) + sharp = np.array([sharp_weight(t) for t in samples]) + for curve in (smooth, linear, sharp): + assert np.all(np.diff(curve) <= 0.0) + assert curve.min() == pytest.approx(0.0) + assert curve.max() == pytest.approx(1.0) + + +def test_falloff_weight_thresholds_and_dispatch() -> None: + assert falloff_weight(0.0, "smooth") == 1.0 + assert falloff_weight(-5.0, "sharp") == 1.0 + assert falloff_weight(1.0, "constant") == 0.0 + assert falloff_weight(1.5, "smooth") == 0.0 + assert falloff_weight(0.4, "linear") == pytest.approx(0.6) + assert falloff_weight(0.4, "sharp") == pytest.approx(0.36) + assert falloff_weight(0.4, "constant") == 1.0 + with pytest.raises(ValueError): + falloff_weight(0.5, "bounce") + + +def test_falloff_modes_list_matches_the_contract() -> None: + assert FALLOFF_MODES == ("smooth", "linear", "sharp", "constant") + + +# -------------------------------------------------------------- basis + + +def _mixed_normals() -> np.ndarray: + """Six unit normals whose mean is tilted away from +z (mixed, not symmetric).""" + angle_a = np.radians(2.5533) + angle_b = np.radians(0.5) + tilted_a = np.array([np.sin(angle_a), 0.0, np.cos(angle_a)]) + tilted_b = np.array([-np.sin(angle_b), 0.0, np.cos(angle_b)]) + return np.array([tilted_a] * 3 + [tilted_b] * 3, dtype=np.float64) + + +def _tilted_normals(angle_deg: float) -> np.ndarray: + """Six unit normals with mean exactly +z and max deviation angle_deg.""" + angle = np.radians(angle_deg) + return np.array( + [[np.sin(angle), 0.0, np.cos(angle)]] * 3 + + [[-np.sin(angle), 0.0, np.cos(angle)]] * 3, + dtype=np.float64, + ) + + +def test_orthonormal_basis_rows_are_x_y_z_and_right_handed() -> None: + normal = np.array([0.2, -0.3, 0.9]) + normals = np.array([normal / np.linalg.norm(normal)] * 6) + origin, basis, report = orthonormal_basis( + normals, origin=[74.76961, 16.2155, 120.80202] + ) + x, y, z = basis + assert report["member_count"] == 6 + assert report["origin_given"] is True + assert origin == pytest.approx([74.76961, 16.2155, 120.80202]) + assert z == pytest.approx(normals[0]) + assert x == pytest.approx( + np.cross([0.0, 0.0, 1.0], normals[0]) + / np.linalg.norm(np.cross([0.0, 0.0, 1.0], normals[0])) + ) + assert y == pytest.approx(np.cross(z, x)) + assert np.allclose(np.cross(z, x), y, atol=1e-12) + assert orthonormality_error(basis) < 1e-12 + assert report["orthonormal"] is True + assert report["x_fallback"] is False + assert report["normal_angle_max_deg"] == pytest.approx(0.0, abs=1e-9) + + +def test_orthonormal_basis_reports_max_normal_angle() -> None: + normals = _mixed_normals() + _, basis, report = orthonormal_basis(normals, origin=[0.0, 0.0, 0.0]) + unit = normals / np.linalg.norm(normals, axis=1)[:, None] + expected = float( + np.degrees(np.arccos(np.clip(unit @ basis[2], -1.0, 1.0))).max() + ) + assert report["normal_angle_max_deg"] == pytest.approx(expected, abs=1e-9) + assert 1.5 < report["normal_angle_max_deg"] < 1.6 + assert orthonormality_error(basis) < 1e-12 + + +def test_orthonormal_basis_origin_is_optional() -> None: + origin, basis, report = orthonormal_basis(_mixed_normals()) + assert origin is None + assert report["origin_given"] is False + assert basis.shape == (3, 3) + + +def test_orthonormal_basis_degenerate_x_falls_back_to_plus_x() -> None: + origin, basis, report = orthonormal_basis( + np.array([[0.0, 0.0, 1.0]] * 4), origin=[0.0, 0.0, 0.0] + ) + assert report["x_fallback"] is True + assert basis[0] == pytest.approx([1.0, 0.0, 0.0]) + assert basis[1] == pytest.approx([0.0, 1.0, 0.0]) + assert basis[2] == pytest.approx([0.0, 0.0, 1.0]) + assert report["orthonormal"] is True + + +def test_orthonormal_basis_rejects_degenerate_input() -> None: + with pytest.raises(ValueError): + orthonormal_basis(np.zeros((0, 3))) + with pytest.raises(ValueError): + orthonormal_basis(np.zeros((2, 2))) + with pytest.raises(ValueError): + orthonormal_basis(np.array([[0.0, 0.0, 0.0]])) + with pytest.raises(ValueError): + # perfectly cancelling normals leave no surface normal + orthonormal_basis( + np.array([[1.0, 0.0, 0.0], [-1.0, 0.0, 0.0]]) + ) + + +def test_orthonormality_error_detects_a_bad_basis() -> None: + assert orthonormality_error(np.eye(3)) == 0.0 + assert orthonormality_error(np.diag([2.0, 1.0, 1.0])) == pytest.approx(3.0) + with pytest.raises(ValueError): + orthonormality_error(np.eye(2)) + + +# ----------------------------------------------------- falloff_weights + + +def test_falloff_weights_are_one_for_members_and_zero_at_radius() -> None: + coords = np.array( + [ + [0.0, 0.0, 0.0], # member + [0.5, 0.0, 0.0], # member + [0.25, 0.0, 0.0], # inside (d = 0.25 from the first member) + [1.0, 0.0, 0.0], # exactly radius from the 0.5 member -> d = 0.5 + [0.0, 0.9, 0.0], # outside + ] + ) + weights = falloff_weights(coords, [0, 1], 0.5, "smooth") + assert weights.dtype == np.float64 + assert weights.shape == (5,) + assert weights[0] == 1.0 + assert weights[1] == 1.0 + assert weights[2] == pytest.approx(smooth_weight(0.5)) + assert weights[3] == 0.0 + assert weights[4] == 0.0 + + +def test_falloff_weights_match_the_scalar_curve() -> None: + rng = np.random.default_rng(7) + coords = rng.uniform(-1.0, 1.0, size=(64, 3)) + members = np.array([0, 1, 2]) + for mode in FALLOFF_MODES: + weights = falloff_weights(coords, members, 0.75, mode) + for index in range(coords.shape[0]): + distance = float( + np.linalg.norm(coords[index] - coords[members], axis=1).min() + ) + assert weights[index] == pytest.approx( + falloff_weight(distance / 0.75, mode), abs=1e-15 + ) + + +def test_falloff_weights_are_symmetric_in_offset_direction() -> None: + coords = np.array( + [ + [0.0, 0.0, 0.0], + [0.3, 0.0, 0.0], + [-0.3, 0.0, 0.0], + [0.0, 0.3, 0.0], + [0.0, 0.0, 0.3], + [0.3 / np.sqrt(3)] * 3, + ] + ) + weights = falloff_weights(coords, [0], 0.5, "smooth") + for index in (2, 3, 4, 5): + assert weights[index] == pytest.approx(weights[1], abs=1e-15) + assert weights[1] == pytest.approx(smooth_weight(0.6)) + + +def test_falloff_weights_constant_mode() -> None: + coords = np.array([[0.0, 0.0, 0.0], [0.4, 0.0, 0.0], [0.6, 0.0, 0.0]]) + weights = falloff_weights(coords, [0], 0.5, "constant") + assert list(weights) == [1.0, 1.0, 0.0] + + +@pytest.mark.parametrize( + "kwargs", + [ + {"radius_mm": 0.0}, + {"radius_mm": -1.0}, + {"mode": "bounce"}, + ], +) +def test_falloff_weights_reject_bad_settings(kwargs: dict) -> None: + coords = np.array([[0.0, 0.0, 0.0], [0.1, 0.0, 0.0]]) + settings = {"radius_mm": 0.5} + settings.update(kwargs) + with pytest.raises(ValueError): + falloff_weights(coords, [0], **settings) + + +def test_falloff_weights_reject_bad_geometry() -> None: + with pytest.raises(ValueError): + falloff_weights(np.zeros((3, 2)), [0], 0.5) + with pytest.raises(ValueError): + falloff_weights(np.zeros((3, 3)), [], 0.5) + with pytest.raises(ValueError): + falloff_weights(np.zeros((3, 3)), [5], 0.5) + + +# -------------------------------------------------------- affected_bands + + +def test_affected_bands_omits_empty_bands() -> None: + weights = np.array([1.0, 1.0, 0.75, 0.4, 0.2, 0.07, 0.01, 0.0]) + assert affected_bands(weights) == { + "1.0": 2, + "0.5-1.0": 1, + "0.3-0.5": 1, + "0.1-0.3": 1, + "0.05-0.1": 1, + "0.0-0.05": 1, + } + assert affected_bands(np.array([0.0, 0.0, 1.0])) == {"1.0": 1} + + +# ------------------------------------------- measured Xynova regression + + +def test_measured_xynova_radius_half_mm_reaches_exactly_five_vertices() -> None: + coords, members = _measured_probe_cloud() + assert coords.shape == (2508, 3) + assert len(members) == 6 + + weights = falloff_weights(coords, members, 0.5, "smooth") + inside = weights[(weights > 0.0) & (weights < 1.0)] + + assert int((weights == 0.0).sum()) == 2497 + assert int((weights >= 1.0).sum()) == 6 + assert inside.size == 5, "radius 0.5 mm must touch exactly 5 non-probe vertices" + + distances = _measured_nonprobe_distances() + assert float(distances[0]) == pytest.approx(0.2853262745311897, abs=1e-6) + assert float(distances[1]) == pytest.approx(0.41612439347389385, abs=1e-6) + assert float(distances[4]) == pytest.approx(0.41676858076285744, abs=1e-6) + assert float(distances[5]) == pytest.approx(0.795993, abs=1e-6) + # The gap between the 5th and 6th neighbour is what makes the count 5, not 11. + assert int((distances < 0.5).sum()) == 5 + assert int((distances < 0.6).sum()) == 5 + assert int((distances < 0.79).sum()) == 5 + + +def test_measured_xynova_weight_bands_match_the_contract_report() -> None: + coords, members = _measured_probe_cloud() + weights = falloff_weights(coords, members, 0.5, "smooth") + inside = np.sort(weights[(weights > 0.0) & (weights < 1.0)]) + + assert affected_bands(weights) == {"1.0": 6, "0.3-0.5": 1, "0.05-0.1": 4} + assert inside[4] == pytest.approx(0.3947265, abs=1e-6) # d = 0.28533 + assert inside[:4] == pytest.approx( + [0.0739043, 0.0739052, 0.0749794, 0.0749802], abs=1e-6 + ) + # One vertex in 0.3-0.5, four in 0.05-0.1, none anywhere else. + assert int(((inside >= 0.3) & (inside < 0.5)).sum()) == 1 + assert int(((inside >= 0.05) & (inside < 0.1)).sum()) == 4 + + +def test_measured_xynova_percentile_utility() -> None: + distances = _measured_nonprobe_distances() + assert percentile(distances, 0.0) == pytest.approx(float(distances.min())) + assert percentile(distances, 50.0) == pytest.approx( + float(np.percentile(distances, 50)), rel=1e-6 + ) + assert percentile(distances, 100.0) == pytest.approx(float(distances.max())) + + +# ----------------------------------------------------------- statistics + + +def test_edge_lengths_mm() -> None: + coords = np.array( + [[0.0, 0.0, 0.0], [3.0, 0.0, 0.0], [3.0, 4.0, 0.0], [0.0, 0.0, 2.0]] + ) + edges = np.array([[0, 1], [1, 2], [0, 3]]) + assert edge_lengths_mm(coords, edges) == pytest.approx([3.0, 4.0, 2.0]) + assert edge_lengths_mm(coords, np.zeros((0, 2), dtype=np.int64)).size == 0 + + +def test_edge_percentiles_match_the_measured_contract_row() -> None: + # Contract: mesh edges min 0.0504, p50 0.6285, p90 0.991, max 1.816 mm. + edges = np.array([0.0504, 0.628501, 0.991, 1.816]) + assert percentile(edges, 0.0) == pytest.approx(0.0504) + assert percentile(edges, 100.0) == pytest.approx(1.816) + assert percentile(edges, 50.0) == pytest.approx(np.percentile(edges, 50)) + + +def test_flatness_mm_is_peak_to_valley_along_the_normal() -> None: + offsets = np.array(_MEASURED_PROBE_OFFSETS_Z) + coords = np.stack([np.zeros_like(offsets), np.zeros_like(offsets), offsets], axis=1) + assert flatness_mm(coords, [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]) == pytest.approx( + 0.007611, abs=1e-6 + ) + assert flatness_mm(coords, [0.0, 0.0, 0.0], [0.0, 0.0, 2.0]) == pytest.approx( + 0.007611, abs=1e-6 + ) # non-unit normals are normalised + with pytest.raises(ValueError): + flatness_mm(coords, [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]) + + +def test_percentile_edges() -> None: + assert percentile([3.0, 1.0, 2.0], 0.0) == 1.0 + assert percentile([3.0, 1.0, 2.0], 100.0) == 3.0 + assert percentile([3.0, 1.0, 2.0], 50.0) == 2.0 + with pytest.raises(ValueError): + percentile([], 50.0) + with pytest.raises(ValueError): + percentile([1.0], 101.0) diff --git a/build/textures/finger-xynova/r01/patch_texture_produce.png b/build/textures/finger-xynova/r01/patch_texture_produce.png index 5affb761d1aad4b797ec4898187b32726ec0b77b..7a65e49ef90209d67432e5a6b175436d342f060b 100644 GIT binary patch literal 238838 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�Uk$d;0Nx6 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 f7?26V=NJu8uB@|NPIst^Cb2yZv=qv@; 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