Add landslide detection menu, separate engine, and Uttarakhand integration plan

Landslide_Detection_Uttarakhand_Integration_Plan.md

@@ -0,0 +1,118 @@
+# Landslide Detection Integration Plan (Uttarakhand)
+
+This note covers:
+- candidate datasets for Uttarakhand landslide monitoring,
+- model/research direction,
+- system architecture for integration,
+- preprocessing and feature extraction starter workflow.
+
+## 1) Candidate Datasets (Uttarakhand + nearby Himalayan context)
+
+Use a layered strategy (event inventory + optical + terrain + rainfall):
+
+1. **Landslide Inventory / Event Data**
+   - Geological Survey of India (GSI) landslide inventory products.
+   - NRSC/Bhuvan and disaster mapping layers (where available for state districts).
+   - State disaster management/public reports for dated event polygons/points.
+
+2. **Optical Satellite Time Series**
+   - **Sentinel-2 (10m/20m)** for frequent revisit and vegetation/soil change.
+   - **Landsat-8/9 (30m)** for long historical baseline.
+   - Optional high-resolution commercial tiles for selected validation zones.
+
+3. **Terrain Data (critical for landslide susceptibility)**
+   - **SRTM/ALOS/CartoDEM** DEM.
+   - Derived slope, aspect, curvature, roughness, topographic wetness proxies.
+
+4. **Rainfall / Trigger Data**
+   - IMD gridded rainfall, GPM/IMERG rainfall products.
+   - Cumulative rainfall windows (1-day, 3-day, 7-day, 15-day anomalies).
+
+5. **Ancillary Layers**
+   - Landcover/forest loss,
+   - road and river proximity,
+   - settlements/infrastructure overlays for risk prioritization.
+
+## 2) Model/Research Direction
+
+Recommended progression:
+
+### Phase A (already started in-app)
+- Rule-based bi-temporal landslide candidate detection:
+  - vegetation loss proxy,
+  - bare-soil increase,
+  - texture and edge disruption,
+  - connected-component region extraction.
+
+### Phase B (ML baseline)
+- Pixel/patch classifier (Random Forest / XGBoost) using:
+  - optical change features,
+  - terrain derivatives,
+  - rainfall context,
+  - neighborhood statistics.
+
+### Phase C (Deep Learning)
+- U-Net/DeepLab/SegFormer style landslide segmentation with multi-channel input:
+  - pre-event image,
+  - post-event image,
+  - DEM-derived bands (slope/aspect),
+  - rainfall summary channels.
+
+### Research papers to review first
+- Remote sensing landslide mapping with deep learning in Himalayan terrain.
+- Bi-temporal change detection for landslide scars (optical and SAR fusion).
+- DEM + rainfall + optical hybrid susceptibility modeling.
+
+## 3) Architecture for Integration (Current App)
+
+Integrated design implemented in the app:
+
+- New detection menu in UI:
+  - `General Change Detection` (existing pipeline),
+  - `Landslide Detection (Uttarakhand)` (separate pipeline).
+
+- Shared API entrypoint:
+  - `POST /api/detect`
+  - new form field `detection_type`.
+
+- Routing:
+  - `detection_type=change_detection` -> `app/detection_engine.py`
+  - `detection_type=landslide_detection` -> `app/landslide_engine.py`
+
+- Shared output contract:
+  - overlay image,
+  - stats,
+  - regions list,
+  - history storage compatible with existing UI and DB.
+
+This keeps current production behavior intact while enabling model-specific evolution for landslide.
+
+## 4) Preprocessing and Feature Extraction (Starter)
+
+Current landslide starter logic (`app/landslide_engine.py`) includes:
+
+1. **Preprocessing**
+   - RGB conversion, controlled resizing.
+
+2. **Feature channels**
+   - Green-index drop (vegetation loss proxy),
+   - Soil score increase (HSV warm/dry proxy),
+   - Texture roughness change (Laplacian-based),
+   - Edge disruption map (Canny difference).
+
+3. **Fusion + threshold**
+   - weighted fusion of channels,
+   - sensitivity-driven percentile threshold.
+
+4. **Post-processing**
+   - morphology cleanup,
+   - region extraction with confidence/severity assignment.
+
+## 5) Immediate next execution tasks
+
+1. Build a curated Uttarakhand event list (district/date) and collect before/after pairs.
+2. Generate DEM derivatives for those AOIs (slope/aspect/curvature).
+3. Create a labeling protocol (landslide polygon + confidence tier).
+4. Add benchmark script (precision/recall/F1/IoU per district/event).
+5. Move from Rule-Based v1 to ML baseline (RF/XGBoost) with reproducible feature table.
+

README.md

@@ -16,6 +16,7 @@ Standalone web application for satellite image change detection with **user acco
 - **Login / Register** — JWT-based auth, passwords hashed with bcrypt
 - **Database** — SQLite (or set `DATABASE_URL` for PostgreSQL); stores users and detection runs
 - **Change detection** — Same model as the original app: AI-based, image difference, feature-based, hybrid
+- **Detection menu** — Choose between General Change Detection and Landslide Detection (Uttarakhand starter)
 - **Object classification** — Changed regions labeled as Water, Vegetation/Tree, Building, Road, Bare Ground/Soil
 - **History** — List of past runs with overlay images and stats
 - **UI** — Single-page app with a dark, “control room” style and teal accents
@@ -57,6 +58,12 @@ Standalone web application for satellite image change detection with **user acco
 - **JWT**: set `SECRET_KEY` in `app/auth.py` (or via env) in production.
 - **Email**: By default, notifications are sent via the manager's email API (`https://emailservice.managemybusinessess.com/api/email/send`). Override with `EMAIL_API_URL` if needed. To use SMTP (e.g. Gmail) instead, set `EMAIL_API_URL` to empty and set `SMTP_USER` and `SMTP_PASS`.
 
+- **Landslide module**:
+  - Integrated at runtime through the same `/api/detect` endpoint using `detection_type=landslide_detection`.
+  - Engine code: `app/landslide_engine.py`
+  - Dataset preprocessing starter: `app/landslide_preprocessing.py`
+  - Planning/research brief: `Landslide_Detection_Uttarakhand_Integration_Plan.md`
+
 ## Project layout
 
 ```

app/landslide_engine.py

@@ -0,0 +1,223 @@
+"""
+Landslide Detection Engine (Uttarakhand-focused starter).
+
+This module is intentionally separate from the generic change detection engine.
+It uses landslide-oriented cues from before/after optical imagery:
+- vegetation loss
+- bare-soil increase
+- texture roughness change
+- edge disruption
+"""
+from __future__ import annotations
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def _preprocess(image: Image.Image, max_size: int = 2200) -> np.ndarray:
+    arr = np.array(image.convert("RGB"))
+    h, w = arr.shape[:2]
+    if max(h, w) > max_size:
+        s = max_size / max(h, w)
+        arr = cv2.resize(arr, (max(1, int(w * s)), max(1, int(h * s))), interpolation=cv2.INTER_AREA)
+    return arr
+
+
+def _norm01(x: np.ndarray) -> np.ndarray:
+    x = x.astype(np.float32)
+    lo = float(np.min(x))
+    hi = float(np.max(x))
+    if hi - lo < 1e-8:
+        return np.zeros_like(x, dtype=np.float32)
+    return (x - lo) / (hi - lo)
+
+
+def _green_index(rgb: np.ndarray) -> np.ndarray:
+    # RGB proxy for vegetation index when NIR is unavailable.
+    r = rgb[:, :, 0].astype(np.float32)
+    g = rgb[:, :, 1].astype(np.float32)
+    return (g - r) / (g + r + 1e-6)
+
+
+def _soil_score(rgb: np.ndarray) -> np.ndarray:
+    hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV).astype(np.float32)
+    h = hsv[:, :, 0]
+    s = hsv[:, :, 1] / 255.0
+    v = hsv[:, :, 2] / 255.0
+    # Dry/bare soil often: warm hue, medium saturation, medium/high brightness.
+    warm = ((h >= 8) & (h <= 38)).astype(np.float32)
+    sat = np.clip(1.0 - np.abs(s - 0.45) / 0.45, 0, 1)
+    bri = np.clip((v - 0.25) / 0.75, 0, 1)
+    return _norm01(0.5 * warm + 0.25 * sat + 0.25 * bri)
+
+
+def _texture_roughness(gray: np.ndarray) -> np.ndarray:
+    lap = cv2.Laplacian(gray, cv2.CV_32F, ksize=3)
+    rough = cv2.GaussianBlur(np.abs(lap), (5, 5), 0)
+    return _norm01(rough)
+
+
+def _edge_change(before: np.ndarray, after: np.ndarray) -> np.ndarray:
+    g1 = cv2.cvtColor(before, cv2.COLOR_RGB2GRAY)
+    g2 = cv2.cvtColor(after, cv2.COLOR_RGB2GRAY)
+    e1 = cv2.Canny(g1, 60, 140)
+    e2 = cv2.Canny(g2, 60, 140)
+    diff = cv2.absdiff(e1, e2).astype(np.float32) / 255.0
+    return cv2.GaussianBlur(diff, (5, 5), 0)
+
+
+def _clean(mask: np.ndarray) -> np.ndarray:
+    m = mask.copy()
+    h, w = m.shape[:2]
+    b = max(8, int(min(h, w) * 0.01))
+    m[:b, :] = 0
+    m[-b:, :] = 0
+    m[:, :b] = 0
+    m[:, -b:] = 0
+    m = cv2.medianBlur(m, 5)
+    k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
+    m = cv2.morphologyEx(m, cv2.MORPH_OPEN, k_open)
+    m = cv2.morphologyEx(m, cv2.MORPH_CLOSE, k_close)
+    return m
+
+
+def _extract_regions(mask: np.ndarray, after: np.ndarray, min_area: int = 350):
+    n, labels, stats, cents = cv2.connectedComponentsWithStats(mask, connectivity=8)
+    h, w = mask.shape[:2]
+    img_area = h * w
+    regions = []
+    rid = 0
+    for i in range(1, n):
+        area = int(stats[i, cv2.CC_STAT_AREA])
+        if area < min_area:
+            continue
+        x = int(stats[i, cv2.CC_STAT_LEFT])
+        y = int(stats[i, cv2.CC_STAT_TOP])
+        bw = int(stats[i, cv2.CC_STAT_WIDTH])
+        bh = int(stats[i, cv2.CC_STAT_HEIGHT])
+        if bw * bh > img_area * 0.9:
+            continue
+        cx, cy = cents[i]
+        ratio = area / max(1, bw * bh)
+        conf = float(np.clip(0.25 + ratio * 0.65, 0.25, 0.95))
+        sev = "minor"
+        if area / img_area > 0.02:
+            sev = "major"
+        elif area / img_area > 0.006:
+            sev = "moderate"
+        rid += 1
+        regions.append(
+            {
+                "id": rid,
+                "area": area,
+                "bbox": (x, y, bw, bh),
+                "center": (int(cx), int(cy)),
+                "object_type": "Landslide Suspected Zone",
+                "confidence": conf,
+                "severity": sev,
+                "sub_type": "Debris / Slope Failure",
+                "sub_type_confidence": conf,
+                "estimated_stories": None,
+                "estimated_height_m": None,
+                "construction_stage": None,
+            }
+        )
+    return regions[:80]
+
+
+def _visualize(after: np.ndarray, mask: np.ndarray, regions: list[dict]) -> np.ndarray:
+    out = after.copy().astype(np.float32)
+    m = (mask > 127).astype(np.float32)
+    amber = np.zeros_like(out)
+    amber[:, :, 0] = 255  # R
+    amber[:, :, 1] = 165  # G
+    alpha = 0.35
+    for c in range(3):
+        out[:, :, c] = out[:, :, c] * (1 - m * alpha) + amber[:, :, c] * (m * alpha)
+    vis = np.clip(out, 0, 255).astype(np.uint8)
+    for r in regions:
+        x, y, w, h = r["bbox"]
+        color = (0, 140, 255)  # BGR-like style for warning tone in RGB draw context
+        cv2.rectangle(vis, (x, y), (x + w, y + h), color, 2)
+        label = f'{r["id"]}'
+        cv2.putText(vis, label, (x + 4, max(14, y - 4)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)
+    return vis
+
+
+def run_landslide_detection(
+    before_pil: Image.Image,
+    after_pil: Image.Image,
+    model_name: str = "Rule-Based v1",
+    detection_sensitivity: float = 0.6,
+    min_region_area: int | None = None,
+):
+    """
+    Returns: change_mask, result_image, stats, regions.
+    """
+    before = _preprocess(before_pil)
+    after = _preprocess(after_pil)
+    if before.shape != after.shape:
+        after = cv2.resize(after, (before.shape[1], before.shape[0]), interpolation=cv2.INTER_LINEAR)
+
+    g_before = _green_index(before)
+    g_after = _green_index(after)
+    veg_loss = _norm01(np.clip(g_before - g_after, 0, None))
+
+    soil_before = _soil_score(before)
+    soil_after = _soil_score(after)
+    soil_gain = _norm01(np.clip(soil_after - soil_before, 0, None))
+
+    gray_before = cv2.cvtColor(before, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    gray_after = cv2.cvtColor(after, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    rough_before = _texture_roughness(gray_before)
+    rough_after = _texture_roughness(gray_after)
+    rough_change = _norm01(np.abs(rough_after - rough_before))
+
+    edge_change = _edge_change(before, after)
+
+    sens = float(np.clip(detection_sensitivity, 0.0, 1.0))
+    # Landslide-oriented fusion
+    fused = (
+        0.38 * veg_loss
+        + 0.30 * soil_gain
+        + 0.20 * rough_change
+        + 0.12 * edge_change
+    )
+    fused = cv2.GaussianBlur(fused.astype(np.float32), (7, 7), 0)
+
+    # Higher sensitivity => lower quantile threshold.
+    q = float(np.clip(0.965 - (sens - 0.5) * 0.08, 0.88, 0.98))
+    thr = float(np.quantile(fused, q))
+    mask = (fused >= thr).astype(np.uint8) * 255
+    mask = _clean(mask)
+
+    if min_region_area is None:
+        min_region_area = int(max(250, min(1400, mask.shape[0] * mask.shape[1] * 0.00010)))
+    regions = _extract_regions(mask, after, min_area=int(min_region_area))
+    result = _visualize(after, mask, regions)
+
+    total = int(mask.shape[0] * mask.shape[1])
+    changed = int(np.sum(mask > 127))
+    stats = {
+        "total_pixels": total,
+        "changed_pixels": changed,
+        "unchanged_pixels": total - changed,
+        "change_percentage": (changed / total * 100.0) if total else 0.0,
+        "image_width": mask.shape[1],
+        "image_height": mask.shape[0],
+        "threshold_debug": {
+            "method": f"Landslide Detection ({model_name})",
+            "threshold_used": int(np.clip(thr * 255.0, 0, 255)),
+            "threshold_percentile_q": q,
+            "sensitivity": sens,
+        },
+        "params": {
+            "detection_sensitivity": sens,
+            "min_region_area": int(min_region_area),
+            "model_name": model_name,
+        },
+    }
+    return mask, result, stats, regions
+

app/landslide_preprocessing.py

@@ -0,0 +1,136 @@
+"""
+Dataset preprocessing and feature extraction starter for landslide modeling.
+
+Usage example:
+  python -m app.landslide_preprocessing --pairs_dir data/landslide_pairs --out_csv data/landslide_features.csv
+
+Expected pairs_dir structure:
+  pairs_dir/
+    event_001/
+      before.png
+      after.png
+      label.png   # optional (binary mask)
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def _norm01(x: np.ndarray) -> np.ndarray:
+    x = x.astype(np.float32)
+    lo = float(np.min(x))
+    hi = float(np.max(x))
+    if hi - lo < 1e-8:
+        return np.zeros_like(x, dtype=np.float32)
+    return (x - lo) / (hi - lo)
+
+
+def _green_index(rgb: np.ndarray) -> np.ndarray:
+    r = rgb[:, :, 0].astype(np.float32)
+    g = rgb[:, :, 1].astype(np.float32)
+    return (g - r) / (g + r + 1e-6)
+
+
+def _soil_score(rgb: np.ndarray) -> np.ndarray:
+    hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV).astype(np.float32)
+    h = hsv[:, :, 0]
+    s = hsv[:, :, 1] / 255.0
+    v = hsv[:, :, 2] / 255.0
+    warm = ((h >= 8) & (h <= 38)).astype(np.float32)
+    sat = np.clip(1.0 - np.abs(s - 0.45) / 0.45, 0, 1)
+    bri = np.clip((v - 0.25) / 0.75, 0, 1)
+    return _norm01(0.5 * warm + 0.25 * sat + 0.25 * bri)
+
+
+def _texture(gray: np.ndarray) -> np.ndarray:
+    lap = cv2.Laplacian(gray.astype(np.float32), cv2.CV_32F, ksize=3)
+    return _norm01(cv2.GaussianBlur(np.abs(lap), (5, 5), 0))
+
+
+def _chip_stats(chip: np.ndarray) -> tuple[float, float, float]:
+    return float(np.mean(chip)), float(np.std(chip)), float(np.quantile(chip, 0.9))
+
+
+def extract_pair_features(before_rgb: np.ndarray, after_rgb: np.ndarray, chip: int = 64):
+    if before_rgb.shape != after_rgb.shape:
+        after_rgb = cv2.resize(after_rgb, (before_rgb.shape[1], before_rgb.shape[0]))
+
+    g_before = _green_index(before_rgb)
+    g_after = _green_index(after_rgb)
+    veg_loss = _norm01(np.clip(g_before - g_after, 0, None))
+
+    soil_before = _soil_score(before_rgb)
+    soil_after = _soil_score(after_rgb)
+    soil_gain = _norm01(np.clip(soil_after - soil_before, 0, None))
+
+    gray_before = cv2.cvtColor(before_rgb, cv2.COLOR_RGB2GRAY)
+    gray_after = cv2.cvtColor(after_rgb, cv2.COLOR_RGB2GRAY)
+    tex_before = _texture(gray_before)
+    tex_after = _texture(gray_after)
+    tex_delta = _norm01(np.abs(tex_after - tex_before))
+
+    h, w = veg_loss.shape
+    rows = []
+    for y in range(0, h - chip + 1, chip):
+        for x in range(0, w - chip + 1, chip):
+            v = veg_loss[y:y + chip, x:x + chip]
+            s = soil_gain[y:y + chip, x:x + chip]
+            t = tex_delta[y:y + chip, x:x + chip]
+            v_m, v_sd, v_q = _chip_stats(v)
+            s_m, s_sd, s_q = _chip_stats(s)
+            t_m, t_sd, t_q = _chip_stats(t)
+            rows.append({
+                "x": x, "y": y,
+                "veg_loss_mean": v_m, "veg_loss_std": v_sd, "veg_loss_q90": v_q,
+                "soil_gain_mean": s_m, "soil_gain_std": s_sd, "soil_gain_q90": s_q,
+                "tex_delta_mean": t_m, "tex_delta_std": t_sd, "tex_delta_q90": t_q,
+            })
+    return rows
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pairs_dir", required=True, help="Directory containing event folders with before/after images.")
+    parser.add_argument("--out_csv", required=True, help="Output CSV path.")
+    parser.add_argument("--chip", type=int, default=64, help="Chip size for feature aggregation.")
+    args = parser.parse_args()
+
+    pairs_dir = Path(args.pairs_dir)
+    out_csv = Path(args.out_csv)
+    out_csv.parent.mkdir(parents=True, exist_ok=True)
+
+    all_rows = []
+    for event_dir in sorted([p for p in pairs_dir.iterdir() if p.is_dir()]):
+        before_path = event_dir / "before.png"
+        after_path = event_dir / "after.png"
+        if not before_path.exists() or not after_path.exists():
+            continue
+        before = np.array(Image.open(before_path).convert("RGB"))
+        after = np.array(Image.open(after_path).convert("RGB"))
+        rows = extract_pair_features(before, after, chip=args.chip)
+        for r in rows:
+            r["event_id"] = event_dir.name
+        all_rows.extend(rows)
+
+    if not all_rows:
+        print("No valid before/after pairs found.")
+        return
+
+    fieldnames = list(all_rows[0].keys())
+    with out_csv.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(all_rows)
+
+    print(f"Wrote {len(all_rows)} rows to {out_csv}")
+
+
+if __name__ == "__main__":
+    main()
+

app/main.py

@@ -225,6 +225,8 @@ async def detect(
     before: UploadFile = File(...),
     after: UploadFile = File(...),
     method: str = Form("AI-Based Deep Learning"),
+    detection_type: str = Form("change_detection"),
+    landslide_model: str = Form("Rule-Based v1"),
     title: str = Form("Untitled run"),
     zone: str = Form(""),
     village: str = Form(""),
@@ -265,16 +267,29 @@ async def detect(
     if min_region_area is not None:
         min_region_area = int(max(50, min(10000, min_region_area)))
 
-    from .detection_engine import run_detection
-    change_mask, result_image, stats, change_regions = run_detection(
-        before_pil,
-        after_pil,
-        method=method,
-        enable_registration=enable_registration,
-        enable_normalization=enable_normalization,
-        detection_sensitivity=detection_sensitivity,
-        min_region_area=min_region_area,
-    )
+    detection_type = (detection_type or "change_detection").strip().lower()
+    if detection_type == "landslide_detection":
+        from .landslide_engine import run_landslide_detection
+        method = f"Landslide - {landslide_model}"
+        change_mask, result_image, stats, change_regions = run_landslide_detection(
+            before_pil,
+            after_pil,
+            model_name=landslide_model,
+            detection_sensitivity=detection_sensitivity,
+            min_region_area=min_region_area,
+        )
+    else:
+        detection_type = "change_detection"
+        from .detection_engine import run_detection
+        change_mask, result_image, stats, change_regions = run_detection(
+            before_pil,
+            after_pil,
+            method=method,
+            enable_registration=enable_registration,
+            enable_normalization=enable_normalization,
+            detection_sensitivity=detection_sensitivity,
+            min_region_area=min_region_area,
+        )
     # Save overlay and thumbnails for history table view
     base_name = f"{user.id}_{uuid.uuid4().hex}"
     overlay_filename = base_name + ".png"
@@ -375,6 +390,7 @@ async def detect(
         "id": run.id,
         "title": run.title,
         "method": run.method,
+        "detectionType": detection_type,
         "zone": run.zone or "",
         "village": run.village or "",
         "statistics": {

static/js/app.js

@@ -186,6 +186,27 @@ function setupUploadZone(inputId, nameId, zoneId, previewId) {
 setupUploadZone('file-before', 'name-before', 'zone-before', 'preview-before');
 setupUploadZone('file-after', 'name-after', 'zone-after', 'preview-after');
 
+// ---- Detection menu (General vs Landslide) ----
+(function initDetectionMenu() {
+  const typeSel = document.getElementById('detect-type');
+  const landslideGroup = document.getElementById('landslide-model-group');
+  const methodGroup = document.getElementById('detect-method')?.closest('.form-group');
+  const regGroup = document.getElementById('detect-registration')?.closest('.form-group');
+  const normGroup = document.getElementById('detect-normalization')?.closest('.form-group');
+  if (!typeSel) return;
+
+  function refresh() {
+    const isLandslide = typeSel.value === 'landslide_detection';
+    if (landslideGroup) landslideGroup.classList.toggle('hidden', !isLandslide);
+    if (methodGroup) methodGroup.classList.toggle('hidden', isLandslide);
+    if (regGroup) regGroup.classList.toggle('hidden', isLandslide);
+    if (normGroup) normGroup.classList.toggle('hidden', isLandslide);
+  }
+
+  typeSel.addEventListener('change', refresh);
+  refresh();
+})();
+
 // ---- Delhi Zone → Village cascading dropdowns ----
 const DELHI_ZONES = {
   "Central Delhi": [
@@ -410,7 +431,12 @@ document.getElementById('form-detect')?.addEventListener('submit', async (e) =>
   const form = new FormData();
   form.append('before', before);
   form.append('after', after);
+  const detectionType = document.getElementById('detect-type')?.value || 'change_detection';
+  form.append('detection_type', detectionType);
   form.append('method', document.getElementById('detect-method').value);
+  if (detectionType === 'landslide_detection') {
+    form.append('landslide_model', document.getElementById('landslide-model')?.value || 'Rule-Based v1');
+  }
   form.append('title', document.getElementById('detect-title').value || 'Untitled run');
   form.append('zone', document.getElementById('detect-zone').value || '');
   form.append('village', document.getElementById('detect-village').value || '');

templates/index.html

@@ -158,6 +158,21 @@
           <h3>Upload / Detection</h3>
         </div>
         <form id="form-detect">
+          <div class="options-row">
+            <div class="form-group">
+              <label for="detect-type">Detection Menu</label>
+              <select id="detect-type">
+                <option value="change_detection" selected>General Change Detection</option>
+                <option value="landslide_detection">Landslide Detection (Uttarakhand)</option>
+              </select>
+            </div>
+            <div class="form-group hidden" id="landslide-model-group">
+              <label for="landslide-model">Landslide Model</label>
+              <select id="landslide-model">
+                <option value="Rule-Based v1" selected>Rule-Based v1 (Vegetation Loss + Soil Gain)</option>
+              </select>
+            </div>
+          </div>
           <div class="location-row">
             <div class="form-group">
               <label for="detect-zone">
@@ -360,6 +375,6 @@
     </div>
   </div>
 
-  <script src="/static/js/app.js?v=25"></script>
+  <script src="/static/js/app.js?v=26"></script>
 </body>
 </html>