Fix dev Space startup: add missing DDA modules referenced by local_routes.

Includes detect_service, geo_regions, geotiff load_rgb_pil, and thumb fallbacks
that were omitted from the 5 GB upload commit.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -21,7 +21,7 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=30
+ARG APP_BUILD=31
 ENV MAX_GEOTIFF_MB=5120
 ENV APP_BUILD=${APP_BUILD}
 ENV GDAL_CONFIG=/usr/bin/gdal-config

app/dda/change_type_map.py

@@ -0,0 +1,44 @@
+"""Map internal detection_engine labels → DDA report change types (FR-04)."""
+from __future__ import annotations
+
+from typing import Optional
+
+DDA_NEW_CONSTRUCTION = "New Construction"
+DDA_DEMOLITION = "Demolition"
+DDA_EXTENSION = "Extension"
+DDA_VEGETATION = "Vegetation Change"
+DDA_OTHER = "Other"
+
+_KEYWORDS = [
+    (DDA_DEMOLITION, ("demolition", "clearing", "removed", "debris")),
+    (DDA_EXTENSION, ("expansion", "widening", "extension", "renovation", "addition")),
+    (DDA_VEGETATION, ("vegetation", "tree", "forest", "green", "crop")),
+    (DDA_NEW_CONSTRUCTION, (
+        "construction", "building", "structure", "road", "pavement",
+        "temporary", "roof", "concrete", "foundation",
+    )),
+    (DDA_OTHER, ("water", "bare", "soil", "land", "unclassified")),
+]
+
+
+def map_to_dda_change_type(internal_type: str) -> str:
+    """Return canonical DDA change type for a detection_engine object_type string."""
+    if not internal_type:
+        return DDA_OTHER
+    lower = internal_type.lower()
+    for dda_type, keywords in _KEYWORDS:
+        if any(kw in lower for kw in keywords):
+            return dda_type
+    if "new" in lower:
+        return DDA_NEW_CONSTRUCTION
+    return DDA_OTHER
+
+
+def enrich_region_for_dda(region: dict, *, dda_change_type: Optional[str] = None) -> dict:
+    """Add DDA report fields to a serialized region dict."""
+    internal = region.get("objectType") or region.get("object_type") or ""
+    out = dict(region)
+    out["ddaChangeType"] = dda_change_type or map_to_dda_change_type(internal)
+    out["internalObjectType"] = internal
+    out["reviewStatus"] = region.get("reviewStatus", "pending")
+    return out

app/dda/detect_service.py

@@ -0,0 +1,208 @@
+"""Run change detection and persist results (shared by upload + library paths)."""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import uuid
+from datetime import timezone
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image
+from sqlalchemy.orm import Session
+
+from ..auth import get_or_create_guest_user
+from ..database import DATA_DIR
+from ..models import DetectionRun
+from .geo_regions import bounds_from_image_path, enrich_regions_geo
+
+logger = logging.getLogger(__name__)
+
+OVERLAYS_DIR = DATA_DIR / "overlays"
+THUMB_MAX_SIZE = 200
+
+
+def _serialize_regions(change_regions) -> list:
+    return [
+        {
+            "id": int(r["id"]),
+            "area": int(r["area"]),
+            "center": {"x": int(r["center"][0]), "y": int(r["center"][1])},
+            "bbox": {
+                "x": int(r["bbox"][0]),
+                "y": int(r["bbox"][1]),
+                "w": int(r["bbox"][2]),
+                "h": int(r["bbox"][3]),
+            },
+            "objectType": str(r["object_type"]),
+            "confidence": float(r["confidence"]),
+            "severity": r.get("severity", "minor"),
+            "subType": r.get("sub_type"),
+            "subTypeConfidence": float(r["sub_type_confidence"])
+            if r.get("sub_type_confidence") is not None
+            else None,
+            "estimatedStories": r.get("estimated_stories"),
+            "estimatedHeightM": float(r["estimated_height_m"])
+            if r.get("estimated_height_m") is not None
+            else None,
+            "constructionStage": r.get("construction_stage"),
+        }
+        for r in change_regions
+    ]
+
+
+def _isoformat_ist(dt):
+    from datetime import timedelta
+    if dt is None:
+        return None
+    _IST = timezone(timedelta(hours=5, minutes=30))
+    if dt.tzinfo is None:
+        from datetime import timezone as tz
+        dt = dt.replace(tzinfo=tz.utc)
+    return dt.astimezone(_IST).isoformat()
+
+
+def run_detection_and_save(
+    db: Session,
+    before_pil: Image.Image,
+    after_pil: Image.Image,
+    *,
+    method: str = "AI-Based Deep Learning",
+    title: str = "Untitled run",
+    zone: str = "",
+    village: str = "",
+    enable_registration: bool = True,
+    enable_normalization: bool = True,
+    detection_sensitivity: float = 0.5,
+    min_region_area: Optional[int] = None,
+    notify_email: Optional[str] = None,
+    max_size: Optional[int] = None,
+    geo_bounds_path: Optional[Path] = None,
+) -> dict:
+    from ..detection_engine import run_detection
+
+    user = get_or_create_guest_user(db)
+    detection_sensitivity = max(0.0, min(1.0, float(detection_sensitivity)))
+    if min_region_area is not None:
+        min_region_area = int(max(50, min(10000, min_region_area)))
+
+    change_mask, result_image, stats, change_regions = run_detection(
+        before_pil,
+        after_pil,
+        method=method,
+        enable_registration=enable_registration,
+        enable_normalization=enable_normalization,
+        detection_sensitivity=detection_sensitivity,
+        min_region_area=min_region_area,
+        max_size=max_size,
+    )
+
+    # Save before image at detection resolution (matches overlay coordinates for slider)
+    from ..detection_engine import preprocess_image, get_detection_max_size
+
+    before_for_slider = Image.fromarray(
+        preprocess_image(before_pil, max_size=max_size or get_detection_max_size())
+    )
+
+    base_name = f"{user.id}_{uuid.uuid4().hex}"
+    overlay_filename = base_name + ".png"
+    overlay_path = OVERLAYS_DIR / overlay_filename
+    overlay_path.parent.mkdir(parents=True, exist_ok=True)
+    Image.fromarray(result_image).save(overlay_path)
+    relative_overlay = f"overlays/{overlay_filename}"
+
+    relative_before_full = ""
+    relative_before_thumb = ""
+    relative_after_thumb = ""
+    try:
+        before_full_file = OVERLAYS_DIR / f"{base_name}_before.png"
+        before_for_slider.save(before_full_file)
+        relative_before_full = f"overlays/{base_name}_before.png"
+        before_thumb_pil = before_pil.copy()
+        before_thumb_pil.thumbnail((THUMB_MAX_SIZE, THUMB_MAX_SIZE), Image.Resampling.LANCZOS)
+        before_thumb_pil.save(OVERLAYS_DIR / f"{base_name}_before_thumb.png")
+        after_thumb_pil = after_pil.copy()
+        after_thumb_pil.thumbnail((THUMB_MAX_SIZE, THUMB_MAX_SIZE), Image.Resampling.LANCZOS)
+        after_thumb_pil.save(OVERLAYS_DIR / f"{base_name}_after_thumb.png")
+        relative_before_thumb = f"overlays/{base_name}_before_thumb.png"
+        relative_after_thumb = f"overlays/{base_name}_after_thumb.png"
+    except Exception as exc:
+        logger.warning("Failed to save thumbnails: %s", exc)
+
+    regions_serializable = _serialize_regions(change_regions)
+    img_w, img_h = before_for_slider.size
+    bounds = bounds_from_image_path(geo_bounds_path) if geo_bounds_path else None
+    regions_serializable = enrich_regions_geo(
+        regions_serializable,
+        img_width=img_w,
+        img_height=img_h,
+        bounds=bounds,
+    )
+    total_px = int(stats["total_pixels"])
+    changed_px = int(stats["changed_pixels"])
+    change_pct = float(stats["change_percentage"])
+
+    run = DetectionRun(
+        user_id=user.id,
+        title=title,
+        method=method,
+        zone=zone,
+        village=village,
+        total_pixels=total_px,
+        changed_pixels=changed_px,
+        change_percentage=change_pct,
+        regions_count=len(change_regions),
+        overlay_path=relative_overlay,
+        before_full_path=relative_before_full,
+        before_thumb_path=relative_before_thumb,
+        after_thumb_path=relative_after_thumb,
+        regions_json=json.dumps(regions_serializable),
+    )
+    db.add(run)
+    db.commit()
+    db.refresh(run)
+
+    overlay_b64 = base64.b64encode(overlay_path.read_bytes()).decode("utf-8")
+    notification_sent = False
+    notification_error = None
+    if notify_email and notify_email.strip():
+        notification_sent, notification_error = send_notification(
+            recipient=notify_email.strip(),
+            title=title,
+            method=method,
+            zone=zone,
+            village=village,
+            change_pct=change_pct,
+            changed_px=changed_px,
+            total_px=total_px,
+            regions=regions_serializable,
+        )
+
+    return {
+        "id": run.id,
+        "title": run.title,
+        "method": run.method,
+        "zone": run.zone or "",
+        "village": run.village or "",
+        "statistics": {
+            "totalPixels": total_px,
+            "changedPixels": changed_px,
+            "unchangedPixels": int(stats["unchanged_pixels"]),
+            "changePercentage": change_pct,
+            "thresholdDebug": stats.get("threshold_debug", {}),
+            "params": stats.get("params", {}),
+            "alignmentWarning": stats.get("alignment_warning"),
+            "registrationOk": stats.get("params", {}).get("registration_ok"),
+        },
+        "regions": regions_serializable,
+        "overlayBase64Png": overlay_b64,
+        "overlayUrl": f"/api/overlay/{relative_overlay}",
+        "beforeFullUrl": f"/api/overlay/{relative_before_full}" if relative_before_full else None,
+        "beforeThumbUrl": f"/api/overlay/{relative_before_thumb}" if relative_before_thumb else None,
+        "afterThumbUrl": f"/api/overlay/{relative_after_thumb}" if relative_after_thumb else None,
+        "notificationSent": notification_sent,
+        "notificationError": notification_error,
+        "createdAt": _isoformat_ist(run.created_at),
+        "detectionMaxSide": max_size,
+    }

app/dda/geo_regions.py

@@ -0,0 +1,114 @@
+"""Pixel coordinates → WGS84 lat/lng for geo-referenced images (FR-04, FR-06)."""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from .change_type_map import enrich_region_for_dda
+from .geotiff_io import inspect_image
+
+logger = logging.getLogger(__name__)
+
+BoundsWGS84 = Tuple[float, float, float, float]  # west, south, east, north
+
+
+def parse_bounds(bounds: Any) -> Optional[BoundsWGS84]:
+    if bounds is None:
+        return None
+    if isinstance(bounds, (list, tuple)) and len(bounds) == 4:
+        return tuple(float(x) for x in bounds)
+    if isinstance(bounds, dict):
+        try:
+            return (
+                float(bounds["west"]),
+                float(bounds["south"]),
+                float(bounds["east"]),
+                float(bounds["north"]),
+            )
+        except (KeyError, TypeError, ValueError):
+            return None
+    if isinstance(bounds, str) and bounds.strip():
+        try:
+            data = json.loads(bounds)
+            return parse_bounds(data)
+        except json.JSONDecodeError:
+            parts = [float(x.strip()) for x in bounds.replace("[", "").replace("]", "").split(",")]
+            if len(parts) == 4:
+                return tuple(parts)
+    return None
+
+
+def bounds_from_image_path(path: Path) -> Optional[BoundsWGS84]:
+    try:
+        meta = inspect_image(path)
+        return meta.bounds_wgs84
+    except Exception as exc:
+        logger.warning("Could not read bounds for %s: %s", path.name, exc)
+        return None
+
+
+def pixel_to_lat_lng(
+    x: float,
+    y: float,
+    img_width: int,
+    img_height: int,
+    bounds: BoundsWGS84,
+) -> Optional[Dict[str, float]]:
+    if img_width <= 0 or img_height <= 0 or not bounds:
+        return None
+    west, south, east, north = bounds
+    lng = west + (float(x) / img_width) * (east - west)
+    lat = north - (float(y) / img_height) * (north - south)
+    return {"lat": round(lat, 6), "lng": round(lng, 6)}
+
+
+def bbox_area_sq_m(
+    bbox: Dict[str, int],
+    img_width: int,
+    img_height: int,
+    bounds: BoundsWGS84,
+) -> Optional[float]:
+    """Approximate region area in square metres using geographic bounds."""
+    if img_width <= 0 or img_height <= 0 or not bounds:
+        return None
+    west, south, east, north = bounds
+    m_per_px_x = abs(east - west) / img_width
+    m_per_px_y = abs(north - south) / img_height
+    # Rough conversion: 1 degree ≈ 111_320 m at equator; scale lng by cos(lat)
+    import math
+    mid_lat = (north + south) / 2.0
+    lat_scale = 111_320.0
+    lng_scale = 111_320.0 * math.cos(math.radians(mid_lat))
+    w_m = bbox.get("w", 0) * m_per_px_x * lng_scale
+    h_m = bbox.get("h", 0) * m_per_px_y * lat_scale
+    return round(w_m * h_m, 1)
+
+
+def enrich_regions_geo(
+    regions: List[dict],
+    *,
+    img_width: int,
+    img_height: int,
+    bounds: Optional[BoundsWGS84],
+) -> List[dict]:
+    """Add latLng, areaSqM, and DDA change type to each region."""
+    out = []
+    for region in regions:
+        enriched = enrich_region_for_dda(region)
+        center = region.get("center") or {}
+        cx = center.get("x", 0)
+        cy = center.get("y", 0)
+        if bounds:
+            lat_lng = pixel_to_lat_lng(cx, cy, img_width, img_height, bounds)
+            if lat_lng:
+                enriched["latLng"] = lat_lng
+            bbox = region.get("bbox") or {}
+            area_sq_m = bbox_area_sq_m(bbox, img_width, img_height, bounds)
+            if area_sq_m is not None:
+                enriched["areaSqM"] = area_sq_m
+        else:
+            enriched["latLng"] = None
+        out.append(enriched)
+    return out

app/dda/geotiff_io.py

@@ -9,6 +9,8 @@ from typing import Optional, Tuple
 
 from PIL import Image
 
+from .config import get_detection_max_side
+
 logger = logging.getLogger(__name__)
 
 
@@ -73,47 +75,94 @@ def inspect_image(path: Path) -> IngestResult:
     return _read_with_pillow(path)
 
 
+def write_placeholder_png(dest_path: Path, label: str = "Image", max_side: int = 256) -> None:
+    """Fallback thumb when GeoTIFF is too large or rasterio is unavailable."""
+    from PIL import ImageDraw
+
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    img = Image.new("RGB", (max_side, max_side), color=(32, 40, 52))
+    draw = ImageDraw.Draw(img)
+    lines = [label[:28], "preview N/A"]
+    y = max_side // 2 - 20
+    for line in lines:
+        draw.text((12, y), line, fill=(100, 200, 170))
+        y += 18
+    img.save(dest_path, format="PNG")
+
+
+def _rasterio_read_rgb(path: Path, max_side: int):
+    import numpy as np
+    import rasterio
+    from rasterio.enums import Resampling
+
+    with rasterio.open(path) as src:
+        count = min(3, src.count)
+        scale = min(1.0, max_side / max(src.width, src.height, 1))
+        out_h = max(1, int(src.height * scale))
+        out_w = max(1, int(src.width * scale))
+        data = src.read(
+            indexes=list(range(1, count + 1)),
+            out_shape=(count, out_h, out_w),
+            resampling=Resampling.bilinear,
+        )
+        if count == 1:
+            rgb = np.stack([data[0], data[0], data[0]])
+        else:
+            rgb = data[:3]
+        rgb = np.transpose(rgb, (1, 2, 0)).astype("float32")
+        if rgb.max() > 255 or rgb.min() < 0:
+            lo, hi = np.percentile(rgb, (2, 98))
+            rgb = np.clip((rgb - lo) / max(hi - lo, 1e-6), 0, 1) * 255
+        return Image.fromarray(rgb.astype("uint8"), mode="RGB")
+
+
+def load_rgb_pil(path: Path, max_side: Optional[int] = None) -> Image.Image:
+    """Load image as RGB PIL, downscaling large GeoTIFFs via rasterio."""
+    if max_side is None:
+        max_side = get_detection_max_side()
+    ext = path.suffix.lower()
+    if ext in (".tif", ".tiff"):
+        try:
+            img = _rasterio_read_rgb(path, max_side)
+            return img.copy()
+        except ImportError as exc:
+            raise RuntimeError(
+                "GeoTIFF support requires rasterio. Install with: pip install rasterio"
+            ) from exc
+        except Exception as exc:
+            raise RuntimeError(f"Could not read GeoTIFF: {exc}") from exc
+    with Image.open(path) as img:
+        img = img.convert("RGB")
+        if max(img.size) > max_side:
+            img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
+        return img.copy()
+
+
 def raster_to_preview_png(src_path: Path, dest_path: Path, max_side: int = 512) -> None:
     """Create RGB thumbnail/preview — uses decimated read for large GeoTIFFs."""
     ext = src_path.suffix.lower()
     if ext in (".tif", ".tiff"):
         try:
-            import numpy as np
-            import rasterio
-            from rasterio.enums import Resampling
-
-            with rasterio.open(src_path) as src:
-                count = min(3, src.count)
-                scale = min(1.0, max_side / max(src.width, src.height, 1))
-                out_h = max(1, int(src.height * scale))
-                out_w = max(1, int(src.width * scale))
-                data = src.read(
-                    indexes=list(range(1, count + 1)),
-                    out_shape=(count, out_h, out_w),
-                    resampling=Resampling.bilinear,
-                )
-                if count == 1:
-                    rgb = np.stack([data[0], data[0], data[0]])
-                else:
-                    rgb = data[:3]
-                rgb = np.transpose(rgb, (1, 2, 0)).astype("float32")
-                if rgb.max() > 255 or rgb.min() < 0:
-                    lo, hi = np.percentile(rgb, (2, 98))
-                    rgb = np.clip((rgb - lo) / max(hi - lo, 1e-6), 0, 1) * 255
-                img = Image.fromarray(rgb.astype("uint8"), mode="RGB")
-                if max(img.size) > max_side:
-                    img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
-                dest_path.parent.mkdir(parents=True, exist_ok=True)
-                img.save(dest_path, format="PNG")
-                return
+            img = _rasterio_read_rgb(src_path, max_side)
+            if max(img.size) > max_side:
+                img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            img.save(dest_path, format="PNG")
+            return
         except Exception as exc:
-            logger.warning("GeoTIFF preview via rasterio failed: %s", exc)
-
-    with Image.open(src_path) as img:
-        img = img.convert("RGB")
-        img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
-        dest_path.parent.mkdir(parents=True, exist_ok=True)
-        img.save(dest_path, format="PNG")
+            logger.warning("GeoTIFF preview failed for %s: %s", src_path.name, exc)
+            write_placeholder_png(dest_path, src_path.name, max_side)
+            return
+
+    try:
+        with Image.open(src_path) as img:
+            img = img.convert("RGB")
+            img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            img.save(dest_path, format="PNG")
+    except Exception as exc:
+        logger.warning("Preview failed for %s: %s", src_path.name, exc)
+        write_placeholder_png(dest_path, src_path.name, max_side)
 
 
 def bounds_to_json(bounds: Optional[Tuple[float, float, float, float]]) -> str:

app/dda/local_library.py

@@ -23,7 +23,7 @@ from urllib.parse import quote
 from fastapi import HTTPException
 
 from .config import ALLOWED_EXTENSIONS, LOCAL_THUMB_CACHE, get_library_roots
-from .geotiff_io import inspect_image, raster_to_preview_png
+from .geotiff_io import inspect_image, raster_to_preview_png, write_placeholder_png
 
 logger = logging.getLogger(__name__)
 
@@ -157,11 +157,16 @@ def thumb_cache_path(relative_path: str) -> Path:
 def get_or_build_thumb(relative_path: str, max_side: int = 256) -> Path:
     full = safe_resolve(relative_path)
     cache = thumb_cache_path(relative_path)
-    if cache.exists() and cache.stat().st_mtime >= full.stat().st_mtime:
+    try:
+        if cache.exists() and cache.stat().st_mtime >= full.stat().st_mtime:
+            return cache
+        cache.parent.mkdir(parents=True, exist_ok=True)
+        raster_to_preview_png(full, cache, max_side=max_side)
+        return cache
+    except Exception as exc:
+        logger.warning("Thumb build failed for %s: %s", relative_path, exc)
+        write_placeholder_png(cache, Path(relative_path).name, max_side)
         return cache
-    cache.parent.mkdir(parents=True, exist_ok=True)
-    raster_to_preview_png(full, cache, max_side=max_side)
-    return cache
 
 
 def ensure_root() -> None: