Phase 0 DDA: APP_MODE, image library API, GeoTIFF ingest, dev UI

DEPLOYMENT.md

@@ -35,9 +35,11 @@ git remote set-url hf-dev https://huggingface.co/spaces/coderuday21/satdetect-de
 Push the current development code to the new Space:
 
 ```powershell
-git push hf-dev master:main
+git push hf-dev master:main --force
 ```
 
+> **First push only:** Hugging Face creates a starter README commit when you create the Space. Use `--force` once to replace it with your app. Later pushes can omit `--force`.
+
 Or run the helper script:
 
 ```powershell
@@ -99,18 +101,27 @@ Helper:
 
 ---
 
-## GitHub (optional mirror)
+## GitHub mirror
+
+**Repo:** https://github.com/Uday-at-Vedang/DDA.ChangeDetection  
+**Default branch on GitHub:** `main`
+
+Push the full app from local `master`:
+
+```powershell
+git push origin master:main
+```
 
-GitHub tracks `master` only:
+Push the production branch too:
 
 ```powershell
-git push origin master
+git push origin production:main-production
 ```
 
-You can add a `production` branch on GitHub too:
+Set upstream (once, after first push):
 
 ```powershell
-git push origin production
+git branch --set-upstream-to=origin/main master
 ```
 
 ---

Dockerfile

@@ -10,6 +10,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libsm6 \
     libxext6 \
     libxrender1 \
+    gdal-bin \
+    libgdal-dev \
     && rm -rf /var/lib/apt/lists/*
 
 # Create non-root user (required by Hugging Face Spaces)
@@ -19,8 +21,9 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=23
+ARG APP_BUILD=25
 ENV APP_BUILD=${APP_BUILD}
+ENV GDAL_CONFIG=/usr/bin/gdal-config
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V
 
 # Install Python dependencies

app/dda/__init__.py

@@ -0,0 +1 @@
+"""DDA change detection module (dev Space / APP_MODE=dda)."""

app/dda/bootstrap.py

@@ -0,0 +1,42 @@
+import logging
+
+from fastapi import FastAPI
+from sqlalchemy import text as sa_text
+
+from ..database import engine
+from .config import IS_DDA_MODE, ensure_library_dirs
+from .library_routes import router as library_router
+from .seed import seed_delhi_hierarchy
+
+logger = logging.getLogger(__name__)
+
+
+def init_dda_database():
+    """Run DDA-specific startup tasks (dirs, seed, migrations)."""
+    if not IS_DDA_MODE:
+        return
+    ensure_library_dirs()
+    try:
+        with engine.connect() as conn:
+            try:
+                conn.execute(sa_text("ALTER TABLE users ADD COLUMN role VARCHAR(32) DEFAULT 'analyst'"))
+                conn.commit()
+            except Exception:
+                conn.rollback()
+    except Exception as exc:
+        logger.warning("DDA user role migration skipped: %s", exc)
+
+    from ..database import SessionLocal
+    db = SessionLocal()
+    try:
+        seed_delhi_hierarchy(db)
+    finally:
+        db.close()
+
+
+def setup_dda(app: FastAPI) -> None:
+    if not IS_DDA_MODE:
+        logger.info("APP_MODE=legacy — DDA routes disabled")
+        return
+    app.include_router(library_router, prefix="/api/dda", tags=["dda"])
+    logger.info("APP_MODE=dda — DDA library routes enabled")

app/dda/config.py

@@ -0,0 +1,32 @@
+import os
+from pathlib import Path
+
+from ..database import DATA_DIR
+
+APP_MODE = os.environ.get("APP_MODE", "legacy").strip().lower()
+IS_DDA_MODE = APP_MODE == "dda"
+
+LIBRARY_DIR = DATA_DIR / "library"
+THUMBS_DIR = LIBRARY_DIR / "thumbs"
+PREVIEWS_DIR = LIBRARY_DIR / "previews"
+
+# GeoTIFF upload limit (DDA responsible for suitable resolution per SOW)
+MAX_GEOTIFF_BYTES = int(os.environ.get("MAX_GEOTIFF_MB", "500")) * 1024 * 1024
+
+ALLOWED_EXTENSIONS = {".tif", ".tiff", ".png", ".jpg", ".jpeg"}
+
+
+def ensure_library_dirs() -> None:
+    for d in (LIBRARY_DIR, THUMBS_DIR, PREVIEWS_DIR):
+        try:
+            d.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            pass
+
+
+def geotiff_io_available() -> bool:
+    try:
+        import rasterio  # noqa: F401
+        return True
+    except ImportError:
+        return False

app/dda/geotiff_io.py

@@ -0,0 +1,113 @@
+"""GeoTIFF ingest and preview generation (FR-02). Rasterio optional at import time."""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class IngestResult:
+    width: int
+    height: int
+    has_georef: bool
+    crs: str
+    bounds_wgs84: Optional[Tuple[float, float, float, float]]  # west, south, east, north
+    format: str
+
+
+def _read_with_rasterio(path: Path) -> IngestResult:
+    import rasterio
+    from rasterio.warp import transform_bounds
+
+    with rasterio.open(path) as src:
+        crs = str(src.crs) if src.crs else ""
+        has_georef = src.crs is not None
+        bounds = None
+        if has_georef and src.bounds:
+            try:
+                w, s, e, n = transform_bounds(src.crs, "EPSG:4326", *src.bounds)
+                bounds = (float(w), float(s), float(e), float(n))
+            except Exception as exc:
+                logger.warning("Could not transform bounds to WGS84: %s", exc)
+        return IngestResult(
+            width=int(src.width),
+            height=int(src.height),
+            has_georef=has_georef,
+            crs=crs,
+            bounds_wgs84=bounds,
+            format="geotiff",
+        )
+
+
+def _read_with_pillow(path: Path) -> IngestResult:
+    with Image.open(path) as img:
+        w, h = img.size
+    ext = path.suffix.lower()
+    fmt = "geotiff" if ext in (".tif", ".tiff") else "image"
+    return IngestResult(
+        width=w,
+        height=h,
+        has_georef=False,
+        crs="",
+        bounds_wgs84=None,
+        format=fmt,
+    )
+
+
+def inspect_image(path: Path) -> IngestResult:
+    ext = path.suffix.lower()
+    if ext in (".tif", ".tiff"):
+        try:
+            return _read_with_rasterio(path)
+        except ImportError:
+            logger.warning("rasterio not installed — GeoTIFF metadata limited")
+        except Exception as exc:
+            logger.warning("rasterio read failed (%s), falling back to Pillow", exc)
+    return _read_with_pillow(path)
+
+
+def raster_to_preview_png(src_path: Path, dest_path: Path, max_side: int = 512) -> None:
+    """Create RGB thumbnail/preview from GeoTIFF or raster image."""
+    ext = src_path.suffix.lower()
+    if ext in (".tif", ".tiff"):
+        try:
+            import numpy as np
+            import rasterio
+
+            with rasterio.open(src_path) as src:
+                count = min(3, src.count)
+                data = src.read(indexes=list(range(1, count + 1)))
+                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")
+                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")
+
+
+def bounds_to_json(bounds: Optional[Tuple[float, float, float, float]]) -> str:
+    if not bounds:
+        return ""
+    return json.dumps({"west": bounds[0], "south": bounds[1], "east": bounds[2], "north": bounds[3]})

app/dda/library_routes.py

@@ -0,0 +1,290 @@
+import json
+import logging
+import shutil
+import uuid
+from datetime import date, datetime
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
+from fastapi.responses import FileResponse
+from sqlalchemy.orm import Session
+
+from ..auth import get_or_create_guest_user
+from ..database import get_db
+from ..models import User
+from .config import (
+    ALLOWED_EXTENSIONS,
+    IS_DDA_MODE,
+    LIBRARY_DIR,
+    MAX_GEOTIFF_BYTES,
+    PREVIEWS_DIR,
+    THUMBS_DIR,
+    ensure_library_dirs,
+    geotiff_io_available,
+)
+from .geotiff_io import bounds_to_json, inspect_image, raster_to_preview_png
+from .models import DdaVillage, DdaZone, ImageAsset
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+def _require_dda():
+    if not IS_DDA_MODE:
+        raise HTTPException(status_code=404, detail="DDA mode is not enabled on this server")
+
+
+def _image_to_dict(asset: ImageAsset, zone_name: str = "", village_name: str = "") -> dict:
+    return {
+        "id": asset.id,
+        "uuid": asset.uuid,
+        "zoneId": asset.zone_id,
+        "zoneName": zone_name,
+        "villageId": asset.village_id,
+        "villageName": village_name,
+        "areaName": asset.area_name or "",
+        "year": asset.year,
+        "gridId": asset.grid_id or "",
+        "captureDate": asset.capture_date.isoformat() if asset.capture_date else None,
+        "source": asset.source,
+        "format": asset.format,
+        "originalFilename": asset.original_filename,
+        "hasGeoref": asset.has_georef,
+        "crs": asset.crs or "",
+        "bounds": json.loads(asset.bounds_json) if asset.bounds_json else None,
+        "width": asset.width,
+        "height": asset.height,
+        "fileSizeBytes": asset.file_size_bytes,
+        "thumbUrl": f"/api/dda/images/{asset.id}/thumb" if asset.thumb_path else None,
+        "createdAt": asset.created_at.isoformat() if asset.created_at else None,
+    }
+
+
+@router.get("/config")
+def dda_config():
+    _require_dda()
+    return {
+        "mode": "dda",
+        "maxUploadMb": MAX_GEOTIFF_BYTES // (1024 * 1024),
+        "geotiffEnabled": geotiff_io_available(),
+        "allowedExtensions": sorted(ALLOWED_EXTENSIONS),
+        "hierarchyMode": "admin",
+    }
+
+
+@router.get("/hierarchy")
+def get_hierarchy(db: Session = Depends(get_db)):
+    _require_dda()
+    zones = db.query(DdaZone).order_by(DdaZone.name).all()
+    tree = []
+    for zone in zones:
+        villages = (
+            db.query(DdaVillage)
+            .filter(DdaVillage.zone_id == zone.id)
+            .order_by(DdaVillage.name)
+            .all()
+        )
+        image_counts = {}
+        for v in villages:
+            cnt = db.query(ImageAsset).filter(ImageAsset.village_id == v.id).count()
+            if cnt:
+                image_counts[v.id] = cnt
+        tree.append({
+            "id": zone.id,
+            "name": zone.name,
+            "mode": zone.mode,
+            "villages": [
+                {
+                    "id": v.id,
+                    "name": v.name,
+                    "imageCount": image_counts.get(v.id, 0),
+                }
+                for v in villages
+            ],
+        })
+    return {"zones": tree}
+
+
+@router.get("/images")
+def list_images(
+    zone_id: Optional[int] = Query(None),
+    village_id: Optional[int] = Query(None),
+    year: Optional[int] = Query(None),
+    q: Optional[str] = Query(None),
+    db: Session = Depends(get_db),
+):
+    _require_dda()
+    query = db.query(ImageAsset).order_by(ImageAsset.created_at.desc())
+    if zone_id:
+        query = query.filter(ImageAsset.zone_id == zone_id)
+    if village_id:
+        query = query.filter(ImageAsset.village_id == village_id)
+    if year:
+        query = query.filter(ImageAsset.year == year)
+    if q:
+        like = f"%{q.strip()}%"
+        query = query.filter(
+            (ImageAsset.area_name.ilike(like))
+            | (ImageAsset.original_filename.ilike(like))
+            | (ImageAsset.grid_id.ilike(like))
+        )
+    assets = query.limit(200).all()
+    zone_map = {z.id: z.name for z in db.query(DdaZone).all()}
+    village_map = {v.id: v.name for v in db.query(DdaVillage).all()}
+    return [
+        _image_to_dict(
+            a,
+            zone_name=zone_map.get(a.zone_id, ""),
+            village_name=village_map.get(a.village_id, ""),
+        )
+        for a in assets
+    ]
+
+
+@router.get("/images/{image_id}")
+def get_image(image_id: int, db: Session = Depends(get_db)):
+    _require_dda()
+    asset = db.query(ImageAsset).filter(ImageAsset.id == image_id).first()
+    if not asset:
+        raise HTTPException(status_code=404, detail="Image not found")
+    zone_name = ""
+    village_name = ""
+    if asset.zone_id:
+        z = db.query(DdaZone).filter(DdaZone.id == asset.zone_id).first()
+        zone_name = z.name if z else ""
+    if asset.village_id:
+        v = db.query(DdaVillage).filter(DdaVillage.id == asset.village_id).first()
+        village_name = v.name if v else ""
+    return _image_to_dict(asset, zone_name=zone_name, village_name=village_name)
+
+
+@router.get("/images/{image_id}/thumb")
+def get_image_thumb(image_id: int, db: Session = Depends(get_db)):
+    _require_dda()
+    asset = db.query(ImageAsset).filter(ImageAsset.id == image_id).first()
+    if not asset or not asset.thumb_path:
+        raise HTTPException(status_code=404, detail="Thumbnail not found")
+    path = LIBRARY_DIR.parent / asset.thumb_path
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="Thumbnail file missing")
+    return FileResponse(path, media_type="image/png")
+
+
+@router.post("/images/upload")
+async def upload_image(
+    file: UploadFile = File(...),
+    zone_id: int = Form(...),
+    village_id: int = Form(...),
+    area_name: str = Form(""),
+    year: int = Form(...),
+    capture_date: str = Form(...),
+    source: str = Form("satellite"),
+    grid_id: str = Form(""),
+    manual_bounds_json: str = Form(""),
+    db: Session = Depends(get_db),
+):
+    _require_dda()
+    ensure_library_dirs()
+    user = get_or_create_guest_user(db)
+
+    zone = db.query(DdaZone).filter(DdaZone.id == zone_id).first()
+    village = db.query(DdaVillage).filter(DdaVillage.id == village_id, DdaVillage.zone_id == zone_id).first()
+    if not zone or not village:
+        raise HTTPException(status_code=400, detail="Invalid zone or village")
+
+    original = file.filename or "upload"
+    ext = Path(original).suffix.lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported format. Allowed: {', '.join(sorted(ALLOWED_EXTENSIONS))}",
+        )
+
+    raw = await file.read()
+    if not raw:
+        raise HTTPException(status_code=400, detail="File is empty")
+    if len(raw) > MAX_GEOTIFF_BYTES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large (max {MAX_GEOTIFF_BYTES // (1024 * 1024)} MB)",
+        )
+
+    try:
+        cap_date = date.fromisoformat(capture_date.strip())
+    except ValueError:
+        raise HTTPException(status_code=400, detail="capture_date must be YYYY-MM-DD")
+
+    if source not in ("satellite", "drone"):
+        raise HTTPException(status_code=400, detail="source must be satellite or drone")
+
+    asset_uuid = uuid.uuid4().hex
+    stored_name = f"{asset_uuid}{ext}"
+    dest_file = LIBRARY_DIR / str(year) / stored_name
+    dest_file.parent.mkdir(parents=True, exist_ok=True)
+    dest_file.write_bytes(raw)
+
+    ingest = inspect_image(dest_file)
+    has_georef = ingest.has_georef
+    manual_location = manual_bounds_json.strip()
+
+    if ext in (".tif", ".tiff") and not has_georef and not manual_location:
+        dest_file.unlink(missing_ok=True)
+        raise HTTPException(
+            status_code=400,
+            detail="GeoTIFF has no embedded georeferencing. Provide manual_bounds_json (west,south,east,north in WGS84).",
+        )
+
+    thumb_file = THUMBS_DIR / f"{asset_uuid}.png"
+    preview_file = PREVIEWS_DIR / f"{asset_uuid}.png"
+    try:
+        raster_to_preview_png(dest_file, thumb_file, max_side=256)
+        raster_to_preview_png(dest_file, preview_file, max_side=1024)
+    except Exception as exc:
+        dest_file.unlink(missing_ok=True)
+        raise HTTPException(status_code=400, detail=f"Could not generate preview: {exc}")
+
+    rel_file = str(dest_file.relative_to(LIBRARY_DIR.parent))
+    rel_thumb = str(thumb_file.relative_to(LIBRARY_DIR.parent))
+    rel_preview = str(preview_file.relative_to(LIBRARY_DIR.parent))
+
+    bounds_json = bounds_to_json(ingest.bounds_wgs84)
+    if not bounds_json and manual_location:
+        try:
+            parts = [float(x.strip()) for x in manual_location.replace("[", "").replace("]", "").split(",")]
+            if len(parts) == 4:
+                bounds_json = bounds_to_json(tuple(parts))
+        except (ValueError, TypeError):
+            pass
+
+    asset = ImageAsset(
+        uuid=asset_uuid,
+        zone_id=zone_id,
+        village_id=village_id,
+        area_name=area_name.strip(),
+        year=year,
+        grid_id=grid_id.strip(),
+        capture_date=cap_date,
+        source=source,
+        format=ingest.format,
+        original_filename=original,
+        file_path=rel_file,
+        thumb_path=rel_thumb,
+        preview_path=rel_preview,
+        crs=ingest.crs,
+        bounds_json=bounds_json,
+        has_georef=has_georef or bool(bounds_json),
+        manual_location_json=manual_location,
+        width=ingest.width,
+        height=ingest.height,
+        file_size_bytes=len(raw),
+        uploaded_by=user.id,
+    )
+    db.add(asset)
+    db.commit()
+    db.refresh(asset)
+
+    return {
+        "status": "success",
+        "image": _image_to_dict(asset, zone_name=zone.name, village_name=village.name),
+    }

app/dda/models.py

@@ -0,0 +1,90 @@
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import Boolean, Column, Date, DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from ..database import Base
+
+
+def _utcnow():
+    return datetime.now(timezone.utc)
+
+
+class DdaZone(Base):
+    __tablename__ = "dda_zones"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(128), unique=True, nullable=False, index=True)
+    mode = Column(String(32), default="admin")  # admin | grid_parent
+    created_at = Column(DateTime, default=_utcnow)
+
+    villages = relationship("DdaVillage", back_populates="zone", cascade="all, delete-orphan")
+
+
+class DdaVillage(Base):
+    __tablename__ = "dda_villages"
+
+    id = Column(Integer, primary_key=True, index=True)
+    zone_id = Column(Integer, ForeignKey("dda_zones.id"), nullable=False, index=True)
+    name = Column(String(128), nullable=False, index=True)
+    created_at = Column(DateTime, default=_utcnow)
+
+    zone = relationship("DdaZone", back_populates="villages")
+    images = relationship("ImageAsset", back_populates="village")
+
+
+class ImageAsset(Base):
+    """Centralized satellite / drone image (FR-01, FR-02)."""
+    __tablename__ = "dda_image_assets"
+
+    id = Column(Integer, primary_key=True, index=True)
+    uuid = Column(String(36), unique=True, nullable=False, default=lambda: str(uuid.uuid4()), index=True)
+    zone_id = Column(Integer, ForeignKey("dda_zones.id"), nullable=True, index=True)
+    village_id = Column(Integer, ForeignKey("dda_villages.id"), nullable=True, index=True)
+    area_name = Column(String(128), default="")
+    year = Column(Integer, nullable=True, index=True)
+    grid_id = Column(String(64), default="", index=True)
+
+    capture_date = Column(Date, nullable=True)
+    source = Column(String(32), default="satellite")  # satellite | drone
+    format = Column(String(32), default="geotiff")
+    original_filename = Column(String(255), default="")
+
+    file_path = Column(String(512), nullable=False)
+    thumb_path = Column(String(512), default="")
+    preview_path = Column(String(512), default="")
+
+    crs = Column(String(64), default="")
+    bounds_json = Column(Text, default="")  # WGS84 [west, south, east, north]
+    has_georef = Column(Boolean, default=False)
+    manual_location_json = Column(Text, default="")
+
+    width = Column(Integer, default=0)
+    height = Column(Integer, default=0)
+    file_size_bytes = Column(Integer, default=0)
+
+    uploaded_by = Column(Integer, ForeignKey("users.id"), nullable=True)
+    created_at = Column(DateTime, default=_utcnow)
+
+    zone = relationship("DdaZone")
+    village = relationship("DdaVillage", back_populates="images")
+
+
+class DetectionJob(Base):
+    """Async change detection job (FR-04 skeleton)."""
+    __tablename__ = "dda_detection_jobs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    status = Column(String(32), default="queued", index=True)  # queued|running|completed|failed
+    base_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=False)
+    comparison_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=False)
+    method = Column(String(64), default="AI-Based Deep Learning")
+    params_json = Column(Text, default="{}")
+    run_id = Column(Integer, ForeignKey("detection_runs.id"), nullable=True)
+    error_message = Column(Text, default="")
+    notify_email = Column(String(255), default="")
+    created_by = Column(Integer, ForeignKey("users.id"), nullable=True)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, default=_utcnow)

app/dda/seed.py

@@ -0,0 +1,30 @@
+import logging
+
+from sqlalchemy.orm import Session
+
+from .models import DdaVillage, DdaZone
+from .seed_data import DELHI_ZONES
+
+logger = logging.getLogger(__name__)
+
+
+def seed_delhi_hierarchy(db: Session) -> dict:
+    """Insert Zone → Village hierarchy if empty. Idempotent."""
+    existing = db.query(DdaZone).count()
+    if existing > 0:
+        return {"seeded": False, "zones": existing}
+
+    zones_created = 0
+    villages_created = 0
+    for zone_name, villages in DELHI_ZONES.items():
+        zone = DdaZone(name=zone_name, mode="admin")
+        db.add(zone)
+        db.flush()
+        zones_created += 1
+        for village_name in villages:
+            db.add(DdaVillage(zone_id=zone.id, name=village_name))
+            villages_created += 1
+
+    db.commit()
+    logger.info("DDA seed: %d zones, %d villages", zones_created, villages_created)
+    return {"seeded": True, "zones": zones_created, "villages": villages_created}

app/dda/seed_data.py

@@ -0,0 +1,60 @@
+"""Delhi administrative hierarchy — seeded into DB for DDA library (FR-01)."""
+
+DELHI_ZONES = {
+    "Central Delhi": [
+        "Karol Bagh", "Paharganj", "Daryaganj", "Rajinder Nagar", "Patel Nagar",
+        "Anand Parbat", "Bapa Nagar", "Prasad Nagar", "Dev Nagar", "Old Rajinder Nagar",
+    ],
+    "New Delhi": [
+        "Connaught Place", "Chanakyapuri", "Lodhi Road", "Mandi House",
+        "India Gate", "Khan Market", "Barakhamba", "Gole Market", "Sansad Marg",
+    ],
+    "North Delhi": [
+        "Civil Lines", "Model Town", "Sadar Bazaar", "Timarpur", "Gulabi Bagh",
+        "Kamla Nagar", "Shakti Nagar", "Roop Nagar", "Vijay Nagar", "Mukherjee Nagar",
+        "GTB Nagar", "Adarsh Nagar", "Azadpur", "Wazirabad",
+    ],
+    "North West Delhi": [
+        "Rohini", "Narela", "Bawana", "Alipur", "Shalimar Bagh",
+        "Pitampura", "Kanjhawala", "Mundka", "Sultanpuri", "Mangolpuri",
+        "Begumpur", "Pooth Kalan", "Holambi Kalan", "Bankner", "Siraspur",
+    ],
+    "North East Delhi": [
+        "Seelampur", "Jafrabad", "Mustafabad", "Babarpur", "Gokulpuri",
+        "Yamuna Vihar", "Karawal Nagar", "Dayalpur", "Khajuri Khas",
+        "Bhajanpura", "Harsh Vihar", "Brahmpuri", "Ghonda",
+    ],
+    "East Delhi": [
+        "Preet Vihar", "Laxmi Nagar", "Mayur Vihar Phase I", "Mayur Vihar Phase II",
+        "Mayur Vihar Phase III", "Patparganj", "Pandav Nagar", "Shakarpur",
+        "Mandawali", "Kalyanpuri", "Trilokpuri", "Kondli", "Gharoli",
+        "Khichripur", "Anand Vihar",
+    ],
+    "Shahdara": [
+        "Shahdara", "Vivek Vihar", "Dilshad Garden", "Seema Puri", "New Seelampur",
+        "Nand Nagri", "Harsh Vihar", "Jhilmil Colony", "Mansarovar Park",
+    ],
+    "South Delhi": [
+        "Hauz Khas", "Mehrauli", "Saket", "Kalkaji", "Greater Kailash",
+        "Malviya Nagar", "Vasant Kunj", "Chattarpur", "Lado Sarai",
+        "Fatehpur Beri", "Mandi Village", "Dera Village", "Aaya Nagar",
+        "Sultanpur", "Ghitorni", "Satbari", "Jonapur", "Asola",
+    ],
+    "South East Delhi": [
+        "Defence Colony", "Okhla", "Jamia Nagar", "Badarpur", "Jaitpur",
+        "Madanpur Khadar", "Sarita Vihar", "Jasola", "Sukhdev Vihar",
+        "Tughlakabad", "Sangam Vihar", "Mithapur", "Pul Pehlad",
+    ],
+    "South West Delhi": [
+        "Dwarka", "Najafgarh", "Kapashera", "Palam", "Dabri",
+        "Mahavir Enclave", "Bindapur", "Uttam Nagar", "Nasirpur",
+        "Chhawla", "Dichaon Kalan", "Ghumanhera", "Jhatikara",
+        "Rawta", "Pochanpur", "Bijwasan", "Sarangpur", "Paprawat",
+    ],
+    "West Delhi": [
+        "Rajouri Garden", "Janakpuri", "Tilak Nagar", "Vikaspuri",
+        "Hari Nagar", "Subhash Nagar", "Tagore Garden", "Moti Nagar",
+        "Kirti Nagar", "Punjabi Bagh", "Nangloi Jat", "Nilothi",
+        "Mundka", "Madipur", "Paschim Vihar",
+    ],
+}

app/main.py

@@ -27,6 +27,10 @@ from .auth import (
 )
 from .database import Base, engine, get_db, DATA_DIR
 from .models import User, DetectionRun
+from . import dda as _dda_pkg  # noqa: F401 — register DDA tables
+from .dda.models import DdaZone, DdaVillage, ImageAsset, DetectionJob  # noqa: F401
+from .dda.config import IS_DDA_MODE
+from .dda.bootstrap import init_dda_database, setup_dda
 from .notifier import send_notification, send_test_email
 
 import logging
@@ -66,18 +70,25 @@ try:
             except Exception:
                 conn.rollback()
     logger.info("Database initialization complete")
+    init_dda_database()
 except Exception as e:
     import logging
     logging.getLogger("uvicorn.error").warning("Startup migration skipped: %s", e)
 
-app = FastAPI(title="AI Change Detection", version="2.2.0")
+app = FastAPI(title="AI Change Detection", version="2.3.0-dda" if IS_DDA_MODE else "2.2.0")
+setup_dda(app)
 
 
 @app.get("/health")
 def health():
     """Lightweight health check so Hugging Face can mark the Space as running quickly."""
     from datetime import datetime
-    return {"status": "ok", "version": "2.2.0", "server_time_ist": _isoformat_ist(datetime.now(timezone.utc))}
+    return {
+        "status": "ok",
+        "version": "2.3.0-dda" if IS_DDA_MODE else "2.2.0",
+        "appMode": "dda" if IS_DDA_MODE else "legacy",
+        "server_time_ist": _isoformat_ist(datetime.now(timezone.utc)),
+    }
 
 
 @app.on_event("startup")
@@ -541,7 +552,10 @@ def delete_run(
 # --- Serve SPA ---
 @app.get("/", response_class=HTMLResponse)
 def index():
-    index_file = TEMPLATES_DIR / "index.html"
+    if IS_DDA_MODE:
+        index_file = TEMPLATES_DIR / "index_dda.html"
+    else:
+        index_file = TEMPLATES_DIR / "index.html"
     if not index_file.exists():
         return HTMLResponse("<h1>Satellite Change Detection</h1><p>Create <code>templates/index.html</code> and <code>static/</code>.</p>")
     return FileResponse(index_file)

docs/IMPLEMENTATION_PLAN_DDA.md

@@ -0,0 +1,583 @@
+# DDA Change Detection — Implementation Plan (Dev Space Only)
+
+**Document:** Scope of Work → Engineering Plan  
+**Client:** DDA (Delhi Development Authority)  
+**Target environment:** Hugging Face **`satdetect-dev`** only (`hf-dev` remote, `master` branch)  
+**Production (`satdetect`) must not receive these changes until explicit sign-off.**
+
+---
+
+## 1. Executive summary
+
+The SOW transforms the current “upload two PNGs → run detection → view history” demo into a **departmental change-monitoring system** with:
+
+- A **persistent image library** (GeoTIFF, hierarchical metadata, search)
+- **Library-driven comparison** (Base T1 vs Comparison T2)
+- **Async AI detection** with geo-referenced outputs
+- **Reports** (browser + PDF + email)
+- **Geo-navigation** and **clickable regions**
+- **Human review** (Confirmed / False Positive) and **export to departmental systems**
+
+The existing codebase is a strong **Phase-0 foundation**: AdaptFormer-based detection, region classification, overlay UI, email notifier, and history. Roughly **40% of FR-07** exists; **FR-01–FR-06 and FR-08 are largely net-new**.
+
+**Recommended approach:** Implement behind a **`APP_MODE=dda`** feature flag on dev, extend the database and API vertically, and keep production on the current simplified flow indefinitely.
+
+---
+
+## 2. SOW requirements → current state
+
+| ID | Requirement | Current state | Gap severity |
+|----|-------------|---------------|--------------|
+| **FR-01** | Centralized image library (Zone → Village → Area → Year or Grid) | Zone/Village are free-text dropdowns on upload; images discarded after run except thumbnails | **Large** |
+| **FR-02** | GeoTIFF upload + validation + manual georef fallback | PNG/JPEG only, 20 MB, Pillow RGB load | **Large** |
+| **FR-03** | Pick Base/Comparison from library or drag from tree | Local file upload only | **Medium** (depends on FR-01) |
+| **FR-04** | AI detection as background job; simplified change types; lat/lng per region | Synchronous `/api/detect`; rich internal taxonomy; pixel coords only | **Medium–Large** |
+| **FR-05** | In-app notification + report link; PDF export; persistent reports | Email optional; HTML modal report; no PDF; history exists | **Medium** |
+| **FR-06** | Navigate to change by lat/lng; Locate action | No geospatial metadata | **Large** (depends on FR-02) |
+| **FR-07** | Clickable regions auto-pan viewer; side-by-side Base/Comparison | Region row hover + compare slider partially exist | **Small–Medium** |
+| **FR-08** | Confirm / False Positive; submit to dept API or export | Not implemented | **Medium** |
+
+### SOW change-type mapping (canonical output)
+
+Map internal `detection_engine` labels → DDA report types:
+
+| DDA type | Internal sources (examples) |
+|----------|------------------------------|
+| **New Construction** | New Construction/Building, Temporary Structure, Road/Pavement Change (New) |
+| **Demolition** | Demolition/Clearing, Partial/Full Demolition |
+| **Extension** | Expansion, Widening, Renovation |
+| **Vegetation Change** | Vegetation Change (+ sub-types) |
+| **Other** | Water Body, Bare Land/Soil, Unclassified |
+
+Store both `dda_change_type` (report) and `internal_object_type` (model/debug) on each region.
+
+---
+
+## 3. Deployment & branching strategy
+
+```
+master (DDA features)  ──push──►  hf-dev  →  coderuday21/satdetect-dev
+production             ──push──►  hf       →  coderuday21/satdetect  (frozen)
+```
+
+### Dev-only safeguards
+
+1. **`APP_MODE` env var** on `satdetect-dev`: `dda` enables library, GeoTIFF, jobs, RBAC, review UI. Default / production: `legacy`.
+2. **Separate DB file** on dev: `data/dda_app.db` (avoid mixing guest history with library assets).
+3. **All new routes** under `/api/dda/*` or gated by `APP_MODE` in `main.py`.
+4. **CI checklist** before any production promote: diff must not touch DDA modules unless mode flag documented.
+
+---
+
+## 4. Target architecture
+
+```mermaid
+flowchart TB
+    subgraph ui [Frontend SPA]
+        LIB[Image Library Tree + Search]
+        CMP[Comparison Picker T1/T2]
+        JOB[Job Status / Notifications]
+        RPT[Report Viewer + PDF]
+        REV[Review Confirmed / FP]
+    end
+
+    subgraph api [FastAPI]
+        AUTH[RBAC Auth]
+        IMG[Image Library API]
+        DET[Detection Job API]
+        RPTAPI[Report + Export API]
+        DEPT[Department Export Adapter]
+    end
+
+    subgraph data [Storage]
+        DB[(SQLite / PostgreSQL)]
+        FS[File Store: GeoTIFF + pyramids + overlays]
+        JQ[Job Queue Table]
+    end
+
+    subgraph proc [Processing]
+        GEO[rasterio ingest + CRS normalize]
+        PIPE[detection_engine.run_detection]
+        GEOOUT[Region centroid → lat/lng]
+    end
+
+    LIB --> IMG
+    CMP --> DET
+    DET --> JQ
+    JQ --> proc
+    proc --> DB
+    proc --> FS
+    JOB --> DET
+    RPT --> RPTAPI
+    REV --> DEPT
+    AUTH --> api
+```
+
+---
+
+## 5. Data model (new & extended)
+
+### 5.1 Hierarchy (FR-01)
+
+Two organization modes (user selects at library root):
+
+**A. Administrative (default for DDA Delhi)**  
+`Zone` → `Village` → `Area` → `Year` → `[ImageAsset…]`
+
+**B. Grid**  
+`GridId` (e.g. `G-12-04`) → `Year` → `[ImageAsset…]`
+
+Implement as normalized tables (not hardcoded JS):
+
+```text
+zones(id, name, mode)           -- mode: admin | grid_parent
+villages(id, zone_id, name)     -- nullable for grid mode
+areas(id, village_id, name)
+library_years(id, area_id, year) -- optional grouping node; images also store year directly
+```
+
+For MVP, **Area** can be a free-text field on `ImageAsset` if DDA taxonomy is not finalized.
+
+### 5.2 `ImageAsset` (FR-01, FR-02)
+
+| Column | Purpose |
+|--------|---------|
+| `id`, `uuid` | Primary identifiers |
+| `zone_id`, `village_id`, `area_name`, `year`, `grid_id` | Hierarchy |
+| `capture_date` | Required metadata |
+| `source` | `satellite` \| `drone` |
+| `format` | `geotiff` |
+| `file_path`, `thumb_path`, `preview_path` | Storage |
+| `crs`, `bounds_json` | Geo metadata (WGS84 bbox) |
+| `width`, `height`, `file_size_bytes` | Validation |
+| `has_georef` | bool |
+| `manual_location_json` | Fallback corner coords + notes if no embedded georef |
+| `uploaded_by`, `created_at` | Audit |
+
+### 5.3 `DetectionJob` (FR-04 async)
+
+| Column | Purpose |
+|--------|---------|
+| `id`, `status` | `queued` \| `running` \| `completed` \| `failed` |
+| `base_image_id`, `comparison_image_id` | FK → ImageAsset |
+| `method`, `params_json` | Detection settings |
+| `run_id` | FK → DetectionRun when done |
+| `error_message`, `started_at`, `completed_at` | Job lifecycle |
+| `notify_email`, `notify_in_app` | FR-05 |
+
+### 5.4 Extend `DetectionRun`
+
+Add: `base_image_id`, `comparison_image_id`, `job_id`, `report_pdf_path`, `status` (`draft` \| `published`).
+
+### 5.5 Extend region JSON schema
+
+Each region gains:
+
+```json
+{
+  "ddaChangeType": "New Construction",
+  "confidence": 0.87,
+  "areaSqM": 142.5,
+  "centroid": { "x": 412, "y": 288 },
+  "latLng": { "lat": 28.6139, "lng": 77.2090 },
+  "bbox": { "x": 380, "y": 260, "w": 64, "h": 56 },
+  "reviewStatus": "pending",
+  "reviewedBy": null,
+  "reviewedAt": null
+}
+```
+
+### 5.6 `RegionReview` + export batch (FR-08)
+
+```text
+region_reviews(id, run_id, region_id, status, reviewer_id, notes, submitted_at)
+export_batches(id, run_id, format, payload_path, dept_api_response, created_at)
+```
+
+### 5.7 RBAC (FR-01, FR-02)
+
+Extend `User`:
+
+```text
+role: viewer | uploader | analyst | admin
+```
+
+| Role | View library | Upload | Run detection | Review/submit |
+|------|--------------|--------|---------------|---------------|
+| viewer | ✓ | | | |
+| uploader | ✓ | ✓ | | |
+| analyst | ✓ | ✓ | ✓ | ✓ |
+| admin | ✓ | ✓ | ✓ | ✓ + manage hierarchy |
+
+**Dev Space:** Re-enable login UI when `APP_MODE=dda`. Production stays guest/no-login.
+
+---
+
+## 6. API design (dev / DDA mode)
+
+### 6.1 Image library
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/dda/hierarchy` | Tree: zones → villages → areas → years (+ counts) |
+| `GET` | `/api/dda/images` | Filter: `zone`, `village`, `area`, `year`, `date_from`, `date_to`, `grid_id`, `q` |
+| `POST` | `/api/dda/images/upload` | Multipart GeoTIFF + metadata form |
+| `GET` | `/api/dda/images/{id}` | Metadata + thumb URL |
+| `GET` | `/api/dda/images/{id}/preview` | Downsampled PNG/Web tile for viewer |
+| `DELETE` | `/api/dda/images/{id}` | Admin only |
+
+**Upload validation (FR-02):**
+
+1. Extension `.tif` / `.tiff`
+2. Max size: **500 MB dev** (configurable; DDA responsible for suitable resolution per SOW)
+3. `rasterio.open()` — verify readable, extract CRS/transform
+4. If no georef: require `manual_bounds` (SW/NE lat-lng) + `capture_date` before commit
+5. Generate 512px thumbnail + 2048px preview for UI
+6. Return `{ id, status: "success" | "failed", errors[] }`
+
+### 6.2 Comparison & detection jobs
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/api/dda/jobs` | Body: `{ baseImageId, comparisonImageId, method?, notifyEmail? }` → `{ jobId }` |
+| `GET` | `/api/dda/jobs/{id}` | Status + progress + runId when complete |
+| `GET` | `/api/dda/jobs` | User's recent jobs (in-app notification feed) |
+| `POST` | `/api/dda/detect` | **Legacy sync path** for small previews only (keep for HF debugging) |
+
+**Job runner logic:**
+
+```text
+POST /jobs → insert DetectionJob(queued)
+           → return 202 + jobId
+Background worker thread:
+  1. Load ImageAsset paths via rasterio
+  2. Align pair (same CRS; reproject if needed)
+  3. Windowed read → RGB numpy arrays (max 1600px for DL)
+  4. run_detection(...)
+  5. For each region: pixel centroid → lat/lng via transform
+  6. Map object types → ddaChangeType
+  7. Save DetectionRun + overlay + update job completed
+  8. Fire notification (in-app row + optional email with report link)
+```
+
+**HF timeout mitigation:** Job endpoint returns immediately; worker runs in-process with status polling. For GeoTIFFs >60s, use **pyramid preview** for detection (DDA supplies suitable resolution) and store full metadata separately. Document in UI: “Analysis uses optimized resolution; full GeoTIFF retained in library.”
+
+### 6.3 Reports (FR-05)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/dda/reports/{run_id}` | Full report JSON (existing shape + geo fields) |
+| `GET` | `/api/dda/reports/{run_id}/pdf` | Generate/download PDF |
+| `POST` | `/api/dda/reports/{run_id}/notify` | Email with link to report |
+
+**PDF engine:** `weasyprint` or `reportlab` — HTML template reuse from `templates/ChangeDetection.html`.
+
+**In-app notification:** Bell icon + `/api/dda/jobs?status=completed&unseen=true`.
+
+### 6.4 Geo-navigation (FR-06, FR-07)
+
+No external map SDK required for MVP — **image viewer geo mode**:
+
+- Report shows `lat, lng` per region
+- **Locate** button: pan/zoom canvas to bbox center at 200% zoom, pulse highlight
+- Optional Phase 2: Leaflet minimap with footprint rectangle
+
+Frontend already has region hover → bbox highlight; extend to **click row → scroll viewer + zoom**.
+
+Side-by-side: keep existing compare slider; add locked **T1 | T2 | Overlay** tabs when images loaded from library.
+
+### 6.5 Review & departmental export (FR-08)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `PATCH` | `/api/dda/reports/{run_id}/regions/{region_id}` | `{ reviewStatus: confirmed \| false_positive, notes? }` |
+| `POST` | `/api/dda/reports/{run_id}/submit` | Submit confirmed only |
+| `GET` | `/api/dda/reports/{run_id}/export.{csv\|xlsx\|pdf}` | Structured export |
+
+**Department adapter pattern:**
+
+```python
+class DepartmentExporter(Protocol):
+    def submit(self, run: DetectionRun, regions: list) -> ExportResult: ...
+
+class ApiExporter(DepartmentExporter):      # DEPT_API_URL + DEPT_API_KEY
+class FileExporter(DepartmentExporter):     # CSV/XLSX fallback
+```
+
+False positives: persist in `region_reviews` with `status=false_positive` for future training export (`/api/dda/training/export` — admin only, Phase 2).
+
+---
+
+## 7. GeoTIFF processing pipeline (accurate logic)
+
+### 7.1 Ingest
+
+```python
+def ingest_geotiff(path: Path) -> GeoImageMeta:
+    with rasterio.open(path) as src:
+        crs = src.crs
+        bounds = transform_bounds(src.crs, "EPSG:4326", *src.bounds)
+        has_georef = crs is not None and src.transform != rasterio.identity()
+        # Prefer RGB or first 3 bands; handle 1-band grayscale
+        preview = read_downsampled(src, max_side=2048)
+    return meta
+```
+
+**Dependencies to add (dev only branch):** `rasterio`, `pyproj` (GDAL wheels on Docker).
+
+### 7.2 Pair compatibility check (before job starts)
+
+| Check | Action |
+|-------|--------|
+| Same CRS or reproject T2 → T1 CRS | Reproject comparison raster |
+| Overlapping bounds | Warn if <50% overlap |
+| Band count | Harmonize to RGB |
+| Resolution ratio | Warn if >2× GSD difference |
+
+### 7.3 Pixel → lat/lng
+
+```python
+def region_centroid_latlng(region_bbox, transform, crs):
+    cx = region_bbox.x + region_bbox.w / 2
+    cy = region_bbox.y + region_bbox.h / 2
+    lng, lat = rasterio.transform.xy(transform, cy, cx, offset="center")
+    if crs != EPSG:4326:
+        lng, lat = transform_coords(crs, 4326, lng, lat)
+    return lat, lng
+```
+
+### 7.4 Area in m²
+
+Use pixel area × GSD² from transform (for projected CRS in meters).
+
+---
+
+## 8. Frontend plan (dev UI)
+
+Replace single upload card with **tabbed workflow** when `APP_MODE=dda`:
+
+### Tab 1 — Image Library
+- Left: collapsible tree (Zone → Village → Area → Year)
+- Right: grid of thumbnails + metadata
+- Upload modal: GeoTIFF + form (hierarchy, capture date, source, manual bounds if needed)
+- Search bar + filters
+
+### Tab 2 — Change Detection
+- Two slots: **Base (T1)** | **Comparison (T2)**
+- Drag image from library OR picker dialog
+- Show thumb + capture date for each
+- Run → job submitted → progress spinner → auto-open report on complete
+
+### Tab 3 — Reports & Review
+- List of completed runs
+- Open report → regions table with DDA types, lat/lng, confidence, area
+- **Locate** per row; click row → pan viewer
+- Toggle Confirmed / False Positive
+- Submit to department / Download export
+
+### Tab 4 — Notifications
+- Job completion feed (FR-05 in-app)
+
+**Auth screens:** Login/register return on dev only (`APP_MODE=dda`).
+
+---
+
+## 9. Implementation phases
+
+### Phase 0 — Foundation (3–4 days)
+- [ ] `APP_MODE` flag + route gating in `main.py`
+- [ ] Alembic-style migrations or existing startup migrations for new tables
+- [ ] `rasterio` in `requirements.txt` + Docker GDAL base image update (dev Dockerfile branch)
+- [ ] Seed script: import current `DELHI_ZONES` into DB
+- [ ] Dev README section
+
+### Phase 1 — Image library (FR-01, FR-02) (5–7 days)
+- [ ] Models: hierarchy + ImageAsset
+- [ ] Upload API + validation + thumbnail generation
+- [ ] Library tree + search UI
+- [ ] RBAC: uploader vs viewer
+
+### Phase 2 — Library-based comparison (FR-03) (2–3 days)
+- [ ] T1/T2 picker from library
+- [ ] Drag-and-drop from tree to comparison slots
+- [ ] Preview + capture date display
+
+### Phase 3 — Async detection + geo output (FR-04, FR-06) (5–6 days)
+- [ ] DetectionJob worker + polling API
+- [ ] GeoTIFF → RGB pipeline integration with `detection_engine`
+- [ ] DDA change type mapping + lat/lng + area m² on regions
+- [ ] Job failure handling + user messaging
+
+### Phase 4 — Reports & notifications (FR-05) (3–4 days)
+- [ ] In-app notification feed
+- [ ] Report page (browser)
+- [ ] PDF export
+- [ ] Email with report deep link
+
+### Phase 5 — Interactive viewer (FR-07) (2–3 days)
+- [ ] Locate button + click-to-pan/zoom
+- [ ] Side-by-side T1/T2/overlay modes
+- [ ] Region highlight sync (extend existing hover logic)
+
+### Phase 6 — Review & export (FR-08) (4–5 days)
+- [ ] Per-region review state
+- [ ] CSV/XLSX/PDF export of confirmed changes
+- [ ] Department API adapter (config-driven)
+- [ ] False-positive archive for training
+
+### Phase 7 — Hardening & UAT (3–5 days)
+- [ ] Load test with sample GeoTIFFs from DDA
+- [ ] Alignment QA on drone vs satellite pairs
+- [ ] Security review (auth, upload limits, path traversal)
+- [ ] Deploy checklist for `satdetect-dev`
+
+**Total estimate:** ~25–35 working days (1 senior dev), assuming DDA provides sample GeoTIFFs and hierarchy taxonomy early.
+
+---
+
+## 10. Hugging Face dev constraints & mitigations
+
+| Constraint | Impact | Mitigation |
+|------------|--------|------------|
+| ~60s HTTP timeout (cpu-basic) | Sync detect fails on large TIFF | Async jobs + immediate 202 response; detection on downsampled preview |
+| Ephemeral disk | Library loss on rebuild | HF persistent storage volume; document backup to S3 optional |
+| No GPU | Slow DL | Keep AdaptFormer on CPU tiles; cap image size; queue one job at a time |
+| 50 GB space limit | Large GeoTIFF library | Per-file quota; admin purge; external blob store Phase 2 |
+| Single worker | No true queue | SQLite job lock; one `running` job at a time |
+
+**Dockerfile (dev):** Switch base to `osgeo/gdal:ubuntu-small` or install `libgdal` in existing image.
+
+---
+
+## 11. File / module layout (new code)
+
+```text
+app/
+├── dda/
+│   ├── __init__.py
+│   ├── config.py              # APP_MODE, limits, DEPT_API_*
+│   ├── models_library.py      # ImageAsset, hierarchy ORMs
+│   ├── models_jobs.py         # DetectionJob, RegionReview, ExportBatch
+│   ├── geotiff_io.py          # rasterio ingest, reproject, preview
+│   ├── geo_regions.py         # pixel→lat/lng, area m²
+│   ├── change_type_map.py     # internal → DDA types
+│   ├── job_runner.py          # async detection worker
+│   ├── library_routes.py      # FR-01, FR-02 API
+│   ├── jobs_routes.py         # FR-04 API
+│   ├── reports_routes.py      # FR-05, PDF
+│   ├── review_routes.py       # FR-08
+│   └── dept_export.py         # adapter pattern
+├── static/js/dda/
+│   ├── library.js
+│   ├── comparison.js
+│   ├── jobs.js
+│   └── review.js
+└── templates/
+    ├── index.html             # legacy (production)
+    └── index_dda.html         # dev SPA shell
+```
+
+Wire routers in `main.py`:
+
+```python
+if os.getenv("APP_MODE") == "dda":
+    app.include_router(library_routes.router, prefix="/api/dda")
+    ...
+```
+
+Set on **`satdetect-dev`** Space: `APP_MODE=dda`.  
+Leave **`satdetect`** unset → legacy behavior.
+
+---
+
+## 12. Testing strategy
+
+| Layer | Tests |
+|-------|-------|
+| GeoTIFF ingest | Unit: georef / no-georef / 1-band / 4-band samples |
+| Pair validation | CRS mismatch, non-overlap |
+| Job lifecycle | queued → running → completed/failed |
+| lat/lng accuracy | Known corner coords → centroid within tolerance |
+| DDA type mapping | Snapshot tests on classified regions |
+| RBAC | Role forbidden on upload/delete |
+| PDF | Report renders all mandatory fields |
+| E2E | Upload 2 TIFFs → job → report → confirm → CSV export |
+
+Use `scripts/validate_detection.py` extended with GeoTIFF fixtures.
+
+---
+
+## 13. Risks & dependencies
+
+| Risk | Owner | Mitigation |
+|------|-------|------------|
+| DDA GeoTIFF quality / GSD | DDA (per SOW) | Pre-upload validation messages |
+| No departmental API spec | DDA IT | File export fallback (FR-08) |
+| Area taxonomy not finalized | DDA | Configurable hierarchy admin UI |
+| Model accuracy on drone imagery | Shared | Alignment warnings; false-positive review loop |
+| HF CPU timeout | Engineering | Async jobs + downsample policy |
+
+**Blocked until DDA provides:**
+1. Sample GeoTIFF pairs (georeferenced + one without georef)
+2. Zone/Village/Area master list (or confirm Delhi list)
+3. Department API spec OR confirm export-only
+4. Grid definition if grid mode required at launch
+
+---
+
+## 14. Out of scope (explicit)
+
+- Training/fine-tuning new DL models (use existing AdaptFormer + review feedback archive for Phase 2)
+- Full GIS desktop analysis (QGIS replacement)
+- Real-time satellite ingestion feeds
+- Mobile native apps
+- Production deployment of DDA features (until UAT sign-off)
+
+---
+
+## 15. Immediate next steps
+
+1. **Create `satdetect-dev` Space env:** `APP_MODE=dda`
+2. **Phase 0 PR** to `master` → `git push hf-dev master:main`
+3. **Request from DDA:** 3 sample GeoTIFF pairs + hierarchy spreadsheet
+4. **Implement Phase 1** (library + upload) — highest dependency for all other FRs
+
+---
+
+## Appendix A — Legacy endpoint compatibility
+
+Keep existing endpoints working in legacy mode:
+
+| Legacy | DDA equivalent |
+|--------|----------------|
+| `POST /api/detect` (multipart files) | `POST /api/dda/jobs` (library IDs) |
+| `GET /api/history` | `GET /api/dda/reports` |
+| Guest user | RBAC users with roles |
+
+No breaking changes to production API contract.
+
+---
+
+## Appendix B — Sample job response
+
+```json
+{
+  "jobId": 42,
+  "status": "completed",
+  "runId": 108,
+  "reportUrl": "/api/dda/reports/108",
+  "summary": {
+    "regionsCount": 7,
+    "changePercentage": 2.34,
+    "byType": {
+      "New Construction": 3,
+      "Vegetation Change": 2,
+      "Other": 2
+    }
+  }
+}
+```
+
+---
+
+*Plan version 1.0 — derived from **Scope of Work_Change Detection-For Team.docx** (FR-01 through FR-08).*

docs/sow_extracted.txt

@@ -0,0 +1,93 @@
+Scope of Work
+The System will provide a simple workflow for change detection over satellite / drone imagery, covering the following:
+A centralized image library organized by Zone, Village, Area and Year (e.g., 2025, 2026), or on a Grid basis.
+Upload of satellite and drone images in TIF / TIFF format.
+A drag-and-drop interface to select two images (Base image and Comparison image) for analysis.
+AI-based change detection using pre-trained deep learning models.
+Notification to the end user along with a change detection report.
+Navigation to change locations based on latitude / longitude.
+Clickable change regions in the report, which pan the image viewer to the corresponding area.
+Typical use cases: monitoring of unauthorized construction, encroachment detection and land-use change monitoring.
+Functional Requirements
+All requirements below are Mandatory unless stated otherwise.
+FR-01: Centralized Image Library
+Requirement ID
+FR-01
+Title
+Centralized Satellite / Drone Image Library
+Description
+The System shall provide a centralized library to store, organize and search satellite and drone images, organized by Zone, Village, Area and Year, or on a Grid basis.
+Hierarchical organization: Zone → Village → Area → Year, maintained through image metadata.
+Basic metadata per image: image ID, capture date, source (satellite / drone), format and location reference.
+Browse (tree view) and search / filter by zone, village, area, year or capture date.
+Role-based access for viewing and uploading images.
+Providing images of suitable size and resolution for change detection shall be the responsibility of DDA.
+FR-02: Upload of Images
+Requirement ID
+FR-02
+Title
+Upload of Satellite / Drone Images
+Description
+The System shall allow authorized users to upload satellite and drone images in TIF / TIFF format with basic validation.
+Supported format: GeoTIFF (.tif / .tiff).
+Where georeferencing is not embedded, the user shall provide location reference and capture date before the image is saved.
+Upload success / failure status shall be shown to the user.
+FR-03: Selection of Two Images for Comparison
+Requirement ID
+FR-03
+Title
+Drag-and-Drop Selection of Two Images
+Description
+The System shall provide a drag-and-drop interface to select a Base (older) image and a Comparison (newer) image for change detection.
+Two clearly labelled drop targets: Base Image (T1) and Comparison Image (T2).
+Images can be dragged from the library or selected through a picker dialog.
+Thumbnail preview and capture dates of both images shown before analysis is started.
+FR-04: AI-Based Change Detection
+Requirement ID
+FR-04
+Title
+AI-Based Change Detection Using Pre-Trained Models
+Description
+The System shall run change detection on the selected image pair using pre-trained deep learning models, subject to the AI accuracy note above.
+Detected changes shall be shown as change regions with change type, approximate area and location (latitude / longitude) along with a model confidence score.
+Indicative change types: New Construction, Demolition, Extension, Vegetation Change, Other. The list may be refined during implementation.
+Detection runs as a background job; the user is informed when it completes.
+Output accuracy depends on image quality and model training maturity, as described in the AI accuracy note.
+FR-05: Notification and Change Detection Report
+Requirement ID
+FR-05
+Title
+Notification with Change Detection Report
+Description
+On completion of analysis, the System shall notify the user and provide a change detection report.
+In-application notification (email optional) with a link to the report.
+Report viewable in the browser and exportable to PDF.
+Reports remain available in the System for later reference.
+FR-06: Geo-Navigation to Change Locations
+Requirement ID
+FR-06
+Title
+Geo-Navigation Based on Latitude / Longitude
+Description
+The System shall allow the user to navigate to the location where a change has been found, based on its latitude / longitude.
+Each change record displays its coordinates in the report.
+A Locate action zooms / pans the viewer to that change location.
+FR-07: Clickable Change Regions
+Requirement ID
+FR-07
+Title
+Clickable Change Types / Regions with Auto-Pan
+Description
+Change regions in the report shall be clickable; on click, the viewer shall pan and zoom to the corresponding area of the image.
+Clicking a change record pans and highlights that region in the viewer.
+Side-by-side view of Base and Comparison images with the change overlay.
+FR-08: Entry of Confirmed Changes into the Departmental System
+Requirement ID
+FR-08
+Title
+Direct Entry of Reported Changes
+Description
+After review, the user shall be able to enter confirmed changes from the report into the departmental system for further action.
+The user verifies each change (Confirmed / False Positive) before submission; only confirmed changes are submitted.
+Submission via API where the departmental system provides one; otherwise a structured export (Excel / CSV / PDF) shall be generated for manual entry.
+False-positive markings are retained and used for future model training and improvement.

requirements.txt

@@ -15,3 +15,5 @@ numpy>=1.24.0
 opencv-python-headless>=4.8.0
 scikit-learn>=1.3.0
 requests>=2.28.0
+rasterio>=1.3.0
+pyproj>=3.6.0

scripts/push_hf_dev.ps1

@@ -14,5 +14,16 @@ if ($branch -ne "master") {
 }
 
 Write-Host "Pushing master -> hf-dev/main (satdetect-dev)..."
-git push hf-dev master:main
+$force = $args -contains "-Force" -or $args -contains "--force"
+if ($force) {
+    git push hf-dev master:main --force
+} else {
+    git push hf-dev master:main
+    if ($LASTEXITCODE -ne 0) {
+        Write-Host ""
+        Write-Host "Push rejected? Hugging Face may have a starter README commit."
+        Write-Host "Re-run with: .\scripts\push_hf_dev.ps1 -Force"
+        exit $LASTEXITCODE
+    }
+}
 Write-Host "Done. Dev app: https://huggingface.co/spaces/coderuday21/satdetect-dev"

static/css/dda.css

@@ -0,0 +1,139 @@
+/* DDA dev UI — extends style.css */
+
+.dda-app { max-width: 1400px; margin: 0 auto; padding: 1rem 1.25rem 2rem; }
+
+.dda-header {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-bottom: 1.25rem;
+}
+.dda-badge {
+  font-size: 0.7rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  padding: 0.15rem 0.45rem;
+  border-radius: 4px;
+  background: rgba(45, 212, 191, 0.15);
+  color: var(--grad-start);
+  margin-left: 0.5rem;
+}
+.dda-tabs { display: flex; gap: 0.35rem; flex-wrap: wrap; }
+.dda-tab {
+  padding: 0.45rem 0.9rem;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--bg-elevated);
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 0.88rem;
+  transition: all var(--transition);
+}
+.dda-tab:hover { border-color: var(--grad-start); color: var(--text); }
+.dda-tab.active {
+  background: linear-gradient(135deg, rgba(45,212,191,0.12), rgba(16,185,129,0.08));
+  border-color: var(--grad-start);
+  color: var(--grad-start);
+  font-weight: 600;
+}
+
+.dda-panel { display: none; }
+.dda-panel.active { display: block; }
+
+.dda-layout {
+  display: grid;
+  grid-template-columns: minmax(220px, 280px) 1fr;
+  gap: 1rem;
+  align-items: start;
+}
+@media (max-width: 900px) {
+  .dda-layout { grid-template-columns: 1fr; }
+}
+
+.dda-sidebar { position: sticky; top: 1rem; max-height: 70vh; overflow: auto; }
+.dda-search {
+  width: 100%;
+  margin-bottom: 0.75rem;
+  padding: 0.45rem 0.65rem;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--bg);
+  color: var(--text);
+  font-size: 0.88rem;
+}
+.dda-tree { font-size: 0.88rem; }
+.dda-tree-zone { margin-bottom: 0.5rem; }
+.dda-tree-zone > button {
+  width: 100%;
+  text-align: left;
+  padding: 0.35rem 0.5rem;
+  border: none;
+  background: transparent;
+  color: var(--text);
+  cursor: pointer;
+  border-radius: 4px;
+  font-weight: 600;
+}
+.dda-tree-zone > button:hover { background: var(--bg-hover); }
+.dda-tree-villages { padding-left: 0.75rem; display: none; }
+.dda-tree-zone.open .dda-tree-villages { display: block; }
+.dda-tree-village {
+  display: block;
+  width: 100%;
+  text-align: left;
+  padding: 0.3rem 0.5rem;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  border-radius: 4px;
+  font-size: 0.85rem;
+}
+.dda-tree-village:hover, .dda-tree-village.active {
+  background: var(--bg-hover);
+  color: var(--grad-start);
+}
+
+.dda-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+  gap: 0.75rem;
+  min-height: 80px;
+}
+.dda-card-img {
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  overflow: hidden;
+  background: var(--bg-elevated);
+  cursor: grab;
+  transition: border-color var(--transition);
+}
+.dda-card-img:hover { border-color: var(--grad-start); }
+.dda-card-img img { width: 100%; aspect-ratio: 1; object-fit: cover; display: block; }
+.dda-card-img .meta {
+  padding: 0.4rem 0.5rem;
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  line-height: 1.3;
+}
+
+.dda-compare-slots {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 1rem;
+  margin: 1rem 0;
+}
+.dda-slot {
+  border: 2px dashed var(--border);
+  border-radius: 10px;
+  padding: 1.5rem;
+  min-height: 140px;
+  text-align: center;
+}
+.dda-slot.filled { border-style: solid; border-color: var(--grad-start); }
+.dda-slot-label { display: block; font-weight: 600; margin-bottom: 0.5rem; }
+
+.dda-upload-form .location-row { margin-bottom: 0.5rem; }

static/js/dda/app.js

@@ -0,0 +1,115 @@
+const API = '';
+
+async function ddaApi(method, path, options = {}) {
+  const headers = { ...options.headers };
+  if (options.body && !(options.body instanceof FormData)) {
+    headers['Content-Type'] = 'application/json';
+  }
+  const res = await fetch(API + path, { method, headers, credentials: 'include', ...options });
+  const text = await res.text();
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch (_) {}
+  if (!res.ok) throw new Error(data?.detail || res.statusText || 'Request failed');
+  return data;
+}
+
+function showDdaError(msg) {
+  const el = document.getElementById('dda-error');
+  if (!el) return;
+  el.textContent = msg;
+  el.classList.remove('hidden');
+}
+function hideDdaError() {
+  document.getElementById('dda-error')?.classList.add('hidden');
+}
+function showDdaSuccess(msg) {
+  const el = document.getElementById('dda-success');
+  if (!el) return;
+  el.textContent = msg;
+  el.classList.remove('hidden');
+  setTimeout(() => el.classList.add('hidden'), 4000);
+}
+
+let ddaConfig = null;
+let ddaHierarchy = null;
+let selectedVillageId = null;
+let selectedZoneId = null;
+
+window.ddaState = {
+  get hierarchy() { return ddaHierarchy; },
+  get config() { return ddaConfig; },
+  get selectedVillageId() { return selectedVillageId; },
+  get selectedZoneId() { return selectedZoneId; },
+  setSelection(zoneId, villageId) {
+    selectedZoneId = zoneId;
+    selectedVillageId = villageId;
+  },
+  refreshImages: () => loadLibraryImages(),
+};
+
+document.querySelectorAll('.dda-tab').forEach((btn) => {
+  btn.addEventListener('click', () => {
+    document.querySelectorAll('.dda-tab').forEach((b) => b.classList.remove('active'));
+    document.querySelectorAll('.dda-panel').forEach((p) => p.classList.remove('active'));
+    btn.classList.add('active');
+    const tab = btn.dataset.tab;
+    document.getElementById('tab-' + tab)?.classList.add('active');
+  });
+});
+
+async function initDda() {
+  hideDdaError();
+  try {
+    ddaConfig = await ddaApi('GET', '/api/dda/config');
+    const hint = document.getElementById('lib-config-hint');
+    if (hint) {
+      hint.textContent = `Max ${ddaConfig.maxUploadMb} MB · GeoTIFF: ${ddaConfig.geotiffEnabled ? 'yes' : 'limited'}`;
+    }
+    ddaHierarchy = await ddaApi('GET', '/api/dda/hierarchy');
+    if (typeof renderHierarchy === 'function') renderHierarchy(ddaHierarchy);
+    if (typeof populateUploadSelects === 'function') populateUploadSelects(ddaHierarchy);
+    await loadLibraryImages();
+  } catch (err) {
+    showDdaError(err.message || 'Failed to load DDA configuration');
+  }
+}
+
+async function loadLibraryImages() {
+  const grid = document.getElementById('lib-grid');
+  if (!grid) return;
+  const q = document.getElementById('lib-filter')?.value?.trim() || '';
+  const params = new URLSearchParams();
+  if (selectedVillageId) params.set('village_id', String(selectedVillageId));
+  else if (selectedZoneId) params.set('zone_id', String(selectedZoneId));
+  if (q) params.set('q', q);
+  try {
+    const items = await ddaApi('GET', '/api/dda/images?' + params.toString());
+    if (!items.length) {
+      grid.innerHTML = '<p class="dim">No images yet. Upload a GeoTIFF or image above.</p>';
+      return;
+    }
+    grid.innerHTML = items.map((img) => `
+      <div class="dda-card-img" draggable="true" data-image-id="${img.id}" title="${img.originalFilename}">
+        ${img.thumbUrl ? `<img src="${img.thumbUrl}" alt="" loading="lazy" />` : '<div class="meta">No preview</div>'}
+        <div class="meta">
+          <strong>${img.year || '—'}</strong><br/>
+          ${img.captureDate || ''}<br/>
+          ${img.villageName || img.zoneName || ''}
+        </div>
+      </div>`).join('');
+    grid.querySelectorAll('.dda-card-img').forEach((card) => {
+      card.addEventListener('dragstart', (e) => {
+        e.dataTransfer.setData('text/plain', card.dataset.imageId);
+      });
+    });
+  } catch (err) {
+    grid.innerHTML = `<p class="dim">Could not load images: ${err.message}</p>`;
+  }
+}
+
+document.getElementById('lib-filter')?.addEventListener('input', () => {
+  clearTimeout(window._libFilterTimer);
+  window._libFilterTimer = setTimeout(loadLibraryImages, 300);
+});
+
+initDda();

static/js/dda/library.js

@@ -0,0 +1,127 @@
+function renderHierarchy(data) {
+  const tree = document.getElementById('lib-tree');
+  if (!tree || !data?.zones) return;
+  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
+
+  tree.innerHTML = data.zones
+    .filter((z) => !filter || z.name.toLowerCase().includes(filter) ||
+      z.villages.some((v) => v.name.toLowerCase().includes(filter)))
+    .map((zone) => `
+      <div class="dda-tree-zone" data-zone-id="${zone.id}">
+        <button type="button" class="dda-zone-toggle">${zone.name}</button>
+        <div class="dda-tree-villages">
+          ${zone.villages
+            .filter((v) => !filter || v.name.toLowerCase().includes(filter) || zone.name.toLowerCase().includes(filter))
+            .map((v) => `
+            <button type="button" class="dda-tree-village" data-zone-id="${zone.id}" data-village-id="${v.id}">
+              ${v.name}${v.imageCount ? ` (${v.imageCount})` : ''}
+            </button>`).join('')}
+        </div>
+      </div>`).join('');
+
+  tree.querySelectorAll('.dda-zone-toggle').forEach((btn) => {
+    btn.addEventListener('click', () => {
+      const zoneEl = btn.closest('.dda-tree-zone');
+      zoneEl?.classList.toggle('open');
+      const zoneId = parseInt(zoneEl?.dataset.zoneId, 10);
+      window.ddaState.setSelection(zoneId, null);
+      window.ddaState.refreshImages();
+    });
+  });
+
+  tree.querySelectorAll('.dda-tree-village').forEach((btn) => {
+    btn.addEventListener('click', () => {
+      tree.querySelectorAll('.dda-tree-village').forEach((b) => b.classList.remove('active'));
+      btn.classList.add('active');
+      btn.closest('.dda-tree-zone')?.classList.add('open');
+      window.ddaState.setSelection(
+        parseInt(btn.dataset.zoneId, 10),
+        parseInt(btn.dataset.villageId, 10),
+      );
+      window.ddaState.refreshImages();
+    });
+  });
+}
+
+document.getElementById('lib-tree-search')?.addEventListener('input', () => {
+  if (window.ddaState?.hierarchy) renderHierarchy(window.ddaState.hierarchy);
+});
+
+function populateUploadSelects(data) {
+  const zoneSel = document.getElementById('up-zone');
+  const villageSel = document.getElementById('up-village');
+  if (!zoneSel || !villageSel || !data?.zones) return;
+
+  zoneSel.innerHTML = '<option value="">— Select —</option>';
+  data.zones.forEach((z) => {
+    const opt = document.createElement('option');
+    opt.value = z.id;
+    opt.textContent = z.name;
+    zoneSel.appendChild(opt);
+  });
+
+  if (!zoneSel.dataset.bound) {
+    zoneSel.dataset.bound = '1';
+    zoneSel.addEventListener('change', () => {
+      const hierarchy = window.ddaState?.hierarchy;
+      const zid = parseInt(zoneSel.value, 10);
+      villageSel.innerHTML = '<option value="">— Select —</option>';
+      villageSel.disabled = !zid;
+      if (!zid || !hierarchy) return;
+      const zone = hierarchy.zones.find((z) => z.id === zid);
+      (zone?.villages || []).forEach((v) => {
+        const opt = document.createElement('option');
+        opt.value = v.id;
+        opt.textContent = v.name;
+        villageSel.appendChild(opt);
+      });
+    });
+  }
+}
+
+document.getElementById('form-upload')?.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  hideDdaError?.();
+  const fileInput = document.getElementById('up-file');
+  const file = fileInput?.files?.[0];
+  if (!file) {
+    showDdaError?.('Select a file to upload.');
+    return;
+  }
+
+  const form = new FormData();
+  form.append('file', file);
+  form.append('zone_id', document.getElementById('up-zone').value);
+  form.append('village_id', document.getElementById('up-village').value);
+  form.append('area_name', document.getElementById('up-area').value || '');
+  form.append('year', document.getElementById('up-year').value);
+  form.append('capture_date', document.getElementById('up-date').value);
+  form.append('source', document.getElementById('up-source').value);
+  form.append('manual_bounds_json', document.getElementById('up-manual-bounds').value || '');
+
+  const btn = document.getElementById('btn-upload');
+  btn.disabled = true;
+  btn.textContent = 'Uploading…';
+  try {
+    const data = await ddaApi('POST', '/api/dda/images/upload', { body: form });
+    showDdaSuccess?.(data?.status === 'success' ? 'Image uploaded to library.' : 'Upload complete.');
+    document.getElementById('form-upload').reset();
+    document.getElementById('up-year').value = '2025';
+    fileInput.value = '';
+    window.ddaState.hierarchy = await ddaApi('GET', '/api/dda/hierarchy');
+    renderHierarchy(window.ddaState.hierarchy);
+    populateUploadSelects(window.ddaState.hierarchy);
+    await window.ddaState.refreshImages();
+  } catch (err) {
+    showDdaError?.(err.message || 'Upload failed');
+  } finally {
+    btn.disabled = false;
+    btn.textContent = 'Upload to Library';
+  }
+});
+
+// Default capture date = today
+const dateInput = document.getElementById('up-date');
+if (dateInput && !dateInput.value) {
+  dateInput.value = new Date().toISOString().slice(0, 10);
+}

templates/index_dda.html

@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>DDA Change Detection</title>
+  <link rel="stylesheet" href="/static/css/style.css?v=30" />
+  <link rel="stylesheet" href="/static/css/dda.css?v=1" />
+</head>
+<body>
+  <div class="app dda-app">
+    <header class="dda-header">
+      <div class="app-brand">
+        <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="12" r="10"/><path d="M2 12h20"/><path d="M12 2a15.3 15.3 0 014 10 15.3 15.3 0 01-4 10 15.3 15.3 0 01-4-10 15.3 15.3 0 014-10z"/></svg>
+        <span>DDA Change Detection</span>
+        <span class="dda-badge">Dev</span>
+      </div>
+      <nav class="dda-tabs" role="tablist">
+        <button type="button" class="dda-tab active" data-tab="library" role="tab">Image Library</button>
+        <button type="button" class="dda-tab" data-tab="detect" role="tab">Change Detection</button>
+        <button type="button" class="dda-tab" data-tab="reports" role="tab">Reports</button>
+      </nav>
+    </header>
+
+    <div id="dda-error" class="alert alert-error hidden"></div>
+    <div id="dda-success" class="alert alert-success hidden"></div>
+
+    <!-- Tab: Image Library (FR-01, FR-02) -->
+    <section id="tab-library" class="dda-panel active" role="tabpanel">
+      <div class="dda-layout">
+        <aside class="dda-sidebar card">
+          <div class="card-header"><h3>Hierarchy</h3></div>
+          <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter zones…" />
+          <div id="lib-tree" class="dda-tree"><p class="dim">Loading…</p></div>
+        </aside>
+        <main class="dda-main">
+          <div class="card">
+            <div class="card-header">
+              <h3>Upload Image</h3>
+              <span class="dim" id="lib-config-hint"></span>
+            </div>
+            <form id="form-upload" class="dda-upload-form">
+              <div class="location-row">
+                <div class="form-group">
+                  <label for="up-zone">Zone</label>
+                  <select id="up-zone" required><option value="">— Select —</option></select>
+                </div>
+                <div class="form-group">
+                  <label for="up-village">Village / Area</label>
+                  <select id="up-village" required disabled><option value="">— Select zone —</option></select>
+                </div>
+                <div class="form-group">
+                  <label for="up-area">Area name</label>
+                  <input type="text" id="up-area" placeholder="Optional sub-area" />
+                </div>
+                <div class="form-group">
+                  <label for="up-year">Year</label>
+                  <input type="number" id="up-year" required min="2000" max="2100" value="2025" />
+                </div>
+              </div>
+              <div class="location-row">
+                <div class="form-group">
+                  <label for="up-date">Capture date</label>
+                  <input type="date" id="up-date" required />
+                </div>
+                <div class="form-group">
+                  <label for="up-source">Source</label>
+                  <select id="up-source"><option value="satellite">Satellite</option><option value="drone">Drone</option></select>
+                </div>
+                <div class="form-group">
+                  <label for="up-file">Image file</label>
+                  <input type="file" id="up-file" accept=".tif,.tiff,.png,.jpg,.jpeg" required />
+                </div>
+              </div>
+              <div class="form-group">
+                <label for="up-manual-bounds">Manual bounds (WGS84)</label>
+                <input type="text" id="up-manual-bounds" placeholder="west,south,east,north — required if GeoTIFF has no georef" />
+              </div>
+              <button type="submit" class="btn btn-primary" id="btn-upload">Upload to Library</button>
+            </form>
+          </div>
+          <div class="card">
+            <div class="card-header">
+              <h3>Library Images</h3>
+              <input type="search" id="lib-filter" class="dda-search" placeholder="Search…" />
+            </div>
+            <div id="lib-grid" class="dda-grid"><p class="dim">Select a village or upload an image.</p></div>
+          </div>
+        </main>
+      </div>
+    </section>
+
+    <!-- Tab: Change Detection (FR-03 placeholder — Phase 2) -->
+    <section id="tab-detect" class="dda-panel" role="tabpanel">
+      <div class="card">
+        <div class="card-header"><h3>Compare Images</h3></div>
+        <p class="sub">Select <strong>Base (T1)</strong> and <strong>Comparison (T2)</strong> from the library. Async job pipeline — Phase 2.</p>
+        <div class="dda-compare-slots">
+          <div class="dda-slot" id="slot-t1" data-slot="t1">
+            <span class="dda-slot-label">Base Image (T1)</span>
+            <p class="dim">Drag from library or click to pick</p>
+          </div>
+          <div class="dda-slot" id="slot-t2" data-slot="t2">
+            <span class="dda-slot-label">Comparison Image (T2)</span>
+            <p class="dim">Drag from library or click to pick</p>
+          </div>
+        </div>
+        <button type="button" class="btn btn-primary" id="btn-run-job" disabled>Run Detection (coming Phase 2)</button>
+      </div>
+    </section>
+
+    <!-- Tab: Reports (FR-05 placeholder) -->
+    <section id="tab-reports" class="dda-panel" role="tabpanel">
+      <div class="card">
+        <div class="card-header"><h3>Detection Reports</h3></div>
+        <p class="dim">Completed detection reports and PDF export — Phase 4.</p>
+        <div id="reports-list"></div>
+      </div>
+    </section>
+  </div>
+
+  <script src="/static/js/dda/app.js?v=1"></script>
+  <script src="/static/js/dda/library.js?v=1"></script>
+</body>
+</html>