Fix region coordinates for all formats, add Google Maps button, harden JPEG

- Resolve georeferencing for PNG/JPEG via rasterio sidecars and explicit
world-file parsing; tag georef source (embedded/worldfile/manual/linear)
- Add out-of-range affine guard with linear fallback; remove (0,0,0,0) sentinel
- Surface a geo debug block in detection statistics
- Accept optional manual WGS84 bounds at tree upload for non-georeferenced files
- Add per-region "Map" button/link opening Google Maps in results and report
- Apply EXIF transpose on JPEG load/preview/upload to avoid rotation artifacts
- Recognize JPEG/PNG image types in filesystem sync
- Raise min region area when registration is poor to cut misalignment false positives

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

app/dda/detect_service.py

@@ -184,6 +184,19 @@ def run_detection_and_save(
         bounds=bounds,
         geo=geo_ctx,
     )
+    regions_with_coords = sum(1 for r in regions_serializable if r.get("latLng"))
+    geo_debug = {
+        "source": geo_ctx.source if geo_ctx else "none",
+        "crs": str(geo_ctx.georef.crs) if (geo_ctx and geo_ctx.georef and geo_ctx.georef.crs) else "",
+        "bounds": list(bounds) if bounds else None,
+        "georefWidth": geo_ctx.georef_width if geo_ctx else 0,
+        "georefHeight": geo_ctx.georef_height if geo_ctx else 0,
+        "detectionWidth": det_w,
+        "detectionHeight": det_h,
+        "regionsWithCoords": regions_with_coords,
+        "regionsTotal": len(regions_serializable),
+    }
+    logger.info("Geo debug for run: %s", geo_debug)
     total_px = int(stats["total_pixels"])
     changed_px = int(stats["changed_pixels"])
     change_pct = float(stats["change_percentage"])
@@ -247,6 +260,7 @@ def run_detection_and_save(
             "params": stats.get("params", {}),
             "alignmentWarning": stats.get("alignment_warning"),
             "registrationOk": stats.get("params", {}).get("registration_ok"),
+            "geo": geo_debug,
         },
         "regions": regions_serializable,
         "overlayBase64Png": overlay_b64,

app/dda/geo_regions.py

@@ -23,6 +23,14 @@ class GeoContext:
     georef: Optional[GeorefInfo]
     georef_width: int
     georef_height: int
+    source: str = "none"  # embedded | worldfile | manual | linear | none
+
+
+def _bounds_in_range(b: Optional[BoundsWGS84]) -> bool:
+    if not b:
+        return False
+    w, s, e, n = b
+    return abs(w) <= 180 and abs(e) <= 180 and abs(s) <= 90 and abs(n) <= 90
 
 
 def parse_bounds(bounds: Any) -> Optional[BoundsWGS84]:
@@ -65,11 +73,16 @@ def resolve_geo_context(
     base_path: str,
     base_file: Path,
 ) -> GeoContext:
-    """Resolve bounds and affine georef for detection geo enrichment."""
+    """Resolve bounds and affine georef for detection geo enrichment.
+
+    Priority: embedded/world-file affine georef → DB manual bounds → linear
+    bounds inferred from the image sidecars. Tracks which source was used.
+    """
     georef = read_georef(base_file)
     bounds = georef.bounds_wgs84 if georef else None
     georef_width = georef.width if georef else 0
     georef_height = georef.height if georef else 0
+    source = getattr(georef, "source", "embedded") if georef else "none"
 
     if not bounds:
         from .tree.image_service import get_image_by_file_path
@@ -77,12 +90,17 @@ def resolve_geo_context(
         rel = base_path.replace("\\", "/").strip().lstrip("/")
         img = get_image_by_file_path(db, rel)
         if img and img.bounds_json:
-            bounds = parse_bounds(img.bounds_json)
+            db_bounds = parse_bounds(img.bounds_json)
+            if db_bounds:
+                bounds = db_bounds
+                source = "manual"
 
     if not bounds:
         bounds = bounds_from_image_path(base_file)
+        if bounds:
+            source = "linear"
 
-    if georef is None and bounds:
+    if (georef_width <= 0 or georef_height <= 0) and bounds:
         meta = inspect_image(base_file)
         georef_width = meta.width or georef_width
         georef_height = meta.height or georef_height
@@ -92,6 +110,7 @@ def resolve_geo_context(
         georef=georef,
         georef_width=georef_width or 0,
         georef_height=georef_height or 0,
+        source=source if bounds else "none",
     )
 
 
@@ -115,7 +134,10 @@ def pixel_to_lat_lng(
         )
         if coords:
             lng, lat = coords
-            return {"lat": round(lat, 6), "lng": round(lng, 6)}
+            # Guard against bad transforms emitting impossible coordinates
+            if abs(lat) <= 90 and abs(lng) <= 180:
+                return {"lat": round(lat, 6), "lng": round(lng, 6)}
+            logger.warning("Affine produced out-of-range lat/lng (%.3f,%.3f); using linear", lat, lng)
 
     if not bounds:
         return None
@@ -177,7 +199,7 @@ def enrich_regions_geo(
         cy = center.get("y", 0)
         if effective_bounds or (geo and geo.georef):
             lat_lng = pixel_to_lat_lng(
-                cx, cy, img_width, img_height, effective_bounds or (0, 0, 0, 0),
+                cx, cy, img_width, img_height, effective_bounds,
                 geo=geo,
             )
             if lat_lng:

app/dda/geotiff_io.py

@@ -7,12 +7,21 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional, Tuple
 
-from PIL import Image
+from PIL import Image, ImageOps
 
 from .config import get_detection_max_side
 
 logger = logging.getLogger(__name__)
 
+# World-file extensions per image type (ESRI convention + generic .wld)
+_WORLD_FILE_EXTS = {
+    ".tif": (".tfw", ".tifw", ".wld"),
+    ".tiff": (".tfw", ".tifw", ".wld"),
+    ".jpg": (".jgw", ".jpgw", ".wld"),
+    ".jpeg": (".jgw", ".jpgw", ".wld"),
+    ".png": (".pgw", ".pngw", ".wld"),
+}
+
 
 @dataclass
 class IngestResult:
@@ -22,6 +31,66 @@ class IngestResult:
     crs: str
     bounds_wgs84: Optional[Tuple[float, float, float, float]]  # west, south, east, north
     format: str
+    georef_source: str = "none"  # embedded | worldfile | none
+
+
+def _find_world_file(path: Path) -> Optional[Path]:
+    """Locate an ESRI world file or generic .wld sidecar next to an image."""
+    ext = path.suffix.lower()
+    candidates = []
+    for wext in _WORLD_FILE_EXTS.get(ext, (".wld",)):
+        candidates.append(path.with_suffix(wext))
+    # e.g. photo.jpg.wld
+    candidates.append(Path(str(path) + ".wld"))
+    for cand in candidates:
+        if cand.is_file():
+            return cand
+    return None
+
+
+def _read_prj_crs(path: Path):
+    """Read a .prj sidecar (WKT) and return a rasterio CRS, or default EPSG:4326."""
+    try:
+        from rasterio.crs import CRS
+    except Exception:
+        return None
+    prj = path.with_suffix(".prj")
+    if prj.is_file():
+        try:
+            return CRS.from_wkt(prj.read_text(encoding="utf-8", errors="ignore").strip())
+        except Exception as exc:
+            logger.warning("Could not parse .prj for %s: %s", path.name, exc)
+    try:
+        return CRS.from_epsg(4326)
+    except Exception:
+        return None
+
+
+def _world_file_georef(path: Path, width: int, height: int):
+    """Build (transform, crs, bounds_wgs84) from a world file sidecar, or None."""
+    wf = _find_world_file(path)
+    if wf is None:
+        return None
+    try:
+        from rasterio.transform import Affine, array_bounds
+        from rasterio.warp import transform_bounds
+
+        nums = [float(x.strip()) for x in wf.read_text().split() if x.strip()]
+        if len(nums) < 6:
+            return None
+        a, d, b, e, c, f = nums[:6]
+        # World file stores center of top-left pixel; shift to corner for GDAL/affine
+        gt_c = c - a / 2.0 - b / 2.0
+        gt_f = f - d / 2.0 - e / 2.0
+        transform = Affine(a, b, gt_c, d, e, gt_f)
+        crs = _read_prj_crs(path)
+        west, south, east, north = array_bounds(height, width, transform)
+        if crs is not None and str(crs) not in ("EPSG:4326", "OGC:CRS84"):
+            west, south, east, north = transform_bounds(crs, "EPSG:4326", west, south, east, north)
+        return transform, crs, (float(west), float(south), float(east), float(north))
+    except Exception as exc:
+        logger.warning("World-file georef failed for %s: %s", path.name, exc)
+        return None
 
 
 def _read_with_rasterio(path: Path) -> IngestResult:
@@ -38,13 +107,15 @@ def _read_with_rasterio(path: Path) -> IngestResult:
                 bounds = (float(w), float(s), float(e), float(n))
             except Exception as exc:
                 logger.warning("Could not transform bounds to WGS84: %s", exc)
+        ext = path.suffix.lower()
         return IngestResult(
             width=int(src.width),
             height=int(src.height),
             has_georef=has_georef,
             crs=crs,
             bounds_wgs84=bounds,
-            format="geotiff",
+            format="geotiff" if ext in (".tif", ".tiff") else "image",
+            georef_source="embedded" if has_georef else "none",
         )
 
 
@@ -53,6 +124,15 @@ def _read_with_pillow(path: Path) -> IngestResult:
         w, h = img.size
     ext = path.suffix.lower()
     fmt = "geotiff" if ext in (".tif", ".tiff") else "image"
+    # Try a world-file sidecar for plain images / non-georeferenced TIFFs
+    wf = _world_file_georef(path, w, h)
+    if wf is not None:
+        _, crs, bounds = wf
+        return IngestResult(
+            width=w, height=h, has_georef=bounds is not None,
+            crs=str(crs) if crs else "", bounds_wgs84=bounds,
+            format=fmt, georef_source="worldfile" if bounds else "none",
+        )
     return IngestResult(
         width=w,
         height=h,
@@ -60,18 +140,32 @@ def _read_with_pillow(path: Path) -> IngestResult:
         crs="",
         bounds_wgs84=None,
         format=fmt,
+        georef_source="none",
     )
 
 
 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)
+    """Read dimensions + georeferencing for any raster (TIFF/PNG/JPEG).
+
+    Tries rasterio first (honors embedded CRS, world files and GDAL .aux.xml for
+    all formats), then falls back to Pillow + explicit world-file parsing.
+    """
+    try:
+        res = _read_with_rasterio(path)
+        # rasterio opened but found no embedded georef: try explicit world file
+        if not res.has_georef:
+            wf = _world_file_georef(path, res.width, res.height)
+            if wf is not None and wf[2] is not None:
+                _, crs, bounds = wf
+                res.has_georef = True
+                res.crs = str(crs) if crs else ""
+                res.bounds_wgs84 = bounds
+                res.georef_source = "worldfile"
+        return res
+    except ImportError:
+        logger.warning("rasterio not installed — georef metadata limited")
+    except Exception as exc:
+        logger.warning("rasterio read failed (%s), falling back to Pillow", exc)
     return _read_with_pillow(path)
 
 
@@ -132,6 +226,7 @@ def load_rgb_pil(path: Path, max_side: Optional[int] = None) -> Image.Image:
         except Exception as exc:
             raise RuntimeError(f"Could not read GeoTIFF: {exc}") from exc
     with Image.open(path) as img:
+        img = ImageOps.exif_transpose(img)
         img = img.convert("RGB")
         if max(img.size) > max_side:
             img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
@@ -156,6 +251,7 @@ def raster_to_preview_png(src_path: Path, dest_path: Path, max_side: int = 512)
 
     try:
         with Image.open(src_path) as img:
+            img = ImageOps.exif_transpose(img)
             img = img.convert("RGB")
             img.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
             dest_path.parent.mkdir(parents=True, exist_ok=True)
@@ -172,38 +268,53 @@ class GeorefInfo:
     width: int
     height: int
     bounds_wgs84: Optional[Tuple[float, float, float, float]]
+    source: str = "embedded"  # embedded | worldfile
 
 
 def read_georef(path: Path) -> Optional[GeorefInfo]:
-    """Read raster affine transform and WGS84 bounds when rasterio is available."""
-    ext = path.suffix.lower()
-    if ext not in (".tif", ".tiff"):
-        return None
+    """Read raster affine transform + WGS84 bounds for any raster format.
+
+    Honors embedded CRS (GeoTIFF), GDAL .aux.xml sidecars, and ESRI world files
+    for TIFF/PNG/JPEG. Returns None when no georeferencing can be resolved.
+    """
+    width = height = 0
     try:
         import rasterio
         from rasterio.warp import transform_bounds
 
         with rasterio.open(path) as src:
-            if src.crs is None:
-                return None
-            bounds = None
-            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 for %s: %s", path.name, exc)
-            return GeorefInfo(
-                transform=src.transform,
-                crs=src.crs,
-                width=int(src.width),
-                height=int(src.height),
-                bounds_wgs84=bounds,
-            )
+            width, height = int(src.width), int(src.height)
+            if src.crs is not None:
+                bounds = None
+                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 for %s: %s", path.name, exc)
+                return GeorefInfo(
+                    transform=src.transform, crs=src.crs,
+                    width=width, height=height, bounds_wgs84=bounds, source="embedded",
+                )
     except ImportError:
         return None
     except Exception as exc:
-        logger.warning("read_georef failed for %s: %s", path.name, exc)
-        return None
+        logger.warning("read_georef rasterio open failed for %s: %s", path.name, exc)
+
+    # No embedded CRS — try an explicit world-file sidecar
+    if width <= 0 or height <= 0:
+        try:
+            with Image.open(path) as img:
+                width, height = img.size
+        except Exception:
+            return None
+    wf = _world_file_georef(path, width, height)
+    if wf is not None and wf[2] is not None:
+        transform, crs, bounds = wf
+        return GeorefInfo(
+            transform=transform, crs=crs,
+            width=width, height=height, bounds_wgs84=bounds, source="worldfile",
+        )
+    return None
 
 
 def pixel_to_geo_wgs84(

app/dda/tree/image_service.py

@@ -60,6 +60,22 @@ def image_to_dict(img: ImageLibrary, node: Optional[TreeNode] = None) -> dict:
     }
 
 
+def _parse_manual_bounds(raw: Optional[str]) -> Optional[str]:
+    """Parse a 'west,south,east,north' WGS84 string into bounds_json, or None."""
+    if not raw or not raw.strip():
+        return None
+    try:
+        parts = [float(x.strip()) for x in raw.replace("[", "").replace("]", "").split(",")]
+    except ValueError:
+        raise HTTPException(status_code=400, detail="manual_bounds must be 'west,south,east,north'")
+    if len(parts) != 4:
+        raise HTTPException(status_code=400, detail="manual_bounds must have 4 values: west,south,east,north")
+    west, south, east, north = parts
+    if abs(west) > 180 or abs(east) > 180 or abs(south) > 90 or abs(north) > 90:
+        raise HTTPException(status_code=400, detail="manual_bounds out of range (lng ±180, lat ±90)")
+    return bounds_to_json((west, south, east, north))
+
+
 async def upload_image(
     db: Session,
     node_id: int,
@@ -68,6 +84,7 @@ async def upload_image(
     image_type: str,
     capture_date: Optional[str],
     uploaded_by: str,
+    manual_bounds: Optional[str] = None,
 ) -> ImageLibrary:
     node = get_node_or_404(db, node_id)
     itype = image_type.strip() or "GeoTIFF"
@@ -103,6 +120,13 @@ async def upload_image(
                 raise HTTPException(status_code=400, detail="capture_date must be YYYY-MM-DD")
 
     meta = inspect_image(dest)
+    # Prefer embedded/world-file georef; fall back to user-supplied manual bounds
+    manual_json = _parse_manual_bounds(manual_bounds)
+    bounds_json = bounds_to_json(meta.bounds_wgs84) or ""
+    has_georef = meta.has_georef
+    if not bounds_json and manual_json:
+        bounds_json = manual_json
+        has_georef = True
     img = ImageLibrary(
         node_id=node.id,
         image_name=dest.name,
@@ -114,8 +138,8 @@ async def upload_image(
         thumb_cache_key=hashlib.sha256(rel.encode()).hexdigest()[:32],
         width=meta.width,
         height=meta.height,
-        has_georef=meta.has_georef,
-        bounds_json=bounds_to_json(meta.bounds_wgs84) or "",
+        has_georef=has_georef,
+        bounds_json=bounds_json,
         format=meta.format,
     )
     db.add(img)

app/dda/tree/routes.py

@@ -157,6 +157,7 @@ async def api_upload_image(
     file: UploadFile = File(...),
     image_type: str = Form("GeoTIFF"),
     capture_date: str = Form(""),
+    manual_bounds: str = Form(""),
     db: Session = Depends(get_db),
     user: User = Depends(current_dda_user),
 ):
@@ -167,6 +168,7 @@ async def api_upload_image(
         image_type=image_type,
         capture_date=capture_date or None,
         uploaded_by=user.email or str(user.id),
+        manual_bounds=manual_bounds or None,
     )
     node = get_node_or_404(db, node_id)
     return {"status": True, "message": "Image Uploaded Successfully", "image": image_to_dict(img, node)}

app/dda/tree/sync_service.py

@@ -105,6 +105,17 @@ def ensure_node_from_disk(db: Session, physical_path: str, *, created_by: str =
     return node
 
 
+def _image_type_for(file_path: Path) -> str:
+    ext = file_path.suffix.lower()
+    if ext in (".tif", ".tiff"):
+        return "GeoTIFF"
+    if ext in (".jpg", ".jpeg"):
+        return "JPEG"
+    if ext == ".png":
+        return "PNG"
+    return "Raster"
+
+
 def _index_image_file(db: Session, node: TreeNode, file_path: Path, rel_file: str) -> bool:
     existing = db.query(ImageLibrary).filter(ImageLibrary.file_path == rel_file).first()
     stat = file_path.stat()
@@ -129,7 +140,7 @@ def _index_image_file(db: Session, node: TreeNode, file_path: Path, rel_file: st
     img = ImageLibrary(
         node_id=node.id,
         image_name=file_path.name,
-        image_type="GeoTIFF" if file_path.suffix.lower() in (".tif", ".tiff") else "Raster",
+        image_type=_image_type_for(file_path),
         file_path=rel_file,
         uploaded_by="filesystem-sync",
         file_size_bytes=stat.st_size,

app/detection_engine.py

@@ -2533,6 +2533,11 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
     if min_area is None:
         min_area = int(max(250, min(1000, img_area * 0.00009)))
 
+    # Poor registration → residual misalignment shows up as many small false
+    # positives. Raise the size floor to keep only confident, larger changes.
+    if not registration_ok:
+        min_area = int(min_area * 1.4)
+
     for i in range(1, num_labels):
         raw_area = stats[i, cv2.CC_STAT_AREA]
         if raw_area < min_area:

app/main.py

@@ -13,7 +13,7 @@ from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
-from PIL import Image
+from PIL import Image, ImageOps
 
 from .auth import (
     COOKIE_NAME,
@@ -306,7 +306,9 @@ async def detect(
                 raise HTTPException(status_code=400, detail=f"{field_name} image is empty")
             if len(raw) > MAX_UPLOAD_BYTES:
                 raise HTTPException(status_code=400, detail="Image too large (max 20 MB)")
-            return Image.open(io.BytesIO(raw)).convert("RGB")
+            img = Image.open(io.BytesIO(raw))
+            img = ImageOps.exif_transpose(img)
+            return img.convert("RGB")
         except HTTPException:
             raise
         except Exception as e:

static/js/dda/library.js

@@ -37,6 +37,8 @@ document.getElementById('form-tree-upload')?.addEventListener('submit', async (e
   form.append('file', file);
   form.append('image_type', document.getElementById('upload-image-type')?.value || 'GeoTIFF');
   form.append('capture_date', document.getElementById('upload-capture-date')?.value || '');
+  const manualBounds = document.getElementById('upload-manual-bounds')?.value?.trim();
+  if (manualBounds) form.append('manual_bounds', manualBounds);
 
   const btn = document.getElementById('btn-tree-upload');
   const progWrap = document.getElementById('upload-progress');

static/js/dda/report_page.js

@@ -67,6 +67,10 @@ async function loadReportPage() {
       tbody.innerHTML = regions.length
         ? regions.map((r) => {
             const { lat, lng } = regionLatLng(r);
+            const hasCoords = Number.isFinite(Number(lat)) && Number.isFinite(Number(lng));
+            const mapsUrl = hasCoords
+              ? `https://www.google.com/maps/search/?api=1&query=${lat},${lng}`
+              : null;
             return `
             <tr>
               <td>${r.id ?? ''}</td>
@@ -76,9 +80,10 @@ async function loadReportPage() {
               <td>${(r.area ?? 0).toLocaleString()}</td>
               <td>${formatCoord(lat)}</td>
               <td>${formatCoord(lng)}</td>
+              <td>${mapsUrl ? `<a class="btn btn-secondary btn-sm" href="${mapsUrl}" target="_blank" rel="noopener">Map</a>` : '—'}</td>
             </tr>`;
           }).join('')
-        : '<tr><td colspan="7" class="dim">No regions detected.</td></tr>';
+        : '<tr><td colspan="8" class="dim">No regions detected.</td></tr>';
     }
 
     const pdfBtn = document.getElementById('report-pdf-btn');

static/js/dda/result.js

@@ -183,7 +183,12 @@ function showDdaResult(data) {
     tr.dataset.regionId = r.id;
     const subType = r.subType || '—';
     const ddaType = r.ddaChangeType || '—';
-    const latLng = r.latLng ? `${r.latLng.lat}, ${r.latLng.lng}` : '—';
+    const mapsUrl = r.latLng
+      ? `https://www.google.com/maps/search/?api=1&query=${r.latLng.lat},${r.latLng.lng}`
+      : null;
+    const latLng = r.latLng
+      ? `<a href="${mapsUrl}" target="_blank" rel="noopener" title="Open in Google Maps">${r.latLng.lat}, ${r.latLng.lng}</a>`
+      : '—';
     const severity = (r.severity || 'minor').toLowerCase();
     const stories = r.estimatedStories != null ? r.estimatedStories : '—';
     const height = r.estimatedHeightM != null ? r.estimatedHeightM + ' m' : '—';
@@ -208,6 +213,7 @@ function showDdaResult(data) {
         <button type="button" class="btn btn-secondary btn-sm btn-review-ok" data-action="confirmed" ${locked ? 'disabled' : ''} title="Confirm">✓</button>
         <button type="button" class="btn btn-secondary btn-sm btn-review-fp" data-action="false_positive" ${locked ? 'disabled' : ''} title="False positive">✗</button>
         <button type="button" class="btn btn-secondary btn-sm btn-review-locate" title="Locate">◎</button>
+        ${mapsUrl ? `<a class="btn btn-secondary btn-sm" href="${mapsUrl}" target="_blank" rel="noopener" title="Open in Google Maps">Map</a>` : ''}
       </td>
     `;
     return tr;

templates/index_dda.html

@@ -72,6 +72,7 @@
                   <select id="upload-image-type">
                     <option>GeoTIFF</option><option>Satellite</option><option>Drone</option>
                     <option>Orthomosaic</option><option>DEM</option><option>Raster</option>
+                    <option>PNG</option><option>JPEG</option>
                   </select>
                 </div>
                 <div class="form-group">
@@ -82,6 +83,10 @@
                   <label for="upload-file">File</label>
                   <input type="file" id="upload-file" accept=".tif,.tiff,.png,.jpg,.jpeg" required />
                 </div>
+                <div class="form-group">
+                  <label for="upload-manual-bounds">Geo bounds (W,S,E,N)</label>
+                  <input type="text" id="upload-manual-bounds" placeholder="optional, e.g. 77.5,12.9,77.6,13.0" />
+                </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>
@@ -319,8 +324,8 @@
 
   <script src="/static/js/dda/app.js?v=15"></script>
   <script src="/static/js/dda/tree.js?v=2"></script>
-  <script src="/static/js/dda/library.js?v=8"></script>
-  <script src="/static/js/dda/result.js?v=6"></script>
+  <script src="/static/js/dda/library.js?v=9"></script>
+  <script src="/static/js/dda/result.js?v=7"></script>
   <script src="/static/js/dda/compare.js?v=11"></script>
   <script src="/static/js/dda/reports.js?v=4"></script>
   <script src="/static/js/dda/notifications.js?v=1"></script>

templates/report_dda.html

@@ -45,6 +45,7 @@
                 <th>Area (px)</th>
                 <th>Lat</th>
                 <th>Lng</th>
+                <th>Map</th>
               </tr>
             </thead>
             <tbody id="report-regions-body"></tbody>
@@ -62,6 +63,6 @@
     </div>
   </div>
   <script src="/static/js/dda/app.js?v=11"></script>
-  <script src="/static/js/dda/report_page.js?v=2"></script>
+  <script src="/static/js/dda/report_page.js?v=3"></script>
 </body>
 </html>