Use local library_sources year folders instead of web upload library

DEPLOYMENT.md

@@ -133,6 +133,7 @@ Set these in each Space’s **Settings → Repository secrets / Variables** if n
 | Variable | Purpose |
 |----------|---------|
 | `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_IMAGE_MB` | PNG/JPEG library cap (default 50 MB) |
 | `SECRET_KEY` | Optional legacy JWT setting (login disabled) |

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=26
+ARG APP_BUILD=27
 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/bootstrap.py

@@ -4,8 +4,9 @@ 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 .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders
 from .library_routes import router as library_router
+from .local_routes import router as local_router
 from .seed import seed_delhi_hierarchy
 
 logger = logging.getLogger(__name__)
@@ -16,6 +17,7 @@ def init_dda_database():
     if not IS_DDA_MODE:
         return
     ensure_library_dirs()
+    ensure_local_year_folders()
     try:
         with engine.connect() as conn:
             try:
@@ -39,4 +41,5 @@ def setup_dda(app: FastAPI) -> None:
         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.include_router(local_router, prefix="/api/dda", tags=["dda-local"])
+    logger.info("APP_MODE=dda — DDA routes enabled (local folder library + legacy upload API)")

app/dda/config.py

@@ -6,9 +6,18 @@ from ..database import DATA_DIR
 APP_MODE = os.environ.get("APP_MODE", "legacy").strip().lower()
 IS_DDA_MODE = APP_MODE == "dda"
 
+# Project root: change_detection_webapp/
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+# Local folder library — drop images into year subfolders here (no web upload required)
+LOCAL_LIBRARY_ROOT = Path(
+    os.environ.get("LOCAL_LIBRARY_ROOT", str(PROJECT_ROOT / "library_sources"))
+).resolve()
+
 LIBRARY_DIR = DATA_DIR / "library"
 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
@@ -20,13 +29,24 @@ ALLOWED_EXTENSIONS = {".tif", ".tiff", ".png", ".jpg", ".jpeg"}
 
 
 def ensure_library_dirs() -> None:
-    for d in (LIBRARY_DIR, THUMBS_DIR, PREVIEWS_DIR):
+    for d in (LIBRARY_DIR, THUMBS_DIR, PREVIEWS_DIR, LOCAL_THUMB_CACHE, LOCAL_LIBRARY_ROOT):
         try:
             d.mkdir(parents=True, exist_ok=True)
         except OSError:
             pass
 
 
+def ensure_local_year_folders() -> None:
+    """Create default year folders under library_sources if missing."""
+    from datetime import datetime
+    current = datetime.now().year
+    for year in (current - 1, current, current + 1):
+        try:
+            (LOCAL_LIBRARY_ROOT / str(year)).mkdir(parents=True, exist_ok=True)
+        except OSError:
+            pass
+
+
 def max_upload_bytes_for_extension(ext: str) -> int:
     if ext in (".tif", ".tiff"):
         return MAX_GEOTIFF_BYTES

app/dda/library_routes.py

@@ -65,7 +65,7 @@ def _image_to_dict(asset: ImageAsset, zone_name: str = "", village_name: str = "
 @router.get("/config")
 def dda_config():
     _require_dda()
-    from .config import MAX_GEOTIFF_BYTES, MAX_IMAGE_BYTES
+    from .config import MAX_GEOTIFF_BYTES, MAX_IMAGE_BYTES, LOCAL_LIBRARY_ROOT
     max_gb = MAX_GEOTIFF_BYTES / (1024 ** 3)
     return {
         "mode": "dda",
@@ -76,6 +76,8 @@ def dda_config():
         "geotiffEnabled": geotiff_io_available(),
         "allowedExtensions": sorted(ALLOWED_EXTENSIONS),
         "hierarchyMode": "admin",
+        "librarySource": "local_folder",
+        "localLibraryPath": str(LOCAL_LIBRARY_ROOT),
     }
 
 

app/dda/local_library.py

@@ -0,0 +1,160 @@
+"""
+Read satellite/drone images from local year-based folders.
+
+Folder layout (under library_sources/):
+
+    library_sources/
+      2024/
+        image_a.tif
+        site_1/
+          image_b.tif
+      2025/
+        image_c.tif
+
+Copy or save files directly into the year folder on disk; the app scans on load / refresh.
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from fastapi import HTTPException
+
+from .config import ALLOWED_EXTENSIONS, LOCAL_LIBRARY_ROOT, LOCAL_THUMB_CACHE
+from .geotiff_io import inspect_image, raster_to_preview_png
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LocalImageEntry:
+    path: str  # relative posix path, e.g. 2025/aerial.tif
+    year: int
+    filename: str
+    file_size_bytes: int
+
+
+def _is_year_dir(name: str) -> bool:
+    return len(name) == 4 and name.isdigit() and 1990 <= int(name) <= 2100
+
+
+def safe_resolve(relative_path: str) -> Path:
+    """Resolve a library-relative path; block path traversal."""
+    rel = relative_path.replace("\\", "/").lstrip("/")
+    if not rel or ".." in rel.split("/"):
+        raise HTTPException(status_code=400, detail="Invalid image path")
+    root = LOCAL_LIBRARY_ROOT.resolve()
+    full = (root / rel).resolve()
+    try:
+        full.relative_to(root)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid image path")
+    if not full.is_file():
+        raise HTTPException(status_code=404, detail="Image file not found")
+    if full.suffix.lower() not in ALLOWED_EXTENSIONS:
+        raise HTTPException(status_code=400, detail="Unsupported image format")
+    return full
+
+
+def scan_years() -> List[dict]:
+    """List year folders and image counts."""
+    ensure_root()
+    years = []
+    if not LOCAL_LIBRARY_ROOT.exists():
+        return years
+    for entry in sorted(LOCAL_LIBRARY_ROOT.iterdir()):
+        if not entry.is_dir() or not _is_year_dir(entry.name):
+            continue
+        count = sum(
+            1
+            for p in entry.rglob("*")
+            if p.is_file() and p.suffix.lower() in ALLOWED_EXTENSIONS
+        )
+        years.append({"year": int(entry.name), "imageCount": count})
+    return years
+
+
+def scan_images(year: Optional[int] = None, query: Optional[str] = None) -> List[LocalImageEntry]:
+    """Scan library_sources for images, optionally filtered by year and filename."""
+    ensure_root()
+    results: List[LocalImageEntry] = []
+    root = LOCAL_LIBRARY_ROOT
+    if not root.exists():
+        return results
+
+    q = (query or "").strip().lower()
+    year_dirs: List[Path]
+    if year is not None:
+        ydir = root / str(year)
+        year_dirs = [ydir] if ydir.is_dir() else []
+    else:
+        year_dirs = [d for d in sorted(root.iterdir()) if d.is_dir() and _is_year_dir(d.name)]
+
+    for ydir in year_dirs:
+        y = int(ydir.name)
+        for path in sorted(ydir.rglob("*")):
+            if not path.is_file() or path.suffix.lower() not in ALLOWED_EXTENSIONS:
+                continue
+            rel = path.relative_to(root).as_posix()
+            if q and q not in rel.lower():
+                continue
+            try:
+                size = path.stat().st_size
+            except OSError:
+                continue
+            results.append(
+                LocalImageEntry(
+                    path=rel,
+                    year=y,
+                    filename=path.name,
+                    file_size_bytes=size,
+                )
+            )
+    return results
+
+
+def entry_to_dict(entry: LocalImageEntry, include_meta: bool = False) -> dict:
+    out = {
+        "path": entry.path,
+        "year": entry.year,
+        "filename": entry.filename,
+        "fileSizeBytes": entry.file_size_bytes,
+        "thumbUrl": f"/api/dda/local/thumb?path={entry.path}",
+        "source": "local_folder",
+    }
+    if include_meta:
+        try:
+            full = safe_resolve(entry.path)
+            meta = inspect_image(full)
+            out.update({
+                "width": meta.width,
+                "height": meta.height,
+                "hasGeoref": meta.has_georef,
+                "format": meta.format,
+            })
+        except Exception as exc:
+            logger.warning("Metadata read failed for %s: %s", entry.path, exc)
+    return out
+
+
+def thumb_cache_path(relative_path: str) -> Path:
+    key = hashlib.sha256(relative_path.encode("utf-8")).hexdigest()[:32]
+    return LOCAL_THUMB_CACHE / f"{key}.png"
+
+
+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():
+        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:
+    LOCAL_LIBRARY_ROOT.mkdir(parents=True, exist_ok=True)
+    LOCAL_THUMB_CACHE.mkdir(parents=True, exist_ok=True)

app/dda/local_routes.py

@@ -0,0 +1,85 @@
+"""API for reading images from local library_sources/ year folders."""
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import FileResponse
+
+from .config import IS_DDA_MODE, LOCAL_LIBRARY_ROOT, geotiff_io_available
+from .local_library import (
+    entry_to_dict,
+    get_or_build_thumb,
+    safe_resolve,
+    scan_images,
+    scan_years,
+)
+
+router = APIRouter()
+
+
+def _require_dda():
+    if not IS_DDA_MODE:
+        raise HTTPException(status_code=404, detail="DDA mode is not enabled on this server")
+
+
+@router.get("/local/config")
+def local_library_config():
+    _require_dda()
+    return {
+        "source": "local_folder",
+        "rootPath": str(LOCAL_LIBRARY_ROOT),
+        "instructions": (
+            "Copy .tif / .tiff images into year folders under library_sources/ "
+            "(e.g. library_sources/2025/my_image.tif), then click Refresh."
+        ),
+        "geotiffEnabled": geotiff_io_available(),
+    }
+
+
+@router.get("/local/years")
+def local_years():
+    _require_dda()
+    return {"years": scan_years(), "rootPath": str(LOCAL_LIBRARY_ROOT)}
+
+
+@router.get("/local/images")
+def local_images(
+    year: Optional[int] = Query(None),
+    q: Optional[str] = Query(None),
+):
+    _require_dda()
+    entries = scan_images(year=year, query=q)
+    return [entry_to_dict(e) for e in entries]
+
+
+@router.get("/local/images/detail")
+def local_image_detail(path: str = Query(..., description="Relative path e.g. 2025/aerial.tif")):
+    _require_dda()
+    entries = scan_images()
+    match = next((e for e in entries if e.path == path.replace("\\", "/")), None)
+    if not match:
+        safe_resolve(path)  # raises 404 if missing
+        entries = scan_images()
+        match = next((e for e in entries if e.path == path.replace("\\", "/")), None)
+    if not match:
+        raise HTTPException(status_code=404, detail="Image not found in library scan")
+    return entry_to_dict(match, include_meta=True)
+
+
+@router.get("/local/thumb")
+def local_thumb(path: str = Query(...)):
+    _require_dda()
+    try:
+        thumb = get_or_build_thumb(path)
+        return FileResponse(thumb, media_type="image/png")
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Thumbnail failed: {exc}") from exc
+
+
+@router.post("/local/rescan")
+def local_rescan():
+    _require_dda()
+    years = scan_years()
+    total = sum(y["imageCount"] for y in years)
+    return {"ok": True, "years": years, "totalImages": total, "rootPath": str(LOCAL_LIBRARY_ROOT)}

library_sources/README.md

@@ -0,0 +1,36 @@
+# Local Image Library
+
+Place satellite / drone images here **by year**. The app reads directly from this folder — no web upload needed.
+
+## Folder structure
+
+```
+library_sources/
+  2024/
+    your_image.tif
+    optional_subfolder/
+      another_image.tif
+  2025/
+    site_a.tif
+  2026/
+```
+
+## Supported formats
+
+- `.tif` / `.tiff` (GeoTIFF — preferred)
+- `.png`, `.jpg`, `.jpeg` (for testing)
+
+## How to use
+
+1. Copy your images into the correct **year** folder (e.g. `library_sources/2025/`).
+2. Run the app (`python run.py` or open the dev Space).
+3. Open **Image Library** → click **Refresh** if you added files while the app was running.
+4. Select a year in the sidebar to view images.
+
+## Large files
+
+GeoTIFF files up to **2 GB** are supported when read from disk. Copy files via Explorer/Finder — much faster than browser upload.
+
+## Custom location
+
+Set environment variable `LOCAL_LIBRARY_ROOT` to use a different folder path.

static/css/dda.css

@@ -65,7 +65,53 @@
   font-size: 0.88rem;
 }
 .dda-tree { font-size: 0.88rem; }
-.dda-tree-zone { margin-bottom: 0.5rem; }
+.dda-tree-year {
+  display: block;
+  width: 100%;
+  text-align: left;
+  padding: 0.4rem 0.55rem;
+  margin-bottom: 0.2rem;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  border-radius: 6px;
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+.dda-tree-year:hover, .dda-tree-year.active {
+  background: var(--bg-hover);
+  color: var(--grad-start);
+}
+
+.dda-folder-path {
+  font-size: 0.78rem;
+  margin-bottom: 0.6rem;
+  word-break: break-all;
+}
+.dda-path-code {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 0.6rem 0.75rem;
+  font-size: 0.8rem;
+  overflow-x: auto;
+  margin: 0.5rem 0 0;
+}
+.dda-instructions .sub code {
+  font-size: 0.85em;
+  background: var(--bg);
+  padding: 0.1rem 0.35rem;
+  border-radius: 4px;
+}
+
+.card-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
 .dda-tree-zone > button {
   width: 100%;
   text-align: left;

static/js/dda/app.js

@@ -30,21 +30,23 @@ function showDdaSuccess(msg) {
   setTimeout(() => el.classList.add('hidden'), 4000);
 }
 
+function formatBytes(n) {
+  if (n >= 1024 ** 3) return (n / 1024 ** 3).toFixed(1) + ' GB';
+  if (n >= 1024 ** 2) return (n / 1024 ** 2).toFixed(1) + ' MB';
+  return (n / 1024).toFixed(0) + ' KB';
+}
+
 let ddaConfig = null;
-let ddaHierarchy = null;
-let selectedVillageId = null;
-let selectedZoneId = null;
+let localYears = [];
+let selectedYear = 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;
-  },
+  get years() { return localYears; },
+  get selectedYear() { return selectedYear; },
+  setYear(year) { selectedYear = year; },
   refreshImages: () => loadLibraryImages(),
+  rescan: () => rescanLibrary(),
 };
 
 document.querySelectorAll('.dda-tab').forEach((btn) => {
@@ -57,51 +59,68 @@ document.querySelectorAll('.dda-tab').forEach((btn) => {
   });
 });
 
+async function rescanLibrary() {
+  const data = await ddaApi('POST', '/api/dda/local/rescan');
+  localYears = data.years || [];
+  if (typeof renderYearTree === 'function') renderYearTree(localYears);
+  await loadLibraryImages();
+  return data;
+}
+
 async function initDda() {
   hideDdaError();
   try {
     ddaConfig = await ddaApi('GET', '/api/dda/config');
+    const localCfg = await ddaApi('GET', '/api/dda/local/config');
+
     const hint = document.getElementById('lib-config-hint');
     if (hint) {
-      const gb = ddaConfig.maxUploadGb;
-      const label = gb >= 1 ? `${gb} GB GeoTIFF` : `${ddaConfig.maxGeotiffMb || ddaConfig.maxUploadMb} MB`;
-      hint.textContent = `Max ${label} · GeoTIFF engine: ${ddaConfig.geotiffEnabled ? 'yes' : 'limited'}`;
+      hint.textContent = localCfg.geotiffEnabled ? 'GeoTIFF ready' : 'GeoTIFF limited';
     }
-    ddaHierarchy = await ddaApi('GET', '/api/dda/hierarchy');
-    if (typeof renderHierarchy === 'function') renderHierarchy(ddaHierarchy);
-    if (typeof populateUploadSelects === 'function') populateUploadSelects(ddaHierarchy);
+    const pathEl = document.getElementById('lib-path-display');
+    if (pathEl) pathEl.textContent = localCfg.rootPath || ddaConfig.localLibraryPath || '';
+    const folderPath = document.getElementById('lib-folder-path');
+    if (folderPath) folderPath.textContent = 'Folder: library_sources/';
+
+    const yearsData = await ddaApi('GET', '/api/dda/local/years');
+    localYears = yearsData.years || [];
+    if (typeof renderYearTree === 'function') renderYearTree(localYears);
     await loadLibraryImages();
   } catch (err) {
-    showDdaError(err.message || 'Failed to load DDA configuration');
+    showDdaError(err.message || 'Failed to load library');
   }
 }
 
 async function loadLibraryImages() {
   const grid = document.getElementById('lib-grid');
+  const title = document.getElementById('lib-grid-title');
   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 (selectedYear) params.set('year', String(selectedYear));
   if (q) params.set('q', q);
+  if (title) {
+    title.textContent = selectedYear ? `Images — ${selectedYear}` : 'Images — all years';
+  }
   try {
-    const items = await ddaApi('GET', '/api/dda/images?' + params.toString());
+    const items = await ddaApi('GET', '/api/dda/local/images?' + params.toString());
     if (!items.length) {
-      grid.innerHTML = '<p class="dim">No images yet. Upload a GeoTIFF or image above.</p>';
+      grid.innerHTML = `<p class="dim">No images in ${selectedYear || 'library_sources'}. Copy .tif files into <code>library_sources/${selectedYear || 'YEAR'}/</code> and click Refresh.</p>`;
       return;
     }
     grid.innerHTML = items.map((img) => `
-      <div class="dda-card-img" draggable="true" data-image-id="${img.id}" title="${img.originalFilename}">
+      <div class="dda-card-img" draggable="true" data-image-path="${img.path}" title="${img.filename}">
         ${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 || ''}
+          <strong>${img.year}</strong><br/>
+          ${img.filename}<br/>
+          <span class="dim">${formatBytes(img.fileSizeBytes)}</span>
         </div>
       </div>`).join('');
     grid.querySelectorAll('.dda-card-img').forEach((card) => {
       card.addEventListener('dragstart', (e) => {
-        e.dataTransfer.setData('text/plain', card.dataset.imageId);
+        e.dataTransfer.setData('application/x-dda-image-path', card.dataset.imagePath);
+        e.dataTransfer.setData('text/plain', card.dataset.imagePath);
       });
     });
   } catch (err) {
@@ -114,4 +133,17 @@ document.getElementById('lib-filter')?.addEventListener('input', () => {
   window._libFilterTimer = setTimeout(loadLibraryImages, 300);
 });
 
+document.getElementById('btn-refresh-lib')?.addEventListener('click', async () => {
+  const btn = document.getElementById('btn-refresh-lib');
+  btn.disabled = true;
+  try {
+    const data = await rescanLibrary();
+    showDdaSuccess(`Library refreshed — ${data.totalImages || 0} image(s) found.`);
+  } catch (err) {
+    showDdaError(err.message);
+  } finally {
+    btn.disabled = false;
+  }
+});
+
 initDda();

static/js/dda/library.js

@@ -1,169 +1,33 @@
-function renderHierarchy(data) {
+function renderYearTree(years) {
   const tree = document.getElementById('lib-tree');
-  if (!tree || !data?.zones) return;
+  if (!tree) 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('');
+  const allBtn = `
+    <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === null ? 'active' : ''}" data-year="">
+      All years
+    </button>`;
 
-  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();
-    });
-  });
+  const yearBtns = (years || [])
+    .filter((y) => !filter || String(y.year).includes(filter))
+    .map((y) => `
+      <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === y.year ? 'active' : ''}" data-year="${y.year}">
+        ${y.year} <span class="dim">(${y.imageCount})</span>
+      </button>`).join('');
 
-  tree.querySelectorAll('.dda-tree-village').forEach((btn) => {
+  tree.innerHTML = allBtn + yearBtns;
+
+  tree.querySelectorAll('.dda-tree-year').forEach((btn) => {
     btn.addEventListener('click', () => {
-      tree.querySelectorAll('.dda-tree-village').forEach((b) => b.classList.remove('active'));
+      tree.querySelectorAll('.dda-tree-year').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),
-      );
+      const raw = btn.dataset.year;
+      window.ddaState.setYear(raw ? parseInt(raw, 10) : null);
       window.ddaState.refreshImages();
     });
   });
 }
 
 document.getElementById('lib-tree-search')?.addEventListener('input', () => {
-  if (window.ddaState?.hierarchy) renderHierarchy(window.ddaState.hierarchy);
+  if (window.ddaState?.years) renderYearTree(window.ddaState.years);
 });
-
-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);
-      });
-    });
-  }
-}
-
-function formatBytes(n) {
-  if (n >= 1024 ** 3) return (n / 1024 ** 3).toFixed(1) + ' GB';
-  if (n >= 1024 ** 2) return (n / 1024 ** 2).toFixed(1) + ' MB';
-  return (n / 1024).toFixed(0) + ' KB';
-}
-
-function uploadWithProgress(url, formData, onProgress) {
-  return new Promise((resolve, reject) => {
-    const xhr = new XMLHttpRequest();
-    xhr.open('POST', url);
-    xhr.withCredentials = true;
-    xhr.upload.addEventListener('progress', (e) => {
-      if (e.lengthComputable && onProgress) onProgress(e.loaded, e.total);
-    });
-    xhr.addEventListener('load', () => {
-      let data = null;
-      try { data = xhr.responseText ? JSON.parse(xhr.responseText) : null; } catch (_) {}
-      if (xhr.status >= 200 && xhr.status < 300) resolve(data);
-      else reject(new Error(data?.detail || xhr.statusText || 'Upload failed'));
-    });
-    xhr.addEventListener('error', () => reject(new Error('Network error during upload')));
-    xhr.addEventListener('abort', () => reject(new Error('Upload cancelled')));
-    xhr.send(formData);
-  });
-}
-
-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');
-  const progWrap = document.getElementById('upload-progress');
-  const progFill = document.getElementById('upload-progress-fill');
-  const progLabel = document.getElementById('upload-progress-label');
-
-  btn.disabled = true;
-  btn.textContent = 'Uploading…';
-  progWrap?.classList.remove('hidden');
-  if (progFill) progFill.style.width = '0%';
-  if (progLabel) progLabel.textContent = `Uploading ${file.name} (${formatBytes(file.size)})… 0%`;
-
-  try {
-    const data = await uploadWithProgress('/api/dda/images/upload', form, (loaded, total) => {
-      const pct = total ? Math.round((loaded / total) * 100) : 0;
-      if (progFill) progFill.style.width = pct + '%';
-      if (progLabel) progLabel.textContent = `Uploading… ${pct}% (${formatBytes(loaded)} / ${formatBytes(total)})`;
-    });
-    if (progFill) progFill.style.width = '100%';
-    showDdaSuccess?.(data?.status === 'success' ? 'Image uploaded to library.' : 'Upload complete.');
-    document.getElementById('form-upload').reset();
-    document.getElementById('up-year').value = '2025';
-    fileInput.value = '';
-    const dateInput = document.getElementById('up-date');
-    if (dateInput) dateInput.value = new Date().toISOString().slice(0, 10);
-    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';
-    setTimeout(() => progWrap?.classList.add('hidden'), 1500);
-  }
-});
-
-// 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

@@ -5,7 +5,7 @@
   <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=2" />
+  <link rel="stylesheet" href="/static/css/dda.css?v=3" />
 </head>
 <body>
   <div class="app dda-app">
@@ -25,70 +25,35 @@
     <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) -->
+    <!-- Tab: Image Library — reads from library_sources/ year folders -->
     <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 class="card-header">
+            <h3>Years</h3>
+            <button type="button" class="btn btn-secondary btn-sm" id="btn-refresh-lib" title="Rescan folder">Refresh</button>
+          </div>
+          <div id="lib-folder-path" class="dda-folder-path dim"></div>
+          <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter years…" />
           <div id="lib-tree" class="dda-tree"><p class="dim">Loading…</p></div>
         </aside>
         <main class="dda-main">
-          <div class="card">
+          <div class="card dda-instructions">
             <div class="card-header">
-              <h3>Upload Image</h3>
+              <h3>Local folder library</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 (.tif up to 2 GB)</label>
-                <input type="file" id="up-file" accept=".tif,.tiff,.png,.jpg,.jpeg" required />
-              </div>
-            </div>
-            <div id="upload-progress" class="dda-upload-progress hidden">
-              <div class="dda-progress-bar"><div id="upload-progress-fill" class="dda-progress-fill"></div></div>
-              <span id="upload-progress-label" class="dim">Uploading… 0%</span>
-            </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>
+            <p class="sub" id="lib-instructions">
+              Copy <code>.tif</code> images into <code>library_sources/YEAR/</code> in your project folder, then click <strong>Refresh</strong>.
+            </p>
+            <pre id="lib-path-display" class="dda-path-code"></pre>
           </div>
           <div class="card">
             <div class="card-header">
-              <h3>Library Images</h3>
-              <input type="search" id="lib-filter" class="dda-search" placeholder="Search…" />
+              <h3 id="lib-grid-title">Images</h3>
+              <input type="search" id="lib-filter" class="dda-search" placeholder="Search filenames…" />
             </div>
-            <div id="lib-grid" class="dda-grid"><p class="dim">Select a village or upload an image.</p></div>
+            <div id="lib-grid" class="dda-grid"><p class="dim">Select a year or add images to library_sources/.</p></div>
           </div>
         </main>
       </div>
@@ -123,7 +88,7 @@
     </section>
   </div>
 
-  <script src="/static/js/dda/app.js?v=2"></script>
-  <script src="/static/js/dda/library.js?v=2"></script>
+  <script src="/static/js/dda/app.js?v=3"></script>
+  <script src="/static/js/dda/library.js?v=3"></script>
 </body>
 </html>