Upload agents/sensor_agent.py with huggingface_hub

agents/sensor_agent.py

@@ -198,13 +198,158 @@ def analyze_bayer_demosaicing(img: Image.Image) -> Dict[str, Any]:
     }
 
 
+# ─── CFA Pattern Verification ────────────────────────────────────────
+def analyze_cfa_pattern(img: Image.Image) -> Dict[str, Any]:
+    """
+    Real camera images retain traces of CFA (Color Filter Array) interpolation.
+    Detect periodic patterns in cross-channel differences at Nyquist frequency.
+    """
+    rgb = np.array(img.convert("RGB")).astype(np.float64)
+    r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
+
+    # Compute RG and BG differences
+    rg = r - g
+    bg = b - g
+
+    # 2D FFT of difference channels
+    fft_rg = np.abs(np.fft.fftshift(np.fft.fft2(rg)))
+    fft_bg = np.abs(np.fft.fftshift(np.fft.fft2(bg)))
+
+    h, w = fft_rg.shape
+    cy, cx = h // 2, w // 2
+
+    # Check for Bayer CFA signature: peaks at (N/2, 0), (0, N/2), (N/2, N/2)
+    nyquist_energy_rg = float(
+        fft_rg[cy, 0] + fft_rg[0, cx] + fft_rg[0, 0]
+    ) / 3
+    center_energy_rg = float(np.mean(fft_rg[cy - 5:cy + 5, cx - 5:cx + 5]))
+    cfa_ratio = nyquist_energy_rg / (center_energy_rg + 1e-9)
+
+    if cfa_ratio > 1.5:
+        score = -0.3
+        note = f"CFA interpolation traces detected (ratio={cfa_ratio:.2f}, real camera)"
+    elif cfa_ratio < 0.5:
+        score = 0.3
+        note = f"No CFA traces (ratio={cfa_ratio:.2f}, possible AI generation)"
+    else:
+        score = 0.0
+        note = f"Ambiguous CFA analysis (ratio={cfa_ratio:.2f})"
+
+    return {
+        "test": "CFA Pattern Verification",
+        "cfa_nyquist_ratio": round(cfa_ratio, 4),
+        "score": score,
+        "note": note,
+    }
+
+
+# ─── Hot/Dead Pixel Analysis ────────────────────────────────────────
+def analyze_hot_dead_pixels(img: Image.Image) -> Dict[str, Any]:
+    """
+    Real sensors have hot (stuck bright) and dead (stuck dark) pixels.
+    AI images lack these sensor defects entirely.
+    """
+    gray = np.array(img.convert("L")).astype(np.float64)
+    h, w = gray.shape
+
+    # Local median filter
+    from scipy.ndimage import median_filter
+    med = median_filter(gray, size=5)
+
+    diff = np.abs(gray - med)
+
+    # Hot pixels: much brighter than neighbors
+    hot_threshold = np.percentile(diff, 99.9)
+    hot_pixels = int(np.sum(diff > hot_threshold))
+
+    # Dead pixels: much darker than neighbors AND very low absolute value
+    dark_mask = (gray < 5) & (diff > hot_threshold * 0.5)
+    dead_pixels = int(np.sum(dark_mask))
+
+    total_defects = hot_pixels + dead_pixels
+    defect_rate = total_defects / (h * w)
+
+    # Real cameras: typically 0.001%-0.01% defective pixels
+    if 0.00001 < defect_rate < 0.001:
+        score = -0.2
+        note = f"Sensor defects detected ({total_defects} pixels, rate={defect_rate:.6f}, real camera)"
+    elif defect_rate < 0.000001:
+        score = 0.2
+        note = f"No sensor defects ({total_defects} pixels, possible AI generation)"
+    else:
+        score = 0.0
+        note = f"Defect rate={defect_rate:.6f} ({total_defects} pixels)"
+
+    return {
+        "test": "Hot/Dead Pixel Analysis",
+        "hot_pixels": hot_pixels,
+        "dead_pixels": dead_pixels,
+        "defect_rate": round(defect_rate, 8),
+        "score": score,
+        "note": note,
+    }
+
+
+# ─── JPEG Quantization Table Analysis ───────────────────────────────
+def analyze_jpeg_quantization(img: Image.Image) -> Dict[str, Any]:
+    """
+    Real JPEG images have specific quantization tables from camera firmware.
+    AI-generated images saved as JPEG have generic tables.
+    Double-compressed images show quantization table mismatches.
+    """
+    try:
+        qtables = img.quantization
+        if qtables:
+            # Standard JPEG quality tables
+            tables = list(qtables.values())
+            n_tables = len(tables)
+
+            # Analyze first table (luminance)
+            if tables:
+                t = np.array(list(tables[0].values()) if isinstance(tables[0], dict) else list(tables[0]))
+                if len(t) == 64:
+                    # Check for standard Photoshop/camera patterns
+                    is_uniform = float(np.std(t)) < 5
+                    max_q = int(np.max(t))
+                    min_q = int(np.min(t))
+
+                    if is_uniform:
+                        score = 0.2
+                        note = f"Unusual uniform quantization table (std={np.std(t):.1f})"
+                    elif max_q > 100:
+                        score = -0.2
+                        note = f"Heavy compression quantization (max={max_q}, camera-typical)"
+                    else:
+                        score = -0.1
+                        note = f"Standard quantization table ({n_tables} tables, range=[{min_q},{max_q}])"
+                else:
+                    score = 0.0
+                    note = "Non-standard quantization table size"
+            else:
+                score = 0.1
+                note = "No luminance quantization table found"
+        else:
+            score = 0.1
+            note = "No quantization tables (not JPEG or tables stripped)"
+    except Exception:
+        score = 0.0
+        note = "Unable to read quantization tables"
+
+    return {
+        "test": "JPEG Quantization Table",
+        "score": score,
+        "note": note,
+    }
+
+
 # ─── Main Agent Entry Point ─────────────────────────────────────────
 def run_sensor_agent(img: Image.Image) -> AgentEvidence:
     """Run all sensor characteristic tests."""
     findings = []
     scores = []
 
-    for fn in [analyze_prnu, analyze_noise_structure, analyze_bayer_demosaicing]:
+    for fn in [analyze_prnu, analyze_noise_structure, analyze_bayer_demosaicing,
+               analyze_cfa_pattern, analyze_hot_dead_pixels, analyze_jpeg_quantization]:
         try:
             result = fn(img)
             findings.append(result)
@@ -233,7 +378,7 @@ def run_sensor_agent(img: Image.Image) -> AgentEvidence:
         agent_name="Sensor Characteristics Agent",
         violation_score=np.clip(avg_score, -1, 1),
         confidence=confidence,
-        failure_prob=max(0.0, 1.0 - len(scores) / 3),
+        failure_prob=max(0.0, 1.0 - len(scores) / 6),
         rationale=rationale,
         sub_findings=findings,
     )