Update landing site safety apps and curated gallery

ARCHITECTURE.md

@@ -3,14 +3,14 @@
 This document describes the flow in the current Gradio app (`app/ui.py`), from input selection through model inference, safety scoring, and UI composition.
 
 ## Data and Models
-- **Inputs**: Images from `data/Image/VISLOC` (populated via `list_all_data_inputs`) with a 5% border crop (`crop_nonblack`) to drop black padding. Supported extensions: jpg/jpeg/png (any case).
+- **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 masking. Loaded once per model id; masks are recomputed every run (no caching). Default `segmentation_max_side` is 384 to keep it fast on CUDA.
 
 ## Constants and Defaults
 - Altitude/FOV defaults: 450 m, 90°.
 - Flatness/gradient thresholds: sliders (`std_thresh`, `grad_thresh`).
-- Clearance factor: default 0.5 (hazards dilated to half the footprint unless changed).
+- Clearance factor: default 1.0 (hazards dilated to the footprint size unless changed).
 - 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.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,31 @@
+# Drone Landing Site Safety
+
+Gradio apps that find safe landing zones in RGB imagery: run live inference or browse a precomputed curated gallery. The pipeline pairs monocular depth (Depth Anything 3) with promptable segmentation (water/motorways/trees) and geometric checks to flag flat, obstacle-free footprints, then renders overlays and metrics so you can see why a spot is safe.
+
+## What’s inside
+- **Main app (`gradio_app.py`)** — runs full inference (DepthAnything3 + SAM3 prompts for water/motorways/trees) with adjustable thresholds, overlays, and camera assumptions.
+- **Curated gallery (`curated_gradio_app.py`)** — precomputed PNG/JPG/JSON artifacts for fast, zero-GPU browsing.
+- Shared defaults live in `app/config.py` (`DEFAULT_ANALYZER_SETTINGS`), so both experiences stay in sync.
+
+## Prereqs
+- Python 3.10+ and a CUDA GPU for the main app (CPU works but is slow).
+- Sample images: drop your RGBs under `data/Image/` (create subfolders if you want); the repo ignores `data/`. Only curated outputs (5 VISLOC samples) are bundled.
+- Install deps: `pip install -r requirements.txt`.
+
+## Run the main Gradio app (live inference)
+```bash
+python gradio_app.py
+```
+- Key defaults: 1024px process cap, 10m footprint, clearance factor 1.0, prompts `water` / `motorway` / `trees`, SAM3 segmentation.
+- Useful env vars: `DA_USE_QUEUE=1`, `DA_SHARE=1`, `GRADIO_SERVER_PORT=7860`, `GRADIO_SERVER_PORT_RANGE=7860,7890`.
+
+## Curated gallery (precomputed, CPU-friendly)
+Already works out of the box with the bundled outputs in `app/demo_assets/curated/build/` (about 60 MB):
+```bash
+python curated_gradio_app.py
+```
+
+## References
+- UAV-VisLoc dataset: Xu et al., 2024 (https://arxiv.org/abs/2405.11936)
+- Depth Anything 3: Lin et al., 2025 (https://arxiv.org/abs/2511.10647)
+- SAM 3: “SAM 3: Segment Anything with Concepts” (https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/)

app/config.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 VISLOC_DIR = Path("data/Image/VISLOC")
-HAGDAVS_DIR = Path("data/Image/HAGDAVS")
+IMAGE_ROOT = Path("data/Image")
 VIDEO_DIR = Path("data/Video")
 IMAGE_EXTS = (".jpg", ".jpeg", ".png", ".JPG", ".JPEG", ".PNG")
 VIDEO_EXTS = {".mp4", ".avi", ".mov", ".mkv", ".flv", ".wmv", ".webm", ".m4v"}
@@ -13,38 +13,44 @@ ASSUMED_FOV_DEG = 90.0
 DEFAULT_MODEL_ID = "depth-anything/DA3MONO-LARGE"
 SEGMENTATION_MODEL_ID = "facebook/sam3"
 SEGMENTATION_MAX_SIDE = 384
-SEGMENTATION_SCORE_THRESH = 0.5
-SEGMENTATION_MASK_THRESH = 0.5
-WATER_PROMPT = "water, river, lake, ocean, sea"
-ROAD_PROMPT = "road, highway, street, runway"
+SEGMENTATION_SCORE_THRESH = 0.25
+SEGMENTATION_MASK_THRESH = 0.25
+WATER_PROMPT = "water"
+ROAD_PROMPT = "motorway"
+TREE_PROMPT = "trees"
 
 
 @dataclass(frozen=True)
 class AnalyzerSettings:
     """Bundle knobs shared between the UI and the processing pipeline."""
 
-    footprint_m: float = 15.0
+    footprint_m: float = 10.0
     std_thresh: float = 0.005
     grad_thresh: float = 0.1
-    clearance_factor: float = 0.5
+    clearance_factor: float = 1.0
     process_res_cap: int = 1024
     depth_smoothing_base: float = 0.0
     segmentation_max_side: int = SEGMENTATION_MAX_SIDE
+    segmentation_model_id: str = SEGMENTATION_MODEL_ID
     segmentation_score_thresh: float = SEGMENTATION_SCORE_THRESH
     segmentation_mask_thresh: float = SEGMENTATION_MASK_THRESH
     water_prompt: str = WATER_PROMPT
     road_prompt: str = ROAD_PROMPT
+    tree_prompt: str = TREE_PROMPT
     coverage_strictness: float = 0.95
     openness_weight: float = 0.3
-    texture_threshold: float = 0.1
+    texture_threshold: float = 0.3
     altitude_m: float = DEFAULT_ALTITUDE_M
     fov_deg: float = ASSUMED_FOV_DEG
     model_id: str = DEFAULT_MODEL_ID
 
 
+DEFAULT_ANALYZER_SETTINGS = AnalyzerSettings()
+
+
 __all__ = [
     "VISLOC_DIR",
-    "HAGDAVS_DIR",
+    "IMAGE_ROOT",
     "VIDEO_DIR",
     "IMAGE_EXTS",
     "VIDEO_EXTS",
@@ -57,5 +63,7 @@ __all__ = [
     "SEGMENTATION_MASK_THRESH",
     "WATER_PROMPT",
     "ROAD_PROMPT",
+    "TREE_PROMPT",
+    "DEFAULT_ANALYZER_SETTINGS",
     "AnalyzerSettings",
 ]

app/curated.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from PIL import Image
+
+
+@dataclass
+class CuratedSample:
+    id: str
+    title: str
+    description: str
+    tags: List[str]
+    source_path: str
+    composed_path: Path
+    rgb_path: Path
+    summary: Dict[str, Any]
+    request: Dict[str, Any]
+
+    def load_composed(self) -> Image.Image:
+        return Image.open(self.composed_path).convert("RGB")
+
+    def load_rgb(self) -> Image.Image:
+        return Image.open(self.rgb_path).convert("RGB")
+
+
+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)
+
+
+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}",
+    ]
+    if not summary.get("used_valid_center", True):
+        lines.append("Warning: No fully safe footprint; showing lowest-variance patch.")
+    warnings = summary.get("warnings") or []
+    if warnings:
+        warn_lines = "<br/>".join(f"⚠️ {msg}" for msg in warnings)
+        lines.append(warn_lines)
+    return "<br/>".join(lines)
+
+
+def load_curated_index(index_path: Path) -> List[CuratedSample]:
+    if not index_path.exists():
+        return []
+    with index_path.open("r") as f:
+        data = json.load(f)
+    samples_in = data.get("samples", [])
+    if not isinstance(samples_in, list):
+        return []
+    base_dir = index_path.parent
+    samples: List[CuratedSample] = []
+    for item in samples_in:
+        if not isinstance(item, dict):
+            continue
+        artifacts = item.get("artifacts") or {}
+        try:
+            composed = base_dir / artifacts["composed"]
+            rgb = base_dir / artifacts["rgb"]
+        except Exception:
+            continue
+        sample = CuratedSample(
+            id=item.get("id") or composed.stem,
+            title=item.get("title") or item.get("id") or composed.stem,
+            description=item.get("description") or "",
+            tags=item.get("tags") or [],
+            source_path=item.get("source_path") or "",
+            composed_path=composed,
+            rgb_path=rgb,
+            summary=item.get("summary") or {},
+            request=item.get("request") or {},
+        )
+        samples.append(sample)
+    return samples
+
+
+__all__ = ["CuratedSample", "format_metrics", "format_status", "load_curated_index"]

app/curated_ui.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List
+
+import gradio as gr
+
+from .curated import CuratedSample, format_metrics, format_status, load_curated_index
+
+
+def _describe_sample(sample: CuratedSample) -> str:
+    lines: List[str] = [f"**{sample.title}**"]
+    if sample.description:
+        lines.append(sample.description)
+    if sample.tags:
+        lines.append("Tags: " + ", ".join(sample.tags))
+    if sample.source_path:
+        lines.append(f"Source: `{sample.source_path}`")
+    return "<br/>".join(lines)
+
+
+def build_curated_ui(index_path: str | Path | None = None) -> gr.Blocks:
+    resolved_index = Path(index_path) if index_path else Path(
+        os.getenv("CURATED_INDEX_PATH", "app/demo_assets/curated/build/index.json")
+    )
+    samples = load_curated_index(resolved_index)
+    title = "Landing Site Safety Analyzer — Curated Gallery"
+    if not samples:
+        with gr.Blocks(title=title) as demo:
+            gr.Markdown(
+                "## Curated gallery not built yet\n"
+                "Generate the curated outputs (PNG + JSON) first:\n"
+                "```bash\n"
+                "python scripts/precompute_curated.py --manifest app/demo_assets/curated/samples.yaml --output-dir app/demo_assets/curated/build\n"
+                "```\n"
+                "Then re-launch this app."
+            )
+        return demo
+
+    samples_by_id = {s.id: s for s in samples}
+    sample_options = [(s.title, s.id) for s in samples]
+    default_id = samples[0].id
+
+    def _select_sample(sample_id: str):
+        sample = samples_by_id.get(sample_id)
+        if not sample:
+            raise gr.Error("Sample not found; rebuild the curated index.")
+        composed = sample.load_composed()
+        rgb = sample.load_rgb()
+        return composed, rgb, _describe_sample(sample), format_status(sample.summary), format_metrics(sample.summary)
+
+    with gr.Blocks(title=title) as demo:
+        gr.Markdown(
+            "## Landing Site Safety — Curated Gallery\n"
+            "Zero-GPU preview. These results are precomputed from the analyzer and load instantly."
+        )
+        gr.Markdown(
+            "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.
+            </div>
+            """
+        )
+        with gr.Row(equal_height=True):
+            sample_dropdown = gr.Dropdown(
+                label="Sample",
+                choices=sample_options,
+                value=default_id,
+                interactive=True,
+                info="Pick a curated VISLOC image and view the precomputed safety analysis.",
+            )
+        with gr.Row():
+            rgb_view = gr.Image(label="RGB reference", type="pil", height=520, show_fullscreen_button=True)
+            composed_view = gr.Image(
+                label="Safety overlay",
+                type="pil",
+                show_fullscreen_button=True,
+                height=520,
+            )
+        gr.Markdown(
+            "**What to look for:** Samples span water, roads, trees, rooftops, and open terrain to show how prompts "
+            "(`water`, `motorway`, `trees`) guide hazard masking and landing-site selection."
+        )
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("**Sample overview**")
+                description_card = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("**Status & masks**")
+                status_card = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("**Safety metrics**")
+                metrics_card = gr.Markdown()
+
+        demo.load(
+            fn=_select_sample,
+            inputs=sample_dropdown,
+            outputs=[composed_view, rgb_view, description_card, status_card, metrics_card],
+            queue=False,
+        )
+        sample_dropdown.change(
+            fn=_select_sample,
+            inputs=sample_dropdown,
+            outputs=[composed_view, rgb_view, description_card, status_card, metrics_card],
+            queue=False,
+        )
+
+    return demo
+
+
+__all__ = ["build_curated_ui"]

app/data_sources.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from functools import lru_cache
 from pathlib import Path
 
-from .config import HAGDAVS_DIR, IMAGE_EXTS, VIDEO_DIR, VIDEO_EXTS, VISLOC_DIR
+from .config import IMAGE_EXTS, IMAGE_ROOT, VIDEO_DIR, VIDEO_EXTS, VISLOC_DIR
 
 
 @lru_cache(maxsize=1)
@@ -14,14 +14,6 @@ def list_visloc_images() -> list[Path]:
     return sorted(files)
 
 
-@lru_cache(maxsize=1)
-def list_hagdavs_images() -> list[Path]:
-    if not HAGDAVS_DIR.exists():
-        return []
-    files = [p for p in HAGDAVS_DIR.iterdir() if p.suffix in IMAGE_EXTS]
-    return sorted(files)
-
-
 @lru_cache(maxsize=1)
 def list_videos() -> list[Path]:
     if not VIDEO_DIR.exists():
@@ -32,19 +24,34 @@ def list_videos() -> list[Path]:
 
 @lru_cache(maxsize=1)
 def list_all_data_inputs() -> list[str]:
-    return [str(p) for p in list_visloc_images()]
+    paths: list[Path] = []
+
+    def _add(paths_in: list[Path]):
+        for p in paths_in:
+            if p not in paths:
+                paths.append(p)
+
+    # Prefer structured datasets first
+    _add(list_visloc_images())
+
+    # Allow arbitrary images anywhere under data/Image/
+    if IMAGE_ROOT.exists():
+        for p in IMAGE_ROOT.rglob("*"):
+            if p.is_file() and p.suffix in IMAGE_EXTS:
+                if p not in paths:
+                    paths.append(p)
+
+    return [str(p) for p in sorted(paths)]
 
 
 def clear_caches() -> None:
     list_visloc_images.cache_clear()
-    list_hagdavs_images.cache_clear()
     list_videos.cache_clear()
     list_all_data_inputs.cache_clear()
 
 
 __all__ = [
     "list_visloc_images",
-    "list_hagdavs_images",
     "list_videos",
     "list_all_data_inputs",
     "clear_caches",

app/depth_pipeline.py

@@ -69,14 +69,26 @@ def fit_plane_ransac(points: np.ndarray, values: np.ndarray, iterations: int = 2
     return best_coef
 
 
-def remove_global_plane(depth: np.ndarray) -> np.ndarray:
+def remove_global_plane(depth: np.ndarray, method: str = "least_squares") -> np.ndarray:
     if depth.ndim != 2:
         return depth
+    method = (method or "least_squares").lower()
+    if method in {"none", "off"}:
+        return depth
     h, w = depth.shape
     yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
     points = np.stack((xx.flatten(), yy.flatten()), axis=1)
     values = depth.astype(np.float32).reshape(-1, 1)
-    coef = fit_plane_ransac(points, values, iterations=300, threshold=0.01 * np.ptp(depth))
+    coef = None
+    if method in {"ls", "least_squares", "lstsq"}:
+        try:
+            coef, *_ = np.linalg.lstsq(
+                np.concatenate([points, np.ones((points.shape[0], 1), dtype=np.float32)], axis=1),
+                values,
+                rcond=None,
+            )
+        except np.linalg.LinAlgError:
+            coef = None
     if coef is None:
         return depth
     plane = (points @ coef[:2] + coef[2]).reshape(h, w)
@@ -151,10 +163,14 @@ class DepthEngine:
         return self._model_cache[model_id]
 
     def predict_depth(
-        self, image: np.ndarray, model_id: str, process_res_cap: int
-    ) -> tuple[np.ndarray, np.ndarray, int]:
+        self, image: np.ndarray, model_id: str, process_res_cap: int, plane_method: str = "least_squares"
+    ) -> tuple[np.ndarray, np.ndarray, int, dict[str, float]]:
+        import time as _time
+
+        t0 = _time.perf_counter()
         model, device = self.get_model(model_id)
         process_res = min(max(image.shape[0], image.shape[1]), int(process_res_cap))
+        t_pre = _time.perf_counter()
         with torch.inference_mode():
             pred = model.inference(
                 image=[image],
@@ -162,9 +178,16 @@ class DepthEngine:
                 process_res_method="upper_bound_resize",
                 export_dir=None,
             )
+        t_model = _time.perf_counter()
         depth_raw = np.array(pred.depth[0])
-        depth = remove_global_plane(depth_raw)
-        return depth_raw, depth, process_res
+        depth = remove_global_plane(depth_raw, method=plane_method)
+        t_post = _time.perf_counter()
+        timings = {
+            "prep_ms": (t_pre - t0) * 1000.0,
+            "model_ms": (t_model - t_pre) * 1000.0,
+            "plane_ms": (t_post - t_model) * 1000.0,
+        }
+        return depth_raw, depth, process_res, timings
 
 
 def smooth_depth(depth: np.ndarray, sigma: float) -> np.ndarray:

app/safety.py

@@ -10,9 +10,9 @@ import numpy as np
 import torch
 from PIL import Image
 
-from .config import IMAGE_EXTS
+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 .segmentation import SegmenterRequest, SegmenterService
+from .segmentation import SegmenterRequest, SegmenterService, get_global_segmenter
 from .visualization import build_result_layers
 
 
@@ -24,14 +24,17 @@ class AnalysisRequest:
     use_water_mask: bool
     use_road_mask: bool
     use_roof_mask: bool
+    use_tree_mask: bool
     water_prompt: str
     road_prompt: str
+    tree_prompt: str
     altitude_m: float
     fov_deg: float
     clearance_factor: float
     process_res_cap: int
     depth_smoothing_base: float
     segmentation_max_side: int
+    segmentation_model_id: str
     segmentation_score_thresh: float
     segmentation_mask_thresh: float
     coverage_strictness: float
@@ -74,7 +77,12 @@ class AnalysisResult:
 class SafetyAnalyzer:
     def __init__(self, depth_engine: DepthEngine | None = None, segmenter: SegmenterService | None = None):
         self.depth_engine = depth_engine or DepthEngine()
-        self.segmenter = segmenter or SegmenterService()
+        self.segmenter = segmenter or get_global_segmenter()
+        # Preload default depth model to avoid first-call latency spikes.
+        try:
+            self.depth_engine.get_model(DEFAULT_MODEL_ID)
+        except Exception as exc:
+            print(f"[WARN] Could not preload depth model {DEFAULT_MODEL_ID}: {exc}")
 
     @staticmethod
     def build_depth_roof_mask(
@@ -119,10 +127,17 @@ class SafetyAnalyzer:
     def analyze_image(self, image: Image.Image, request: AnalysisRequest) -> AnalysisResult:
         t0 = time.perf_counter()
         rgb_np = np.array(image)
-        depth_raw, depth, process_res = self.depth_engine.predict_depth(rgb_np, request.model_id, request.process_res_cap)
+        t_rgb = time.perf_counter()
+        depth_raw, depth, process_res, depth_times = self.depth_engine.predict_depth(
+            rgb_np, request.model_id, request.process_res_cap, "least_squares"
+        )
+        t_depth = time.perf_counter()
         res_scale = max(0.5, min(2.5, process_res / 1024))
         sigma = max(0.0, request.depth_smoothing_base) * res_scale
         depth = smooth_depth(depth, sigma)
+        # Keep all downstream processing at the depth resolution to avoid expensive full-res passes.
+        proc_size = (depth.shape[1], depth.shape[0])  # (W, H)
+        rgb_proc = cv2.resize(rgb_np, proc_size, interpolation=cv2.INTER_AREA) if rgb_np.shape[:2][::-1] != proc_size else rgb_np
 
         fov = max(10.0, min(170.0, float(request.fov_deg)))
         altitude = max(1.0, float(request.altitude_m))
@@ -158,8 +173,9 @@ class SafetyAnalyzer:
         std_map_vis = np.sqrt(
             np.maximum(box_mean_np(depth_norm * depth_norm, vis_patch) - box_mean_np(depth_norm, vis_patch) ** 2, 0.0)
         )
+        t_depth_post = time.perf_counter()
 
-        gray = cv2.cvtColor(rgb_np, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
+        gray = cv2.cvtColor(rgb_proc, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
         gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
         gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
         texture = np.sqrt(gx * gx + gy * gy)
@@ -169,14 +185,21 @@ class SafetyAnalyzer:
             texture_norm = (texture - texture.min()) / (np.ptp(texture) + 1e-6)
         else:
             texture_norm = np.zeros_like(texture)
-        texture_norm = cv2.resize(texture_norm, (depth.shape[1], depth.shape[0]), interpolation=cv2.INTER_LINEAR)
+
+        dy_depth, dx_depth = np.gradient(depth_norm)
+        grad_mag = np.sqrt(dx_depth * dx_depth + dy_depth * dy_depth)
+        grad_ref = np.percentile(grad_mag, 95) + 1e-6
+        grad_norm = np.clip(grad_mag / grad_ref, 0.0, 1.0)
+        t_texture = time.perf_counter()
 
         water_mask_resized = None
         road_mask_resized = None
         roof_mask_resized = None
+        tree_mask_resized = None
         water_mask_block = None
         road_mask_block = None
         roof_mask_block = None
+        tree_mask_block = None
 
         def expand_mask_for_footprint(mask: np.ndarray | None) -> np.ndarray | None:
             if mask is None:
@@ -189,19 +212,22 @@ class SafetyAnalyzer:
                 return mask.copy()
             expanded = cv2.dilate(mask.astype(np.uint8), kernel, iterations=1)
             return expanded.astype(bool)
-        if request.use_water_mask or request.use_road_mask:
+        if request.use_water_mask or request.use_road_mask or request.use_tree_mask:
             masks = self.segmenter.get_masks(
                 SegmenterRequest(
-                    image=image,
+                    image=Image.fromarray(rgb_proc),
                     source_path=request.source_path,
                     want_water=request.use_water_mask,
                     want_road=request.use_road_mask,
-                    max_side=int(max(128, request.segmentation_max_side)),
+                    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,
+                    tree_prompt=request.tree_prompt,
                     score_threshold=float(request.segmentation_score_thresh),
                     mask_threshold=float(request.segmentation_mask_thresh),
-                )
+                ),
+                model_id=request.segmentation_model_id,
             )
             if request.use_water_mask and masks.get("water") is not None:
                 water_mask_resized = Image.fromarray(masks["water"].astype(np.uint8) * 255).resize(
@@ -215,6 +241,13 @@ class SafetyAnalyzer:
                 )
                 road_mask_resized = np.array(road_mask_resized) > 0
                 road_mask_block = expand_mask_for_footprint(road_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
+                )
+                tree_mask_resized = np.array(tree_mask_resized) > 0
+                tree_mask_block = expand_mask_for_footprint(tree_mask_resized)
+        t_masks = time.perf_counter()
 
         # Autoscale sensitivity with resolution: stricter when resolution is low
         std_thresh_eff = max(1e-6, float(request.std_thresh)) * (res_scale ** -0.5)
@@ -227,6 +260,7 @@ class SafetyAnalyzer:
             grad_thresh=grad_thresh_eff,
             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,
@@ -236,13 +270,14 @@ class SafetyAnalyzer:
             )
             roof_mask_block = expand_mask_for_footprint(roof_mask_resized)
         seg_block_mask = None
-        for mask in (water_mask_block, road_mask_block, roof_mask_block):
+        for mask in (water_mask_block, road_mask_block, tree_mask_block, roof_mask_block):
             if mask is None:
                 continue
             if seg_block_mask is None:
                 seg_block_mask = mask.copy()
             else:
                 seg_block_mask |= mask
+        landing_mask_pre_interior = landing_mask.copy()
         if seg_block_mask is not None:
             landing_mask = landing_mask & (~seg_block_mask)
         if half_span > 0:
@@ -386,24 +421,69 @@ class SafetyAnalyzer:
         center_img = (cx_img, cy_img)
         center_depth = (cx, cy)
 
-        safe_display_mask = safe_mask
+        # Display mask without interior cropping so overlays are not clipped at borders.
+        safe_display_mask = (
+            (std_map < std_thresh_eff)
+            & (grad_norm < grad_thresh_eff)
+            & landing_mask_pre_interior
+            & texture_mask
+        )
+        if seg_block_mask is not None:
+            safe_display_mask = safe_display_mask & (~seg_block_mask)
+        try:
+            clearance_px = max(1, int(round(request.clearance_factor * patch_px)))
+            if clearance_px % 2 == 0:
+                clearance_px += 1
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (clearance_px, clearance_px))
+            hazard_disp = ~safe_display_mask
+            if seg_block_mask is not None:
+                hazard_disp = hazard_disp & (~seg_block_mask)
+            buffered_disp = cv2.dilate(hazard_disp.astype(np.uint8), kernel, iterations=1).astype(bool)
+            safe_display_mask = safe_display_mask & (~buffered_disp)
+            if seg_block_mask is not None:
+                safe_display_mask = safe_display_mask & (~seg_block_mask)
+        except Exception:
+            pass
+        try:
+            coverage_disp = cv2.boxFilter(
+                safe_display_mask.astype(np.float32),
+                ddepth=-1,
+                ksize=(patch_px, patch_px),
+                normalize=True,
+                anchor=(patch_px // 2, patch_px // 2),
+            )
+            safe_display_mask = coverage_disp >= max(0.0, min(1.0, request.coverage_strictness))
+        except Exception:
+            pass
         try:
             footprint_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (patch_px, patch_px))
-            safe_display_mask = cv2.dilate(safe_mask.astype(np.uint8), footprint_kernel, iterations=1).astype(bool)
+            safe_display_mask = cv2.dilate(safe_display_mask.astype(np.uint8), footprint_kernel, iterations=1).astype(
+                bool
+            )
         except Exception:
-            safe_display_mask = safe_mask
+            pass
         mask_union = None
-        for mask in (water_mask_resized, road_mask_resized, roof_mask_resized):
+        overlay_union = None
+        for mask in (water_mask_resized, road_mask_resized, tree_mask_resized, roof_mask_resized):
             if mask is None:
                 continue
             if mask_union is None:
                 mask_union = mask.copy()
             else:
                 mask_union |= mask
+        for mask in (water_mask_resized, road_mask_resized, tree_mask_resized):
+            if mask is None:
+                continue
+            if overlay_union is None:
+                overlay_union = mask.copy()
+            else:
+                overlay_union |= mask
         seg_mask_union = mask_union.copy() if mask_union is not None else None
         if mask_union is not None:
             safe_display_mask = safe_display_mask & (~mask_union)
         hazard_mask = ~safe_display_mask
+        if roof_mask_resized is not None:
+            hazard_mask = hazard_mask & (~roof_mask_resized)
 
         layers = build_result_layers(
             image=image,
@@ -418,7 +498,7 @@ class SafetyAnalyzer:
             water_mask=water_mask_resized,
             road_mask=road_mask_resized,
             roof_mask=roof_mask_resized,
-            seg_mask_union=seg_mask_union,
+            tree_mask=tree_mask_resized,
             hazard_mask=hazard_mask,
         )
         try:
@@ -451,6 +531,20 @@ class SafetyAnalyzer:
         elif roof_mask_resized is None:
             warnings.append("Roof segmentation unavailable; continuing without mask.")
 
+        t_final = time.perf_counter()
+        print(
+            "[TIMING] rgb->np {:.0f}ms | depth_model {:.0f}ms | plane {:.0f}ms | depth_misc {:.0f}ms | texture {:.0f}ms | masks {:.0f}ms | pick {:.0f}ms | compose {:.0f}ms | total {:.0f}ms".format(
+                (t_rgb - t0) * 1000,
+                depth_times.get("model_ms", 0.0),
+                depth_times.get("plane_ms", 0.0),
+                depth_times.get("prep_ms", 0.0),
+                (t_texture - t_depth_post) * 1000,
+                (t_masks - t_texture) * 1000,
+                (t_pick - t_masks) * 1000,
+                (t_final - t_pick) * 1000,
+                (t_final - t0) * 1000,
+            )
+        )
         summary = AnalysisSummary(
             model_id=request.model_id,
             process_resolution=process_res,

app/segmentation.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional
 import re
 
 import numpy as np
@@ -15,6 +14,7 @@ from .config import (
     SEGMENTATION_MODEL_ID,
     SEGMENTATION_SCORE_THRESH,
     WATER_PROMPT,
+    TREE_PROMPT,
 )
 
 
@@ -23,6 +23,13 @@ class SemanticSegmenter:
 
     def __init__(self, model_id: str):
         import transformers  # type: ignore
+        from transformers.utils import logging as hf_logging  # type: ignore
+
+        hf_logging.set_verbosity_error()
+        try:
+            hf_logging.disable_progress_bar()
+        except Exception:
+            pass
 
         processor_cls = getattr(transformers, "Sam3Processor", None) or getattr(
             transformers, "AutoProcessor", None
@@ -113,9 +120,11 @@ class SegmenterRequest:
     source_path: Optional[str] = None
     want_water: bool = False
     want_road: bool = False
+    want_tree: bool = False
     max_side: int = SEGMENTATION_MAX_SIDE
     water_prompt: str = WATER_PROMPT
     road_prompt: str = ROAD_PROMPT
+    tree_prompt: str = TREE_PROMPT
     score_threshold: float = SEGMENTATION_SCORE_THRESH
     mask_threshold: float = SEGMENTATION_MASK_THRESH
 
@@ -126,21 +135,28 @@ class SegmenterService:
     def __init__(self, model_id: str = SEGMENTATION_MODEL_ID):
         self.model_id = model_id
         self._segmenters: Dict[str, SemanticSegmenter] = {}
+        # Eagerly load the default model once to avoid repeated cold-starts.
+        try:
+            self._segmenters[model_id] = SemanticSegmenter(model_id)
+        except Exception as exc:
+            print(f"[WARN] Failed to preload segmentation model {model_id}: {exc}")
 
     def _get_segmenter(self, model_id: str) -> SemanticSegmenter:
         if model_id not in self._segmenters:
             self._segmenters[model_id] = SemanticSegmenter(model_id)
         return self._segmenters[model_id]
 
-    def get_masks(self, request: SegmenterRequest) -> dict[str, np.ndarray]:
-        if not (request.want_water or request.want_road):
+    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):
             return {}
-        segmenter = self._get_segmenter(self.model_id)
+        segmenter = self._get_segmenter(model_id or self.model_id)
         prompts: dict[str, str] = {}
         if request.want_water and request.water_prompt:
             prompts["water"] = request.water_prompt
         if request.want_road and request.road_prompt:
             prompts["road"] = request.road_prompt
+        if request.want_tree and request.tree_prompt:
+            prompts["tree"] = request.tree_prompt
         try:
             masks = segmenter.segment(
                 request.image,
@@ -161,3 +177,13 @@ class SegmenterService:
 
 
 __all__ = ["SegmenterService", "SegmenterRequest", "SemanticSegmenter"]
+
+# Shared singleton to avoid reloads across analyzer instances
+_GLOBAL_SEGMENTER: SegmenterService | None = None
+
+
+def get_global_segmenter(default_model_id: str = SEGMENTATION_MODEL_ID) -> SegmenterService:
+    global _GLOBAL_SEGMENTER
+    if _GLOBAL_SEGMENTER is None or _GLOBAL_SEGMENTER.model_id != default_model_id:
+        _GLOBAL_SEGMENTER = SegmenterService(default_model_id)
+    return _GLOBAL_SEGMENTER

app/ui.py

@@ -5,7 +5,7 @@ from typing import Dict
 
 import gradio as gr
 
-from .config import AnalyzerSettings, IMAGE_EXTS
+from .config import DEFAULT_ANALYZER_SETTINGS, IMAGE_EXTS
 from .data_sources import list_all_data_inputs
 from .safety import AnalysisRequest, AnalysisSummary, SafetyAnalyzer
 from .visualization import compose_view
@@ -19,14 +19,16 @@ def _make_request(
     use_water_mask,
     use_road_mask,
     use_roof_mask,
+    use_tree_mask,
     water_prompt,
     road_prompt,
+    tree_prompt,
     altitude_m,
     fov_deg,
     clearance_factor,
     process_res_cap,
-    depth_smoothing_base,
     segmentation_max_side,
+    segmentation_model_id,
     segmentation_score_thresh,
     segmentation_mask_thresh,
     coverage_strictness,
@@ -41,14 +43,17 @@ def _make_request(
         use_water_mask=use_water_mask,
         use_road_mask=use_road_mask,
         use_roof_mask=use_roof_mask,
+        use_tree_mask=use_tree_mask,
         water_prompt=water_prompt,
         road_prompt=road_prompt,
+        tree_prompt=tree_prompt,
         altitude_m=altitude_m,
         fov_deg=fov_deg,
         clearance_factor=clearance_factor,
         process_res_cap=process_res_cap,
-        depth_smoothing_base=depth_smoothing_base,
+        depth_smoothing_base=0.0,
         segmentation_max_side=segmentation_max_side,
+        segmentation_model_id=segmentation_model_id,
         segmentation_score_thresh=segmentation_score_thresh,
         segmentation_mask_thresh=segmentation_mask_thresh,
         coverage_strictness=coverage_strictness,
@@ -102,7 +107,7 @@ def _format_metrics(summary: AnalysisSummary | None) -> str:
 
 def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
     analyzer = analyzer or SafetyAnalyzer()
-    defaults = AnalyzerSettings()
+    defaults = DEFAULT_ANALYZER_SETTINGS
     data_inputs = list_all_data_inputs()
 
     with gr.Blocks(title="Landing Site Safety Analyzer (VISLOC)") as demo:
@@ -110,6 +115,30 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             "## Landing Site Safety Analyzer\n"
             "Evaluate VISLOC imagery with DepthAnything3 to spot flat, obstacle-free landing sites."
         )
+        gr.HTML(
+            """
+            <style>
+            #preview-wrap { position: relative; }
+            #preview-wrap .hover-legend {
+                position: absolute;
+                right: 12px;
+                bottom: 12px;
+                background: rgba(0, 0, 0, 0.65);
+                color: #fff;
+                padding: 8px 10px;
+                border-radius: 10px;
+                font-size: 12px;
+                line-height: 1.4;
+                opacity: 0;
+                transition: opacity 0.2s ease;
+                pointer-events: none;
+            }
+            #preview-wrap:hover .hover-legend { opacity: 1; }
+            #preview-wrap .hover-legend .row { display: flex; align-items: center; gap: 6px; margin-bottom: 4px; }
+            #preview-wrap .hover-legend .swatch { width: 12px; height: 12px; border-radius: 3px; display: inline-block; }
+            </style>
+            """
+        )
         images_state = gr.State({})
 
         with gr.Row(equal_height=False):
@@ -130,6 +159,14 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                     ],
                     info="Select a pretrained checkpoint.",
                 )
+                process_res_cap = gr.Slider(
+                    label="Processing max side (px)",
+                    value=defaults.process_res_cap,
+                    minimum=512,
+                    maximum=2048,
+                    step=32,
+                    info="Global resolution cap for depth/analysis steps.",
+                )
                 footprint_m = gr.Slider(
                     label="Landing footprint (meters)",
                     value=defaults.footprint_m,
@@ -154,23 +191,67 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                     step=0.01,
                     info="Lower suppresses slopes/edges; higher tolerates tilt.",
                 )
-                use_water_mask = gr.Checkbox(label="Exclude water (segmentation)", value=True)
+                use_water_mask = gr.Checkbox(
+                    label="Exclude water (segmentation)",
+                    value=True,
+                    info="Runs SAM3 segmentation with water prompts.",
+                )
                 water_prompt = gr.Textbox(
                     label="Water prompt",
                     value=defaults.water_prompt,
-                    placeholder="e.g., water, river, lake, ocean, sea",
+                    placeholder="e.g., water",
                 )
                 use_road_mask = gr.Checkbox(label="Exclude roads (segmentation)", value=True)
                 road_prompt = gr.Textbox(
                     label="Road prompt",
                     value=defaults.road_prompt,
-                    placeholder="e.g., road, highway, street, runway",
+                    placeholder="e.g., road",
                 )
-                use_roof_mask = gr.Checkbox(label="Exclude rooftops (depth-based)", value=False)
+                use_tree_mask = gr.Checkbox(label="Exclude trees (segmentation)", value=True)
+                tree_prompt = gr.Textbox(
+                    label="Tree prompt",
+                    value=defaults.tree_prompt,
+                    placeholder="e.g., tree",
+                )
+                use_roof_mask = gr.Checkbox(label="Exclude rooftops (depth-based)", value=True)
                 with gr.Row():
                     run_btn = gr.Button("Run", variant="primary")
                     stop_btn = gr.Button("Stop", variant="stop")
-                with gr.Accordion("Advanced tuning", open=False):
+                with gr.Accordion("Segmentation settings", open=False):
+                    gr.Markdown("Control SAM3/Mask2Former and thresholds.")
+                    segmentation_model_id = gr.Dropdown(
+                        label="Segmentation model",
+                        value=defaults.segmentation_model_id,
+                        choices=[
+                            ("SAM3", "facebook/sam3"),
+                        ],
+                        info="Choose segmentation backbone for water/road masks (SAM3 only).",
+                    )
+                    segmentation_max_side = gr.Slider(
+                        label="Segmentation max side (px)",
+                        value=defaults.segmentation_max_side,
+                        minimum=256,
+                        maximum=2048,
+                        step=32,
+                        info="Largest long-side resolution for running the segmentation model.",
+                    )
+                    segmentation_score_thresh = gr.Slider(
+                        label="Segmentation score threshold",
+                        value=defaults.segmentation_score_thresh,
+                        minimum=0.1,
+                        maximum=0.9,
+                        step=0.05,
+                        info="Minimum instance confidence from SAM3 to keep a mask.",
+                    )
+                    segmentation_mask_thresh = gr.Slider(
+                        label="Segmentation mask threshold",
+                        value=defaults.segmentation_mask_thresh,
+                        minimum=0.1,
+                        maximum=0.9,
+                        step=0.05,
+                        info="Pixel probability threshold when binarizing SAM3 masks.",
+                    )
+                with gr.Accordion("Advanced settings", open=False):
                     gr.Markdown("Adjust detail levels and scoring.")
                     clearance_factor = gr.Slider(
                         label="Clearance factor",
@@ -180,22 +261,6 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                         step=0.05,
                         info="Dilate unsafe regions relative to footprint size.",
                     )
-                    process_res_cap = gr.Slider(
-                        label="Depth max side (px)",
-                        value=defaults.process_res_cap,
-                        minimum=512,
-                        maximum=2048,
-                        step=32,
-                        info="Largest long-side resolution fed into the depth model.",
-                    )
-                    depth_smoothing_base = gr.Slider(
-                        label="Depth smoothing base",
-                        value=defaults.depth_smoothing_base,
-                        minimum=0.0,
-                        maximum=2.0,
-                        step=0.05,
-                        info="Base Gaussian sigma applied before flatness scoring.",
-                    )
                     coverage_strictness = gr.Slider(
                         label="Coverage strictness",
                         value=defaults.coverage_strictness,
@@ -220,49 +285,8 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                         step=0.05,
                         info="Lower values avoid visually textured (high-contrast) regions like tracks or debris.",
                     )
-                with gr.Accordion("Segmentation settings", open=False):
-                    gr.Markdown("Control SAM3 resolution and thresholds.")
-                    segmentation_max_side = gr.Slider(
-                        label="Segmentation max side (px)",
-                        value=defaults.segmentation_max_side,
-                        minimum=256,
-                        maximum=2048,
-                        step=32,
-                        info="Largest long-side resolution for running the segmentation model.",
-                    )
-                    segmentation_score_thresh = gr.Slider(
-                        label="Segmentation score threshold",
-                        value=defaults.segmentation_score_thresh,
-                        minimum=0.1,
-                        maximum=0.9,
-                        step=0.05,
-                        info="Minimum instance confidence from SAM3 to keep a mask.",
-                    )
-                    segmentation_mask_thresh = gr.Slider(
-                        label="Segmentation mask threshold",
-                        value=defaults.segmentation_mask_thresh,
-                        minimum=0.1,
-                        maximum=0.9,
-                        step=0.05,
-                        info="Pixel probability threshold when binarizing SAM3 masks.",
-                    )
-                with gr.Accordion("Camera settings", open=False):
-                    gr.Markdown("Configure capture assumptions for footprint sizing.")
-                    altitude_m = gr.Slider(
-                        label="Camera altitude (m)",
-                        value=defaults.altitude_m,
-                        minimum=10,
-                        maximum=1500,
-                        step=5,
-                    )
-                    fov_deg = gr.Slider(
-                        label="Camera FOV (deg)",
-                        value=defaults.fov_deg,
-                        minimum=30,
-                        maximum=150,
-                        step=1,
-                    )
-                with gr.Accordion("Layer overlays", open=False):
+                    # Plane removal fixed to least squares; toggle removed.
+                with gr.Accordion("Overlay settings", open=False):
                     gr.Markdown("Toggle visualization layers.")
                     base_view = gr.Dropdown(
                         label="Base view",
@@ -274,42 +298,54 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                             "Depth gradient",
                             "Gradient mask",
                             "Water mask",
+                            "Road mask",
+                            "Tree mask",
                             "Safety score",
                             "Safety heatmap overlay",
                         ],
                     )
-                    heat_on = gr.Checkbox(label="Safety highlights", value=True, info="Show safe landing mask (green).")
-                    heat_opacity = gr.Slider(
-                        label="Safety opacity",
-                        value=0.2,
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.05,
-                        info="Transparency for the safety highlight overlay.",
-                    )
-                    hazard_on = gr.Checkbox(
-                        label="Hazard highlights",
-                        value=True,
-                        info="Show excluded segmentation masks (water/roads/roofs) in red.",
-                    )
-                    hazard_opacity = gr.Slider(
-                        label="Hazard opacity",
-                        value=0.2,
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.05,
-                        info="Transparency for the hazard overlay.",
-                    )
+                    with gr.Row():
+                        heat_on = gr.Checkbox(label="Safety highlight", value=True, info="Show safe landing mask (green).")
+                        hazard_on = gr.Checkbox(label="Hazard highlight", value=False, info="Show hazard mask (red).")
+                    with gr.Row():
+                        water_on = gr.Checkbox(label="Water overlay", value=True, info="Color water masks blue.")
+                        road_on = gr.Checkbox(label="Road overlay", value=True, info="Color road masks orange.")
+                        tree_on = gr.Checkbox(label="Tree overlay", value=True, info="Color tree masks green.")
                     grad_on = gr.Checkbox(label="Depth gradient", value=False, info="Gradient magnitude overlay.")
-                    flat_on = gr.Checkbox(label="Flatness map", value=False, info="Flatness std map overlay.")
                     spot_on = gr.Checkbox(label="Show landing spot", value=True)
-            with gr.Column(scale=2, min_width=520):
+                with gr.Accordion("Camera settings", open=False):
+                    gr.Markdown("Configure capture assumptions for footprint sizing.")
+                    altitude_m = gr.Slider(
+                        label="Camera altitude (m)",
+                        value=defaults.altitude_m,
+                        minimum=10,
+                        maximum=1500,
+                        step=5,
+                    )
+                    fov_deg = gr.Slider(
+                        label="Camera FOV (deg)",
+                        value=defaults.fov_deg,
+                        minimum=30,
+                        maximum=150,
+                        step=1,
+                    )
+            with gr.Column(scale=2, min_width=520, elem_id="preview-wrap"):
                 main_view = gr.Image(
                     label="Preview",
                     height=720,
                     elem_id="main-preview",
                     show_fullscreen_button=False,
                 )
+                gr.HTML(
+                    """
+                    <div class="hover-legend">
+                      <div class="row"><span class="swatch" style="background: linear-gradient(90deg, #1e0a3c 0%, #fcfecf 100%);"></span><span>Continuous safety gradient</span></div>
+                      <div class="row"><span class="swatch" style="background: #00ff00;"></span><span>Safe outline</span></div>
+                      <div class="row"><span class="swatch" style="background: #007aff;"></span><span>Water hazards</span></div>
+                      <div class="row"><span class="swatch" style="background: #ff6200;"></span><span>Road hazards</span></div>
+                    </div>
+                    """
+                )
                 status_card = gr.Markdown("**Status:** Awaiting analysis.")
                 metrics_card = gr.Markdown("No metrics yet. Run the analyzer to get results.")
 
@@ -321,14 +357,16 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             use_water_mask,
             use_road_mask,
             use_roof_mask,
+            use_tree_mask,
             water_prompt,
             road_prompt,
+            tree_prompt,
             altitude_m,
             fov_deg,
             clearance_factor,
             process_res_cap,
-            depth_smoothing_base,
             segmentation_max_side,
+            segmentation_model_id,
             segmentation_score_thresh,
             segmentation_mask_thresh,
             coverage_strictness,
@@ -337,11 +375,11 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             texture_threshold,
             base_view,
             heat_on,
-            heat_alpha,
             hazard_on,
-            hazard_alpha,
+            water_on,
+            road_on,
+            tree_on,
             grad_on,
-            flat_on,
             spot_on,
         ):
             if not input_path:
@@ -358,14 +396,16 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                 use_water_mask,
                 use_road_mask,
                 use_roof_mask,
+                use_tree_mask,
                 water_prompt,
                 road_prompt,
+                tree_prompt,
                 altitude_m,
                 fov_deg,
                 clearance_factor,
                 process_res_cap,
-                depth_smoothing_base,
                 segmentation_max_side,
+                segmentation_model_id,
                 segmentation_score_thresh,
                 segmentation_mask_thresh,
                 coverage_strictness,
@@ -383,11 +423,15 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                 imgs,
                 base_view,
                 heat_on,
-                heat_alpha,
+                0.2,
                 hazard_on,
-                hazard_alpha,
+                0.2,
+                water_on,
+                road_on,
+                tree_on,
                 grad_on,
-                flat_on,
+                False,
+                False,
                 spot_on=spot_on,
             )
             return imgs, composed, _format_status(summary), _format_metrics(summary)
@@ -400,14 +444,16 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             use_water_mask,
             use_road_mask,
             use_roof_mask,
+            use_tree_mask,
             water_prompt,
             road_prompt,
+            tree_prompt,
             altitude_m,
             fov_deg,
             clearance_factor,
             process_res_cap,
-            depth_smoothing_base,
             segmentation_max_side,
+            segmentation_model_id,
             segmentation_score_thresh,
             segmentation_mask_thresh,
             coverage_strictness,
@@ -416,11 +462,11 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             texture_threshold,
             base_view,
             heat_on,
-            heat_opacity,
             hazard_on,
-            hazard_opacity,
+            water_on,
+            road_on,
+            tree_on,
             grad_on,
-            flat_on,
             spot_on,
         ]
 
@@ -435,11 +481,11 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             images_state,
             base_view,
             heat_on,
-            heat_opacity,
             hazard_on,
-            hazard_opacity,
+            water_on,
+            road_on,
+            tree_on,
             grad_on,
-            flat_on,
             spot_on,
         ]
 
@@ -447,11 +493,11 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
             images_state_val,
             base_view_val,
             heat_on_val,
-            heat_opacity_val,
             hazard_on_val,
-            hazard_opacity_val,
+            water_on_val,
+            road_on_val,
+            tree_on_val,
             grad_on_val,
-            flat_on_val,
             spot_on_val,
         ):
             if not images_state_val:
@@ -460,11 +506,15 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                 images_state_val,
                 base_view_val,
                 heat_on_val,
-                heat_opacity_val,
+                0.2,
                 hazard_on_val,
-                hazard_opacity_val,
+                0.2,
+                water_on_val,
+                road_on_val,
+                tree_on_val,
                 grad_on_val,
-                flat_on_val,
+                False,
+                False,
                 spot_on_val,
             )
             return images_state_val, composed, gr.update(), gr.update()
@@ -477,8 +527,10 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
         overlay_toggle_controls = (
             heat_on,
             hazard_on,
+            water_on,
+            road_on,
+            tree_on,
             grad_on,
-            flat_on,
             spot_on,
         )
         for control in overlay_toggle_controls:
@@ -487,170 +539,7 @@ def build_ui(analyzer: SafetyAnalyzer | None = None) -> gr.Blocks:
                 inputs=overlay_inputs,
                 outputs=[images_state, main_view, status_card, metrics_card],
             )
-        for slider in (heat_opacity, hazard_opacity):
-            slider.release(
-                fn=update_overlays_only,
-                inputs=overlay_inputs,
-                outputs=[images_state, main_view, status_card, metrics_card],
-            )
-
-        model_inputs = [
-            images_state,
-            input_path,
-            footprint_m,
-            std_thresh,
-            grad_thresh,
-            use_water_mask,
-            use_road_mask,
-            use_roof_mask,
-            water_prompt,
-            road_prompt,
-            altitude_m,
-            fov_deg,
-            clearance_factor,
-            process_res_cap,
-            depth_smoothing_base,
-            segmentation_max_side,
-            segmentation_score_thresh,
-            segmentation_mask_thresh,
-            coverage_strictness,
-            model_id,
-            base_view,
-            heat_on,
-            heat_opacity,
-            hazard_on,
-            hazard_opacity,
-            grad_on,
-            flat_on,
-            spot_on,
-            openness_weight,
-            texture_threshold,
-        ]
-
-        def update_preview_ui(*vals):
-            (
-                images_state_val,
-                input_path_val,
-                footprint_m_val,
-                std_thresh_val,
-                grad_thresh_val,
-                use_water_mask_val,
-                use_road_mask_val,
-                use_roof_mask_val,
-                water_prompt_val,
-                road_prompt_val,
-                altitude_m_val,
-                fov_deg_val,
-                clearance_factor_val,
-                process_res_cap_val,
-                depth_smoothing_base_val,
-                segmentation_max_side_val,
-                segmentation_score_thresh_val,
-                segmentation_mask_thresh_val,
-                coverage_strictness_val,
-                model_id_val,
-                base_view_val,
-                heat_on_val,
-                heat_opacity_val,
-                hazard_on_val,
-                hazard_opacity_val,
-                grad_on_val,
-                flat_on_val,
-                spot_on_val,
-                openness_weight_val,
-                texture_threshold_val,
-            ) = vals
-            path = Path(str(input_path_val))
-            imgs_val = images_state_val
-            summary_val: AnalysisSummary | None = None
-            if path.exists() and path.suffix.lower() in IMAGE_EXTS:
-                request = _make_request(
-                    footprint_m_val,
-                    std_thresh_val,
-                    grad_thresh_val,
-                    use_water_mask_val,
-                    use_road_mask_val,
-                    use_roof_mask_val,
-                    water_prompt_val,
-                    road_prompt_val,
-                    altitude_m_val,
-                    fov_deg_val,
-                    clearance_factor_val,
-                    process_res_cap_val,
-                    depth_smoothing_base_val,
-                    segmentation_max_side_val,
-                    segmentation_score_thresh_val,
-                    segmentation_mask_thresh_val,
-                    coverage_strictness_val,
-                    model_id_val,
-                    openness_weight_val,
-                    texture_threshold_val,
-                )
-                try:
-                    result = analyzer.process_path(path, request)
-                    imgs_val = result.images
-                    summary_val = result.summary
-                except Exception:
-                    imgs_val = images_state_val
-                    summary_val = None
-            if not imgs_val:
-                return images_state_val, gr.update(), gr.update(), gr.update()
-            composed = compose_view(
-                imgs_val,
-                base_view_val,
-                heat_on_val,
-                heat_opacity_val,
-                hazard_on_val,
-                hazard_opacity_val,
-                grad_on_val,
-                flat_on_val,
-                spot_on_val,
-            )
-            if summary_val is None:
-                status_txt = gr.update()
-                metrics_txt = gr.update()
-            else:
-                status_txt = _format_status(summary_val)
-                metrics_txt = _format_metrics(summary_val)
-            return imgs_val, composed, status_txt, metrics_txt
-
-        for control in (
-            input_path,
-            footprint_m,
-            std_thresh,
-            grad_thresh,
-            use_water_mask,
-            use_road_mask,
-            use_roof_mask,
-            altitude_m,
-            fov_deg,
-            clearance_factor,
-            model_id,
-            openness_weight,
-            texture_threshold,
-            segmentation_max_side,
-            segmentation_score_thresh,
-            segmentation_mask_thresh,
-        ):
-            control.change(
-                fn=update_preview_ui, inputs=model_inputs, outputs=[images_state, main_view, status_card, metrics_card]
-            )
-        for prompt_control in (water_prompt, road_prompt):
-            prompt_control.submit(
-                fn=update_preview_ui,
-                inputs=model_inputs,
-                outputs=[images_state, main_view, status_card, metrics_card],
-            )
-        coverage_strictness.release(
-            fn=update_preview_ui,
-            inputs=model_inputs,
-            outputs=[images_state, main_view, status_card, metrics_card],
-        )
-        depth_smoothing_base.release(
-            fn=update_preview_ui,
-            inputs=model_inputs,
-            outputs=[images_state, main_view, status_card, metrics_card],
-        )
+        # Opacity sliders removed; overlays now use fixed alpha.
 
     return demo
 

app/visualization.py

@@ -41,6 +41,30 @@ def make_safety_heatmap(
     return safe_img, hazard_img, score_gray
 
 
+def make_flatness_heatmap(std_map_vis: np.ndarray, target_size: tuple[int, int]) -> Image.Image:
+    # Normalize and map to a simple turbo-like palette
+    std_norm = std_map_vis
+    if std_norm.max() > std_norm.min():
+        std_norm = (std_norm - std_norm.min()) / (np.ptp(std_norm) + 1e-6)
+    cmap = np.array(
+        [
+            [48, 18, 59],
+            [65, 68, 135],
+            [42, 120, 142],
+            [34, 168, 132],
+            [122, 209, 81],
+            [253, 231, 36],
+        ],
+        dtype=np.float32,
+    )
+    idx = np.clip((std_norm * (len(cmap) - 1)).astype(np.int32), 0, len(cmap) - 1)
+    heat_rgb = cmap[idx]
+    heat_overlay = np.zeros((std_norm.shape[0], std_norm.shape[1], 4), dtype=np.uint8)
+    heat_overlay[..., :3] = heat_rgb.astype(np.uint8)
+    heat_overlay[..., 3] = (np.clip(std_norm, 0.0, 1.0) * 160).astype(np.uint8)
+    return Image.fromarray(heat_overlay, mode="RGBA").resize(target_size, resample=Image.BILINEAR)
+
+
 def build_result_layers(
     image: Image.Image,
     depth_raw: np.ndarray,
@@ -54,7 +78,7 @@ def build_result_layers(
     water_mask: np.ndarray | None,
     road_mask: np.ndarray | None,
     roof_mask: np.ndarray | None,
-    seg_mask_union: np.ndarray | None,
+    tree_mask: np.ndarray | None,
     hazard_mask: np.ndarray,
 ) -> Dict[str, Image.Image]:
     depth_vis = Image.fromarray(visualize_depth(depth_raw, cmap="Spectral")).resize(
@@ -76,9 +100,21 @@ def build_result_layers(
     water_mask_img = _mask_to_image(water_mask)
     road_mask_img = _mask_to_image(road_mask)
     roof_mask_img = _mask_to_image(roof_mask)
-    seg_mask_img = _mask_to_image(seg_mask_union) if seg_mask_union is not None else Image.new("L", image.size, 0)
+    tree_mask_img = _mask_to_image(tree_mask)
+
+    def _color_overlay(mask: np.ndarray | None, color: tuple[int, int, int]) -> Image.Image:
+        if mask is None:
+            return Image.new("RGBA", image.size, (0, 0, 0, 0))
+        m = Image.fromarray((mask.astype(np.uint8) * 255)).resize(image.size, resample=Image.NEAREST)
+        rgba = Image.new("RGBA", image.size, color + (255,))
+        return Image.composite(rgba, Image.new("RGBA", image.size, (0, 0, 0, 0)), m)
+
+    water_hazard_overlay = _color_overlay(water_mask, (0, 122, 255))  # blue
+    road_hazard_overlay = _color_overlay(road_mask, (255, 98, 0))  # orange/red
+    tree_hazard_overlay = _color_overlay(tree_mask, (34, 139, 34))  # forest green
 
     safe_overlay, hazard_overlay, heat_gray = make_safety_heatmap(image, safe_mask, hazard_mask, risk_map)
+    flat_heat_overlay = make_flatness_heatmap(std_map_vis, image.size)
 
     spot_overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
     draw = ImageDraw.Draw(spot_overlay)
@@ -123,6 +159,17 @@ def build_result_layers(
     box_draw = ImageDraw.Draw(overlay_box)
     fill = (0, 102, 255, 60)
     outline = (0, 102, 255, 255)
+
+    # Crosshair sized 3x the landing box for clearer focus.
+    cross_half = int(round(side_img * 1.5))
+    hx0 = max(0, cx_draw - cross_half)
+    hx1 = min(image.width - 1, cx_draw + cross_half)
+    hy0 = max(0, cy_draw - cross_half)
+    hy1 = min(image.height - 1, cy_draw + cross_half)
+    cross_width = 4
+    draw.line((hx0, cy_draw, hx1, cy_draw), fill=outline, width=cross_width)
+    draw.line((cx_draw, hy0, cx_draw, hy1), fill=outline, width=cross_width)
+
     box_draw.rectangle((bx0, by0, bx1, by1), fill=fill, outline=outline, width=4)
     box_draw.line((cx_draw, by0, cx_draw, by1), fill=outline, width=2)
     box_draw.line((bx0, cy_draw, bx1, cy_draw), fill=outline, width=2)
@@ -138,9 +185,13 @@ def build_result_layers(
         "Water mask": water_mask_img,
         "Road mask": road_mask_img,
         "Roof mask": roof_mask_img,
-        "Segmentation hazards": seg_mask_img,
+        "Tree mask": tree_mask_img,
         "Safety heatmap overlay": safe_overlay,
         "Hazard overlay": hazard_overlay,
+        "Water hazard overlay": water_hazard_overlay,
+        "Road hazard overlay": road_hazard_overlay,
+        "Tree hazard overlay": tree_hazard_overlay,
+        "Flatness heatmap overlay": flat_heat_overlay,
         "Safety score": heat_gray,
         "Landing spot overlay": Image.alpha_composite(spot_overlay, overlay_box),
     }
@@ -153,8 +204,12 @@ def compose_view(
     heat_alpha: float,
     hazard_on: bool,
     hazard_alpha: float,
+    water_on: bool,
+    road_on: bool,
+    tree_on: bool,
     grad_on: bool,
     flat_on: bool,
+    flat_heat_on: bool,
     spot_on: bool,
 ) -> Image.Image:
     import gradio as gr
@@ -170,24 +225,54 @@ def compose_view(
     out = base.convert("RGBA")
 
     if heat_on and "Safety heatmap overlay" in images_dict:
-        heat = images_dict["Safety heatmap overlay"]
-        if heat is not None:
-            heat_rgba = heat.convert("RGBA")
+        safe_overlay = images_dict["Safety heatmap overlay"]
+        if safe_overlay is not None:
+            safe_rgba = safe_overlay.convert("RGBA")
             alpha_factor = max(0.0, min(1.0, heat_alpha))
-            alpha_channel = np.array(heat_rgba.getchannel("A"), dtype=np.uint8)
+            alpha_channel = np.array(safe_rgba.getchannel("A"), dtype=np.uint8)
             alpha_channel = (alpha_channel.astype(np.float32) * alpha_factor).astype(np.uint8)
-            heat_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
-            out = Image.alpha_composite(out, heat_rgba)
+            safe_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
+            out = Image.alpha_composite(out, safe_rgba)
 
-    if hazard_on and "Segmentation hazards" in images_dict:
-        hazard = images_dict["Segmentation hazards"]
+    if hazard_on and "Hazard overlay" in images_dict:
+        hazard = images_dict.get("Hazard overlay")
         if hazard is not None:
-            mask = hazard.convert("L")
-            alpha = int(max(0.0, min(1.0, hazard_alpha)) * 255)
-            overlay = Image.new("RGBA", hazard.size, (0, 0, 0, 0))
-            pattern = Image.new("RGBA", hazard.size, (255, 0, 0, alpha))
-            overlay = Image.composite(pattern, overlay, mask)
-            out = Image.alpha_composite(out, overlay)
+            hazard_rgba = hazard.convert("RGBA")
+            alpha_factor = max(0.0, min(1.0, hazard_alpha))
+            alpha_channel = np.array(hazard_rgba.getchannel("A"), dtype=np.uint8)
+            alpha_channel = (alpha_channel.astype(np.float32) * alpha_factor).astype(np.uint8)
+            hazard_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
+            out = Image.alpha_composite(out, hazard_rgba)
+
+    if water_on and "Water hazard overlay" in images_dict:
+        water = images_dict.get("Water hazard overlay")
+        if water is not None:
+            water_rgba = water.convert("RGBA")
+            alpha_factor = max(0.0, min(1.0, hazard_alpha))
+            alpha_channel = np.array(water_rgba.getchannel("A"), dtype=np.uint8)
+            alpha_channel = (alpha_channel.astype(np.float32) * alpha_factor).astype(np.uint8)
+            water_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
+            out = Image.alpha_composite(out, water_rgba)
+
+    if road_on and "Road hazard overlay" in images_dict:
+        road = images_dict.get("Road hazard overlay")
+        if road is not None:
+            road_rgba = road.convert("RGBA")
+            alpha_factor = max(0.0, min(1.0, hazard_alpha))
+            alpha_channel = np.array(road_rgba.getchannel("A"), dtype=np.uint8)
+            alpha_channel = (alpha_channel.astype(np.float32) * alpha_factor).astype(np.uint8)
+            road_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
+            out = Image.alpha_composite(out, road_rgba)
+
+    if tree_on and "Tree hazard overlay" in images_dict:
+        tree = images_dict.get("Tree hazard overlay")
+        if tree is not None:
+            tree_rgba = tree.convert("RGBA")
+            alpha_factor = max(0.0, min(1.0, hazard_alpha))
+            alpha_channel = np.array(tree_rgba.getchannel("A"), dtype=np.uint8)
+            alpha_channel = (alpha_channel.astype(np.float32) * alpha_factor).astype(np.uint8)
+            tree_rgba.putalpha(Image.fromarray(alpha_channel, mode="L"))
+            out = Image.alpha_composite(out, tree_rgba)
 
     if grad_on and "Depth gradient" in images_dict:
         grad_img = images_dict["Depth gradient"]
@@ -203,6 +288,12 @@ def compose_view(
             flat_rgba.putalpha(int(FLAT_ALPHA * 255))
             out = Image.alpha_composite(out, flat_rgba)
 
+    if flat_heat_on and "Flatness heatmap overlay" in images_dict:
+        flat_heat = images_dict["Flatness heatmap overlay"]
+        if flat_heat is not None:
+            flat_heat_rgba = flat_heat.convert("RGBA")
+            out = Image.alpha_composite(out, flat_heat_rgba)
+
     if spot_on and "Landing spot overlay" in images_dict:
         spot = images_dict["Landing spot overlay"]
         if spot is not None:

app/water.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+
+def heuristic_water_mask(
+    rgb_np: np.ndarray,
+    grad_norm: np.ndarray,
+    texture_norm: np.ndarray | None = None,
+    max_side: int = 512,
+) -> np.ndarray | None:
+    """Cheap water detector using color, low texture, and flat depth cues."""
+    if rgb_np is None or grad_norm is None:
+        return None
+    h, w = rgb_np.shape[:2]
+    if h == 0 or w == 0:
+        return None
+
+    scale = min(1.0, float(max_side) / float(max(h, w)))
+    if scale < 1.0:
+        new_size = (max(1, int(round(w * scale))), max(1, int(round(h * scale))))
+        rgb_small = cv2.resize(rgb_np, new_size, interpolation=cv2.INTER_AREA)
+        grad_small = cv2.resize(grad_norm, new_size, interpolation=cv2.INTER_LINEAR)
+        tex_small = (
+            cv2.resize(texture_norm, new_size, interpolation=cv2.INTER_LINEAR) if texture_norm is not None else None
+        )
+    else:
+        rgb_small = rgb_np
+        grad_small = grad_norm
+        tex_small = texture_norm
+
+    hsv = cv2.cvtColor(rgb_small, cv2.COLOR_RGB2HSV)
+    h_ch, s_ch, v_ch = cv2.split(hsv)
+
+    hue_mask = (h_ch >= 80) & (h_ch <= 140)  # blues/cyans
+    sat_mask = s_ch > 40
+    val_mask = v_ch > 40
+    color_mask = hue_mask & sat_mask & val_mask
+
+    gray = cv2.cvtColor(rgb_small, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
+    gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
+    gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
+    texture = np.sqrt(gx * gx + gy * gy)
+    texture = cv2.GaussianBlur(texture, (0, 0), sigmaX=1.2, sigmaY=1.2)
+    if tex_small is None:
+        if texture.max() > texture.min():
+            tex_norm = (texture - texture.min()) / (np.ptp(texture) + 1e-6)
+        else:
+            tex_norm = np.zeros_like(texture)
+    else:
+        tex_norm = np.clip(tex_small.astype(np.float32), 0.0, 1.0)
+    low_texture = tex_norm < 0.35
+
+    depth_flat = grad_small < 0.08
+
+    mask = color_mask & low_texture & depth_flat
+
+    mask_uint = mask.astype(np.uint8)
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    try:
+        mask_uint = cv2.morphologyEx(mask_uint, cv2.MORPH_OPEN, kernel)
+        mask_uint = cv2.morphologyEx(mask_uint, cv2.MORPH_CLOSE, kernel)
+        mask_uint = cv2.dilate(mask_uint, kernel, iterations=1)
+    except Exception:
+        pass
+
+    if mask_uint.max() == 0:
+        return None
+
+    if (rgb_small.shape[0], rgb_small.shape[1]) != (h, w):
+        mask_uint = cv2.resize(mask_uint, (w, h), interpolation=cv2.INTER_NEAREST)
+    return mask_uint.astype(bool)
+
+
+__all__ = ["heuristic_water_mask"]

curated_gradio_app.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Launch the curated (precomputed) Landing Site Safety Gradio demo."""
+
+from __future__ import annotations
+
+import os
+
+from app.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()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=3.50
+numpy
+opencv-python
+Pillow
+pyyaml
+torch
+transformers>=4.39

scripts/precompute_curated.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Precompute curated demo outputs for the gallery mode.
+
+Given a sample manifest, this script runs the Landing Site Safety Analyzer on each
+image, saves the composed preview and RGB thumbnail, and writes an index.json that
+the curated Gradio app can serve instantly (CPU-friendly).
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+import numpy as np
+
+try:
+    import yaml  # type: ignore
+except ImportError as exc:  # pragma: no cover - dependency shim
+    raise SystemExit("pyyaml is required for curated manifest parsing (pip install pyyaml).") from exc
+from PIL import Image
+
+# Ensure repository root is on the path so `app` imports work when running the script directly
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))
+
+from app.config import DEFAULT_ANALYZER_SETTINGS, AnalyzerSettings, IMAGE_EXTS  # type: ignore  # noqa: E402
+from app.safety import AnalysisRequest, SafetyAnalyzer  # type: ignore  # noqa: E402
+from app.visualization import compose_view  # type: ignore  # noqa: E402
+
+
+def _load_manifest(path: Path) -> List[Dict[str, Any]]:
+    if not path.exists():
+        raise FileNotFoundError(f"Manifest not found: {path}")
+    with path.open("r") as f:
+        data = yaml.safe_load(f)
+    samples = data.get("samples") if isinstance(data, dict) else None
+    if not samples:
+        raise ValueError(f"No samples found in manifest: {path}")
+    entries: List[Dict[str, Any]] = []
+    for item in samples:
+        if not isinstance(item, dict):
+            continue
+        if "id" not in item or "path" not in item:
+            continue
+        entries.append(item)
+    if not entries:
+        raise ValueError(f"Manifest contained no usable entries: {path}")
+    return entries
+
+
+def _analysis_request_from_args(args: argparse.Namespace, source_path: Path) -> AnalysisRequest:
+    defaults = DEFAULT_ANALYZER_SETTINGS
+    resolve = lambda value, default: default if value is None else value  # noqa: E731
+
+    process_res_cap = int(resolve(args.process_res_cap, defaults.process_res_cap))
+    segmentation_max_side = int(resolve(args.segmentation_max_side, defaults.segmentation_max_side))
+    return AnalysisRequest(
+        footprint_m=float(resolve(args.footprint_m, defaults.footprint_m)),
+        std_thresh=float(resolve(args.std_thresh, defaults.std_thresh)),
+        grad_thresh=float(resolve(args.grad_thresh, defaults.grad_thresh)),
+        use_water_mask=bool(args.use_water_mask),
+        use_road_mask=bool(args.use_road_mask),
+        use_roof_mask=bool(args.use_roof_mask),
+        use_tree_mask=True,
+        water_prompt=resolve(args.water_prompt, defaults.water_prompt),
+        road_prompt=resolve(args.road_prompt, defaults.road_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)),
+        clearance_factor=float(resolve(args.clearance_factor, defaults.clearance_factor)),
+        process_res_cap=process_res_cap,
+        depth_smoothing_base=float(resolve(args.depth_smoothing_base, defaults.depth_smoothing_base)),
+        segmentation_model_id=resolve(args.segmentation_model_id, defaults.segmentation_model_id),
+        segmentation_max_side=segmentation_max_side,
+        segmentation_score_thresh=float(resolve(args.segmentation_score_thresh, defaults.segmentation_score_thresh)),
+        segmentation_mask_thresh=float(resolve(args.segmentation_mask_thresh, defaults.segmentation_mask_thresh)),
+        coverage_strictness=float(resolve(args.coverage_strictness, defaults.coverage_strictness)),
+        model_id=resolve(args.model_id, defaults.model_id),
+        openness_weight=float(resolve(args.openness_weight, defaults.openness_weight)),
+        texture_threshold=float(resolve(args.texture_threshold, defaults.texture_threshold)),
+        source_path=str(source_path),
+    )
+
+
+def _ensure_image(path: Path) -> Path:
+    if not path.exists():
+        raise FileNotFoundError(f"Sample image missing: {path}")
+    if path.suffix.lower() not in IMAGE_EXTS:
+        raise ValueError(f"Unsupported image type for curated sample: {path.name}")
+    return path
+
+
+def _save_image(img: Image.Image, path: Path, quality: int = 95) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    save_kwargs: Dict[str, Any] = {}
+    if path.suffix.lower() in (".jpg", ".jpeg"):
+        save_kwargs["quality"] = quality
+        save_kwargs["optimize"] = True
+    img.save(path, **save_kwargs)
+
+
+def _relative_to_base(path: Path, base: Path) -> str:
+    try:
+        return path.relative_to(base).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _to_builtin(obj: Any) -> Any:
+    """Recursively convert numpy/scalar types to JSON-friendly Python types."""
+    if isinstance(obj, np.generic):
+        return obj.item()
+    if isinstance(obj, dict):
+        return {k: _to_builtin(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_builtin(v) for v in obj]
+    return obj
+
+
+def precompute_curated(
+    manifest_path: Path,
+    output_root: Path,
+    args: argparse.Namespace,
+    base_view: str = "RGB",
+    heat_opacity: float = 0.2,
+    hazard_opacity: float = 0.2,
+) -> Path:
+    manifest_entries = _load_manifest(manifest_path)
+    output_root.mkdir(parents=True, exist_ok=True)
+    analyzer = SafetyAnalyzer()
+    index_entries: List[Dict[str, Any]] = []
+
+    for item in manifest_entries:
+        sample_id = item.get("id")
+        source_path = _ensure_image(Path(item.get("path")))
+        title = item.get("title") or sample_id
+        description = item.get("description") or ""
+        tags = item.get("tags") or []
+
+        request = _analysis_request_from_args(args, source_path)
+        print(f"[INFO] Processing {sample_id} -> {source_path}")
+        result = analyzer.process_path(source_path, request)
+        composed = compose_view(
+            result.images,
+            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,
+            grad_on=False,
+            flat_on=False,
+            flat_heat_on=False,
+            spot_on=True,
+        )
+
+        sample_dir = output_root / sample_id
+        rgb_path = sample_dir / "rgb.jpg"
+        composed_path = sample_dir / "composed.png"
+        summary_path = sample_dir / "summary.json"
+
+        summary_dict = _to_builtin(dataclasses.asdict(result.summary))
+
+        _save_image(result.images["RGB"], rgb_path)
+        _save_image(composed, composed_path, quality=98)
+        with summary_path.open("w") as f:
+            json.dump(summary_dict, f, indent=2)
+
+        entry = {
+            "id": sample_id,
+            "title": title,
+            "description": description,
+            "tags": tags,
+            "source_path": str(source_path),
+            "artifacts": {
+                "rgb": _relative_to_base(rgb_path, output_root),
+                "composed": _relative_to_base(composed_path, output_root),
+                "summary": _relative_to_base(summary_path, output_root),
+            },
+            "summary": summary_dict,
+            "request": _to_builtin(dataclasses.asdict(request)),
+        }
+        index_entries.append(entry)
+
+    index = {
+        "generated_at": datetime.utcnow().isoformat(timespec="seconds") + "Z",
+        "num_samples": len(index_entries),
+        "output_root": output_root.as_posix(),
+        "manifest": manifest_path.as_posix(),
+        "samples": index_entries,
+    }
+    index_path = output_root / "index.json"
+    with index_path.open("w") as f:
+        json.dump(index, f, indent=2)
+    print(f"[DONE] Wrote curated index: {index_path}")
+    return index_path
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="Precompute curated demo outputs.")
+    p.add_argument(
+        "--manifest",
+        type=Path,
+        default=Path("app/demo_assets/curated/samples.yaml"),
+        help="YAML manifest with curated sample definitions.",
+    )
+    p.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("app/demo_assets/curated/build"),
+        help="Directory to store curated outputs and index.json.",
+    )
+    # Analysis controls
+    p.add_argument("--model-id", type=str, help="DepthAnything3 model id to use.")
+    p.add_argument("--footprint-m", type=float, help="Landing footprint size in meters.")
+    p.add_argument("--std-thresh", type=float, help="Flatness threshold.")
+    p.add_argument("--grad-thresh", type=float, help="Gradient threshold.")
+    p.add_argument("--coverage-strictness", type=float, help="Coverage strictness for safe areas.")
+    p.add_argument("--openness-weight", type=float, help="Weight for distance-from-hazards when scoring.")
+    p.add_argument("--texture-threshold", type=float, help="Texture tolerance.")
+    p.add_argument("--clearance-factor", type=float, help="Clearance dilation multiplier.")
+    p.add_argument("--process-res-cap", type=int, help="Depth max resolution (long side).")
+    p.add_argument("--depth-smoothing-base", type=float, help="Base sigma for depth smoothing.")
+    p.add_argument("--segmentation-max-side", type=int, help="Segmentation max side.")
+    p.add_argument("--segmentation-model-id", type=str, help="Segmentation model id (e.g., facebook/sam3 or maskformer).")
+    p.add_argument("--segmentation-score-thresh", type=float, help="Segmentation score threshold.")
+    p.add_argument("--segmentation-mask-thresh", type=float, help="Segmentation mask threshold.")
+    p.add_argument("--altitude-m", type=float, help="Camera altitude in meters.")
+    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("--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.")
+    p.add_argument("--use-road-mask", action="store_true", dest="use_road_mask", help="Enable road mask.")
+    p.add_argument("--no-road-mask", action="store_false", dest="use_road_mask", help="Disable road mask.")
+    p.add_argument("--use-roof-mask", action="store_true", dest="use_roof_mask", default=True, help="Enable roof mask.")
+    p.add_argument("--no-roof-mask", action="store_false", dest="use_roof_mask", help="Disable roof mask.")
+    p.set_defaults(use_water_mask=True, use_road_mask=True)
+    p.add_argument("--cpu", action="store_true", help="Force CPU inference to avoid CUDA OOM.")
+    # View controls
+    p.add_argument("--base-view", type=str, default="RGB", help="Base view to compose (RGB/Depth/etc).")
+    p.add_argument("--heat-opacity", type=float, default=0.2, help="Safety overlay opacity.")
+    p.add_argument("--hazard-opacity", type=float, default=0.2, help="Hazard overlay opacity.")
+    return p
+
+
+if __name__ == "__main__":
+    parser = build_parser()
+    args = parser.parse_args()
+    if args.cpu:
+        import os
+
+        os.environ["CUDA_VISIBLE_DEVICES"] = ""
+    precompute_curated(
+        manifest_path=Path(args.manifest),
+        output_root=Path(args.output_dir),
+        args=args,
+        base_view=args.base_view,
+        heat_opacity=args.heat_opacity,
+        hazard_opacity=args.hazard_opacity,
+    )