Raise library GeoTIFF upload limit to 5 GB on dev.

Default MAX_GEOTIFF_MB to 5120, stream uploads with GB-aware errors,
client-side size check, and longer keep-alive for large file transfers.

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

DEPLOYMENT.md

@@ -134,7 +134,7 @@ Set these in each Space’s **Settings → Repository secrets / Variables** if n
 |----------|---------|
 | `APP_MODE` | Set to `dda` on **satdetect-dev** only (enables DDA library UI) |
 | `LOCAL_LIBRARY_ROOT` | Path to year folders (default: `library_sources/` in project) |
-| `MAX_GEOTIFF_MB` | Library GeoTIFF upload cap (default **2048** = 2 GB on dev) |
+| `MAX_GEOTIFF_MB` | Library GeoTIFF upload cap (default **5120** = 5 GB on dev) |
 | `MAX_IMAGE_MB` | PNG/JPEG library cap (default 50 MB) |
 | `SECRET_KEY` | Optional legacy JWT setting (login disabled) |
 | `DATABASE_URL` | PostgreSQL instead of SQLite (optional) |

Dockerfile

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

app/dda/config.py

@@ -58,8 +58,8 @@ THUMBS_DIR = LIBRARY_DIR / "thumbs"
 PREVIEWS_DIR = LIBRARY_DIR / "previews"
 LOCAL_THUMB_CACHE = DATA_DIR / "library_cache" / "thumbs"
 
-# GeoTIFF library upload limit (default 2 GB; override with MAX_GEOTIFF_MB on HF dev Space)
-MAX_GEOTIFF_BYTES = int(os.environ.get("MAX_GEOTIFF_MB", "2048")) * 1024 * 1024
+# GeoTIFF library upload limit (default 5 GB; override with MAX_GEOTIFF_MB on HF dev Space)
+MAX_GEOTIFF_BYTES = int(os.environ.get("MAX_GEOTIFF_MB", "5120")) * 1024 * 1024
 
 # Raster sidecar formats (PNG/JPEG) — smaller cap for library uploads
 MAX_IMAGE_BYTES = int(os.environ.get("MAX_IMAGE_MB", "50")) * 1024 * 1024
@@ -104,3 +104,13 @@ def geotiff_io_available() -> bool:
         return True
     except ImportError:
         return False
+
+
+def get_detection_max_side() -> int:
+    """Max pixel dimension for GeoTIFF load + detection pipeline (higher = sharper, more RAM)."""
+    default = "2048" if is_hf_hosted() else "4096"
+    try:
+        value = int(os.environ.get("DETECTION_MAX_SIDE", default))
+    except ValueError:
+        value = int(default)
+    return max(1024, min(8192, value))

app/dda/library_routes.py

@@ -72,6 +72,7 @@ def dda_config():
         "maxUploadMb": MAX_GEOTIFF_BYTES // (1024 * 1024),
         "maxUploadGb": round(max_gb, 2),
         "maxGeotiffMb": MAX_GEOTIFF_BYTES // (1024 * 1024),
+        "maxGeotiffBytes": MAX_GEOTIFF_BYTES,
         "maxImageMb": MAX_IMAGE_BYTES // (1024 * 1024),
         "geotiffEnabled": geotiff_io_available(),
         "allowedExtensions": sorted(ALLOWED_EXTENSIONS),

app/dda/local_routes.py

@@ -3,12 +3,20 @@ import logging
 from pathlib import Path
 from typing import Optional
 
-from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
 from fastapi.responses import FileResponse
+from PIL import Image
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from .detect_service import run_detection_and_save
+from .geotiff_io import load_rgb_pil
 
 from .config import (
     IS_DDA_MODE,
+    MAX_GEOTIFF_BYTES,
     geotiff_io_available,
+    get_detection_max_side,
     get_library_roots,
     get_writable_library_root,
     is_hf_hosted,
@@ -69,6 +77,10 @@ def local_library_config():
         "writablePath": writable,
         "instructions": instructions,
         "geotiffEnabled": geotiff_io_available(),
+        "detectionMaxSide": get_detection_max_side(),
+        "maxGeotiffMb": MAX_GEOTIFF_BYTES // (1024 * 1024),
+        "maxGeotiffBytes": MAX_GEOTIFF_BYTES,
+        "maxUploadGb": round(MAX_GEOTIFF_BYTES / (1024 ** 3), 2),
     }
 
 
@@ -117,7 +129,13 @@ def local_thumb(path: str = Query(...)):
     except HTTPException:
         raise
     except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Thumbnail failed: {exc}") from exc
+        logger.warning("Thumb endpoint fallback for %s: %s", path, exc)
+        from .config import LOCAL_THUMB_CACHE
+        from .geotiff_io import write_placeholder_png
+
+        cache = LOCAL_THUMB_CACHE / "fallback.png"
+        write_placeholder_png(cache, Path(path).name)
+        return FileResponse(cache, media_type="image/png")
 
 
 @router.post("/local/upload")
@@ -177,3 +195,74 @@ def local_rescan():
         "writablePath": str(get_writable_library_root()),
         "debug": info,
     }
+
+
+@router.post("/detect/from-library")
+async def detect_from_library(
+    base_path: str = Form(...),
+    comparison_path: str = Form(...),
+    method: str = Form("AI-Based Deep Learning"),
+    title: str = Form("Untitled run"),
+    zone: str = Form(""),
+    village: str = Form(""),
+    enable_registration: bool = Form(True),
+    enable_normalization: bool = Form(True),
+    detection_sensitivity: float = Form(0.5),
+    min_region_area: Optional[int] = Form(150),
+    notify_email: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+):
+    """Run change detection on two library images by relative path (e.g. 2025/aerial.tif)."""
+    _require_dda()
+    base_norm = base_path.replace("\\", "/").strip()
+    comp_norm = comparison_path.replace("\\", "/").strip()
+    if not base_norm or not comp_norm:
+        raise HTTPException(status_code=400, detail="base_path and comparison_path are required")
+    if base_norm == comp_norm:
+        raise HTTPException(status_code=400, detail="Base and comparison images must be different")
+
+    try:
+        base_file = safe_resolve(base_norm)
+        comp_file = safe_resolve(comp_norm)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid library path: {exc}") from exc
+
+    try:
+        before_pil = load_rgb_pil(base_file, max_side=get_detection_max_side())
+        after_pil = load_rgb_pil(comp_file, max_side=get_detection_max_side())
+    except RuntimeError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Could not load images: {exc}") from exc
+
+    # Match dimensions so registration and overlay align with the before image
+    if before_pil.size != after_pil.size:
+        after_pil = after_pil.resize(before_pil.size, Image.Resampling.LANCZOS)
+
+    max_side = get_detection_max_side()
+
+    if title == "Untitled run":
+        title = f"{Path(base_norm).name} vs {Path(comp_norm).name}"
+
+    try:
+        return run_detection_and_save(
+            db,
+            before_pil,
+            after_pil,
+            method=method,
+            title=title,
+            zone=zone,
+            village=village,
+            enable_registration=enable_registration,
+            enable_normalization=enable_normalization,
+            detection_sensitivity=detection_sensitivity,
+            min_region_area=min_region_area,
+            notify_email=notify_email,
+            max_size=max_side,
+            geo_bounds_path=base_file,
+        )
+    except Exception as exc:
+        logger.exception("Library detection failed for %s vs %s", base_norm, comp_norm)
+        raise HTTPException(status_code=500, detail=f"Detection failed: {exc}") from exc

app/dda/upload_io.py

@@ -30,9 +30,11 @@ async def stream_upload_to_file(
                     break
                 total += len(chunk)
                 if total > max_bytes:
+                    max_mb = max_bytes // (1024 * 1024)
+                    limit = f"{max_mb // 1024} GB" if max_mb >= 1024 else f"{max_mb} MB"
                     raise HTTPException(
                         status_code=400,
-                        detail=f"File too large (max {max_bytes // (1024 * 1024)} MB)",
+                        detail=f"File too large (max {limit})",
                     )
                 out.write(chunk)
     except HTTPException:

library_sources/README.md

@@ -44,7 +44,7 @@ library_sources/
 
 ## Large files
 
-GeoTIFF files up to **2 GB** are supported when read from disk. Copy files via Explorer/Finder — much faster than browser upload.
+GeoTIFF files up to **5 GB** are supported when read from disk. Copy files via Explorer/Finder — much faster than browser upload.
 
 ## Custom location
 

run.py

@@ -54,7 +54,13 @@ def main():
 
     # reload=False keeps it simple and IDLE-friendly. For live-reload during
     # development, run instead:  uvicorn app.main:app --reload --port 8000
-    uvicorn.run("app.main:app", host=HOST, port=PORT, reload=False)
+    uvicorn.run(
+        "app.main:app",
+        host=HOST,
+        port=PORT,
+        reload=False,
+        timeout_keep_alive=600,
+    )
 
 
 if __name__ == "__main__":

static/js/dda/app.js

@@ -57,6 +57,9 @@ document.querySelectorAll('.dda-tab').forEach((btn) => {
     btn.classList.add('active');
     const tab = btn.dataset.tab;
     document.getElementById('tab-' + tab)?.classList.add('active');
+    if (tab === 'detect' && typeof loadCompareLibraryGrid === 'function') {
+      loadCompareLibraryGrid();
+    }
   });
 });
 
@@ -100,6 +103,16 @@ async function initDda() {
     const hfUpload = document.getElementById('hf-upload-card');
     if (hfUpload) hfUpload.classList.toggle('hidden', !localCfg.isHosted);
 
+    const resHint = document.getElementById('dda-detect-res-hint');
+    if (resHint && localCfg.detectionMaxSide) {
+      resHint.textContent = `Detection runs at up to ${localCfg.detectionMaxSide}px per side for sharper results (set DETECTION_MAX_SIDE to change).`;
+    }
+
+    const uploadLimit = document.getElementById('hf-upload-limit');
+    if (uploadLimit && localCfg.maxUploadGb) {
+      uploadLimit.textContent = `Files on your computer are not on the server. Upload .tif images here (up to ${localCfg.maxUploadGb} GB each).`;
+    }
+
     if (!localCfg.isHosted && ddaConfig.appMode !== 'dda') {
       showDdaError('DDA mode is off. Run locally with: python run.py');
     }
@@ -126,6 +139,7 @@ async function loadLibraryImages() {
   }
   try {
     const items = await ddaApi('GET', '/api/dda/local/images?' + params.toString());
+    window.ddaState.libraryItems = items;
     if (!items.length) {
       const hf = window.ddaState?.localCfg?.isHosted;
       grid.innerHTML = hf
@@ -151,6 +165,7 @@ async function loadLibraryImages() {
         e.dataTransfer.setData('text/plain', card.dataset.imagePath);
       });
     });
+    if (typeof loadCompareLibraryGrid === 'function') loadCompareLibraryGrid();
   } catch (err) {
     grid.innerHTML = `<p class="dim">Could not load images: ${err.message}</p>`;
   }

static/js/dda/library.js

@@ -67,6 +67,13 @@ document.getElementById('form-hf-upload')?.addEventListener('submit', async (e)
     return;
   }
 
+  const maxBytes = window.ddaState?.localCfg?.maxGeotiffBytes
+    || (window.ddaState?.localCfg?.maxGeotiffMb || 5120) * 1024 * 1024;
+  if (file.size > maxBytes) {
+    showDdaError?.(`File is ${formatBytes(file.size)} — maximum upload size is ${formatBytes(maxBytes)}.`);
+    return;
+  }
+
   const form = new FormData();
   form.append('file', file);
   form.append('year', document.getElementById('hf-year').value);