Switch rooftop masking to SAM3 and refresh demos

ARCHITECTURE.md

@@ -5,7 +5,7 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
 ## Data and Models
 - **Inputs**: Images under `data/Image/` (VISLOC and any custom folders) via `list_all_data_inputs`, with a 5% border crop (`crop_nonblack`) to drop black padding. Supported extensions: jpg/jpeg/png (any case).
 - **Depth model**: Depth Anything 3, cached per model id (`DepthEngine`). Inference caps the long side to `process_res_cap` (default 1024) using `upper_bound_resize` before predicting.
-- **Segmentation model**: SAM3 (`facebook/sam3`) for promptable water/road/tree masking. The segmenter is cached per model id but masks are recomputed every run (no output cache). Default `segmentation_max_side` is 384 and is clamped to the depth resolution (min 128).
+- **Segmentation model**: SAM3 (`facebook/sam3`) for promptable water/road/tree/roof masking. The segmenter is cached per model id but masks are recomputed every run (no output cache). Default `segmentation_max_side` is 512 and is clamped to the depth resolution (min 128).
 
 ## Constants and Defaults
 - Altitude/FOV defaults: 450 m, 90° (footprint default 10 m).
@@ -14,7 +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).
 - Texture threshold: default 0.3 (suppresses highly textured regions).
 - Depth smoothing is supported but set to 0.0 in the UI (effectively off).
-- Roof mask: depth-based, with large components (>20% of the map) discarded to avoid masking whole fields.
+- Roof mask: SAM3 promptable segmentation (default prompt: `roof`), resized to depth scale and expanded to footprint size; no depth-based roof heuristics remain.
 
 ## Per-Image Processing Pipeline
 1. **Load and crop** the selected image (RGB, 5% border removed).
@@ -25,8 +25,7 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
    - Visualization window `vis_patch` is an odd size capped to 1/8 of the smallest depth dimension for sharper std previews.
 4. **Texture mask**: Sobel magnitude on the RGB (blurred by `patch_px/40`), normalized; pixels above `texture_threshold` are suppressed.
 5. **Segmentation masks (optional)**:
-   - Water/Road/Tree via SAM3 at `segmentation_max_side`, with text prompts. Instance masks are unioned per class, resized to depth scale, and dilated to footprint size for blocking.
-   - 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.
+   - Water/Road/Tree/Roof via SAM3 at `segmentation_max_side`, with text prompts. Instance masks are unioned per class, resized to depth scale, and dilated to footprint size 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_eff`, excludes water if present, and keeps the lowest-variance patch as a fallback box.
@@ -72,9 +71,10 @@ This document describes the flow in the current Gradio app (`app/ui.py`), from i
 
 ## Error Handling
 - Bad/missing inputs raise Gradio errors.
-- Segmentation failures warn and proceed without that mask; roof/water/road warnings clarify when masks are disabled or not detected.
+- Segmentation failures warn and proceed without that mask; water/road/tree/roof warnings clarify when masks are disabled or not detected.
 - Coverage/boxFilter fallbacks keep processing even if OpenCV operations fail.
 
 ## Outputs
 - Dict of PIL Images keyed by: RGB, Depth, Flatness map (std), Depth gradient, Gradient mask, Water mask, Road mask, Tree mask, Roof mask, Safety heatmap overlay, Hazard overlay, Water/Road/Tree hazard overlays, Flatness heatmap overlay, Safety score (grayscale), Landing spot overlay.
+- Run summaries surface model id, process resolution, runtime, footprint size (depth + image scale), landing center, safe/hazard coverage, effective thresholds, per-mask coverage (water/road/tree/roof), and warnings for disabled/absent masks or missing safe regions; the UI cards render these fields directly.
 - `compose_view` uses these to build the preview. 

README.md

@@ -10,7 +10,7 @@ Analyze aerial RGB imagery to detect safe drone landing sites. Combines monocula
 
 ## What’s inside
 - **Main app (`landing_app.py`)** — runs full inference with adjustable thresholds, overlays, and camera assumptions; requires >8GB VRAM (assuming default 1024 px processing resolution); runtime is ~1000ms per image.
-- **Curated gallery (`demo/curated_app.py`)** — precomputed PNG/JPG/JSON artifacts for fast, zero-GPU browsing.
+- **Curated gallery (`demo/demo_app.py`)** — precomputed PNG/JPG/JSON artifacts for fast, zero-GPU browsing.
 
 ## Prereqs
 - Python 3.10+ and a CUDA GPU for the main app (CPU works but is slow).

app/config.py

@@ -10,12 +10,13 @@ DEFAULT_ALTITUDE_M = 450.0
 ASSUMED_FOV_DEG = 90.0
 DEFAULT_MODEL_ID = "depth-anything/DA3MONO-LARGE"
 SEGMENTATION_MODEL_ID = "facebook/sam3"
-SEGMENTATION_MAX_SIDE = 384
+SEGMENTATION_MAX_SIDE = 512
 SEGMENTATION_SCORE_THRESH = 0.25
 SEGMENTATION_MASK_THRESH = 0.25
 WATER_PROMPT = "water"
 ROAD_PROMPT = "motorway"
 TREE_PROMPT = "trees"
+ROOF_PROMPT = "rooftop"
 
 
 @dataclass(frozen=True)
@@ -25,7 +26,7 @@ class AnalyzerSettings:
     footprint_m: float = 10.0
     std_thresh: float = 0.005
     grad_thresh: float = 0.1
-    clearance_factor: float = 1.0
+    clearance_factor: float = 1.5
     process_res_cap: int = 1024
     depth_smoothing_base: float = 0.0
     segmentation_max_side: int = SEGMENTATION_MAX_SIDE
@@ -35,9 +36,10 @@ class AnalyzerSettings:
     water_prompt: str = WATER_PROMPT
     road_prompt: str = ROAD_PROMPT
     tree_prompt: str = TREE_PROMPT
+    roof_prompt: str = ROOF_PROMPT
     coverage_strictness: float = 0.95
-    openness_weight: float = 0.3
-    texture_threshold: float = 0.3
+    openness_weight: float = 0.5
+    texture_threshold: float = 0.5
     altitude_m: float = DEFAULT_ALTITUDE_M
     fov_deg: float = ASSUMED_FOV_DEG
     model_id: str = DEFAULT_MODEL_ID
@@ -60,6 +62,7 @@ __all__ = [
     "WATER_PROMPT",
     "ROAD_PROMPT",
     "TREE_PROMPT",
+    "ROOF_PROMPT",
     "DEFAULT_ANALYZER_SETTINGS",
     "AnalyzerSettings",
 ]

app/depth_pipeline.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-import functools
-import math
 from pathlib import Path
-from typing import Tuple
 
 import cv2
 import numpy as np
@@ -29,25 +26,6 @@ def crop_nonblack(img: Image.Image, frac: float = 0.05) -> Image.Image:
     return img.crop((dx, dy, w - dx, h - dy))
 
 
-def compute_roof_mask_depth(depth: np.ndarray, aggressiveness: float = 1.3, morph_kernel: int = 5) -> np.ndarray:
-    d = depth.astype(np.float32)
-    med = np.median(d)
-    mad = np.median(np.abs(d - med)) + 1e-6
-    threshold = med - aggressiveness * mad
-    mask = d < threshold
-    mask = mask.astype(np.uint8)
-    k = max(1, int(morph_kernel))
-    if k % 2 == 0:
-        k += 1
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
-    try:
-        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
-        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-    except Exception:
-        pass
-    return mask > 0
-
-
 def remove_global_plane(depth: np.ndarray, method: str = "least_squares") -> np.ndarray:
     if depth.ndim != 2:
         return depth
@@ -182,7 +160,6 @@ def smooth_depth(depth: np.ndarray, sigma: float) -> np.ndarray:
 
 __all__ = [
     "DepthEngine",
-    "compute_roof_mask_depth",
     "crop_nonblack",
     "pick_flat_patch",
     "remove_global_plane",

app/safety.py

@@ -11,7 +11,7 @@ import torch
 from PIL import Image
 
 from .config import DEFAULT_MODEL_ID, IMAGE_EXTS
-from .depth_pipeline import DepthEngine, compute_roof_mask_depth, crop_nonblack, pick_flat_patch, smooth_depth
+from .depth_pipeline import DepthEngine, crop_nonblack, pick_flat_patch, smooth_depth
 from .segmentation import SegmenterRequest, SegmenterService, get_global_segmenter
 from .visualization import build_result_layers
 
@@ -27,6 +27,7 @@ class AnalysisRequest:
     use_tree_mask: bool
     water_prompt: str
     road_prompt: str
+    roof_prompt: str
     tree_prompt: str
     altitude_m: float
     fov_deg: float
@@ -59,9 +60,11 @@ class AnalysisSummary:
     water_mask_pct: Optional[float]
     road_mask_pct: Optional[float]
     roof_mask_pct: Optional[float]
+    tree_mask_pct: Optional[float]
     water_mask_enabled: bool
     road_mask_enabled: bool
     roof_mask_enabled: bool
+    tree_mask_enabled: bool
     used_valid_center: bool
     warnings: list[str]
     std_thresh_applied: float
@@ -84,64 +87,6 @@ class SafetyAnalyzer:
         except Exception as exc:
             print(f"[WARN] Could not preload depth model {DEFAULT_MODEL_ID}: {exc}")
 
-    @staticmethod
-    def build_depth_roof_mask(
-        depth: np.ndarray,
-        grad_norm: np.ndarray,
-        footprint_px: int,
-        aggressiveness: float = 1.2,
-        grad_threshold: float = 0.35,
-        max_area_frac: float = 0.2,
-    ) -> np.ndarray | None:
-        depth_mask = compute_roof_mask_depth(
-            depth,
-            aggressiveness=aggressiveness,
-            morph_kernel=max(3, int(round(max(3, footprint_px * 0.15))) | 1),
-        )
-        flat_mask = grad_norm < grad_threshold
-        roof_mask = depth_mask & flat_mask
-        roof_mask = roof_mask.astype(np.uint8)
-        kernel = cv2.getStructuringElement(
-            cv2.MORPH_ELLIPSE,
-            (
-                max(3, int(round(footprint_px * 0.1)) | 1),
-                max(3, int(round(footprint_px * 0.1)) | 1),
-            ),
-        )
-        roof_mask = cv2.morphologyEx(roof_mask, cv2.MORPH_CLOSE, kernel)
-        roof_mask = cv2.morphologyEx(roof_mask, cv2.MORPH_OPEN, kernel)
-        area_thresh = max(footprint_px * footprint_px // 4, 64)
-        num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(roof_mask, connectivity=8)
-        refined = np.zeros_like(roof_mask, dtype=bool)
-        depth_norm = (depth - depth.min()) / (np.ptp(depth) + 1e-6)
-        global_mad = np.median(np.abs(depth_norm - np.median(depth_norm))) + 1e-6
-        ring_kernel = cv2.getStructuringElement(
-            cv2.MORPH_ELLIPSE,
-            (
-                max(3, int(round(footprint_px * 0.6)) | 1),
-                max(3, int(round(footprint_px * 0.6)) | 1),
-            ),
-        )
-        max_area = max_area_frac * depth_mask.size if max_area_frac > 0 else None
-        for i in range(1, num_labels):
-            area = stats[i, cv2.CC_STAT_AREA]
-            if area < area_thresh:
-                continue
-            if max_area is not None and area > max_area:
-                # Skip overly large blobs (e.g., entire fields) to avoid over-masking
-                continue
-            comp_mask = labels == i
-            ring = cv2.dilate(comp_mask.astype(np.uint8), ring_kernel, iterations=1).astype(bool) & (~comp_mask)
-            if not ring.any():
-                continue
-            comp_mean = float(depth_norm[comp_mask].mean())
-            ring_mean = float(depth_norm[ring].mean())
-            prominence = ring_mean - comp_mean
-            min_prominence = max(0.02, 0.5 * global_mad)
-            if prominence < min_prominence or ring_mean <= comp_mean:
-                continue
-            refined |= comp_mask
-        return refined if refined.any() else None
 
     def analyze_image(self, image: Image.Image, request: AnalysisRequest) -> AnalysisResult:
         t0 = time.perf_counter()
@@ -238,10 +183,12 @@ class SafetyAnalyzer:
                     source_path=request.source_path,
                     want_water=request.use_water_mask,
                     want_road=request.use_road_mask,
+                    want_roof=request.use_roof_mask,
                     want_tree=request.use_tree_mask,
                     max_side=int(max(128, min(request.segmentation_max_side, process_res))),
                     water_prompt=request.water_prompt,
                     road_prompt=request.road_prompt,
+                    roof_prompt=request.roof_prompt,
                     tree_prompt=request.tree_prompt,
                     score_threshold=float(request.segmentation_score_thresh),
                     mask_threshold=float(request.segmentation_mask_thresh),
@@ -260,6 +207,12 @@ class SafetyAnalyzer:
                 )
                 road_mask_resized = np.array(road_mask_resized) > 0
                 road_mask_block = expand_mask_for_footprint(road_mask_resized)
+            if request.use_roof_mask and masks.get("roof") is not None:
+                roof_mask_resized = Image.fromarray(masks["roof"].astype(np.uint8) * 255).resize(
+                    (depth.shape[1], depth.shape[0]), resample=Image.NEAREST
+                )
+                roof_mask_resized = np.array(roof_mask_resized) > 0
+                roof_mask_block = expand_mask_for_footprint(roof_mask_resized)
             if request.use_tree_mask and masks.get("tree") is not None:
                 tree_mask_resized = Image.fromarray(masks["tree"].astype(np.uint8) * 255).resize(
                     (depth.shape[1], depth.shape[0]), resample=Image.NEAREST
@@ -280,14 +233,6 @@ class SafetyAnalyzer:
             water_mask=water_mask_block if water_mask_block is not None else water_mask_resized,
         )
         t_pick = time.perf_counter()
-        if request.use_roof_mask:
-            roof_mask_resized = self.build_depth_roof_mask(
-                depth=depth,
-                grad_norm=grad_norm,
-                footprint_px=patch_px,
-                max_area_frac=0.2,
-            )
-            roof_mask_block = expand_mask_for_footprint(roof_mask_resized)
         seg_block_mask = None
         for mask in (water_mask_block, road_mask_block, tree_mask_block, roof_mask_block):
             if mask is None:
@@ -545,6 +490,10 @@ class SafetyAnalyzer:
             warnings.append("Road mask disabled.")
         elif road_mask_resized is None:
             warnings.append("Road segmentation unavailable; continuing without mask.")
+        if not request.use_tree_mask:
+            warnings.append("Tree mask disabled.")
+        elif tree_mask_resized is None:
+            warnings.append("Tree segmentation unavailable; continuing without mask.")
         if not request.use_roof_mask:
             warnings.append("Roof mask disabled.")
         elif roof_mask_resized is None:
@@ -578,9 +527,11 @@ class SafetyAnalyzer:
             water_mask_pct=mask_pct(water_mask_resized) if request.use_water_mask else None,
             road_mask_pct=mask_pct(road_mask_resized) if request.use_road_mask else None,
             roof_mask_pct=mask_pct(roof_mask_resized) if request.use_roof_mask else None,
+            tree_mask_pct=mask_pct(tree_mask_resized) if request.use_tree_mask else None,
             water_mask_enabled=request.use_water_mask,
             road_mask_enabled=request.use_road_mask,
             roof_mask_enabled=request.use_roof_mask,
+            tree_mask_enabled=request.use_tree_mask,
             used_valid_center=used_valid_center,
             warnings=warnings,
             std_thresh_applied=std_thresh_eff,

app/segmentation.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Dict, Optional
 import re
 
 import numpy as np
@@ -9,6 +10,7 @@ from PIL import Image
 
 from .config import (
     ROAD_PROMPT,
+    ROOF_PROMPT,
     SEGMENTATION_MASK_THRESH,
     SEGMENTATION_MAX_SIDE,
     SEGMENTATION_MODEL_ID,
@@ -120,10 +122,12 @@ class SegmenterRequest:
     source_path: Optional[str] = None
     want_water: bool = False
     want_road: bool = False
+    want_roof: bool = False
     want_tree: bool = False
     max_side: int = SEGMENTATION_MAX_SIDE
     water_prompt: str = WATER_PROMPT
     road_prompt: str = ROAD_PROMPT
+    roof_prompt: str = ROOF_PROMPT
     tree_prompt: str = TREE_PROMPT
     score_threshold: float = SEGMENTATION_SCORE_THRESH
     mask_threshold: float = SEGMENTATION_MASK_THRESH
@@ -147,7 +151,7 @@ class SegmenterService:
         return self._segmenters[model_id]
 
     def get_masks(self, request: SegmenterRequest, model_id: str | None = None) -> dict[str, np.ndarray]:
-        if not (request.want_water or request.want_road or request.want_tree):
+        if not (request.want_water or request.want_road or request.want_tree or request.want_roof):
             return {}
         segmenter = self._get_segmenter(model_id or self.model_id)
         prompts: dict[str, str] = {}
@@ -155,6 +159,8 @@ class SegmenterService:
             prompts["water"] = request.water_prompt
         if request.want_road and request.road_prompt:
             prompts["road"] = request.road_prompt
+        if request.want_roof and request.roof_prompt:
+            prompts["roof"] = request.roof_prompt
         if request.want_tree and request.tree_prompt:
             prompts["tree"] = request.tree_prompt
         try:
@@ -173,6 +179,8 @@ class SegmenterService:
             result["water"] = masks["water"]
         if request.want_road and masks.get("road") is not None:
             result["road"] = masks["road"]
+        if request.want_roof and masks.get("roof") is not None:
+            result["roof"] = masks["roof"]
         if request.want_tree and masks.get("tree") is not None:
             result["tree"] = masks["tree"]
         return result

app/ui.py

@@ -23,6 +23,7 @@ def _make_request(
     use_tree_mask,
     water_prompt,
     road_prompt,
+    roof_prompt,
     tree_prompt,
     altitude_m,
     fov_deg,
@@ -47,6 +48,7 @@ def _make_request(
         use_tree_mask=use_tree_mask,
         water_prompt=water_prompt,
         road_prompt=road_prompt,
+        roof_prompt=roof_prompt,
         tree_prompt=tree_prompt,
         altitude_m=altitude_m,
         fov_deg=fov_deg,
@@ -68,11 +70,12 @@ def _format_status(summary: AnalysisSummary | None) -> str:
     if not summary:
         return "**Status**\nAwaiting analysis."
     masks_line = " / ".join(
-        f"{label}:{'off' if not enabled else ('n/a' if pct is None else f'{pct:.1f}%')}"
-        for label, enabled, pct in (
-            ("Water", summary.water_mask_enabled, summary.water_mask_pct),
-            ("Road", summary.road_mask_enabled, summary.road_mask_pct),
-            ("Roof", summary.roof_mask_enabled, summary.roof_mask_pct),
+        f"{label}:{'on' if enabled else 'off'}"
+        for label, enabled in (
+            ("Water", summary.water_mask_enabled),
+            ("Road", summary.road_mask_enabled),
+            ("Tree", summary.tree_mask_enabled),
+            ("Roof", summary.roof_mask_enabled),
         )
     )
     warning_text = ""
@@ -83,8 +86,8 @@ def _format_status(summary: AnalysisSummary | None) -> str:
         f"- Model: `{summary.model_id}`\n"
         f"- Process res: {summary.process_resolution}px; Runtime: {summary.runtime_ms:.0f} ms\n"
         f"- Footprint: {summary.footprint_m:.1f} m (~{summary.footprint_image_px}px)\n"
-        f"- Safe: {summary.safe_area_pct:.1f}% | Hazard: {summary.hazard_pct:.1f}%\n"
-        f"- Masks: {masks_line}"
+        f"- Safe: {summary.safe_area_pct:.1f}% | Hazard: {summary.hazard_pct:.1f}%"
+        f"\n- Masks: {masks_line}"
         f"{warning_text}"
     )
 
@@ -179,12 +182,14 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                     step=0.01,
                     info="Lower suppresses slopes/edges; higher tolerates tilt.",
                 )
-                with gr.Row():
-                    use_water_mask = gr.Checkbox(label="Exclude water", value=True, info="Mask water regions.")
-                    use_road_mask = gr.Checkbox(label="Exclude roads", value=True, info="Mask road surfaces.")
-                with gr.Row():
-                    use_tree_mask = gr.Checkbox(label="Exclude trees", value=True, info="Mask trees/foliage.")
-                    use_roof_mask = gr.Checkbox(label="Exclude rooftops", value=True, info="Mask rooftop areas.")
+                with gr.Accordion("Hazard segmentation", open=False):
+                    gr.Markdown("Select which hazards to mask using SAM3 segmentation.")
+                    with gr.Row():
+                        use_water_mask = gr.Checkbox(label="Exclude water", value=True, info="Mask water regions.")
+                        use_road_mask = gr.Checkbox(label="Exclude roads", value=True, info="Mask road surfaces.")
+                    with gr.Row():
+                        use_tree_mask = gr.Checkbox(label="Exclude trees", value=True, info="Mask trees/foliage.")
+                        use_roof_mask = gr.Checkbox(label="Exclude rooftops", value=True, info="Mask rooftop areas.")
                 with gr.Accordion("Segmentation settings", open=False):
                     gr.Markdown("Control SAM3 and prompts.")
                     segmentation_model_id = gr.Dropdown(
@@ -213,6 +218,11 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                         value=defaults.road_prompt,
                         placeholder="e.g., road",
                     )
+                    roof_prompt = gr.Textbox(
+                        label="Roof prompt",
+                        value=defaults.roof_prompt,
+                        placeholder="e.g., roof",
+                    )
                     tree_prompt = gr.Textbox(
                         label="Tree prompt",
                         value=defaults.tree_prompt,
@@ -288,14 +298,14 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             with gr.Column(scale=2, min_width=520, elem_id="preview-wrap", elem_classes="preview-col"):
                 main_view = gr.Image(
                     label="Analyzed",
-                    height=441,
+                    height=485,
                     elem_id="main-preview",
                     show_download_button=True,
                     show_fullscreen_button=False,
                 )
                 orig_view = gr.Image(
                     label="Original",
-                    height=441,
+                    height=485,
                     show_download_button=True,
                     show_fullscreen_button=False,
                 )
@@ -346,6 +356,7 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             use_tree_mask,
             water_prompt,
             road_prompt,
+            roof_prompt,
             tree_prompt,
             altitude_m,
             fov_deg,
@@ -381,6 +392,7 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                 use_tree_mask,
                 water_prompt,
                 road_prompt,
+                roof_prompt,
                 tree_prompt,
                 altitude_m,
                 fov_deg,
@@ -432,6 +444,7 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             use_tree_mask,
             water_prompt,
             road_prompt,
+            roof_prompt,
             tree_prompt,
             altitude_m,
             fov_deg,

demo/__init__.py

@@ -0,0 +1 @@
+# Makes the curated demo importable as a package (demo.*).

demo/curated.py

@@ -29,38 +29,35 @@ class CuratedSample:
 
 def format_status(summary: Optional[Dict[str, Any]]) -> str:
     if not summary:
-        return "**Status:** Awaiting analysis."
-    mask_bits = []
-    for label, enabled, pct in (
-        ("Water", summary.get("water_mask_enabled"), summary.get("water_mask_pct")),
-        ("Road", summary.get("road_mask_enabled"), summary.get("road_mask_pct")),
-        ("Roof", summary.get("roof_mask_enabled"), summary.get("roof_mask_pct")),
-    ):
-        if enabled:
-            pct_text = "n/a" if pct is None else f"{pct:.1f}%"
-            mask_bits.append(f"{label} {pct_text}")
-        else:
-            mask_bits.append(f"{label} off")
-    masks_line = " • ".join(mask_bits)
-    lines = [
-        "**Status**",
-        f"Model: `{summary.get('model_id')}` — Process res: {summary.get('process_resolution')}px — Runtime: {summary.get('runtime_ms', 0):.0f} ms",
-        f"Footprint: {summary.get('footprint_m', 0.0):.1f} m ({summary.get('footprint_image_px', 0)}px image scale)",
-        f"Masks: {masks_line}",
-    ]
-    return "<br/>".join(lines)
+        return "**Status**\nAwaiting analysis."
+    masks_line = " / ".join(
+        f"{label}:{'on' if summary.get(enabled_key) else 'off'}"
+        for label, enabled_key in (
+            ("Water", "water_mask_enabled"),
+            ("Road", "road_mask_enabled"),
+            ("Tree", "tree_mask_enabled"),
+            ("Roof", "roof_mask_enabled"),
+        )
+    )
+    warnings = summary.get("warnings") or []
+    warning_text = ""
+    if warnings:
+        warning_text = "\nWarnings: " + " | ".join(warnings)
+    return (
+        "**Run Status**\n"
+        f"- Model: `{summary.get('model_id')}`\n"
+        f"- Process res: {summary.get('process_resolution')}px; Runtime: {summary.get('runtime_ms', 0):.0f} ms\n"
+        f"- Footprint: {summary.get('footprint_m', 0.0):.1f} m (~{summary.get('footprint_image_px', 0)}px)\n"
+        f"- Safe: {summary.get('safe_area_pct', 0.0):.1f}% | Hazard: {summary.get('hazard_pct', 0.0):.1f}%\n"
+        f"- Masks: {masks_line}"
+        f"{warning_text}"
+    )
 
 
 def format_metrics(summary: Optional[Dict[str, Any]]) -> str:
     if not summary:
         return "No metrics yet. Run the analyzer to populate this section."
-    lines = [
-        f"**Safe coverage:** {summary.get('safe_area_pct', 0.0):.1f}% of frame",
-        f"**Hazard coverage:** {summary.get('hazard_pct', 0.0):.1f}%",
-        f"**Landing center (px):** {summary.get('landing_center_image', ['-', '-'])[0]}, {summary.get('landing_center_image', ['-', '-'])[1]}",
-        f"**Footprint size:** {summary.get('footprint_m', 0.0):.1f} m ≈ {summary.get('footprint_image_px', 0)}px",
-        f"**Effective thresholds:** std ≤ {summary.get('std_thresh_applied', 0.0):.4f}, grad ≤ {summary.get('grad_thresh_applied', 0.0):.3f}",
-    ]
+    lines: list[str] = []
     if not summary.get("used_valid_center", True):
         lines.append("Warning: No fully safe footprint; showing lowest-variance patch.")
     warnings = summary.get("warnings") or []

demo/curated_ui.py

@@ -59,13 +59,10 @@ def build_curated_ui(index_path: str | Path | None = None) -> gr.Blocks:
             "DepthAnything3 + segmentation + landing-safety scoring, showcased on VISLOC scenes. "
             "Each sample pairs the raw RGB with a safety overlay that highlights flat, obstacle-free landing zones."
         )
-        gr.Markdown(
-            "1) Pick a sample below. 2) Compare the RGB and safety overlay. 3) Scan the status/metrics to see why that spot was chosen."
-        )
         gr.HTML(
             """
             <div style="background: #0d1117; color: #e6edf3; padding: 10px 12px; border-radius: 10px; font-size: 13px;">
-              <strong>Legend</strong>: safe mask = <span style="color:#00ff00;">green</span>, water = <span style="color:#0b84ff;">blue</span>, roads = <span style="color:#ff7800;">orange</span>, trees = <span style="color:#228b22;">forest green</span>, landing spot = blue box + crosshair.
+              <strong>Legend</strong>: safe mask = <span style="color:#00ff00;">green fill + outline</span>; depth hazards = <span style="color:#ff4d4f;">red</span> heat; segmentation hazards (water/road/tree/roof) = <span style="color:#e6edf3;">black, hatched overlays</span>; landing spot = <span style="color:#ff8c00;">orange box + crosshair</span>.
             </div>
             """
         )
@@ -94,10 +91,10 @@ def build_curated_ui(index_path: str | Path | None = None) -> gr.Blocks:
                 gr.Markdown("**Sample overview**")
                 description_card = gr.Markdown()
             with gr.Column():
-                gr.Markdown("**Status & masks**")
+                gr.Markdown("**Status**")
                 status_card = gr.Markdown()
             with gr.Column():
-                gr.Markdown("**Safety metrics**")
+                gr.Markdown("**Metrics**")
                 metrics_card = gr.Markdown()
 
         demo.load(

demo/demo_app.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Launch the curated (precomputed) Landing Site Safety Gradio demo."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# Ensure repository root on sys.path so `demo.*` imports work when run as a script.
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from demo.curated_ui import build_curated_ui
+
+
+def main() -> None:
+    index_override = os.getenv("CURATED_INDEX_PATH")
+    demo = build_curated_ui(index_override)
+
+    use_queue = os.getenv("DA_USE_QUEUE")
+    use_queue_flag = False if use_queue is None else use_queue.lower() not in {"0", "false", "no"}
+    share = os.getenv("DA_SHARE")
+    share_flag = False if share is None else share.lower() not in {"0", "false", "no"}
+    server_port_str = os.getenv("GRADIO_SERVER_PORT")
+    server_port = int(server_port_str) if server_port_str else None
+    server_port_range = None
+    range_env = os.getenv("GRADIO_SERVER_PORT_RANGE")
+    if range_env:
+        try:
+            start_str, end_str = range_env.split(",", 1)
+            server_port_range = (int(start_str), int(end_str))
+        except ValueError:
+            server_port_range = None
+    launch_kwargs = {"share": share_flag}
+    if server_port is not None:
+        launch_kwargs["server_port"] = server_port
+    if server_port_range is not None:
+        launch_kwargs["server_port_range"] = server_port_range
+    if use_queue_flag:
+        try:
+            demo.queue().launch(**launch_kwargs)
+        except TypeError:
+            launch_kwargs.pop("server_port_range", None)
+            demo.queue().launch(**launch_kwargs)
+    else:
+        try:
+            demo.launch(**launch_kwargs)
+        except TypeError:
+            launch_kwargs.pop("server_port_range", None)
+            demo.launch(**launch_kwargs)
+
+
+if __name__ == "__main__":
+    main()

demo/precompute_curated.py

@@ -70,6 +70,7 @@ def _analysis_request_from_args(args: argparse.Namespace, source_path: Path) ->
         use_tree_mask=True,
         water_prompt=resolve(args.water_prompt, defaults.water_prompt),
         road_prompt=resolve(args.road_prompt, defaults.road_prompt),
+        roof_prompt=resolve(getattr(args, "roof_prompt", None), defaults.roof_prompt),
         tree_prompt=resolve(getattr(args, "tree_prompt", None), defaults.tree_prompt),
         altitude_m=float(resolve(args.altitude_m, defaults.altitude_m)),
         fov_deg=float(resolve(args.fov_deg, defaults.fov_deg)),
@@ -151,11 +152,9 @@ def precompute_curated(
             base_view=base_view,
             heat_on=True,
             heat_alpha=float(heat_opacity),
-            hazard_on=True,
-            hazard_alpha=float(hazard_opacity),
-            water_on=True,
-            road_on=True,
-            tree_on=True,
+            risk_on=True,
+            risk_alpha=float(hazard_opacity),
+            hazards_on=True,
             grad_on=False,
             flat_on=False,
             flat_heat_on=False,
@@ -237,6 +236,7 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--fov-deg", type=float, help="Camera FOV in degrees.")
     p.add_argument("--water-prompt", type=str, help="Water segmentation prompt.")
     p.add_argument("--road-prompt", type=str, help="Road segmentation prompt.")
+    p.add_argument("--roof-prompt", type=str, help="Roof segmentation prompt.")
     p.add_argument("--tree-prompt", type=str, help="Tree segmentation prompt.")
     p.add_argument("--use-water-mask", action="store_true", dest="use_water_mask", help="Enable water mask.")
     p.add_argument("--no-water-mask", action="store_false", dest="use_water_mask", help="Disable water mask.")