Track examples for GitHub; drop HF front-matter; ignore scripts

.gitignore

@@ -3,4 +3,4 @@ __pycache__/
 .python-version
 data/
 *.pyc
-examples/
+scripts/

README.md

@@ -1,18 +1,13 @@
----
-title: Drone Landing Site Safety
-emoji: 🛰️
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
-pinned: false
----
-
 # Drone Landing Site Safety
 
 Analyze aerial RGB imagery to detect safe drone landing sites. Combines monocular depth estimation, promptable hazard segmentation, and geometric heuristics to flag flat, obstacle-free areas, with overlays and metrics that show why a spot is safe.
 
+<p align="center">
+  <img src="examples/build/visloc_03_0001/rgb.jpg" alt="RGB reference" width="80%" />
+  <br/>
+  <img src="examples/build/visloc_03_0001/composed.png" alt="Safety overlay" width="80%" />
+</p>
+
 ## What’s inside
 - **Main app (`app.py`)** — runs full inference with adjustable thresholds, overlays, and camera assumptions; requires >8GB VRAM (assuming default 1024 px processing resolution); runtime is ~2000 ms per image.
 

scripts/precompute_examples.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-"""Precompute example outputs for static distribution.
-
-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 for browsing.
-"""
-
-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 example 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),
-        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)),
-        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 example 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_examples(
-    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),
-            risk_on=True,
-            risk_alpha=float(hazard_opacity),
-            hazards_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 examples index: {index_path}")
-    return index_path
-
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(description="Precompute example outputs for distribution.")
-    p.add_argument(
-        "--manifest",
-        type=Path,
-        required=True,
-        help="YAML manifest with example sample definitions.",
-    )
-    p.add_argument(
-        "--output-dir",
-        type=Path,
-        default=Path("examples/build"),
-        help="Directory to store example 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("--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.")
-    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_examples(
-        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,
-    )