Keep fallback landing center inside safe areas

ARCHITECTURE.md

@@ -38,6 +38,7 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
    - Drop small components (< footprint area).
 8. **Center selection**:
    - Prefer centers where full-footprint coverage exists; choose the largest component and rank by distance transform minus flatness penalty (`openness_weight`).
+   - If no full coverage but safe pixels exist, pick the safest point inside the safe mask (distance vs. flatness).
    - Fallbacks: landing mask with segmentation removed; if empty, use the flattest patch center.
    - Convert depth center to image space; footprint box is scaled to image pixels and clamped to a minimum of 3 px.
 9. **Visualization layers**:

app/safety.py

@@ -340,28 +340,43 @@ class SafetyAnalyzer:
                 idx = int(np.argmin(std_cand))
             cy, cx = cand[0][idx], cand[1][idx]
         else:
-            fallback_mask = landing_mask.copy()
-            if not fallback_mask.any():
-                fallback_mask = np.ones_like(landing_mask, dtype=bool)
-                if seg_block_mask is not None:
-                    fallback_mask &= (~seg_block_mask)
-                fallback_mask &= interior_mask
-            if fallback_mask.any():
-                cand = np.where(fallback_mask)
+            # Fall back to safest pixel inside any safe region (even if full coverage fails)
+            if safe_mask.any():
+                cand = np.where(safe_mask)
+                dist_cand = distance[cand]
                 std_cand = std_map[cand]
-                idx = int(np.argmin(std_cand))
+                if dist_cand.size:
+                    dist_norm = dist_cand / (dist_cand.max() + 1e-6)
+                    std_norm = (std_cand - std_cand.min()) / (np.ptp(std_cand) + 1e-6)
+                    weight = max(0.0, min(1.0, request.openness_weight))
+                    score = dist_norm - weight * std_norm
+                    idx = int(np.argmax(score))
+                else:
+                    idx = int(np.argmin(std_cand))
                 cy, cx = cand[0][idx], cand[1][idx]
             else:
-                y0, x0, y1, x1 = box[1], box[0], box[3], box[2]
-                cy, cx = (y0 + y1) // 2, (x0 + x1) // 2
-                if half_span > 0 and depth.shape[0] > 2 * half_span:
-                    cy = min(max(int(cy), half_span), depth.shape[0] - half_span - 1)
-                else:
-                    cy = min(max(int(cy), 0), depth.shape[0] - 1)
-                if half_span > 0 and depth.shape[1] > 2 * half_span:
-                    cx = min(max(int(cx), half_span), depth.shape[1] - half_span - 1)
+                fallback_mask = landing_mask.copy()
+                if not fallback_mask.any():
+                    fallback_mask = np.ones_like(landing_mask, dtype=bool)
+                    if seg_block_mask is not None:
+                        fallback_mask &= (~seg_block_mask)
+                    fallback_mask &= interior_mask
+                if fallback_mask.any():
+                    cand = np.where(fallback_mask)
+                    std_cand = std_map[cand]
+                    idx = int(np.argmin(std_cand))
+                    cy, cx = cand[0][idx], cand[1][idx]
                 else:
-                    cx = min(max(int(cx), 0), depth.shape[1] - 1)
+                    y0, x0, y1, x1 = box[1], box[0], box[3], box[2]
+                    cy, cx = (y0 + y1) // 2, (x0 + x1) // 2
+                    if half_span > 0 and depth.shape[0] > 2 * half_span:
+                        cy = min(max(int(cy), half_span), depth.shape[0] - half_span - 1)
+                    else:
+                        cy = min(max(int(cy), 0), depth.shape[0] - 1)
+                    if half_span > 0 and depth.shape[1] > 2 * half_span:
+                        cx = min(max(int(cx), half_span), depth.shape[1] - half_span - 1)
+                    else:
+                        cx = min(max(int(cx), 0), depth.shape[1] - 1)
 
         scale_x = image.width / depth.shape[1]
         scale_y = image.height / depth.shape[0]