Upload agents/sensor_agent.py with huggingface_hub

agents/sensor_agent.py

@@ -1,384 +1,229 @@
-"""
-FORENSIQ — Sensor Characteristics Agent
-Analyzes sensor physics violations:
-  - PRNU (Photo-Response Non-Uniformity) noise residual analysis
-  - Noise structure (Poisson-Gaussian model fit)
-  - Bayer demosaicing artifact detection
-"""
-
+"""FORENSIQ — Sensor Characteristics Agent (18 features)"""
 import numpy as np
 from PIL import Image
-from scipy.ndimage import gaussian_filter, uniform_filter
+from scipy.ndimage import gaussian_filter, uniform_filter, median_filter, label
 from scipy.signal import convolve2d
-from dataclasses import dataclass
 from typing import Dict, Any
-
 from agents.optical_agent import AgentEvidence
 
+def _g(img): return np.array(img.convert("L")).astype(np.float64)
+def _rgb(img): return np.array(img.convert("RGB")).astype(np.float64)
 
-# ─── PRNU Noise Residual ────────────────────────────────────────────
-def analyze_prnu(img: Image.Image) -> Dict[str, Any]:
-    """
-    Extract noise residual fingerprint.
-    Real cameras leave a unique PRNU pattern; AI images have uniform or random noise.
-    Inconsistent local noise variance → splicing / AI generation.
-    """
-    rgb = np.array(img.convert("RGB")).astype(np.float64)
-    
-    noise_residuals = []
+def s01_prnu_uniformity(img):
+    rgb=_rgb(img); res=[]
     for c in range(3):
-        channel = rgb[:, :, c]
-        denoised = gaussian_filter(channel, sigma=3.0)
-        residual = channel - denoised
-        noise_residuals.append(residual)
-
-    noise = np.stack(noise_residuals, axis=-1)
-    noise_energy = np.mean(noise ** 2, axis=-1)
-
-    # Local variance map (32x32 blocks)
-    local_var = uniform_filter(noise_energy, size=32)
-    
-    noise_std = float(np.std(local_var))
-    noise_mean = float(np.mean(local_var))
-    uniformity = 1.0 - min(noise_std / (noise_mean + 1e-9), 1.0)
-
-    # Correlation between channels (real sensors have correlated PRNU)
-    r_noise = noise_residuals[0].ravel()
-    g_noise = noise_residuals[1].ravel()
-    b_noise = noise_residuals[2].ravel()
-
-    # Subsample for speed
-    step = max(1, len(r_noise) // 100000)
-    rg_corr = float(np.corrcoef(r_noise[::step], g_noise[::step])[0, 1])
-    rb_corr = float(np.corrcoef(r_noise[::step], b_noise[::step])[0, 1])
-
-    # Real cameras: correlated noise residuals; AI: uncorrelated
-    avg_corr = (rg_corr + rb_corr) / 2
-
-    if uniformity > 0.7 and avg_corr > 0.3:
-        score = -0.4
-        note = "Consistent sensor noise pattern with correlated channels (real camera)"
-    elif uniformity < 0.4:
-        score = 0.5
-        note = "Inconsistent noise regions suggest splicing or AI generation"
-    elif avg_corr < 0.1:
-        score = 0.4
-        note = "Uncorrelated channel noise (atypical for real cameras)"
-    else:
-        score = 0.1
-        note = "Moderate noise consistency"
-
-    return {
-        "test": "PRNU Noise Residual",
-        "noise_uniformity": round(uniformity, 4),
-        "noise_mean": round(noise_mean, 4),
-        "rg_correlation": round(rg_corr, 4),
-        "rb_correlation": round(rb_corr, 4),
-        "score": score,
-        "note": note,
-        "noise_map": noise_energy,
-    }
-
-
-# ─── Noise Structure (Poisson-Gaussian Model) ──────────────────────
-def analyze_noise_structure(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real sensor noise follows σ² = σ²_read + k·I (Poisson-Gaussian).
-    AI images lack this physical noise model.
-    """
-    rgb = np.array(img.convert("RGB")).astype(np.float64)
-    gray = np.mean(rgb, axis=-1)
-
-    # Compute local mean and local variance in blocks
-    block_size = 16
-    h, w = gray.shape
-    h_crop, w_crop = (h // block_size) * block_size, (w // block_size) * block_size
-    gray = gray[:h_crop, :w_crop]
-
-    intensities = []
-    variances = []
-
-    for i in range(0, h_crop, block_size):
-        for j in range(0, w_crop, block_size):
-            block = gray[i:i + block_size, j:j + block_size]
-            intensities.append(float(np.mean(block)))
-            variances.append(float(np.var(block)))
-
-    intensities = np.array(intensities)
-    variances = np.array(variances)
-
-    # Filter out extreme blocks
-    valid = (intensities > 10) & (intensities < 245) & (variances > 0)
-    if np.sum(valid) < 20:
-        return {
-            "test": "Noise Structure (Poisson-Gaussian)",
-            "score": 0.0,
-            "note": "Insufficient data for noise model fitting",
-        }
-
-    I = intensities[valid]
-    V = variances[valid]
-
-    # Fit linear model: V = a + b*I (Poisson-Gaussian)
+        ch=rgb[:,:,c]; dn=gaussian_filter(ch,3.0); res.append(ch-dn)
+    ne=np.mean(np.stack(res,axis=-1)**2,axis=-1)
+    lv=uniform_filter(ne,32); std=float(np.std(lv)); mn=float(np.mean(lv))
+    u=1.0-min(std/(mn+1e-9),1.0)
+    if u>0.7: s,n=-0.4, f"Uniform sensor noise (uniformity={u:.3f})"
+    elif u<0.4: s,n=0.5, f"Inconsistent noise ({u:.3f}) — splicing/AI"
+    else: s,n=0.1, f"Moderate noise uniformity ({u:.3f})"
+    return {"test":"PRNU Uniformity","uniformity":round(u,4),"score":s,"note":n,"noise_map":ne}
+
+def s02_prnu_correlation(img):
+    rgb=_rgb(img); res=[]
+    for c in range(3): ch=rgb[:,:,c]; res.append((ch-gaussian_filter(ch,3.0)).ravel())
+    step=max(1,len(res[0])//100000)
+    rg=float(np.corrcoef(res[0][::step],res[1][::step])[0,1])
+    rb=float(np.corrcoef(res[0][::step],res[2][::step])[0,1])
+    avg=(rg+rb)/2
+    if avg>0.3: s,n=-0.3, f"Correlated channel noise ({avg:.3f}) — real sensor"
+    elif avg<0.1: s,n=0.4, f"Uncorrelated noise ({avg:.3f}) — AI-like"
+    else: s,n=0.1, f"Moderate noise correlation ({avg:.3f})"
+    return {"test":"PRNU Cross-Channel","correlation":round(avg,4),"score":s,"note":n}
+
+def s03_noise_model(img):
+    rgb=_rgb(img); gray=np.mean(rgb,axis=-1); h,w=gray.shape; bs=16
+    hc,wc=(h//bs)*bs,(w//bs)*bs; gray=gray[:hc,:wc]
+    I,V=[],[]
+    for i in range(0,hc,bs):
+        for j in range(0,wc,bs):
+            b=gray[i:i+bs,j:j+bs]; I.append(float(np.mean(b))); V.append(float(np.var(b)))
+    I,V=np.array(I),np.array(V); v=(I>10)&(I<245)&(V>0)
+    if np.sum(v)<20: return {"test":"Poisson-Gaussian Model","score":0.0,"note":"Insufficient data"}
     try:
-        coeffs = np.polyfit(I, V, 1)
-        fitted = np.polyval(coeffs, I)
-        residual = float(np.mean((V - fitted) ** 2))
-        r_squared = 1.0 - residual / (np.var(V) + 1e-9)
-    except Exception:
-        r_squared = 0.0
-
-    if r_squared > 0.5:
-        score = -0.3
-        note = f"Noise follows Poisson-Gaussian model (R²={r_squared:.3f}, real sensor)"
-    elif r_squared < 0.1:
-        score = 0.5
-        note = f"Noise does NOT follow sensor physics (R²={r_squared:.3f}, AI-like)"
-    else:
-        score = 0.15
-        note = f"Weak Poisson-Gaussian fit (R²={r_squared:.3f})"
-
-    return {
-        "test": "Noise Structure (Poisson-Gaussian)",
-        "r_squared": round(r_squared, 4),
-        "slope": round(float(coeffs[0]), 6) if r_squared > 0 else None,
-        "intercept": round(float(coeffs[1]), 4) if r_squared > 0 else None,
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── Bayer Demosaicing Artifacts ────────────────────────────────────
-def analyze_bayer_demosaicing(img: Image.Image) -> Dict[str, Any]:
-    """
-    Real cameras: green channel has ~2x samples → lower noise than R/B.
-    Expected: σ_green < σ_red ≈ σ_blue.
-    AI images lack this Bayer pattern artifact.
-    """
-    rgb = np.array(img.convert("RGB")).astype(np.float64)
-    
-    # High-frequency noise per channel
-    noise_std = {}
-    for c, name in enumerate(["red", "green", "blue"]):
-        channel = rgb[:, :, c]
-        denoised = gaussian_filter(channel, sigma=1.5)
-        noise = channel - denoised
-        noise_std[name] = float(np.std(noise))
-
-    green_lower = noise_std["green"] < min(noise_std["red"], noise_std["blue"])
-    rb_similar = abs(noise_std["red"] - noise_std["blue"]) / (
-        max(noise_std["red"], noise_std["blue"]) + 1e-9
-    ) < 0.2
-
-    if green_lower and rb_similar:
-        score = -0.4
-        note = (
-            f"Bayer pattern detected: σ_green({noise_std['green']:.3f}) < "
-            f"σ_red({noise_std['red']:.3f}) ≈ σ_blue({noise_std['blue']:.3f})"
-        )
-    elif green_lower:
-        score = -0.2
-        note = "Green channel is quieter but R/B difference is large"
-    else:
-        score = 0.4
-        note = (
-            f"No Bayer pattern: σ_green({noise_std['green']:.3f}), "
-            f"σ_red({noise_std['red']:.3f}), σ_blue({noise_std['blue']:.3f})"
-        )
-
-    return {
-        "test": "Bayer Demosaicing Artifacts",
-        "noise_red": round(noise_std["red"], 4),
-        "noise_green": round(noise_std["green"], 4),
-        "noise_blue": round(noise_std["blue"], 4),
-        "green_is_lower": green_lower,
-        "rb_similar": rb_similar,
-        "score": score,
-        "note": note,
-    }
-
-
-# ─── 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.
-    """
+        c=np.polyfit(I[v],V[v],1); f=np.polyval(c,I[v]); r2=1.0-float(np.mean((V[v]-f)**2))/(np.var(V[v])+1e-9)
+    except: r2=0.0
+    if r2>0.5: s,n=-0.3, f"Poisson-Gaussian fit R²={r2:.3f}"
+    elif r2<0.1: s,n=0.5, f"No sensor noise model R²={r2:.3f}"
+    else: s,n=0.15, f"Weak fit R²={r2:.3f}"
+    return {"test":"Poisson-Gaussian Model","r_squared":round(r2,4),"score":s,"note":n}
+
+def s04_bayer(img):
+    rgb=_rgb(img); ns={}
+    for c,nm in enumerate(["red","green","blue"]):
+        ch=rgb[:,:,c]; ns[nm]=float(np.std(ch-gaussian_filter(ch,1.5)))
+    gl=ns["green"]<min(ns["red"],ns["blue"])
+    rb=abs(ns["red"]-ns["blue"])/(max(ns["red"],ns["blue"])+1e-9)<0.2
+    if gl and rb: s,n=-0.4, f"Bayer: σG({ns['green']:.3f})<σR({ns['red']:.3f})≈σB({ns['blue']:.3f})"
+    elif gl: s,n=-0.2, "Green quieter but R/B differ"
+    else: s,n=0.4, f"No Bayer pattern: σG={ns['green']:.3f}"
+    return {"test":"Bayer CFA Pattern","score":s,"note":n}
+
+def s05_cfa_nyquist(img):
+    rgb=_rgb(img); rg=rgb[:,:,0]-rgb[:,:,1]; fft=np.abs(np.fft.fftshift(np.fft.fft2(rg)))
+    h,w=fft.shape; cy,cx=h//2,w//2
+    nyq=float(fft[cy,0]+fft[0,cx]+fft[0,0])/3; cen=float(np.mean(fft[cy-5:cy+5,cx-5:cx+5]))
+    r=nyq/(cen+1e-9)
+    if r>1.5: s,n=-0.3, f"CFA traces (ratio={r:.2f})"
+    elif r<0.5: s,n=0.3, f"No CFA traces ({r:.2f})"
+    else: s,n=0.0, f"CFA ratio={r:.2f}"
+    return {"test":"CFA Nyquist","ratio":round(r,4),"score":s,"note":n}
+
+def s06_hot_dead(img):
+    gray=_g(img); h,w=gray.shape; med=median_filter(gray,5); diff=np.abs(gray-med)
+    hot=int(np.sum(diff>np.percentile(diff,99.9)))
+    dead=int(np.sum((gray<5)&(diff>np.percentile(diff,99.5))))
+    rate=(hot+dead)/(h*w)
+    if 0.00001<rate<0.001: s,n=-0.2, f"Sensor defects ({hot+dead}px, rate={rate:.6f})"
+    elif rate<0.000001: s,n=0.2, f"No defects — possible AI"
+    else: s,n=0.0, f"Defect rate={rate:.6f}"
+    return {"test":"Hot/Dead Pixels","count":hot+dead,"score":s,"note":n}
+
+def s07_fixed_pattern(img):
+    rgb=_rgb(img); gray=np.mean(rgb,axis=-1); h,w=gray.shape
+    row_means=np.mean(gray,axis=1); col_means=np.mean(gray,axis=0)
+    row_var=float(np.var(row_means-gaussian_filter(row_means,10)))
+    col_var=float(np.var(col_means-gaussian_filter(col_means,10)))
+    fpn=row_var+col_var
+    if fpn>5: s,n=-0.2, f"Fixed pattern noise ({fpn:.2f}) — sensor"
+    elif fpn<0.5: s,n=0.2, f"No fixed pattern ({fpn:.2f})"
+    else: s,n=0.0, f"FPN={fpn:.2f}"
+    return {"test":"Fixed Pattern Noise","fpn":round(fpn,4),"score":s,"note":n}
+
+def s08_dark_current(img):
+    gray=_g(img); dark=gray[gray<10]
+    if len(dark)<100: return {"test":"Dark Current","score":0.0,"note":"No dark pixels"}
+    dk_mean=float(np.mean(dark)); dk_std=float(np.std(dark))
+    if dk_std>1: s,n=-0.2, f"Dark current variation (σ={dk_std:.2f}) — sensor"
+    elif dk_std<0.3: s,n=0.1, f"Flat dark pixels (σ={dk_std:.2f})"
+    else: s,n=0.0, f"Dark σ={dk_std:.2f}"
+    return {"test":"Dark Current","dark_std":round(dk_std,3),"score":s,"note":n}
+
+def s09_read_noise(img):
+    rgb=_rgb(img); gray=np.mean(rgb,axis=-1); h,w=gray.shape
+    flat=gray[(gray>100)&(gray<150)]
+    if len(flat)<1000: return {"test":"Read Noise Floor","score":0.0,"note":"No flat regions"}
+    rn=float(np.std(flat-gaussian_filter(flat.reshape(-1,1),1).ravel()))
+    if 0.5<rn<5: s,n=-0.2, f"Read noise={rn:.2f} — real sensor"
+    elif rn<0.2: s,n=0.3, f"No read noise ({rn:.2f})"
+    else: s,n=0.0, f"Read noise={rn:.2f}"
+    return {"test":"Read Noise Floor","read_noise":round(rn,3),"score":s,"note":n}
+
+def s10_pixel_nonlinearity(img):
+    gray=_g(img); bins=np.linspace(0,255,20)
+    hist,_=np.histogram(gray,bins=bins); hist=hist.astype(float)
+    # Check for gaps/non-linearities in tonal response
+    smooth=gaussian_filter(hist.astype(np.float64),2); diff=np.abs(hist-smooth)
+    nonlin=float(np.mean(diff)/(np.mean(hist)+1e-9))
+    if nonlin<0.1: s,n=-0.2, f"Smooth tonal response ({nonlin:.3f})"
+    elif nonlin>0.3: s,n=0.3, f"Non-linear tonality ({nonlin:.3f})"
+    else: s,n=0.0, f"Tonal linearity={nonlin:.3f}"
+    return {"test":"Pixel Response Linearity","nonlinearity":round(nonlin,4),"score":s,"note":n}
+
+def s11_color_matrix(img):
+    rgb=_rgb(img)
+    rg=float(np.corrcoef(rgb[:,:,0].ravel()[::100],rgb[:,:,1].ravel()[::100])[0,1])
+    rb=float(np.corrcoef(rgb[:,:,0].ravel()[::100],rgb[:,:,2].ravel()[::100])[0,1])
+    gb=float(np.corrcoef(rgb[:,:,1].ravel()[::100],rgb[:,:,2].ravel()[::100])[0,1])
+    avg=(rg+rb+gb)/3
+    if 0.5<avg<0.95: s,n=-0.2, f"Natural color matrix (avg_corr={avg:.3f})"
+    elif avg>0.98: s,n=0.2, f"Identical channels ({avg:.3f})"
+    else: s,n=0.0, f"Color correlation={avg:.3f}"
+    return {"test":"Color Matrix Verify","avg_corr":round(avg,4),"score":s,"note":n}
+
+def s12_quantization(img):
     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,
-               analyze_cfa_pattern, analyze_hot_dead_pixels, analyze_jpeg_quantization]:
-        try:
-            result = fn(img)
-            findings.append(result)
-            scores.append(result["score"])
-        except Exception as e:
-            findings.append({"test": fn.__name__, "error": str(e), "score": 0})
-
-    avg_score = float(np.mean(scores)) if scores else 0.0
-    confidence = min(1.0, 0.5 + 0.5 * abs(avg_score))
-
-    violations = [f["test"] for f in findings if f.get("score", 0) > 0.2]
-    compliant = [f["test"] for f in findings if f.get("score", 0) < -0.1]
-
-    if violations:
-        rationale = f"Sensor violations: {', '.join(violations)}."
-    elif compliant:
-        rationale = f"Sensor physics consistent: {', '.join(compliant)}."
-    else:
-        rationale = "Sensor analysis inconclusive."
-
+        qt=img.quantization
+        if qt:
+            t=list(list(qt.values())[0].values()) if isinstance(list(qt.values())[0],dict) else list(list(qt.values())[0])
+            if len(t)==64:
+                mx,mn=int(np.max(t)),int(np.min(t)); std=float(np.std(t))
+                if std<5: s,n=0.2, f"Uniform quantization (std={std:.1f})"
+                elif mx>100: s,n=-0.2, f"Camera quantization (max={mx})"
+                else: s,n=-0.1, f"Standard JPEG table (range=[{mn},{mx}])"
+            else: s,n=0.0, "Non-standard table"
+        else: s,n=0.1, "No JPEG tables"
+    except: s,n=0.0, "Cannot read tables"
+    return {"test":"JPEG Quantization","score":s,"note":n}
+
+def s13_bit_depth(img):
+    gray=_g(img); unique=len(np.unique(gray.astype(int)))
+    ratio=unique/256
+    if ratio>0.95: s,n=-0.2, f"Full 8-bit usage ({unique} levels)"
+    elif ratio<0.5: s,n=0.3, f"Limited tonal range ({unique} levels)"
+    else: s,n=0.0, f"{unique} unique levels"
+    return {"test":"Bit Depth Usage","unique_levels":unique,"score":s,"note":n}
+
+def s14_saturation_clipping(img):
+    gray=_g(img); clip_white=float(np.mean(gray>254)); clip_black=float(np.mean(gray<1))
+    total=clip_white+clip_black
+    if 0.001<total<0.05: s,n=-0.2, f"Natural clipping ({total:.3%})"
+    elif total<0.0001: s,n=0.2, f"No clipping ({total:.5%}) — unusual"
+    elif total>0.1: s,n=0.1, f"Heavy clipping ({total:.1%})"
+    else: s,n=0.0, f"Clipping={total:.3%}"
+    return {"test":"Saturation Clipping","clip_fraction":round(total,5),"score":s,"note":n}
+
+def s15_noise_spatial_freq(img):
+    rgb=_rgb(img); gray=np.mean(rgb,axis=-1)
+    noise=gray-gaussian_filter(gray,2)
+    fft=np.abs(np.fft.fftshift(np.fft.fft2(noise))); h,w=fft.shape; cy,cx=h//2,w//2
+    lf=float(np.mean(fft[cy-h//8:cy+h//8,cx-w//8:cx+w//8]))
+    hf=float(np.mean(fft))-lf
+    ratio=hf/(lf+1e-9)
+    if ratio>1.5: s,n=-0.2, f"High-freq noise dominant ({ratio:.2f}) — sensor"
+    elif ratio<0.5: s,n=0.3, f"Low-freq noise ({ratio:.2f}) — unusual"
+    else: s,n=0.0, f"Noise freq ratio={ratio:.2f}"
+    return {"test":"Noise Spatial Frequency","ratio":round(ratio,3),"score":s,"note":n}
+
+def s16_green_imbalance(img):
+    rgb=_rgb(img); g=rgb[:,:,1]; h,w=g.shape
+    g1=g[0::2,0::2]; g2=g[1::2,1::2]
+    mh,mw=min(g1.shape[0],g2.shape[0]),min(g1.shape[1],g2.shape[1])
+    diff=float(np.mean(np.abs(g1[:mh,:mw]-g2[:mh,:mw])))
+    if diff>0.5: s,n=-0.2, f"Green channel imbalance ({diff:.3f}) — Bayer"
+    elif diff<0.1: s,n=0.2, f"Identical green subpixels ({diff:.3f})"
+    else: s,n=0.0, f"Green diff={diff:.3f}"
+    return {"test":"Green Pixel Imbalance","diff":round(diff,4),"score":s,"note":n}
+
+def s17_sensor_crop_factor(img):
+    """Check aspect ratio against common sensor sizes."""
+    w,h=img.size; ratio=max(w,h)/min(w,h)
+    common=[1.0,4/3,3/2,16/9,1.85,2.35,2.39]
+    min_diff=min(abs(ratio-c) for c in common)
+    if min_diff<0.02: s,n=-0.1, f"Standard aspect ratio ({ratio:.3f})"
+    elif min_diff>0.1: s,n=0.2, f"Unusual aspect ratio ({ratio:.3f})"
+    else: s,n=0.0, f"Aspect ratio={ratio:.3f}"
+    return {"test":"Sensor Aspect Ratio","ratio":round(ratio,4),"score":s,"note":n}
+
+def s18_demosaic_interpolation(img):
+    rgb=_rgb(img); h,w,_=rgb.shape
+    # Check for demosaic interpolation artifacts at pixel level
+    r=rgb[:,:,0]; g=rgb[:,:,1]; b=rgb[:,:,2]
+    # Real demosaiced images: neighboring pixels in same channel are correlated
+    r_h_corr = float(np.corrcoef(r[:,:-1].ravel()[::100],r[:,1:].ravel()[::100])[0,1])
+    g_h_corr = float(np.corrcoef(g[:,:-1].ravel()[::100],g[:,1:].ravel()[::100])[0,1])
+    # In Bayer, green has higher correlation due to 2x sampling
+    if g_h_corr > r_h_corr + 0.005: s,n = -0.3, f"Demosaic pattern (G_corr={g_h_corr:.4f}>R_corr={r_h_corr:.4f})"
+    elif abs(g_h_corr-r_h_corr)<0.001: s,n = 0.2, f"No demosaic signature"
+    else: s,n = 0.0, f"G_corr={g_h_corr:.4f}, R_corr={r_h_corr:.4f}"
+    return {"test":"Demosaic Interpolation","g_corr":round(g_h_corr,4),"r_corr":round(r_h_corr,4),"score":s,"note":n}
+
+ALL_TESTS=[s01_prnu_uniformity,s02_prnu_correlation,s03_noise_model,s04_bayer,s05_cfa_nyquist,
+           s06_hot_dead,s07_fixed_pattern,s08_dark_current,s09_read_noise,s10_pixel_nonlinearity,
+           s11_color_matrix,s12_quantization,s13_bit_depth,s14_saturation_clipping,
+           s15_noise_spatial_freq,s16_green_imbalance,s17_sensor_crop_factor,s18_demosaic_interpolation]
+
+def run_sensor_agent(img):
+    findings,scores=[],[]
+    for fn in ALL_TESTS:
+        try: r=fn(img); findings.append(r); scores.append(r["score"])
+        except Exception as e: findings.append({"test":fn.__name__,"error":str(e),"score":0})
+    avg=float(np.mean(scores)) if scores else 0.0; conf=min(1.0,0.5+0.5*abs(avg))
+    viol=[f["test"] for f in findings if f.get("score",0)>0.2]
+    comp=[f["test"] for f in findings if f.get("score",0)<-0.1]
+    rat=f"Sensor violations: {', '.join(viol)}." if viol else f"Sensor consistent: {', '.join(comp)}." if comp else "Sensor inconclusive."
     for f in findings:
-        if f.get("note"):
-            rationale += f" [{f['test']}]: {f['note']}."
-
-    return 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) / 6),
-        rationale=rationale,
-        sub_findings=findings,
-    )
+        if f.get("note"): rat+=f" [{f['test']}]: {f['note']}."
+    return AgentEvidence("Sensor Characteristics Agent",np.clip(avg,-1,1),conf,max(0,1-len(scores)/len(ALL_TESTS)),rat,findings)