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

sensors/finger-xynova/r01/design.yaml

@@ -87,6 +87,82 @@ optics:
       ior: 1.43
       ior_source: assumed_silicone_literature
 
+# Probe sensitivity bench (`orisys-design deform|render|track|sensitivity|optimise`).
+# Deforms the vertices of `group` through known x/y/z displacements expressed in a
+# local probe-average basis (normal force along z, shear along x/y), renders what
+# `camera` sees, and measures DIS optical flow against the zero-displacement frame.
+#
+# Contract: docs/probe-pipeline.md. The `.blend` is never written by the pipeline.
+probe:
+  mesh: sensing_surface
+  camera: cam_sensor
+  group: probe
+  uv_map: compute
+  texture: patch_texture_compute.png
+  # Proportional falloff radius for the outer rubber. Note this mesh has a median
+  # edge of 0.63 mm, so 0.5 mm reaches only the probe's immediate neighbours; the
+  # deform report prints how many vertices actually move rather than hiding it.
+  radius_mm: 0.5
+  falloff: smooth
+  step_mm: 0.01
+  max_mm: 0.10
+  axes: [x, y, z]
+  # Frames are rendered at the revision's real camera resolution. Keep this in step with
+  # the camera in source/geometry.blend: the pipeline overrides the scene resolution from
+  # here, so a blend edited to a different size is silently ignored otherwise.
+  #
+  # Single scale on purpose. The ROI radius is radius_mm x the probe-local px/mm, so at
+  # 125x125 it would be 1.66 px against an 8 px DIS window: the estimator measures its own
+  # regulariser, not the displacement. See docs/probe-findings.md section 2.
+  resolution: [250, 250]
+  process_resolution: [250, 250]
+  # Mirrors the SDK sensor tracker keys (orisys-sdk config/finger.json), EXCEPT
+  # dis_mode. The estimator window is 8 * 2**dis_mode input px (16 at dis_mode=1, 8 at 0)
+  # and the moving region is ~6.6 px across at 250x250, so the shipped dis_mode=1 gives
+  # window/moving = 2.42: DIS's smoothness pulls the estimate toward zero and the measured
+  # response drops ~3x (1.42 -> 4.30 px/mm at the matched cell). dis_mode=0 gives 1.21,
+  # the same ratio as 500x500 with dis_mode=1, which recovers to ~73%.
+  # See docs/probe-findings.md section 2.
+  # If the deployed tracker is fixed at dis_mode=1, run the bench at 500x500 instead.
+  tracker:
+    algorithm: dis
+    dis_preset: medium
+    dis_mode: 0
+  # Standard (not AgX) and denoise off: a filmic view transform silently distorts
+  # the marker values the tracker is supposed to measure.
+  render:
+    engine: CYCLES
+    samples: 16
+    denoise: false
+    view_transform: Standard
+    interpolate: Closest
+    seed: 0
+  # Noise calibration and the injected noise model.
+  #
+  # The estimator's `floor_px` is measured as reference vs a re-render at seed+1, which
+  # is Cycles antialiasing jitter, NOT sensor noise: on this data it differs by ~5 grey
+  # levels RMS on half the pixels and scales with edge contrast. Ranking patterns by
+  # gain/that-floor is unsound - the ordering reverses under additive noise, and it
+  # understates the real idle floor measured from the footage below, coarse patterns
+  # most. So the render-seed floor is kept only as a reproducibility diagnostic and the
+  # score is anchored to the injected model plus this measured calibration.
+  noise:
+    # Real idle (no-contact) footage, relative to the repo root. Measured: floor
+    # ~0.23 px at 1280x720 (short baseline == long baseline, so it is white noise and
+    # the clip is genuinely idle), dominant marker period ~25 px, i.e. ~0.0093 floor
+    # per period. That is 2-6x the simulated render-seed floor per cell.
+    idle_footage: ../data/dd02-0703/190.mp4
+    roi_fraction: 0.18
+    max_frames: 120
+    # Additive white Gaussian in grey levels. Defaults are deliberately small: each
+    # sigma costs a full DIS pass, and the process scale is a resample of the render
+    # one, so only the render scale is evaluated unless asked.
+    sigmas: [4.0, 16.0]
+    draws: 1
+    seed: 0
+    models: [render_seed, injected]
+    scales: [render]
+
 collections:
   frames: FRAMES
   export_compute: EXPORT_COMPUTE

sensors/finger/r01/profiles/compute.yaml

@@ -16,6 +16,36 @@ artifacts:
 runtime_owned_by_sdk:
   - unroll_map_uv_s0.4.npz
 
+# Parameters of the unroll/valid-mask domain. Recorded here because the mask decides which
+# part of the sensing mesh the application treats as *sensing* (everything else renders
+# grey), and because regenerating it wrongly still produces a plausible-looking map:
+#   * source_width/height are NOT recorded — they are derived from the export's own
+#     camera_intrinsics.npz (native size x source_scale). Inheriting another camera's
+#     source size produced 0.8 % island coverage instead of 40.8 %.
+#   * source_K must be scaled by source_scale (orisys.unroll.geometry.scale_camera_geometry).
+#     Passing the native K produced 3.5 % instead of 40.8 %.
+# Rebuild with tools/build_uv_map.py --profile <this file>; it writes into output_dir first
+# and is promoted to the SDK asset dir only after tools/scene_assets/compare_uv_map.py agrees.
+uv_map:
+  out_width: 280          # = camera.resolution_stitch[0]; the field domain the app sees
+  out_height: 300         # = camera.resolution_stitch[1]
+  flip_v: true
+  # source_scale: the live frame is resized by this before undistort/remap, so it sets both the
+  # per-frame pixel work and the resolution the tracker/flow measures at. The floor that avoids
+  # upsampling the output grid is derived, not guessed:
+  #     s >= max(out_width / native_width, out_height / native_height)
+  #   * 1280x720 camera -> max(280/1280, 300/720) = 0.417  (source 533x300)
+  #   * 1920x1080 camera -> max(280/1920, 300/1080) = 0.278  (source 533x300 — the same grid,
+  #     because the rule follows the *output* requirement, not the camera)
+  # 0.4 is pinned because it is the value the running system and the existing recordings were
+  # measured at; at a 1280x720 camera it yields a 512x288 source, i.e. 4 % coarser than the
+  # 300-row output (mild upsampling). Changing it changes the flow magnitudes the app's
+  # thresholds were tuned against AND the map's field_domain_id, so it must move together with
+  # sensor.json's camera.source_scale and a recompiled scene package.
+  source_scale: 0.4
+  edge_band: 0.12
+  edge_expand: 1.0        # <= 1.0 means "resolve from the measured UV distortion"
+
 validation:
   # orisys-app validate_scene.py --legacy-dir <output_dir> --map <sdk unroll map>
   require_sensing_surface_only: true