Fix water misclassification and reduce detection hallucinations.

Use confidence-pruned union fusion, structural evidence to prefer building
over water, and stricter region filters for low-confidence speckle.

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

Dockerfile

@@ -19,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=25
+ARG APP_BUILD=26
 ENV APP_BUILD=${APP_BUILD}
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V
 

app/detection_engine.py

@@ -797,35 +797,120 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5, registration_ok=True):
     return change_mask, classical_score, debug
 
 
+def _smart_union_fusion(model_mask, rule_mask, dl_score, classical_score, sensitivity=0.5):
+    """
+    Union with confidence pruning: keep pixels where at least one engine is
+    confident, or both agree. Drops weak single-engine speckle (hallucinations).
+    """
+    sens = float(np.clip(sensitivity, 0.0, 1.0))
+    model_on = model_mask > 127
+    rule_on = rule_mask > 127
+    both_agree = model_on & rule_on
+
+    dl_floor = 0.32 + (1.0 - sens) * 0.10
+    cl_q = float(np.clip(0.91 - (sens - 0.5) * 0.03, 0.87, 0.94))
+    cl_floor = (
+        float(np.quantile(classical_score, cl_q))
+        if float(classical_score.max()) > 1e-6 else 0.38
+    )
+
+    dl_ok = dl_score >= dl_floor
+    cl_ok = classical_score >= cl_floor
+    keep = both_agree | (model_on & dl_ok) | (rule_on & cl_ok)
+    return np.where(keep, 255, 0).astype(np.uint8)
+
+
+def _structural_evidence(diff, feat_a):
+    """Score how strongly a region looks like built structure (not water/vegetation)."""
+    score = 0.0
+    if diff:
+        if diff.get("delta_lines", 0) > 2:
+            score += 0.28
+        if diff.get("delta_corners", 0) > 3:
+            score += 0.24
+        if diff.get("delta_edge_density", 0) > 8:
+            score += 0.20
+        if diff.get("hull_ratio_after", 0) > 0.35:
+            score += 0.18
+        if diff.get("lines_after", 0) > 4:
+            score += 0.14
+        if diff.get("ssim", 1.0) < 0.65:
+            score += 0.12
+    if feat_a.get("edge_density", 0) > 35:
+        score += 0.18
+    if feat_a.get("orientation_entropy", 3.0) < 2.4:
+        score += 0.14
+    return min(1.0, score)
+
+
+def _resolve_classification(scores, diff, feat_a):
+    """Apply cross-type constraints; fix water vs construction confusion."""
+    structural = _structural_evidence(diff, feat_a)
+
+    water = scores.get("Water Body Change", 0.0)
+    bld = scores.get("New Construction/Building", 0.0)
+
+    water_cues = sum([
+        feat_a["blue_ratio"] > 0.38,
+        feat_a["edge_density"] < 28,
+        feat_a["texture_std"] < 26,
+        95 <= feat_a["hue"] <= 130,
+        feat_a["lbp_variance"] < 0.045,
+    ])
+    if water_cues < 3:
+        scores["Water Body Change"] = water * 0.45
+    elif water_cues < 4:
+        scores["Water Body Change"] = water * 0.75
+
+    if structural >= 0.30:
+        scores["Water Body Change"] *= max(0.1, 1.0 - structural * 1.2)
+        scores["New Construction/Building"] = min(1.0, bld + structural * 0.45)
+
+    best = max(scores, key=scores.get)
+    conf = scores[best]
+
+    if (
+        best == "Water Body Change"
+        and scores["New Construction/Building"] >= conf * 0.72
+        and structural >= 0.22
+    ):
+        best = "New Construction/Building"
+        conf = scores["New Construction/Building"]
+
+    return best, conf
+
+
 def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
     """
-    Dual-engine approach: AdaptFormer for structure + classical fusion for
-    vegetation/texture. Union (not gated AND) maximizes recall.
+    Dual-engine: AdaptFormer + classical fusion with confidence-pruned union.
     """
     from .model_inference import is_model_available, predict_change_mask
 
     model_mask = None
+    dl_score = None
     model_ok = False
-    threshold = 0.25 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
+    threshold = 0.30 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.22
 
     if is_model_available():
         try:
-            model_mask, _ = predict_change_mask(img1, img2, threshold=threshold)
-            model_mask = _clean_mask(model_mask, sensitivity=sensitivity)
-            model_ok = model_mask is not None
+            model_mask, dl_score = predict_change_mask(img1, img2, threshold=threshold)
+            model_ok = dl_score is not None
         except Exception as e:
             _log.warning("AdaptFormer inference failed: %s", e)
 
-    rule_mask, _, core_debug = _ai_fusion_core(
+    rule_mask, classical_score, core_debug = _ai_fusion_core(
         img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
 
-    if model_ok and model_mask is not None:
-        combined = np.maximum(model_mask, rule_mask)
+    if model_ok and dl_score is not None:
+        if model_mask is None:
+            model_mask = (dl_score >= threshold).astype(np.uint8) * 255
+        combined = _smart_union_fusion(
+            model_mask, rule_mask, dl_score, classical_score, sensitivity=sensitivity)
         combined = _clean_mask(combined, sensitivity=sensitivity)
         debug = {
-            "method": "AI-Based Deep Learning (AdaptFormer + rule-based union)",
+            "method": "AI-Based Deep Learning (AdaptFormer + confidence union)",
             "model": "adaptformer-levir-cd",
-            "fusion": "union",
+            "fusion": "smart_union",
             "threshold_used": int(threshold * 255),
             "sensitivity": float(sensitivity),
             "model_changed_px": int(np.sum(model_mask > 127)),
@@ -1030,7 +1115,7 @@ def _clean_mask(mask, sensitivity=0.5, border_margin=12):
     filled = cv2.dilate(filled, k_break, iterations=1)
 
     # 7. Component-level filtering: remove tiny survivors and elongated noise
-    min_component_px = max(50, int(h * w * 0.00003))
+    min_component_px = max(80, int(h * w * 0.000035))
     num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(filled, connectivity=8)
     clean = np.zeros_like(filled)
     for i in range(1, num_labels):
@@ -1401,20 +1486,23 @@ def classify_object_type(image_region, bbox, before_region=None):
 
     # ---- Water Body Change ----
     water = 0.0
-    if feat_a["blue_ratio"] > 0.36:
-        water += 0.22
-    if feat_a["texture_std"] < 28:
-        water += 0.18
-    if feat_a["edge_density"] < 35:
-        water += 0.14
-    if 90 <= feat_a["hue"] <= 135:
-        water += 0.18
-    if feat_a["lbp_variance"] < 0.05:
-        water += 0.14
-    if feat_a["glcm_contrast"] < 500:
-        water += 0.10
-    if area > 800:
-        water += 0.04
+    if diff and _structural_evidence(diff, feat_a) >= 0.25:
+        water = 0.0
+    else:
+        if feat_a["blue_ratio"] > 0.38:
+            water += 0.22
+        if feat_a["texture_std"] < 26:
+            water += 0.18
+        if feat_a["edge_density"] < 28:
+            water += 0.16
+        if 95 <= feat_a["hue"] <= 130:
+            water += 0.18
+        if feat_a["lbp_variance"] < 0.045:
+            water += 0.14
+        if feat_a["glcm_contrast"] < 450:
+            water += 0.08
+        if area > 1200:
+            water += 0.04
     scores["Water Body Change"] = water
 
     # ---- Vegetation Change ----
@@ -1694,10 +1782,9 @@ def classify_object_type(image_region, bbox, before_region=None):
         soil += 0.10
     scores["Bare Land/Soil Change"] = soil
 
-    best = max(scores, key=scores.get)
-    conf = scores[best]
+    best, conf = _resolve_classification(scores, diff, feat_a)
 
-    if conf < 0.22:
+    if conf < 0.28:
         return "Unclassified", conf
     return best, min(conf, 1.0)
 
@@ -2387,7 +2474,7 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
     # - keeps sensitivity on smaller images
     # - suppresses speckle noise on larger images
     if min_area is None:
-        min_area = int(max(200, min(1000, img_area * 0.00008)))
+        min_area = int(max(250, min(1000, img_area * 0.00009)))
 
     for i in range(1, num_labels):
         raw_area = stats[i, cv2.CC_STAT_AREA]
@@ -2397,7 +2484,7 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
         x, y, w, h, fill_ratio = _tight_bbox(labels, i, stats[i])
 
         # Reject very sparse regions (bbox is mostly empty)
-        if fill_ratio < 0.12:
+        if fill_ratio < 0.15:
             continue
 
         # Keep large real changes; only suppress near-full-frame artifacts.
@@ -2416,14 +2503,15 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
                 image, (x, y, w, h), before_region=before_img)
 
         if object_type is None:
-            # Do not silently drop large coherent regions; keep them as generic
-            # ground-change candidates so key changes are still surfaced.
-            if raw_area >= max(min_area * 2, 800) and fill_ratio >= 0.18:
+            if raw_area >= max(min_area * 2, 900) and fill_ratio >= 0.20:
                 object_type = "Unclassified Ground Change"
                 confidence = max(0.2, min(0.5, fill_ratio))
             else:
                 continue
 
+        if confidence < 0.24 and raw_area < min_area * 3:
+            continue
+
         region_id += 1
         region = {
             "id": region_id,

app/main.py

@@ -70,7 +70,7 @@ except Exception as e:
     import logging
     logging.getLogger("uvicorn.error").warning("Startup migration skipped: %s", e)
 
-app = FastAPI(title="AI Change Detection", version="2.2.2")
+app = FastAPI(title="AI Change Detection", version="2.2.3")
 
 
 @app.get("/health")
@@ -82,7 +82,7 @@ def health():
     model = get_model_status()
     return {
         "status": "ok" if model.get("available") else "degraded",
-        "version": "2.2.2",
+        "version": "2.2.3",
         "server_time_ist": _isoformat_ist(datetime.now(timezone.utc)),
         "adaptFormer": model,
     }

app/model_inference.py

@@ -98,14 +98,14 @@ def preload_model():
 def get_model_status() -> dict:
     """Status for /health — shows whether AI detection or classical fallback is active."""
     if _AVAILABLE is True:
-        mode = "adaptformer_union_fusion"
+        mode = "adaptformer_smart_union"
         available = True
     elif _LOAD_FAILED:
         mode = "classical_fallback"
         available = False
     else:
         available = is_model_available()
-        mode = "adaptformer_union_fusion" if available else "classical_fallback"
+        mode = "adaptformer_smart_union" if available else "classical_fallback"
 
     return {
         "modelId": _MODEL_ID,