Upload agents/sensor_agent.py with huggingface_hub

agents/sensor_agent.py

@@ -16,7 +16,7 @@ def s01_prnu_uniformity(img):
     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})"
+    if u>0.7: s,n=-0.4, f"Spatially consistent noise pattern (uniformity={u:.3f}) — authentic sensor"
     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}
@@ -76,8 +76,11 @@ def s06_hot_dead(img):
     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)
+    # Note: JPEG compression removes hot pixel signatures, so absence is not strong evidence
+    is_jpeg = img.format == "JPEG" if hasattr(img, 'format') and img.format else False
     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"
+    elif rate<0.000001 and not is_jpeg: s,n=0.15, f"No defects, non-JPEG — mild AI indicator"
+    elif rate<0.000001 and is_jpeg: s,n=0.0, f"No defects (JPEG strips hot pixels — inconclusive)"
     else: s,n=0.0, f"Defect rate={rate:.6f}"
     return {"test":"Hot/Dead Pixels","count":hot+dead,"score":s,"note":n}
 
@@ -103,9 +106,13 @@ def s08_dark_current(img):
 
 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()))
+    # Find flat regions in 2D (preserve spatial structure)
+    flat_mask = (gray > 100) & (gray < 150)
+    if np.sum(flat_mask) < 1000: return {"test":"Read Noise Floor","score":0.0,"note":"No flat regions"}
+    # Compute noise as std of (original - smoothed) within flat regions only
+    smoothed = gaussian_filter(gray, sigma=2.0)
+    noise_residual = gray - smoothed
+    rn = float(np.std(noise_residual[flat_mask]))
     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}"
@@ -187,15 +194,20 @@ def s16_green_imbalance(img):
     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 s17_noise_autocorrelation(img):
+    """Real sensor noise has spatial correlation from the anti-aliasing filter.
+    AI noise is typically white (uncorrelated) or has non-physical correlation."""
+    gray=_g(img); noise=gray-gaussian_filter(gray,2.0)
+    h,w=noise.shape
+    if h<20 or w<20: return {"test":"Noise Autocorrelation","score":0.0,"note":"Too small"}
+    step=max(1,h*w//200000)
+    ac1=float(np.corrcoef(noise[:,:-1].ravel()[::step],noise[:,1:].ravel()[::step])[0,1])
+    ac2=float(np.corrcoef(noise[:,:-2].ravel()[::step],noise[:,2:].ravel()[::step])[0,1])
+    decay=ac1-ac2
+    if ac1>0.05 and decay>0.02: s,n=-0.3, f"AA-filtered noise (ac1={ac1:.3f}, decay={decay:.3f}) — real sensor"
+    elif ac1<0.01: s,n=0.2, f"White noise (ac1={ac1:.3f}) — no AA filter"
+    else: s,n=0.0, f"Noise ac1={ac1:.3f}, decay={decay:.3f}"
+    return {"test":"Noise Autocorrelation","ac1":round(ac1,4),"decay":round(decay,4),"score":s,"note":n}
 
 def s18_demosaic_interpolation(img):
     rgb=_rgb(img); h,w,_=rgb.shape
@@ -213,17 +225,9 @@ def s18_demosaic_interpolation(img):
 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]
+           s15_noise_spatial_freq,s16_green_imbalance,s17_noise_autocorrelation,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"): 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)
+    from agents.utils import run_agent_tests
+    findings, avg, conf, fail, rat = run_agent_tests(ALL_TESTS, img, "Sensor Characteristics Agent")
+    return AgentEvidence("Sensor Characteristics Agent",np.clip(avg,-1,1),conf,fail,rat,findings)