Update app.py

app.py

@@ -1,233 +1,133 @@
-import io, os, tempfile, math
+import io
 import numpy as np
 import gradio as gr
-from PIL import Image, ImageChops, ImageFilter
+from PIL import Image, ImageChops
 import cv2
 from skimage import exposure
 
-# ---------- Forensic primitives ----------
+# ------------------ Forensic primitives ------------------
+
+def _enhance_for_display(pil_img, scale: float):
+    arr = np.array(pil_img).astype("float32") * scale
+    arr = np.clip(arr, 0, 255).astype("uint8")
+    return Image.fromarray(arr)
 
 def error_level_analysis(pil_img: Image.Image, quality: int = 90):
     """
-    ELA: save as JPEG (quality q), diff with original, enhance to visualize anomalies.
-    Returns: ELA image (PIL), mean ELA intensity (float)
+    ELA: save as JPEG (quality q), diff with original, then enhance.
+    Returns: (enhanced_ela_image, mean_intensity) but we only use mean_intensity downstream.
     """
     img = pil_img.convert("RGB")
-    with io.BytesIO() as buffer:
-        img.save(buffer, "JPEG", quality=quality)
-        buffer.seek(0)
-        comp = Image.open(buffer).convert("RGB")
+    with io.BytesIO() as buf:
+        img.save(buf, "JPEG", quality=quality)
+        buf.seek(0)
+        comp = Image.open(buf).convert("RGB")
 
     diff = ImageChops.difference(img, comp)
-    # amplify differences to be human-visible
+    # amplify differences to be human-visible (for our metric we just need mean)
     extrema = diff.getextrema()
     max_diff = max([m for (_, m) in extrema])
     scale = 255.0 / max(1, max_diff)
-    ela = ImageEnhance(diff, scale)
-    ela_np = np.array(ela)
-    mean_intensity = float(ela_np.mean() / 255.0)
-    return ela, mean_intensity
-
-def ImageEnhance(pil_img: Image.Image, scale: float):
-    arr = np.array(pil_img).astype("float32") * scale
-    arr = np.clip(arr, 0, 255).astype("uint8")
-    return Image.fromarray(arr)
+    ela_vis = _enhance_for_display(diff, scale)
+    ela_np = np.array(ela_vis, dtype=np.float32)
+    mean_intensity = float(ela_np.mean() / 255.0)  # ~[0,1]
+    return ela_vis, mean_intensity
 
 def fft_high_freq_ratio(pil_img: Image.Image):
     """
-    Compute high-frequency energy ratio from grayscale FFT.
-    Returns: spectrum image (PIL), hf_ratio (float in [0,1] approx)
+    High-frequency (HF) energy ratio from 2D FFT magnitude.
     """
     gray = np.array(pil_img.convert("L"), dtype=np.float32) / 255.0
-    # windowing to reduce edge artifacts
     h, w = gray.shape
+    # windowing mitigates edge spill
     win_y = np.hanning(h)[:, None]
     win_x = np.hanning(w)[None, :]
     grayw = gray * (win_y * win_x)
 
     F = np.fft.fftshift(np.fft.fft2(grayw))
-    mag = np.log1p(np.abs(F))
-    # visualize spectrum normalized
-    spec = (mag / mag.max() * 255).astype("uint8")
-    spec_img = Image.fromarray(spec)
+    mag = np.log1p(np.abs(F))  # stabilize
 
-    # high vs low freq using radius threshold
     cy, cx = h // 2, w // 2
     yy, xx = np.ogrid[:h, :w]
     dist = np.sqrt((yy - cy) ** 2 + (xx - cx) ** 2)
-    r_low = min(h, w) * 0.08  # low radius
+    r_low = min(h, w) * 0.08  # central low-freq radius
     mask_low = dist <= r_low
-    low_energy = mag[mask_low].sum()
-    high_energy = mag[~mask_low].sum()
-    hf_ratio = float(high_energy / (high_energy + low_energy + 1e-9))
-    return spec_img, hf_ratio
 
-def noise_map_score(pil_img: Image.Image):
+    low_energy = float(mag[mask_low].sum())
+    high_energy = float(mag[~mask_low].sum())
+    hf_ratio = high_energy / (high_energy + low_energy + 1e-9)
+    return None, float(hf_ratio)  # visual not needed
+
+def noise_inconsistency(pil_img: Image.Image):
     """
-    Laplacian variance map as a proxy for local sharpness / noise consistency.
-    Returns: heatmap (PIL), inconsistency score (float)
+    Laplacian-based local sharpness variance consistency.
+    Returns a normalized inconsistency score ~[0,1].
     """
     img = np.array(pil_img.convert("L"))
     lap = cv2.Laplacian(img, cv2.CV_32F, ksize=3)
-    # normalize heatmap for display
     lap_abs = np.abs(lap)
-    heat = (lap_abs / (lap_abs.max() + 1e-9) * 255).astype("uint8")
-    heat_eq = exposure.equalize_adapthist(heat, clip_limit=0.01)
-    heat_disp = Image.fromarray((heat_eq * 255).astype("uint8"))
 
-    # inconsistency: std dev of local variance over tiles
+    # equalize for stability (visual not used here)
+    _ = exposure.equalize_adapthist(
+        (lap_abs / (lap_abs.max() + 1e-9)).astype("float32"), clip_limit=0.01
+    )
+
+    # measure variability of texture across tiles
     tile = 32
     H, W = img.shape
     vars_ = []
     for y in range(0, H, tile):
         for x in range(0, W, tile):
             patch = lap_abs[y:min(y+tile, H), x:min(x+tile, W)]
-            if patch.size > 0:
+            if patch.size:
                 vars_.append(patch.var())
+    if not vars_:
+        return None, 0.0
     vars_ = np.array(vars_, dtype=np.float32)
-    score = float((vars_.std() / (vars_.mean() + 1e-9)))  # higher = more inconsistent
-    # squash to approx [0,1]
-    score_norm = float(np.tanh(score / 5.0))
-    return heat_disp, score_norm
+    score = float((vars_.std() / (vars_.mean() + 1e-9)))   # higher => more inconsistent
+    score_norm = float(np.tanh(score / 5.0))               # squash to ~[0,1]
+    return None, score_norm
 
-# ---------- Simple decision rule ----------
+# ------------------ Decision rule ------------------
 
-def combine_scores(ela_mean, hf_ratio, noise_incons):
+def combine_scores(ela_mean, hf_ratio, noise_incons_score):
     """
-    Combine three signals into a simple confidence of manipulation.
-    Tuned conservatively to avoid false alarms on clean photos.
+    Weighted aggregation -> final 'manipulated' confidence in [0,1].
+    Tweak weights if you want it stricter/looser.
     """
-    # weights (can tweak)
     w1, w2, w3 = 0.4, 0.35, 0.25
-    # normalize features roughly to [0,1]
-    s_ela = np.clip(ela_mean * 2.5, 0, 1)         # more ELA intensity -> more suspect
-    s_hf  = np.clip((hf_ratio - 0.65) / 0.25, 0, 1)  # lots of HF energy -> suspect
-    s_noi = np.clip(noise_incons, 0, 1)
+    # map raw features to [0,1] suspicion signals
+    s_ela = np.clip(ela_mean * 2.5, 0, 1)                  # more ELA diff => more suspect
+    s_hf  = np.clip((hf_ratio - 0.65) / 0.25, 0, 1)        # unusually high HF content
+    s_noi = np.clip(noise_incons_score, 0, 1)              # texture inconsistency
 
     suspect = float(w1 * s_ela + w2 * s_hf + w3 * s_noi)
     label = "Likely Manipulated" if suspect >= 0.55 else "Likely Authentic"
     return label, suspect
 
-# ---------- Gradio handlers ----------
+# ------------------ Gradio handler ------------------
 
-def analyze_image(pil_img: Image.Image):
+def analyze_simple(pil_img: Image.Image):
     if pil_img is None:
-        return {}, None, None, None, "Upload an image"
-
-    # Standardize size for stable scores (keeps aspect, pads)
-    pil_img = pil_img.convert("RGB")
-    pil_img = pil_img.resize((512, 512))
-
-    ela_img, ela_mean = error_level_analysis(pil_img, quality=90)
-    spec_img, hf_ratio = fft_high_freq_ratio(pil_img)
-    noise_img, noise_incons = noise_map_score(pil_img)
-
-    label, conf = combine_scores(ela_mean, hf_ratio, noise_incons)
-    scores = {
-        "Confidence manipulated": round(conf, 3),
-        "ELA mean": round(ela_mean, 3),
-        "HF ratio": round(hf_ratio, 3),
-        "Noise inconsistency": round(noise_incons, 3)
-    }
-    msg = f"Result: **{label}**  —  confidence: {conf:.2f}\n\n" \
-          f"*ELA={ela_mean:.3f}, HF={hf_ratio:.3f}, Noise={noise_incons:.3f}*"
-
-    return scores, pil_img, ela_img, spec_img, noise_img, msg
-
-def analyze_video(video_file):
-    if video_file is None:
-        return {}, None, None, None, None, "Upload a short video (<= 10–15s)"
-    # write to temp, sample frames
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-    tmp.write(video_file.read()); tmp.flush(); tmp.close()
-
-    cap = cv2.VideoCapture(tmp.name)
-    frames = []
-    idx = 0
-    while True:
-        ret, frame = cap.read()
-        if not ret: break
-        if idx % 15 == 0:     # sample every 15th frame
-            frames.append(Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)))
-            if len(frames) >= 8: break
-        idx += 1
-    cap.release()
-    os.unlink(tmp.name)
-
-    if not frames:
-        return {}, None, None, None, None, "Couldn’t read frames; try a different/shorter video."
-
-    # analyze first frame for visuals, average scores across all
-    scores_list = []
-    vis_sample = frames[0].resize((512, 512)).convert("RGB")
-
-    ela_img, ela_mean = error_level_analysis(vis_sample)
-    spec_img, hf_ratio = fft_high_freq_ratio(vis_sample)
-    noise_img, noise_incons = noise_map_score(vis_sample)
-
-    # avg over all frames
-    elas, hfs, noises = [ela_mean], [hf_ratio], [noise_incons]
-    for f in frames[1:]:
-        f = f.resize((512, 512)).convert("RGB")
-        _, em = error_level_analysis(f)
-        _, hr = fft_high_freq_ratio(f)
-        _, ns = noise_map_score(f)
-        elas.append(em); hfs.append(hr); noises.append(ns)
-
-    ela_m = float(np.mean(elas))
-    hf_m = float(np.mean(hfs))
-    noi_m = float(np.mean(noises))
-    label, conf = combine_scores(ela_m, hf_m, noi_m)
-
-    scores = {
-        "Confidence manipulated": round(conf, 3),
-        "ELA mean (avg)": round(ela_m, 3),
-        "HF ratio (avg)": round(hf_m, 3),
-        "Noise inconsistency (avg)": round(noi_m, 3)
-    }
-    msg = f"Result: **{label}**  —  confidence: {conf:.2f}\n\n" \
-          f"*ELA={ela_m:.3f}, HF={hf_m:.3f}, Noise={noi_m:.3f}*\n" \
-          f"_Note: rule-based (no ML), indicative only._"
-
-    return scores, vis_sample, ela_img, spec_img, noise_img, msg
-
-# ---------- UI ----------
-
-with gr.Blocks(title="Deepfake Forensics (No-ML)") as demo:
-    gr.Markdown("## Deepfake Forensics (No-ML)\n"
-                "Upload an **image** or a short **video**. We run three classical forensic checks:\n"
-                "- **ELA** (Error Level Analysis)\n- **Frequency Spectrum** (high-freq energy)\n- **Noise Consistency** (Laplacian map)\n"
-                "Outputs a **Likely Authentic / Likely Manipulated** decision with visual evidence.")
-
-    with gr.Tab("Image"):
-        with gr.Row():
-            with gr.Column(scale=1):
-                img_in = gr.Image(type="pil", label="Upload image")
-                btn = gr.Button("Analyze")
-            with gr.Column(scale=2):
-                scores = gr.Label(label="Scores")
-                img_std = gr.Image(label="Normalized Input")
-                img_ela = gr.Image(label="ELA Heatmap")
-                img_fft = gr.Image(label="Frequency Spectrum")
-                img_noise = gr.Image(label="Noise/Sharpness Map")
-                msg = gr.Markdown()
-        btn.click(analyze_image, inputs=img_in,
-                  outputs=[scores, img_std, img_ela, img_fft, img_noise, msg])
-
-    with gr.Tab("Video (optional)"):
-        with gr.Row():
-            with gr.Column(scale=1):
-                vid_in = gr.Video(label="Upload short MP4 (<=10–15s)")
-                btnv = gr.Button("Analyze Video")
-            with gr.Column(scale=2):
-                vscores = gr.Label(label="Scores (avg over frames)")
-                vimg_std = gr.Image(label="Frame Preview")
-                vimg_ela = gr.Image(label="ELA Heatmap (frame)")
-                vimg_fft = gr.Image(label="Frequency Spectrum (frame)")
-                vimg_noise = gr.Image(label="Noise/Sharpness Map (frame)")
-                vmsg = gr.Markdown()
-        btnv.click(analyze_video, inputs=vid_in,
-                   outputs=[vscores, vimg_std, vimg_ela, vimg_fft, vimg_noise, vmsg])
+        return "Upload an image."
+    # normalize size for stability
+    pil_img = pil_img.convert("RGB").resize((512, 512))
+
+    _, ela_mean = error_level_analysis(pil_img, quality=90)
+    _, hf_ratio = fft_high_freq_ratio(pil_img)
+    _, noi_score = noise_inconsistency(pil_img)
+
+    label, conf = combine_scores(ela_mean, hf_ratio, noi_score)
+    return f"Deepfake likelihood: {conf*100:.1f}% — {label}"
+
+# ------------------ UI ------------------
+
+with gr.Blocks(title="Deepfake Detector") as demo:
+    gr.Markdown("### Deepfake Detector\nUpload an image to get a single likelihood estimate.")
+    inp = gr.Image(type="pil", label="Image")
+    btn = gr.Button("Analyze")
+    out = gr.Markdown()
+    btn.click(analyze_simple, inputs=inp, outputs=out)
 
 if __name__ == "__main__":
     demo.launch()