v5: Add minimum Bayer margin (0.005) to prevent JPEG-induced false Bayer detection on AI images

agents/modality_detector.py

@@ -1,12 +1,10 @@
 """
-FORENSIQ — Capture Modality Detector v4
+FORENSIQ — Capture Modality Detector v5
 
-Classifies images BEFORE forensic analysis. Pure content-based detection
-that works even when Gradio strips metadata (format=None, no EXIF).
-
-v4 fix: sharpness_ratio > 3.0 is now a HARD requirement for macro detection.
-Without extreme center-vs-edge sharpness, other indicators (bimodal ratio,
-background uniformity) are not sufficient to distinguish macro from landscape.
+v5: Added minimum bayer_margin threshold (0.005) to prevent JPEG re-encoding
+from creating false Bayer CFA patterns on AI images. Real cameras have 
+bayer_margin > 0.01; AI images through JPEG have margin < 0.001.
+Also: sharpness_ratio > 3.0 hard gate for macro detection.
 """
 
 import sys
@@ -25,6 +23,12 @@ class ModalityResult:
     score_adjustments: dict
 
 
+# Minimum Bayer CFA margin — below this, the "Bayer" signal is likely
+# JPEG encoding artifacts, not a real camera sensor signature.
+# Real cameras: margin > 0.01. JPEG artifacts: margin < 0.001.
+MIN_BAYER_MARGIN = 0.005
+
+
 def detect_modality(img: Image.Image) -> ModalityResult:
     """Detect capture modality from image content and metadata."""
     indicators = {}
@@ -35,23 +39,29 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     rgb = np.array(img.convert("RGB")).astype(np.float64)
     
     # ═══ CRITICAL PRE-CHECK: Bayer CFA pattern ═══════════════════════
+    # Real camera: σ_green < σ_red ≈ σ_blue (green has 2x sampling density)
+    # AI image through JPEG: all channels have ~same noise (margin ≈ 0)
     noise_std = {}
     for c, nm in enumerate(["red", "green", "blue"]):
         ch = rgb[:, :, c]
         dn = gaussian_filter(ch, sigma=1.5)
         noise_std[nm] = float(np.std(ch - dn))
     
-    has_bayer = noise_std["green"] < min(noise_std["red"], noise_std["blue"])
     bayer_margin = min(noise_std["red"], noise_std["blue"]) - noise_std["green"]
+    # Require BOTH: green < min(red, blue) AND margin above noise floor
+    has_bayer = (noise_std["green"] < min(noise_std["red"], noise_std["blue"]) 
+                 and bayer_margin > MIN_BAYER_MARGIN)
+    
     indicators["has_bayer"] = has_bayer
     indicators["bayer_margin"] = round(bayer_margin, 4)
+    indicators["bayer_margin_threshold"] = MIN_BAYER_MARGIN
     indicators["noise_g"] = round(noise_std["green"], 3)
     indicators["noise_r"] = round(noise_std["red"], 3)
     indicators["noise_b"] = round(noise_std["blue"], 3)
     
-    # ═══ CONTENT-BASED DETECTION (works without metadata) ═════════════
+    # ═══ CONTENT-BASED DETECTION ═════════════════════════════════════
     
-    # ── Sharpness analysis (shared by portrait and macro) ─────────────
+    # ── Sharpness analysis ────────────────────────────────────────────
     lap = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float64)
     laplacian = convolve2d(gray, lap, mode="same", boundary="symm")
     sharpness = gaussian_filter(np.abs(laplacian), sigma=max(10, min(h, w) // 80))
@@ -61,32 +71,26 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     p75 = float(np.percentile(sharpness, 75))
     p95 = float(np.percentile(sharpness, 95))
     
-    # Bimodality: large gap between p25 and p75
     iqr = p75 - p25
     bimodal_ratio = iqr / (p50 + 1e-9)
     
-    # Sharp region detection
     sharp_thresh = p75
     sharp_region = sharpness > sharp_thresh
     sharp_frac = float(np.mean(sharp_region))
     
-    # Blur region: use content-based threshold (20% of p95)
-    # This is more meaningful than percentile-based — it measures actual blur
+    # Blur region: content-based threshold (20% of p95)
     blur_content_thresh = p95 * 0.20
     blur_region = sharpness < blur_content_thresh
     blur_frac = float(np.mean(blur_region))
     
-    # Blur uniformity (computational/optical blur is very uniform)
     blur_vals = sharpness[blur_region] if np.any(blur_region) else np.array([1])
     blur_uniformity = 1.0 - min(float(np.std(blur_vals)) / (float(np.mean(blur_vals)) + 1e-9), 1.0)
     
-    # Transition abruptness (computational segmentation = sharp boundary)
     sharpness_grad = np.hypot(sobel(sharpness, 0), sobel(sharpness, 1))
     max_grad = float(np.percentile(sharpness_grad, 99))
     mean_grad = float(np.mean(sharpness_grad))
     transition = max_grad / (mean_grad + 1e-9)
     
-    # Absolute detail level (real photos have p95 > 5 even after heavy compression)
     has_detail = p95 > 5.0
     
     indicators["p95_sharpness"] = round(p95, 2)
@@ -114,11 +118,6 @@ def detect_modality(img: Image.Image) -> ModalityResult:
         indicators["portrait_detected"] = True
     
     # ── Macro/DSLR shallow DoF detection ─────────────────────────────
-    # KEY INSIGHT: The defining feature of macro photography is EXTREME
-    # center-vs-edge sharpness difference (>3x). Without this, an image
-    # cannot be macro — it could be a landscape with fog/haze that mimics
-    # bimodal sharpness distribution.
-    
     ch_s, cw_s = gray.shape
     center_region = sharpness[ch_s//4:3*ch_s//4, cw_s//4:3*cw_s//4]
     edge_region = np.concatenate([
@@ -131,7 +130,6 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     edge_sharp = float(np.mean(edge_region))
     sharpness_ratio = center_sharp / (edge_sharp + 1e-9)
     
-    # Background uniformity
     blur_region_pixels = gray[blur_region] if np.any(blur_region) else np.array([128])
     bg_color_std = float(np.std(blur_region_pixels))
     
@@ -140,33 +138,24 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     indicators["center_sharp_p90"] = round(center_sharp, 2)
     indicators["edge_sharp_mean"] = round(edge_sharp, 2)
     
-    # ── Macro scoring (GATED by sharpness_ratio) ─────────────────────
-    # sharpness_ratio > 3.0 is a HARD REQUIREMENT — other signals alone
-    # are not sufficient to distinguish macro from landscape/portrait.
-    
+    # ── Macro scoring (GATED by sharpness_ratio > 3.0) ───────────────
     macro_score = 0.0
     macro_components = []
-    
     macro_gate_passed = has_detail and sharpness_ratio > 3.0
     
     if macro_gate_passed:
-        # Base score for passing the hard gate
         macro_score += 0.25
         macro_components.append(f"ratio={sharpness_ratio:.1f}")
         
-        # Additional indicators (each adds confidence)
         if blur_frac > 0.25:
             macro_score += 0.15
             macro_components.append(f"blur={blur_frac:.2f}")
-        
         if bimodal_ratio > 1.5:
             macro_score += 0.20
             macro_components.append(f"bimodal={bimodal_ratio:.2f}")
-        
         if bg_color_std < 40:
             macro_score += 0.15
             macro_components.append(f"bg_std={bg_color_std:.1f}")
-        
         if blur_uniformity > 0.6:
             macro_score += 0.15
             macro_components.append(f"blur_uni={blur_uniformity:.2f}")
@@ -175,7 +164,6 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     indicators["macro_components"] = macro_components
     indicators["macro_gate_passed"] = macro_gate_passed
     
-    # Macro requires GATE + (Bayer OR high signal strength)
     if macro_score >= 0.55:
         scores["MACRO_DSLR"] = macro_score
         indicators["macro_detected"] = True
@@ -208,7 +196,7 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     
     indicators["blockiness"] = round(blockiness, 3)
     
-    # ═══ METADATA-BASED DETECTION (bonus signals) ═════════════════════
+    # ═══ METADATA-BASED DETECTION ═════════════════════════════════════
     
     try:
         exif = img._getexif() or {}
@@ -226,7 +214,6 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     indicators["has_exif"] = has_exif
     indicators["format"] = getattr(img, 'format', None)
     
-    # Phone brand in EXIF
     phone_brands = ["apple", "samsung", "google", "pixel", "huawei", "xiaomi", "oneplus",
                     "oppo", "vivo", "realme", "motorola", "lg", "nothing"]
     make = decoded.get("Make", "").lower()
@@ -237,13 +224,11 @@ def detect_modality(img: Image.Image) -> ModalityResult:
         scores["SMARTPHONE"] = scores.get("SMARTPHONE", 0) + 0.4
         indicators["phone_brand"] = True
     
-    # Rich EXIF with lens → DSLR
     cam_fields = sum(["Make" in decoded, "Model" in decoded, 
                       "LensModel" in decoded or "LensInfo" in decoded, "FocalLength" in decoded])
     if cam_fields >= 3 and ("LensModel" in decoded or "LensInfo" in decoded):
         scores["DSLR"] = scores.get("DSLR", 0) + 0.5
     
-    # No EXIF + low res + double JPEG → messaging
     max_side = max(w, h)
     no_exif_low_res = not has_exif and max_side <= 1600
     if no_exif_low_res:
@@ -262,35 +247,32 @@ def detect_modality(img: Image.Image) -> ModalityResult:
         modality = max(scores, key=scores.get)
         conf = min(1.0, scores[modality])
     
-    # Macro DSLR wins over portrait mode when detected (more specific)
     if scores.get("MACRO_DSLR", 0) >= 0.4:
         modality = "MACRO_DSLR"
         conf = min(1.0, scores["MACRO_DSLR"])
-    # Portrait mode wins when detected and no macro
     elif scores.get("PORTRAIT_MODE", 0) > 0.3:
         modality = "PORTRAIT_MODE"
         conf = min(1.0, scores["PORTRAIT_MODE"])
     
-    # SAFETY GUARD 1: No detail = possible AI. Disable all suppression.
+    # SAFETY GUARD 1: No detail = possible AI
     if not has_detail:
         modality = "UNKNOWN"
         conf = 0.2
         indicators["safety_override"] = "Low-detail image — suppression disabled"
     
-    # SAFETY GUARD 2: No Bayer pattern = not from a real camera sensor.
-    # Exception: MACRO_DSLR with strong signals can bypass this
+    # SAFETY GUARD 2: No real Bayer = not a real camera
     if not has_bayer and modality in ("PORTRAIT_MODE", "SMARTPHONE", "MESSAGING"):
         modality = "UNKNOWN"
         conf = 0.2
-        indicators["safety_override"] = f"No Bayer CFA pattern (margin={bayer_margin:.3f}) — not from a real camera sensor. All suppression disabled."
+        indicators["safety_override"] = f"No Bayer CFA (margin={bayer_margin:.4f} < {MIN_BAYER_MARGIN}) — suppression disabled"
     elif not has_bayer and modality == "MACRO_DSLR" and scores.get("MACRO_DSLR", 0) < 0.55:
         modality = "UNKNOWN"
         conf = 0.2
-        indicators["safety_override"] = f"Macro signal weak ({scores.get('MACRO_DSLR', 0):.2f}) + no Bayer — suppression disabled"
+        indicators["safety_override"] = f"Macro weak ({scores.get('MACRO_DSLR', 0):.2f}) + no Bayer — suppression disabled"
     
     # ═══ DEBUG LOGGING ════════════════════════════════════════════════
     print(f"[MODALITY] detected={modality} conf={conf:.2f} scores={scores}", file=sys.stderr)
-    print(f"[MODALITY] has_bayer={has_bayer} bayer_margin={bayer_margin:.4f}", file=sys.stderr)
+    print(f"[MODALITY] has_bayer={has_bayer} margin={bayer_margin:.4f} (min={MIN_BAYER_MARGIN})", file=sys.stderr)
     print(f"[MODALITY] macro_score={macro_score:.3f} gate={macro_gate_passed} components={macro_components}", file=sys.stderr)
     print(f"[MODALITY] sharpness_ratio={sharpness_ratio:.2f} bimodal={bimodal_ratio:.3f} blur_frac={blur_frac:.3f} blur_uni={blur_uniformity:.3f} bg_std={bg_color_std:.2f}", file=sys.stderr)
     print(f"[MODALITY] p95={p95:.2f} has_detail={has_detail}", file=sys.stderr)
@@ -301,14 +283,12 @@ def detect_modality(img: Image.Image) -> ModalityResult:
     
     adjustments = _get_modality_adjustments(modality)
     
-    # Merge messaging adjustments when portrait + messaging both detected
     if modality == "PORTRAIT_MODE" and scores.get("MESSAGING", 0) > 0.15:
         msg_adj = _get_modality_adjustments("MESSAGING")
         for k, v in msg_adj.items():
             adjustments[k] = min(adjustments.get(k, 1.0), v)
         indicators["dual_modality"] = "PORTRAIT_MODE + MESSAGING"
     
-    # Merge messaging adjustments when macro + messaging both detected
     if modality == "MACRO_DSLR" and scores.get("MESSAGING", 0) > 0.15:
         msg_adj = _get_modality_adjustments("MESSAGING")
         for k, v in msg_adj.items():
@@ -323,64 +303,32 @@ def detect_modality(img: Image.Image) -> ModalityResult:
 def _get_modality_adjustments(modality: str) -> dict:
     if modality == "MACRO_DSLR":
         return {
-            "Autocorrelation Peak": 0.1,
-            "Texture Repetition": 0.1,
-            "DoF Consistency": 0.1,
-            "Bayer CFA Pattern": 0.3,
-            "CFA Nyquist": 0.3,
-            "PRNU Uniformity": 0.2,
-            "Demosaic Interpolation": 0.4,
-            "DCT Kurtosis": 0.1,
-            "Wavelet Kurtosis": 0.1,
-            "Spectral Slope 1/f²": 0.4,
-            "Spectral Symmetry": 0.3,
-            "Phase Coherence": 0.4,
-            "Noise Spatial Frequency": 0.2,
-            "Poisson-Gaussian Model": 0.2,
-            "HF Noise Structure": 0.3,
-            "Pixel Response Linearity": 0.4,
-            "Saturation Clipping": 0.4,
-            "VAE Patch Boundaries": 0.3,
+            "Autocorrelation Peak": 0.1, "Texture Repetition": 0.1, "DoF Consistency": 0.1,
+            "Bayer CFA Pattern": 0.3, "CFA Nyquist": 0.3, "PRNU Uniformity": 0.2,
+            "Demosaic Interpolation": 0.4, "DCT Kurtosis": 0.1, "Wavelet Kurtosis": 0.1,
+            "Spectral Slope 1/f²": 0.4, "Spectral Symmetry": 0.3, "Phase Coherence": 0.4,
+            "Noise Spatial Frequency": 0.2, "Poisson-Gaussian Model": 0.2,
+            "HF Noise Structure": 0.3, "Pixel Response Linearity": 0.4,
+            "Saturation Clipping": 0.4, "VAE Patch Boundaries": 0.3,
         }
     elif modality == "PORTRAIT_MODE":
         return {
-            "Autocorrelation Peak": 0.1,
-            "Texture Repetition": 0.1,
-            "VAE Patch Boundaries": 0.2,
-            "PRNU Uniformity": 0.15,
-            "Poisson-Gaussian Model": 0.3,
-            "DoF Consistency": 0.2,
-            "Vignetting cos⁴θ": 0.3,
-            "HF Noise Structure": 0.3,
-            "Noise Spatial Frequency": 0.3,
-            "CFA Nyquist": 0.25,
-            "Spectral Slope 1/f²": 0.5,
-            "Spectral Symmetry": 0.4,
-            "Phase Coherence": 0.4,
-            "Pixel Response Linearity": 0.3,
-            "Demosaic Interpolation": 0.4,
-            "Saturation Clipping": 0.4,
+            "Autocorrelation Peak": 0.1, "Texture Repetition": 0.1,
+            "VAE Patch Boundaries": 0.2, "PRNU Uniformity": 0.15,
+            "Poisson-Gaussian Model": 0.3, "DoF Consistency": 0.2,
+            "Vignetting cos⁴θ": 0.3, "HF Noise Structure": 0.3,
+            "Noise Spatial Frequency": 0.3, "CFA Nyquist": 0.25,
+            "Spectral Slope 1/f²": 0.5, "Spectral Symmetry": 0.4,
+            "Phase Coherence": 0.4, "Pixel Response Linearity": 0.3,
+            "Demosaic Interpolation": 0.4, "Saturation Clipping": 0.4,
         }
     elif modality == "MESSAGING":
         return {
-            "EXIF Completeness": 0.15,
-            "Compression Ghosts": 0.2,
-            "ICC Color Profile": 0.2,
-            "Maker Note": 0.2,
-            "Thumbnail Check": 0.2,
-            "Software Detection": 0.2,
-            "JPEG Quantization": 0.3,
-            "CFA Nyquist": 0.5,
-            "Watermark Detection": 0.2,
-            "Demosaic Interpolation": 0.5,
-        }
-    elif modality == "SOCIAL_MEDIA":
-        return {
-            "EXIF Completeness": 0.2,
-            "Compression Ghosts": 0.3,
-            "ICC Color Profile": 0.3,
-            "Maker Note": 0.2,
-            "Thumbnail Check": 0.3,
+            "EXIF Completeness": 0.15, "Compression Ghosts": 0.2,
+            "ICC Color Profile": 0.2, "Maker Note": 0.2,
+            "Thumbnail Check": 0.2, "Software Detection": 0.2,
+            "JPEG Quantization": 0.3, "CFA Nyquist": 0.5,
+            "Watermark Detection": 0.2, "Demosaic Interpolation": 0.5,
         }
     elif modality == "SCREENSHOT":
         return {
@@ -393,10 +341,8 @@ def _get_modality_adjustments(modality: str) -> dict:
         }
     elif modality == "SMARTPHONE":
         return {
-            "Vignetting cos⁴θ": 0.5,
-            "CFA Nyquist": 0.7,
-            "Poisson-Gaussian Model": 0.7,
-            "Pixel Response Linearity": 0.4,
+            "Vignetting cos⁴θ": 0.5, "CFA Nyquist": 0.7,
+            "Poisson-Gaussian Model": 0.7, "Pixel Response Linearity": 0.4,
             "Spectral Slope 1/f²": 0.7,
         }
     else: