Auto-scale thresholds with resolution

ARCHITECTURE.md

@@ -14,6 +14,7 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
 - Coverage strictness: default 0.95 (fraction of the footprint that must be safe).
 - Depth smoothing: `depth_smoothing_base` scaled by resolution to reduce speckle before scoring.
 - Roof mask: depth-based, with large components (>20% of the map) discarded to avoid masking whole fields.
+- Resolution-aware thresholds: flatness (`std_thresh`) and gradient (`grad_thresh`) are auto-scaled with the actual depth resolution; the UI sliders act as base values.
 
 ## Per-Image Processing Pipeline
 1. **Load and crop** the selected image (RGB, 5% border removed).
@@ -28,9 +29,9 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
    - Roof via depth MAD threshold + grad gate; components smaller than `area_thresh` and not exceeding `max_area_frac` (20%) are kept; also dilated to the footprint for blocking.
 6. **Flat region search (`pick_flat_patch`)**:
    - Normalize depth to [0,1], compute `std_map` via box mean/mean_sq, and `grad_norm` via `np.gradient` normalized at the 95th percentile.
-   - Landing mask starts from `grad_norm < grad_thresh`, excludes water/road if present, and keeps the lowest-variance patch as a fallback box.
+   - Landing mask starts from `grad_norm < grad_thresh_eff` (resolution-adjusted), excludes water/road if present, and keeps the lowest-variance patch as a fallback box.
 7. **Safe mask construction**:
-   - Base safe mask: `(std_map < std_thresh) & (grad_norm < grad_thresh) & landing_mask & texture_mask`.
+   - Base safe mask: `(std_map < std_thresh_eff) & (grad_norm < grad_thresh_eff) & landing_mask & texture_mask`.
    - Apply segmentation blocks (expanded masks) to remove water/road/roof regions.
    - Clearance: dilate hazards by `clearance_factor * patch_px` (default 0, so off unless raised).
    - Coverage: box filter with `patch_px` window; keep pixels meeting `coverage_strictness` (default 0.95).

app/safety.py

@@ -60,6 +60,8 @@ class AnalysisSummary:
     roof_mask_enabled: bool
     used_valid_center: bool
     warnings: list[str]
+    std_thresh_applied: float
+    grad_thresh_applied: float
 
 
 @dataclass
@@ -213,11 +215,15 @@ class SafetyAnalyzer:
                 road_mask_resized = np.array(road_mask_resized) > 0
                 road_mask_block = expand_mask_for_footprint(road_mask_resized)
 
+        # Autoscale sensitivity with resolution: stricter when resolution is low
+        std_thresh_eff = max(1e-6, float(request.std_thresh)) * (res_scale ** -0.5)
+        grad_thresh_eff = max(1e-6, float(request.grad_thresh)) * (res_scale ** -0.3)
+
         box, std_map, grad_norm, grad_mask, landing_mask = pick_flat_patch(
             depth,
             patch=patch_px,
-            std_thresh=request.std_thresh,
-            grad_thresh=request.grad_thresh,
+            std_thresh=std_thresh_eff,
+            grad_thresh=grad_thresh_eff,
             water_mask=water_mask_block if water_mask_block is not None else water_mask_resized,
         )
         if request.use_roof_mask:
@@ -251,7 +257,7 @@ class SafetyAnalyzer:
             interior_mask = np.ones_like(landing_mask, dtype=bool)
         landing_mask = landing_mask & interior_mask
         texture_mask = texture_norm <= max(0.0, min(1.0, request.texture_threshold))
-        safe_mask = (std_map < request.std_thresh) & (grad_norm < request.grad_thresh) & landing_mask & texture_mask
+        safe_mask = (std_map < std_thresh_eff) & (grad_norm < grad_thresh_eff) & landing_mask & texture_mask
 
         try:
             clearance_px = max(1, int(round(request.clearance_factor * patch_px)))
@@ -289,8 +295,8 @@ class SafetyAnalyzer:
                     keep |= labels == i
             safe_mask = keep
 
-        risk_std = np.clip((std_map - request.std_thresh) / (request.std_thresh + 1e-6), 0.0, 1.0)
-        risk_grad = np.clip((grad_norm - request.grad_thresh) / (request.grad_thresh + 1e-6), 0.0, 1.0)
+        risk_std = np.clip((std_map - std_thresh_eff) / (std_thresh_eff + 1e-6), 0.0, 1.0)
+        risk_grad = np.clip((grad_norm - grad_thresh_eff) / (grad_thresh_eff + 1e-6), 0.0, 1.0)
         risk_map = np.maximum(risk_std, risk_grad) * (~safe_mask)
 
         safe_fit = safe_mask.astype(np.float32)
@@ -443,6 +449,8 @@ class SafetyAnalyzer:
             roof_mask_enabled=request.use_roof_mask,
             used_valid_center=used_valid_center,
             warnings=warnings,
+            std_thresh_applied=std_thresh_eff,
+            grad_thresh_applied=grad_thresh_eff,
         )
         return AnalysisResult(images=layers, summary=summary)
 

app/ui.py

@@ -90,6 +90,7 @@ def _format_metrics(summary: AnalysisSummary | None) -> str:
         f"**Hazard coverage:** {summary.hazard_pct:.1f}%",
         f"**Landing center (px):** {summary.landing_center_image[0]}, {summary.landing_center_image[1]}",
         f"**Footprint size:** {summary.footprint_m:.1f} m ≈ {summary.footprint_image_px}px",
+        f"**Effective thresholds:** std ≤ {summary.std_thresh_applied:.4f}, grad ≤ {summary.grad_thresh_applied:.3f}",
     ]
     if not summary.used_valid_center:
         lines.append("Warning: No fully safe footprint; showing lowest-variance patch.")