Revert to satellite change detection only - remove landslide, pothole, detection type menu

Dockerfile

@@ -3,13 +3,6 @@ FROM python:3.11-slim
 # Ensure build logs flush immediately (helps when HF shows “BUILDING” with no output)
 ENV PYTHONUNBUFFERED=1
 
-# Hugging Face Hub cache:
-# Some Spaces build steps scan/download using the local Hugging Face cache.
-# In containers this cache can be missing/unwritable unless we force it.
-ENV HF_HOME=/tmp/hf
-ENV HF_HUB_CACHE=/tmp/hf/hub
-ENV TRANSFORMERS_CACHE=/tmp/hf/transformers
-
 # System dependencies for OpenCV and image processing
 RUN apt-get update && apt-get install -y --no-install-recommends \
     libgl1 \
@@ -26,7 +19,7 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=11
+ARG APP_BUILD=12
 ENV APP_BUILD=${APP_BUILD}
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V
 

Landslide_Detection_Uttarakhand_Integration_Plan.md

@@ -1,118 +0,0 @@
-# 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.
-

Pothole_Detection_Integration_Plan.md

@@ -1,92 +0,0 @@
-# Pothole Detection Integration (Research + Architecture)
-
-## 1) Computer vision approaches for road damage detection
-
-Typical successful families:
-
-- **Object detection (bounding boxes)**: YOLOv5/YOLOv8, Faster R-CNN  
-  - Pros: simple outputs, fast, easy UI.  
-  - Cons: boxes are coarse; struggles with thin cracks and complex shapes.
-
-- **Instance segmentation**: Mask R-CNN, YOLACT  
-  - Pros: tighter region boundary and size estimation.  
-  - Cons: heavier models, more training complexity.
-
-- **Semantic segmentation**: U-Net / DeepLabv3+ / SegFormer  
-  - Pros: best for pixel-level damage maps, severity estimation.  
-  - Cons: needs mask labels; inference cost.
-
-- **Two-stage pipelines**:
-  1) road surface ROI extraction (segment road), then  
-  2) damage detection inside road only  
-  - Pros: reduces false positives (buildings, shadows, non-road textures).
-
-## 2) Datasets and pretrained models (starting points)
-
-Common public datasets (road damage + potholes):
-
-- **RDD (Road Damage Dataset / Road Damage Detection)**  
-  Includes potholes and other damage classes from multiple countries.
-
-- **Pothole-600 / Pothole datasets on Kaggle**  
-  Smaller but useful for prototyping.
-
-- **CrackForest / CFD / other crack datasets**  
-  More focused on cracks; can help pretraining for surface defects.
-
-Practical approach:
-- Use a model pretrained on COCO, then fine-tune on RDD/pothole datasets.
-- For best results, fine-tune on **your region-specific imagery** (road texture and lighting differs).
-
-## 3) Feasibility: drone vs satellite vs vehicle camera
-
-- **Vehicle camera (recommended)**:
-  - Highest feasibility for potholes.
-  - Typical resolution and perspective supports pothole features.
-
-- **Drone (good)**:
-  - Works well at low altitude with good GSD (cm/px).
-  - Requires flight plan and stable capture.
-
-- **Satellite (usually not feasible)**:
-  - Most satellite imagery is too low resolution for potholes.
-  - Only very high-res (sub-10cm) commercial imagery could work, and still hard due to shadows and angle.
-
-## 4) Detection pipeline (integrated with current system)
-
-Implemented integration strategy:
-
-- Add **Pothole Detection** as another detection type in the menu.
-- Route through the existing `POST /api/detect` using:
-  - `detection_type=pothole_detection`
-  - `pothole_model=<selected>`
-- Separate engine module:
-  - `app/pothole_engine.py`
-
-### Starter logic implemented (Rule-Based v1)
-
-For fast CPU MVP (vehicle/drone imagery):
-- shadow/dark region score (local brightness drop)
-- rough texture score (Laplacian roughness)
-- edge score (Canny)
-- fuse + sensitivity percentile threshold
-- region extraction + severity/confidence
-
-## 5) Model architectures to implement next
-
-- **YOLOv8n (boxes)** for fast detection and scalable deployment.
-- **SegFormer-b0 / U-Net** for pixel-level damage mapping.
-- Optional road ROI segmentation first to reduce false positives.
-
-## 6) Immediate next steps for dataset preprocessing / feature extraction
-
-1. Define input standard: camera height, FOV, resolution, and capture protocol.
-2. Build a labeled dataset:
-   - bounding boxes or masks for potholes,
-   - metadata: day/night, wet/dry, shadows.
-3. Add preprocessing:
-   - road ROI extraction,
-   - illumination normalization,
-   - motion blur handling.
-4. Train baseline YOLO model and integrate as `pothole_model=YOLOv8`.
-

app/landslide_engine.py

@@ -1,223 +0,0 @@
-"""
-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

@@ -1,136 +0,0 @@
-"""
-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

@@ -222,12 +222,9 @@ def me(user: Optional[User] = Depends(get_current_user)):
 @app.post("/api/detect")
 async def detect(
     request: Request,
-    before: Optional[UploadFile] = File(None),
-    after: Optional[UploadFile] = File(None),
+    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"),
-    pothole_model: str = Form("Rule-Based v1"),
     title: str = Form("Untitled run"),
     zone: str = Form(""),
     village: str = Form(""),
@@ -252,11 +249,8 @@ async def detect(
     if not user:
         raise HTTPException(status_code=401, detail="Login required")
     MAX_UPLOAD_BYTES = 20 * 1024 * 1024  # 20 MB
-    detection_type = (detection_type or "change_detection").strip().lower()
 
-    def _read_upload(upload: Optional[UploadFile], field_name: str):
-        if upload is None:
-            raise HTTPException(status_code=400, detail=f"{field_name} image is required")
+    def _read_upload(upload: UploadFile, field_name: str):
         raw = None
         try:
             raw = upload.file.read()
@@ -276,50 +270,22 @@ async def detect(
             except Exception:
                 pass
 
-    if detection_type == "pothole_detection":
-        # Single-image mode: use after if present, else before.
-        primary = after if after is not None else before
-        after_pil = _read_upload(primary, "road")
-        before_pil = after_pil
-    else:
-        before_pil = _read_upload(before, "before")
-        after_pil = _read_upload(after, "after")
+    before_pil = _read_upload(before, "before")
+    after_pil = _read_upload(after, "after")
     detection_sensitivity = max(0.0, min(1.0, float(detection_sensitivity)))
     if min_region_area is not None:
         min_region_area = int(max(50, min(10000, min_region_area)))
 
-    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,
-        )
-    elif detection_type == "pothole_detection":
-        from .pothole_engine import run_pothole_detection
-        method = f"Pothole - {pothole_model}"
-        change_mask, result_image, stats, change_regions = run_pothole_detection(
-            before_pil,
-            after_pil,
-            model_name=pothole_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,
-        )
+    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"
@@ -420,7 +386,6 @@ async def detect(
         "id": run.id,
         "title": run.title,
         "method": run.method,
-        "detectionType": detection_type,
         "zone": run.zone or "",
         "village": run.village or "",
         "statistics": {
@@ -594,20 +559,3 @@ def index():
     if not index_file.exists():
         return HTMLResponse("<h1>Satellite Change Detection</h1><p>Create <code>templates/index.html</code> and <code>static/</code>.</p>")
     return FileResponse(index_file)
-
-
-# --- Detection type landing pages ---
-# These serve the same SPA, but the frontend selects the correct mode based on URL.
-@app.get("/detect/change", response_class=HTMLResponse)
-def detect_change_page():
-    return index()
-
-
-@app.get("/detect/landslide", response_class=HTMLResponse)
-def detect_landslide_page():
-    return index()
-
-
-@app.get("/detect/pothole", response_class=HTMLResponse)
-def detect_pothole_page():
-    return index()

app/pothole_detection/__init__.py

@@ -1,2 +0,0 @@
-from .pothole_detector import PotholeDetector
-

app/pothole_detection/inference.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Dict
-
-import numpy as np
-
-
-def run_pothole_inference(
-    model,
-    image_bgr: np.ndarray,
-    conf_threshold: float = 0.25,
-    iou_threshold: float = 0.45,
-) -> List[Dict]:
-    """
-    Run YOLO inference and normalize predictions to a simple list format.
-    """
-    results = model.predict(
-        source=image_bgr,
-        conf=conf_threshold,
-        iou=iou_threshold,
-        verbose=False,
-    )
-    preds: List[Dict] = []
-    if not results:
-        return preds
-
-    r = results[0]
-    names = getattr(r, "names", {}) or {}
-    boxes = getattr(r, "boxes", None)
-    if boxes is None:
-        return preds
-
-    xyxy = boxes.xyxy.cpu().numpy() if hasattr(boxes.xyxy, "cpu") else boxes.xyxy
-    confs = boxes.conf.cpu().numpy() if hasattr(boxes.conf, "cpu") else boxes.conf
-    clss = boxes.cls.cpu().numpy() if hasattr(boxes.cls, "cpu") else boxes.cls
-
-    for i in range(len(xyxy)):
-        x1, y1, x2, y2 = [int(v) for v in xyxy[i]]
-        confidence = float(confs[i])
-        cls_id = int(clss[i]) if clss is not None else 0
-        cls_name = names.get(cls_id, "pothole")
-        preds.append(
-            {
-                "bbox": [x1, y1, x2, y2],
-                "confidence": confidence,
-                "class_id": cls_id,
-                "class_name": str(cls_name),
-            }
-        )
-
-    return preds
-

app/pothole_detection/model_loader.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import os
-from functools import lru_cache
-
-
-@lru_cache(maxsize=1)
-def get_yolo_model():
-    """
-    Lazy-load Ultralytics YOLO model once per process.
-
-    Env:
-    - POTHOLE_MODEL_PATH: local path or model name (default: yolov8n.pt)
-    """
-    model_path = os.environ.get("POTHOLE_MODEL_PATH", "yolov8n.pt").strip() or "yolov8n.pt"
-    from ultralytics import YOLO
-    return YOLO(model_path)
-

app/pothole_detection/pothole_detector.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Any, List
-
-import cv2
-import numpy as np
-
-from .model_loader import get_yolo_model
-from .inference import run_pothole_inference
-from .visualization import draw_pothole_boxes
-
-
-class PotholeDetector:
-    """
-    Modular pothole detector:
-    - preprocessing
-    - model inference
-    - post-processing
-    - visualization
-    """
-
-    def __init__(self, conf_threshold: float = 0.25, iou_threshold: float = 0.45):
-        self.conf_threshold = float(conf_threshold)
-        self.iou_threshold = float(iou_threshold)
-        self.model = get_yolo_model()
-
-    def preprocess(self, image_bgr: np.ndarray) -> np.ndarray:
-        # Lightweight denoise for road textures
-        return cv2.bilateralFilter(image_bgr, 5, 35, 35)
-
-    def infer(self, image_bgr: np.ndarray) -> List[Dict[str, Any]]:
-        return run_pothole_inference(
-            self.model,
-            image_bgr,
-            conf_threshold=self.conf_threshold,
-            iou_threshold=self.iou_threshold,
-        )
-
-    def postprocess(self, detections: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        # Keep all detections; custom filtering can be added here.
-        return detections
-
-    def visualize(self, image_bgr: np.ndarray, detections: List[Dict[str, Any]]) -> np.ndarray:
-        return draw_pothole_boxes(image_bgr, detections)
-
-    def run(self, image_bgr: np.ndarray):
-        prep = self.preprocess(image_bgr)
-        detections = self.infer(prep)
-        detections = self.postprocess(detections)
-        vis = self.visualize(image_bgr, detections)
-        return detections, vis
-

app/pothole_detection/visualization.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Dict
-
-import cv2
-import numpy as np
-
-
-def draw_pothole_boxes(image_bgr: np.ndarray, detections: List[Dict]) -> np.ndarray:
-    """
-    Draw red bounding boxes with confidence labels.
-    """
-    out = image_bgr.copy()
-    for det in detections:
-        x1, y1, x2, y2 = det["bbox"]
-        conf = float(det.get("confidence", 0.0))
-        label = f"pothole {conf:.2f}"
-
-        # Red box (BGR)
-        cv2.rectangle(out, (x1, y1), (x2, y2), (0, 0, 255), 2)
-
-        # Label background
-        (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.55, 1)
-        y_text = max(16, y1 - 6)
-        cv2.rectangle(out, (x1, y_text - th - 6), (x1 + tw + 8, y_text + 2), (0, 0, 255), -1)
-        cv2.putText(out, label, (x1 + 4, y_text - 2), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 1, cv2.LINE_AA)
-    return out
-

app/pothole_engine.py

@@ -1,119 +0,0 @@
-"""
-Pothole / road damage detection engine (YOLO-ready).
-
-Uses modular pipeline under app/pothole_detection:
-- model_loader.py
-- inference.py
-- visualization.py
-- pothole_detector.py
-"""
-from __future__ import annotations
-
-import numpy as np
-from PIL import Image
-import cv2
-
-from .pothole_detection import PotholeDetector
-
-
-def _preprocess(image: Image.Image, max_size: int = 1600) -> 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 run_pothole_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,
-):
-    """
-    Current UI uses (before, after) upload. For potholes, we treat the provided road
-    image as the target and run YOLO-style detection.
-    """
-    img = _preprocess(after_pil)
-    # Ultralytics model expects BGR ndarray from OpenCV style pipeline.
-    bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-
-    # Sensitivity maps to confidence threshold inversely.
-    sens = float(np.clip(detection_sensitivity, 0.0, 1.0))
-    conf_thr = float(np.clip(0.45 - (sens - 0.5) * 0.35, 0.10, 0.70))
-    iou_thr = 0.45
-    detector = PotholeDetector(conf_threshold=conf_thr, iou_threshold=iou_thr)
-    detections, vis_bgr = detector.run(bgr)
-    result = cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB)
-
-    regions = []
-    rid = 0
-    for d in detections:
-        x1, y1, x2, y2 = d["bbox"]
-        w = max(1, x2 - x1)
-        h = max(1, y2 - y1)
-        area = int(w * h)
-        if min_region_area is not None and area < int(min_region_area):
-            continue
-        rid += 1
-        conf = float(d.get("confidence", 0.0))
-        severity = "minor"
-        area_ratio = area / max(1, img.shape[0] * img.shape[1])
-        if area_ratio > 0.01:
-            severity = "major"
-        elif area_ratio > 0.003:
-            severity = "moderate"
-        regions.append(
-            {
-                "id": rid,
-                "area": area,
-                "bbox": (int(x1), int(y1), int(w), int(h)),
-                "center": (int(x1 + w // 2), int(y1 + h // 2)),
-                "object_type": "Pothole / Road Damage",
-                "confidence": conf,
-                "severity": severity,
-                "sub_type": str(d.get("class_name", "pothole")),
-                "sub_type_confidence": conf,
-                "estimated_stories": None,
-                "estimated_height_m": None,
-                "construction_stage": None,
-            }
-        )
-
-    total = int(img.shape[0] * img.shape[1])
-    changed = int(sum(r["area"] for r in regions))
-    stats = {
-        "total_pixels": total,
-        "changed_pixels": changed,
-        "unchanged_pixels": total - changed,
-        "change_percentage": (changed / total * 100.0) if total else 0.0,
-        "image_width": img.shape[1],
-        "image_height": img.shape[0],
-        "threshold_debug": {
-            "method": f"Pothole Detection ({model_name})",
-            "threshold_used": None,
-            "confidence_threshold": conf_thr,
-            "iou_threshold": iou_thr,
-            "sensitivity": sens,
-            "detected_boxes": len(regions),
-        },
-        "params": {
-            "detection_sensitivity": sens,
-            "min_region_area": int(min_region_area) if min_region_area is not None else None,
-            "model_name": model_name,
-            "input": "after_only",
-        },
-    }
-    return mask, result, stats, regions
-

requirements.txt

@@ -10,4 +10,3 @@ numpy>=1.24.0
 opencv-python-headless>=4.8.0
 scikit-learn>=1.3.0
 requests>=2.28.0
-ultralytics>=8.2.0

static/js/app.js

@@ -12,49 +12,6 @@ function showView(id) {
   if (el) el.classList.add('active');
 }
 
-function getDetectionTypeFromPath() {
-  const p = (window.location.pathname || '').toLowerCase();
-  if (p.includes('/detect/landslide')) return 'landslide_detection';
-  if (p.includes('/detect/pothole')) return 'pothole_detection';
-  if (p.includes('/detect/change')) return 'change_detection';
-  return null;
-}
-
-function applyDetectionTypeToUI(type) {
-  const typeSel = document.getElementById('detect-type');
-  if (!typeSel || !type) return;
-  typeSel.value = type;
-  typeSel.dispatchEvent(new Event('change'));
-}
-
-function pathForDetectionType(type) {
-  if (type === 'landslide_detection') return '/detect/landslide';
-  if (type === 'pothole_detection') return '/detect/pothole';
-  return '/detect/change';
-}
-
-function navigateToDetectionType(type, replace = false) {
-  applyDetectionTypeToUI(type);
-  const targetPath = pathForDetectionType(type);
-  if ((window.location.pathname || '') !== targetPath) {
-    const fn = replace ? 'replaceState' : 'pushState';
-    window.history[fn]({}, '', targetPath);
-  }
-  showView('dashboard');
-  loadHistory();
-}
-
-// ---- Detection type selection buttons ----
-document.getElementById('btn-type-change')?.addEventListener('click', () => {
-  navigateToDetectionType('change_detection');
-});
-document.getElementById('btn-type-landslide')?.addEventListener('click', () => {
-  navigateToDetectionType('landslide_detection');
-});
-document.getElementById('btn-type-pothole')?.addEventListener('click', () => {
-  navigateToDetectionType('pothole_detection');
-});
-
 function showError(id, msg) {
   const el = document.getElementById(id);
   if (!el) return;
@@ -121,9 +78,8 @@ document.getElementById('form-register')?.addEventListener('submit', async (e) =
 });
 
 function handlePostAuthNavigation() {
-  const preferred = getDetectionTypeFromPath();
-  if (preferred) applyDetectionTypeToUI(preferred);
-  showView('detection-type');
+  showView('dashboard');
+  loadHistory();
 }
 
 // ---- Forgot password ----
@@ -187,13 +143,8 @@ async function init() {
   try {
     const user = await api('GET', '/api/me');
     document.getElementById('user-email').textContent = user.email;
-    // Always show the selection menu first.
-    // If the user already landed on /detect/change or /detect/landslide, we
-    // pre-select the corresponding detection type in the dropdown for convenience,
-    // but we still show the menu page before redirecting.
-    const preferred = getDetectionTypeFromPath();
-    if (preferred) applyDetectionTypeToUI(preferred);
-    showView('detection-type');
+    showView('dashboard');
+    loadHistory();
   } catch (_) { setToken(null); showView('login'); }
 }
 
@@ -238,42 +189,6 @@ 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 vs Pothole) ----
-(function initDetectionMenu() {
-  const typeSel = document.getElementById('detect-type');
-  const landslideGroup = document.getElementById('landslide-model-group');
-  const potholeGroup = document.getElementById('pothole-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';
-    const isPothole = typeSel.value === 'pothole_detection';
-    const beforeZone = document.getElementById('zone-before');
-    const beforeInput = document.getElementById('file-before');
-    const beforeName = document.getElementById('name-before');
-    if (landslideGroup) landslideGroup.classList.toggle('hidden', !isLandslide);
-    if (potholeGroup) potholeGroup.classList.toggle('hidden', !isPothole);
-    const hideCore = isLandslide || isPothole;
-    if (methodGroup) methodGroup.classList.toggle('hidden', hideCore);
-    if (regGroup) regGroup.classList.toggle('hidden', hideCore);
-    if (normGroup) normGroup.classList.toggle('hidden', hideCore);
-    // Pothole mode uses a single image upload (after image).
-    if (beforeZone) beforeZone.classList.toggle('hidden', isPothole);
-    if (isPothole && beforeInput) {
-      beforeInput.value = '';
-      if (beforeName) beforeName.textContent = 'No file chosen';
-      const prev = document.getElementById('preview-before');
-      if (prev) prev.classList.add('hidden');
-    }
-  }
-
-  typeSel.addEventListener('change', refresh);
-  refresh();
-})();
-
 // ---- Delhi Zone → Village cascading dropdowns ----
 const DELHI_ZONES = {
   "Central Delhi": [
@@ -481,15 +396,9 @@ function stopDetectionProgress(success) {
 document.getElementById('form-detect')?.addEventListener('submit', async (e) => {
   e.preventDefault();
   hideError('dashboard-error');
-  const detectionType = document.getElementById('detect-type')?.value || 'change_detection';
   const before = document.getElementById('file-before').files?.[0];
   const after = document.getElementById('file-after').files?.[0];
-  if (detectionType === 'pothole_detection') {
-    if (!after && !before) {
-      showError('dashboard-error', 'Please upload one road image for pothole detection.');
-      return;
-    }
-  } else if (!before || !after) {
+  if (!before || !after) {
     showError('dashboard-error', 'Please select both before and after images.');
     return;
   }
@@ -498,20 +407,13 @@ document.getElementById('form-detect')?.addEventListener('submit', async (e) =>
   const loading = document.getElementById('run-loading');
   btn.disabled = true;
   loading.classList.remove('hidden');
-   startDetectionProgress();
+  startDetectionProgress();
 
   const token = getToken();
   const form = new FormData();
-  if (before) form.append('before', before);
-  if (after) form.append('after', after);
-  form.append('detection_type', detectionType);
+  form.append('before', before);
+  form.append('after', after);
   form.append('method', document.getElementById('detect-method').value);
-  if (detectionType === 'landslide_detection') {
-    form.append('landslide_model', document.getElementById('landslide-model')?.value || 'Rule-Based v1');
-  }
-  if (detectionType === 'pothole_detection') {
-    form.append('pothole_model', document.getElementById('pothole-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

@@ -131,25 +131,6 @@
     </section>
 
     <!-- Dashboard view -->
-    <section id="view-detection-type" class="view">
-      <div class="auth-container">
-        <div class="auth-logo">
-          <div class="auth-logo-icon">
-            <svg width="36" height="36" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2l9 4.5-9 4.5-9-4.5L12 2z"/><path d="M3 6.5V17.5L12 22l9-4.5V6.5"/><path d="M12 11v11"/></svg>
-          </div>
-          <span>Choose Detection Type</span>
-        </div>
-        <div class="card">
-          <h2 style="margin-bottom:0.75rem;">Select what you want to detect</h2>
-          <button type="button" class="btn btn-primary btn-block" id="btn-type-change">General Change Detection</button>
-          <div style="height:0.75rem;"></div>
-          <button type="button" class="btn btn-secondary btn-block" id="btn-type-landslide">Landslide Detection (Uttarakhand)</button>
-          <div style="height:0.75rem;"></div>
-          <button type="button" class="btn btn-secondary btn-block" id="btn-type-pothole">Pothole Detection</button>
-        </div>
-      </div>
-    </section>
-
     <section id="view-dashboard" class="view">
       <div class="topbar">
         <div class="nav-user">
@@ -177,28 +158,6 @@
           <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>
-                <option value="pothole_detection">Pothole Detection</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 class="form-group hidden" id="pothole-model-group">
-              <label for="pothole-model">Pothole Model</label>
-              <select id="pothole-model">
-                <option value="Rule-Based v1" selected>Rule-Based v1 (Edges + Shadows + Texture)</option>
-              </select>
-            </div>
-          </div>
           <div class="location-row">
             <div class="form-group">
               <label for="detect-zone">
@@ -401,6 +360,6 @@
     </div>
   </div>
 
-  <script src="/static/js/app.js?v=32"></script>
+  <script src="/static/js/app.js?v=33"></script>
 </body>
 </html>