feat: add cross-indicator compound signal detection

Implements compound signal module with 4 detection patterns:
- land_conversion: NDVI decline + settlement growth
- flood_event: SAR backscatter decrease + water increase
- drought_stress: NDVI decline + water decline + SAR increase
- displacement_pressure: settlement growth adjacent to vegetation loss

Includes overlap calculation, confidence tagging, and comprehensive tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

app/analysis/compound.py

@@ -0,0 +1,109 @@
+"""Cross-indicator compound signal detection."""
+from __future__ import annotations
+
+import numpy as np
+
+from app.models import CompoundSignal
+
+
+def compute_overlap_pct(mask_a: np.ndarray, mask_b: np.ndarray) -> float:
+    """Compute overlap percentage: intersection / min(count_a, count_b) * 100."""
+    intersection = np.sum(mask_a & mask_b)
+    min_count = min(np.sum(mask_a), np.sum(mask_b))
+    if min_count == 0:
+        return 0.0
+    return float(intersection / min_count * 100)
+
+
+def _tag_confidence(n_indicators: int, overlap_pct: float) -> str:
+    if n_indicators >= 3 and overlap_pct > 20:
+        return "strong"
+    if n_indicators >= 2 and overlap_pct >= 10:
+        return "moderate"
+    return "weak"
+
+
+def detect_compound_signals(
+    zscore_rasters: dict[str, np.ndarray],
+    pixel_area_ha: float,
+    threshold: float = 2.0,
+) -> list[CompoundSignal]:
+    """Test for compound signal patterns across indicator z-score rasters."""
+    decline: dict[str, np.ndarray] = {}
+    increase: dict[str, np.ndarray] = {}
+    for ind_id, z in zscore_rasters.items():
+        decline[ind_id] = z < -threshold
+        increase[ind_id] = z > threshold
+
+    signals: list[CompoundSignal] = []
+
+    # 1. Land conversion: NDVI decline + Settlement growth
+    if "ndvi" in decline and "buildup" in increase:
+        overlap = compute_overlap_pct(decline["ndvi"], increase["buildup"])
+        triggered = overlap > 10
+        affected = float(np.sum(decline["ndvi"] & increase["buildup"])) * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="land_conversion", triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"NDVI decline overlaps with settlement growth ({overlap:.0f}% overlap, "
+                f"{affected:.1f} ha affected). Suggests possible vegetation loss to urbanization."
+            ) if triggered else "No land conversion signal detected.",
+            indicators=["ndvi", "buildup"], overlap_pct=overlap, affected_ha=affected,
+        ))
+
+    # 2. Flood event: SAR decrease + Water increase
+    if "sar" in decline and "water" in increase:
+        overlap = compute_overlap_pct(decline["sar"], increase["water"])
+        triggered = overlap > 10
+        affected = float(np.sum(decline["sar"] & increase["water"])) * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="flood_event", triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"SAR backscatter decrease coincides with water extent increase "
+                f"({overlap:.0f}% overlap, {affected:.1f} ha). Suggests potential flooding."
+            ) if triggered else "No flood signal detected.",
+            indicators=["sar", "water"], overlap_pct=overlap, affected_ha=affected,
+        ))
+
+    # 3. Drought stress: NDVI decline + Water decline + SAR increase
+    if "ndvi" in decline and "water" in decline and "sar" in increase:
+        combined = decline["ndvi"] & decline["water"] & increase["sar"]
+        n_combined = int(np.sum(combined))
+        min_single = min(np.sum(decline["ndvi"]), np.sum(decline["water"]), np.sum(increase["sar"]))
+        overlap = float(n_combined / min_single * 100) if min_single > 0 else 0.0
+        triggered = overlap > 10
+        affected = n_combined * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="drought_stress", triggered=triggered,
+            confidence=_tag_confidence(3, overlap) if triggered else "weak",
+            description=(
+                f"NDVI decline, water decline, and SAR increase co-occur "
+                f"({overlap:.0f}% overlap, {affected:.1f} ha). Suggests possible drought."
+            ) if triggered else "No drought signal detected.",
+            indicators=["ndvi", "water", "sar"], overlap_pct=overlap, affected_ha=affected,
+        ))
+
+    # 4. Displacement pressure: Settlement growth + NDVI decline adjacent
+    if "buildup" in increase and "ndvi" in decline:
+        from scipy.ndimage import binary_dilation
+        expanded_buildup = binary_dilation(increase["buildup"], iterations=1)
+        adjacent_decline = expanded_buildup & decline["ndvi"] & ~increase["buildup"]
+        n_adjacent = int(np.sum(adjacent_decline))
+        n_buildup = int(np.sum(increase["buildup"]))
+        overlap = float(n_adjacent / max(n_buildup, 1) * 100)
+        triggered = overlap > 10 and n_adjacent > 0
+        affected = n_adjacent * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="displacement_pressure", triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"Settlement growth hotspots are adjacent to NDVI decline areas "
+                f"({affected:.1f} ha of surrounding vegetation loss). "
+                f"Suggests expansion into previously vegetated land."
+            ) if triggered else "No displacement pressure signal detected.",
+            indicators=["ndvi", "buildup"], overlap_pct=overlap, affected_ha=affected,
+        ))
+
+    return signals

tests/test_compound.py

@@ -0,0 +1,54 @@
+"""Tests for cross-indicator compound signal detection."""
+import numpy as np
+import pytest
+
+
+def test_compute_overlap_pct():
+    from app.analysis.compound import compute_overlap_pct
+    a = np.array([[True, True, False], [False, False, True]], dtype=bool)
+    b = np.array([[True, False, False], [False, False, True]], dtype=bool)
+    pct = compute_overlap_pct(a, b)
+    assert pct > 0
+
+
+def test_detect_land_conversion():
+    from app.analysis.compound import detect_compound_signals
+    ndvi_z = np.full((10, 10), -2.5, dtype=np.float32)
+    buildup_z = np.full((10, 10), 2.5, dtype=np.float32)
+    water_z = np.zeros((10, 10), dtype=np.float32)
+    sar_z = np.zeros((10, 10), dtype=np.float32)
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": ndvi_z, "water": water_z, "sar": sar_z, "buildup": buildup_z},
+        pixel_area_ha=0.04, threshold=2.0,
+    )
+    land_conv = [s for s in signals if s.name == "land_conversion"]
+    assert len(land_conv) == 1
+    assert land_conv[0].triggered is True
+    assert "ndvi" in land_conv[0].indicators
+    assert "buildup" in land_conv[0].indicators
+
+
+def test_no_signals_when_all_normal():
+    from app.analysis.compound import detect_compound_signals
+    normal = np.zeros((10, 10), dtype=np.float32)
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": normal, "water": normal, "sar": normal, "buildup": normal},
+        pixel_area_ha=0.04, threshold=2.0,
+    )
+    triggered = [s for s in signals if s.triggered]
+    assert len(triggered) == 0
+
+
+def test_flood_signal():
+    from app.analysis.compound import detect_compound_signals
+    sar_z = np.full((10, 10), -2.5, dtype=np.float32)
+    water_z = np.full((10, 10), 2.5, dtype=np.float32)
+    ndvi_z = np.zeros((10, 10), dtype=np.float32)
+    buildup_z = np.zeros((10, 10), dtype=np.float32)
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": ndvi_z, "water": water_z, "sar": sar_z, "buildup": buildup_z},
+        pixel_area_ha=0.04, threshold=2.0,
+    )
+    flood = [s for s in signals if s.name == "flood_event"]
+    assert len(flood) == 1
+    assert flood[0].triggered is True