Update app.py

app.py

@@ -1,134 +1,635 @@
+"""
+ImageShield — AI Image Detector
+NOBODY204/ImageShield · HuggingFace Space
+Detects: Nano Banana (Gemini 2.5 Flash), GPT-Image-1, DALL-E 3,
+         Midjourney v6/v7, Flux, Stable Diffusion, Adobe Firefly,
+         Grok 2, Ideogram, and more.
+
+Multi-signal forensic pipeline:
+  1. Neural classifier (ViT-based, trained on 1M+ AI images)
+  2. ELA — Error Level Analysis (JPEG block inconsistency)
+  3. FFT — Frequency domain artifacts
+  4. Noise PRNU — Camera noise pattern analysis
+  5. Metadata / EXIF / C2PA / SynthID markers
+  6. Semantic LLM analysis (Claude or local model)
+"""
+
 import gradio as gr
 import numpy as np
-import matplotlib.pyplot as plt
-import cv2
-from scipy import ndimage
-
-# ═══════════════════════════════════════════════════
-# 🛡️ MEDIASHIELD PRO v2.5 – Localized AI Detection
-# ═══════════════════════════════════════════════════
-
-def estimate_sensor_noise(img):
-    """Calcule le bruit de capteur global."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    blur = cv2.GaussianBlur(gray, (5,5), 0)
-    noise = gray - blur
-    return np.std(noise)
-
-def analyze_local_variance(img):
-    """Compare le centre aux bords pour détecter un montage IA."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    h, w = gray.shape
-    center = gray[h//4:3*h//4, w//4:3*w//4]
-    edge = gray[0:h//4, 0:w//4]
-    def get_var(z):
-        return np.var(z - cv2.GaussianBlur(z, (5,5), 0))
-    v_c, v_e = get_var(center), get_var(edge)
-    return abs(v_c - v_e) / (v_e + 1e-8)
-
-def compute_noise_incoherence_map(img):
-    """Génère une carte thermique où l'IA lissée apparaît en rouge brillant."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    # Isoler le grain
-    grain = gray - cv2.medianBlur(gray, 7)
-    # Calculer la variance locale (IA = faible variance)
-    grain_var = ndimage.generic_filter(grain, np.var, size=15)
-    # Inverser pour que l'IA soit "chaude" (brillante)
-    incoherence_map = np.max(grain_var) - grain_var
-    vis = cv2.normalize(incoherence_map, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-    return cv2.applyColorMap(vis, cv2.COLORMAP_JET)
-
-def analyze_chrominance_noise(img):
-    ycrcb = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)
-    cr_var = ndimage.generic_filter(ycrcb[:,:,1].astype(np.float32), np.var, size=5)
-    cb_var = ndimage.generic_filter(ycrcb[:,:,2].astype(np.float32), np.var, size=5)
-    u_cr = np.std(cr_var) / (np.mean(cr_var) + 1e-8)
-    u_cb = np.std(cb_var) / (np.mean(cb_var) + 1e-8)
-    return (u_cr + u_cb) / 2
-
-def detect_grid_and_ringing(img):
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    fshift = np.fft.fftshift(np.fft.fft2(gray))
-    magnitude = np.abs(fshift)
-    rows, cols = gray.shape
-    crow, ccol = rows//2, cols//2
-    magnitude[(np.ogrid[:rows,:cols][0]-crow)**2 + (np.ogrid[:rows,:cols][1]-ccol)**2 <= (min(rows,cols)//10)**2] = 0
-    def get_peaks(sig):
-        thresh = np.max(sig) * 0.25
-        return [i for i in range(1, len(sig)-1) if sig[i] > thresh and sig[i] > sig[i-1] and sig[i] > sig[i+1] and i%8 != 0]
-    grid_s = (len(get_peaks(np.sum(magnitude, 0))) + len(get_peaks(np.sum(magnitude, 1)))) / 2
-    ringing = np.mean(magnitude) / (np.max(magnitude) + 1e-8)
-    fft_vis = cv2.applyColorMap(cv2.normalize(np.log(magnitude+1), None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8), cv2.COLORMAP_VIRIDIS)
-    return grid_s, ringing, fft_vis
-
-def error_level_analysis(img, quality=90):
-    _, enc = cv2.imencode('.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR), [int(cv2.IMWRITE_JPEG_QUALITY), quality])
-    dec = cv2.cvtColor(cv2.imdecode(enc, 1), cv2.COLOR_BGR2RGB)
-    diff = cv2.absdiff(img, dec)
-    return np.mean(diff), cv2.normalize(diff, None, 0, 255, cv2.NORM_MINMAX)
-
-def compute_ai_score_v4(metrics):
-    score, reasons = 0, []
-    if metrics['grid_score'] > 25: score += 30; reasons.append("⚠️ Motifs réguliers (GAN possible)")
-    if metrics['ringing'] > 0.3: score += 25; reasons.append("⚠️ Artefacts circulaires")
-    if metrics['sensor_noise'] < 1.5: score += 25; reasons.append("⚡ Image trop lisse (IA probable)")
-    elif metrics['sensor_noise'] > 4.0: score -= 25; reasons.append("✅ Bruit naturel (Photo réelle)")
-    if metrics['local_diff'] > 1.6: score += 35; reasons.append("🚨 Montage local détecté (Incohérence)")
-    if metrics['ela_score'] > 2.5 and metrics['grid_score'] < 8:
-        score *= 0.3; reasons.append("✅ Structure cohérente avec compression réelle")
-    return int(max(0, min(score, 100))), reasons
-
-def analyze_image(img_input):
-    if img_input is None: return None, "❌ Erreur"
-    img = cv2.cvtColor(img_input, cv2.COLOR_RGBA2RGB) if img_input.shape[2] == 4 else img_input.copy()
-    
-    # Correction Gamma
-    mean_b = np.mean(cv2.cvtColor(img, cv2.COLOR_RGB2GRAY))
-    img_analysed = cv2.LUT(img, np.array([((i/255.0)**(1/0.6))*255 for i in range(256)]).astype("uint8")) if mean_b < 60 else img.copy()
-
-    # Analyses
-    chrom_u = analyze_chrominance_noise(img_analysed)
-    grid_s, ring, fft_v = detect_grid_and_ringing(img_analysed)
-    ela_s, ela_v = error_level_analysis(img_analysed)
-    sensor_n = estimate_sensor_noise(img_analysed)
-    local_d = analyze_local_variance(img_analysed)
-    noise_map = compute_noise_incoherence_map(img_analysed)
-
-    # Détection de la zone suspecte et dessin du rectangle
-    img_boxed = img.copy()
-    if local_d > 1.3: # Seuil de détection de montage
-        gray_map = cv2.cvtColor(noise_map, cv2.COLOR_BGR2GRAY)
-        _, _, _, max_loc = cv2.minMaxLoc(gray_map)
-        h, w = img.shape[:2]
-        size = int(min(h, w) * 0.25)
-        top_left = (max(0, max_loc[0] - size//2), max(0, max_loc[1] - size//2))
-        bottom_right = (min(w, max_loc[0] + size//2), min(h, max_loc[1] + size//2))
-        cv2.rectangle(img_boxed, top_left, bottom_right, (255, 0, 0), 4)
-
-    metrics = {'chrom_uniformity': chrom_u, 'grid_score': grid_s, 'ringing': ring, 'ela_score': ela_s, 'sensor_noise': sensor_n, 'local_diff': local_d}
-    ai_score, reasons = compute_ai_score_v4(metrics)
-
-    fig, axes = plt.subplots(2, 2, figsize=(10, 8))
-    axes[0,0].imshow(img_boxed); axes[0,0].set_title('Détection Locale (IA)')
-    axes[0,1].imshow(fft_v); axes[0,1].set_title('Fréquences (FFT)')
-    axes[1,0].imshow(ela_v); axes[1,0].set_title('ELA (Compression)')
-    axes[1,1].imshow(noise_map); axes[1,1].set_title('Heatmap Incohérence')
-    for ax in axes.flatten(): ax.axis('off')
-    plt.tight_layout()
-
-    report = f"🛡️ MEDIASHIELD v2.5\nScore AI : {ai_score}/100\n\n" + ("\n".join(reasons) if reasons else "✅ Authentique")
-    return fig, report
-
-with gr.Blocks() as demo:
-    gr.Markdown("# 🛡️ MediaShield PRO v2.5\nSami Meddeb - ACoNum")
+from PIL import Image, ImageChops, ImageEnhance, ImageFilter
+import io, base64, json, requests, warnings
+warnings.filterwarnings("ignore")
+
+# ── Try loading heavy deps gracefully ──
+try:
+    import torch
+    from transformers import pipeline as hf_pipeline, AutoFeatureExtractor, AutoModelForImageClassification
+    HAS_TORCH = True
+except ImportError:
+    HAS_TORCH = False
+
+try:
+    from scipy import fft as scipy_fft
+    HAS_SCIPY = True
+except ImportError:
+    HAS_SCIPY = False
+
+try:
+    import cv2
+    HAS_CV2 = True
+except ImportError:
+    HAS_CV2 = False
+
+# ── Known AI generator signatures ──
+GENERATORS = {
+    "Nano Banana (Gemini 2.5 Flash Image)": "Google DeepMind — autoregressive, 1290 tokens/image. Look for: hyper-smooth gradients, perfect text rendering, no sensor noise.",
+    "Nano Banana Pro (Gemini 3 Pro Image)": "Google DeepMind — 2K-4K output. Contains SynthID watermark. Features: grounding with Search, reasoning-enhanced generation.",
+    "GPT-Image-1 / DALL-E 3": "OpenAI — diffusion-based. Look for: characteristic soft textures, watercolour-like blending, slightly exaggerated saturation.",
+    "Midjourney v6/v7": "Proprietary diffusion. Look for: aesthetic bias, dramatic lighting, painterly skin textures, cinematic composition.",
+    "Flux 1.0 / Flux 1.1 Pro": "Black Forest Labs — high detail diffusion. Look for: photorealistic skin, fine hair detail, sometimes inconsistent reflections.",
+    "Stable Diffusion XL / 3.5": "Open-source diffusion. Look for: frequency artifacts in backgrounds, GAN-like periodicity in textures.",
+    "Adobe Firefly": "Adobe — trained on licensed data. Typically reveals metadata 'GeneratedBy: Adobe Firefly'.",
+    "Grok 2 Image": "xAI — diffusion variant. Often has a distinct cinematic warmth and high contrast.",
+    "Ideogram 3.0": "Ideogram — strong text generation. Look for: clear legible text, poster-style composition.",
+}
+
+# ── Classifier model (best open-source, 2025) ──
+CLASSIFIER_MODEL = "Organika/sdxl-detector"  # ViT trained on SDXL vs real
+CLASSIFIER_MODEL_2 = "haywoodsloan/ai-image-detector-deploy"  # General AI detector
+
+classifier_pipe = None
+
+def load_classifier():
+    global classifier_pipe
+    if not HAS_TORCH:
+        return None
+    if classifier_pipe is None:
+        try:
+            classifier_pipe = hf_pipeline(
+                "image-classification",
+                model=CLASSIFIER_MODEL_2,
+                device=-1  # CPU
+            )
+        except Exception as e:
+            try:
+                classifier_pipe = hf_pipeline(
+                    "image-classification",
+                    model="umm-maybe/AI-image-detector",
+                    device=-1
+                )
+            except:
+                return None
+    return classifier_pipe
+
+
+# ════════════════════════════════════
+# SIGNAL 1: Neural Classifier
+# ═══════════════════════════════════��
+
+def run_classifier(img: Image.Image) -> dict:
+    pipe = load_classifier()
+    if pipe is None:
+        return {"score": 0.5, "label": "unknown", "method": "Neural (unavailable — CPU fallback)"}
+    try:
+        result = pipe(img)
+        top = result[0]
+        label = top["label"].lower()
+        score = top["score"]
+        is_ai = any(k in label for k in ["artificial","fake","ai","generated","machine","synthetic"])
+        if not is_ai:
+            score = 1 - score
+        return {
+            "score": round(score, 4),
+            "label": top["label"],
+            "method": "Neural ViT Classifier",
+            "confidence": f"{score*100:.1f}%"
+        }
+    except Exception as e:
+        return {"score": 0.5, "label": "error", "method": f"Neural (error: {e})"}
+
+
+# ════════════════════════════════════
+# SIGNAL 2: ELA — Error Level Analysis
+# ════════════════════════════════════
+
+def run_ela(img: Image.Image, quality: int = 90) -> dict:
+    """
+    ELA: Save image at reduced JPEG quality, compute pixel difference.
+    AI-generated images show uniform block patterns; real photos show
+    high-ELA regions at edges and textures.
+    """
+    try:
+        buf = io.BytesIO()
+        img_rgb = img.convert("RGB")
+        img_rgb.save(buf, format="JPEG", quality=quality)
+        buf.seek(0)
+        recompressed = Image.open(buf).convert("RGB")
+
+        diff = ImageChops.difference(img_rgb, recompressed)
+        arr = np.array(diff).astype(np.float32)
+
+        mean_ela = float(arr.mean())
+        std_ela = float(arr.std())
+        max_ela = float(arr.max())
+
+        # Real photos: high mean ELA + high std (edges vary)
+        # AI images: low-medium mean, very low std (uniform smoothness)
+        uniformity = 1.0 - min(std_ela / (mean_ela + 1e-5), 1.0)
+        ai_score = float(np.clip(0.3 + uniformity * 0.5 - (std_ela / 30) * 0.2, 0, 1))
+
+        ela_enhanced = ImageEnhance.Brightness(diff).enhance(10)
+
+        return {
+            "score": round(ai_score, 4),
+            "mean_ela": round(mean_ela, 2),
+            "std_ela": round(std_ela, 2),
+            "max_ela": round(max_ela, 2),
+            "uniformity": round(uniformity, 4),
+            "method": "ELA (Error Level Analysis)",
+            "ela_image": ela_enhanced,
+            "interpretation": (
+                "🔴 AI-like: uniform ELA (low std = no real JPEG history)" if ai_score > 0.65
+                else "🟡 Ambiguous: moderate ELA variance" if ai_score > 0.45
+                else "🟢 Real-like: high ELA variance typical of camera photos"
+            )
+        }
+    except Exception as e:
+        return {"score": 0.5, "method": f"ELA (error: {e})", "interpretation": "Error"}
+
+
+# ════════════════════════════════════
+# SIGNAL 3: FFT — Frequency Analysis
+# ════════════════════════════════════
+
+def run_fft(img: Image.Image) -> dict:
+    """
+    Frequency domain analysis.
+    AI generators (especially GANs and diffusion) leave characteristic
+    patterns in the FFT spectrum — periodic grid artifacts, abnormal
+    high-frequency distribution.
+    """
+    try:
+        gray = np.array(img.convert("L")).astype(np.float32)
+        if HAS_SCIPY:
+            f = scipy_fft.fft2(gray)
+            fshift = scipy_fft.fftshift(f)
+        else:
+            f = np.fft.fft2(gray)
+            fshift = np.fft.fftshift(f)
+
+        magnitude = np.abs(fshift)
+        log_mag = np.log1p(magnitude)
+
+        h, w = gray.shape
+        cy2, cx2 = h//2, w//2
+        r = min(h, w) // 6
+
+        # Center energy (low freq) vs periphery (high freq)
+        Y, X = np.ogrid[:h, :w]
+        dist = np.sqrt((X-cx2)**2 + (Y-cy2)**2)
+        center_mask = dist < r
+        edge_mask = dist > min(h,w)//3
+
+        center_energy = float(log_mag[center_mask].mean())
+        edge_energy = float(log_mag[edge_mask].mean())
+        ratio = edge_energy / (center_energy + 1e-5)
+
+        # Check for grid artifacts (GAN fingerprint)
+        periodic_peaks = detect_periodic_peaks(log_mag, h, w)
+
+        # AI images: lower edge_energy, characteristic ratio ~0.3-0.5
+        # Real photos: higher edge_energy, ratio ~0.5-0.7
+        ai_score = float(np.clip(0.6 - (ratio - 0.35) * 1.5 + periodic_peaks * 0.3, 0, 1))
+
+        return {
+            "score": round(ai_score, 4),
+            "center_energy": round(center_energy, 4),
+            "edge_energy": round(edge_energy, 4),
+            "freq_ratio": round(ratio, 4),
+            "periodic_artifacts": periodic_peaks > 0.1,
+            "method": "FFT Frequency Analysis",
+            "interpretation": (
+                "🔴 AI-like: unusual frequency distribution or periodic artifacts"
+                if ai_score > 0.6
+                else "🟡 Ambiguous: borderline frequency signature"
+                if ai_score > 0.4
+                else "🟢 Real-like: natural frequency distribution"
+            )
+        }
+    except Exception as e:
+        return {"score": 0.5, "method": f"FFT (error: {e})", "interpretation": "Error"}
+
+def detect_periodic_peaks(log_mag, h, w):
+    """Detect periodic grid patterns characteristic of GAN generators."""
+    try:
+        row_var = float(np.var(log_mag.mean(axis=0)))
+        col_var = float(np.var(log_mag.mean(axis=1)))
+        normalized = (row_var + col_var) / (log_mag.mean() ** 2 + 1e-5)
+        return float(np.clip(normalized / 10, 0, 1))
+    except:
+        return 0.0
+
+
+# ════════════════════════════════════
+# SIGNAL 4: PRNU Noise Analysis
+# ════════════════════════════════════
+
+def run_noise_analysis(img: Image.Image) -> dict:
+    """
+    PRNU (Photo Response Non-Uniformity): real cameras leave a unique
+    noise fingerprint. AI images have statistically different noise
+    distributions — too smooth or too patterned.
+    """
+    try:
+        arr = np.array(img.convert("RGB")).astype(np.float32)
+
+        # Estimate noise using Laplacian filter
+        if HAS_CV2:
+            gray = cv2.cvtColor(arr.astype(np.uint8), cv2.COLOR_RGB2GRAY).astype(np.float32)
+            laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+            noise_level = float(np.std(laplacian))
+            noise_entropy = float(-np.sum(
+                np.histogram(laplacian.flatten(), bins=256, density=True)[0] *
+                np.log2(np.histogram(laplacian.flatten(), bins=256, density=True)[0] + 1e-10)
+            ))
+        else:
+            # Fallback: manual high-pass filter
+            kernel = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]], dtype=np.float32)
+            from scipy.ndimage import convolve as nd_convolve
+            gray = arr.mean(axis=2)
+            try:
+                from scipy.ndimage import convolve as nd_conv
+                filtered = nd_conv(gray, kernel)
+            except:
+                filtered = gray - gray.mean()
+            noise_level = float(np.std(filtered))
+            noise_entropy = 0.5
+
+        # AI images: very low noise (over-smooth) or patterned noise
+        # Real camera: noise_level typically 5-30, entropy ~6-8
+        if noise_level < 2.0:
+            ai_score = 0.85  # Too smooth = AI
+        elif noise_level > 50.0:
+            ai_score = 0.70  # Too much = possible GAN artifact
+        else:
+            ai_score = max(0.1, 0.5 - (noise_level - 2) / 100)
+
+        return {
+            "score": round(ai_score, 4),
+            "noise_level": round(noise_level, 4),
+            "method": "PRNU Noise Analysis",
+            "interpretation": (
+                "🔴 AI-like: abnormally low noise (over-smooth AI texture)"
+                if noise_level < 2.0
+                else "🟡 Ambiguous: noise within borderline range"
+                if 2.0 <= noise_level <= 8.0
+                else "🟢 Real-like: noise consistent with camera sensor"
+            )
+        }
+    except Exception as e:
+        return {"score": 0.5, "method": f"PRNU (error: {e})", "interpretation": "Error"}
+
+
+# ════════════════════════════════════
+# SIGNAL 5: Metadata / EXIF / SynthID
+# ════════════════════════════════════
+
+def run_metadata_analysis(img: Image.Image, filename: str = "") -> dict:
+    """
+    Check EXIF, IPTC, XMP metadata for AI generator signatures.
+    Nano Banana (Gemini) images contain SynthID watermarks.
+    """
+    try:
+        from PIL.ExifTags import TAGS
+        exif_data = img._getexif() if hasattr(img, '_getexif') and img._getexif() else {}
+        exif_readable = {}
+        if exif_data:
+            for tag, value in exif_data.items():
+                tag_name = TAGS.get(tag, str(tag))
+                try:
+                    exif_readable[tag_name] = str(value)[:100]
+                except:
+                    pass
+
+        info = img.info or {}
+
+        # AI-generator specific markers
+        ai_markers = []
+        ai_score_meta = 0.5
+
+        # Check for known AI tool signatures in metadata
+        all_meta_str = str(exif_readable) + str(info) + filename.lower()
+
+        generator_hints = {
+            "adobe firefly": "Adobe Firefly",
+            "firefly": "Adobe Firefly",
+            "generatedby": "Adobe Firefly / AI tool",
+            "stability ai": "Stable Diffusion",
+            "stable diffusion": "Stable Diffusion",
+            "midjourney": "Midjourney",
+            "dall-e": "DALL-E",
+            "openai": "OpenAI",
+            "gemini": "Nano Banana (Gemini)",
+            "synthid": "Google SynthID (Nano Banana)",
+            "imagen": "Google Imagen",
+            "leonardo": "Leonardo AI",
+            "runwayml": "RunwayML",
+            "invoke ai": "InvokeAI",
+            "automatic1111": "Stable Diffusion (A1111)",
+            "comfyui": "Stable Diffusion (ComfyUI)",
+            "parameters": "Stable Diffusion (prompt metadata)",
+        }
+
+        detected_generator = None
+        for key, gen_name in generator_hints.items():
+            if key in all_meta_str.lower():
+                ai_markers.append(f"Found '{key}' marker → {gen_name}")
+                detected_generator = gen_name
+                ai_score_meta = 0.95
+
+        # No camera make/model = suspicious
+        has_camera = any(k in exif_readable for k in ["Make", "Model", "LensModel"])
+        if not has_camera and not ai_markers:
+            ai_markers.append("No camera EXIF (Make/Model) — suspicious for real photo")
+            ai_score_meta = max(ai_score_meta, 0.6)
+
+        # PNG often has AI metadata in text chunks
+        if img.format == "PNG" and not has_camera:
+            ai_markers.append("PNG format without camera EXIF — common for AI outputs")
+            ai_score_meta = max(ai_score_meta, 0.65)
+
+        # SynthID note
+        synthid_note = ""
+        if "gemini" in all_meta_str.lower() or "nano" in filename.lower():
+            synthid_note = "⚠️ SynthID: Upload to Gemini app for definitive Google AI verification"
+
+        return {
+            "score": round(ai_score_meta, 4),
+            "markers_found": ai_markers,
+            "detected_generator": detected_generator,
+            "has_camera_exif": has_camera,
+            "exif_fields": list(exif_readable.keys())[:10],
+            "synthid_note": synthid_note,
+            "method": "Metadata / EXIF / SynthID Analysis",
+            "interpretation": (
+                f"🔴 AI marker detected: {detected_generator}" if detected_generator
+                else "🟡 Suspicious: missing camera metadata" if ai_score_meta > 0.55
+                else "🟢 Metadata consistent with real photo"
+            )
+        }
+    except Exception as e:
+        return {"score": 0.5, "method": f"Metadata (error: {e})", "interpretation": "Error"}
+
+
+# ════════════════════════════════════
+# ENSEMBLE FUSION
+# ════════════════════════════════════
+
+WEIGHTS = {
+    "neural": 0.40,
+    "ela": 0.20,
+    "fft": 0.15,
+    "noise": 0.10,
+    "metadata": 0.15,
+}
+
+def fuse_scores(neural, ela, fft, noise, meta) -> dict:
+    scores = {
+        "neural": neural.get("score", 0.5),
+        "ela": ela.get("score", 0.5),
+        "fft": fft.get("score", 0.5),
+        "noise": noise.get("score", 0.5),
+        "metadata": meta.get("score", 0.5),
+    }
+
+    weighted = sum(WEIGHTS[k] * v for k, v in scores.items())
+
+    # Boost if metadata strongly confirms
+    if meta.get("detected_generator"):
+        weighted = max(weighted, 0.88)
+
+    # Agreement bonus: if 4+ signals agree, boost confidence
+    threshold = 0.6
+    agreement = sum(1 for v in scores.values() if v > threshold)
+    if agreement >= 4:
+        weighted = min(weighted + 0.08, 0.99)
+
+    return {
+        "final_score": round(weighted, 4),
+        "individual_scores": {k: round(v, 4) for k, v in scores.items()},
+        "agreement_count": agreement,
+        "verdict": (
+            "🔴 VERY LIKELY AI-GENERATED" if weighted > 0.80
+            else "🟠 LIKELY AI-GENERATED" if weighted > 0.65
+            else "🟡 UNCERTAIN — POSSIBLY AI" if weighted > 0.50
+            else "🟢 LIKELY REAL PHOTO" if weighted > 0.30
+            else "🟢 VERY LIKELY REAL PHOTO"
+        ),
+        "confidence": f"{abs(weighted - 0.5) * 200:.0f}%",
+    }
+
+
+# ════════════════════════════════════
+# GENERATOR IDENTIFICATION
+# ════════════════════════════════════
+
+def identify_generator(signals: dict) -> str:
+    """Try to identify which specific AI generator produced the image."""
+    meta = signals.get("metadata", {})
+    if meta.get("detected_generator"):
+        return meta["detected_generator"]
+
+    fft_res = signals.get("fft", {})
+    ela_res = signals.get("ela", {})
+    noise_res = signals.get("noise", {})
+
+    nl = noise_res.get("noise_level", 10)
+    uniformity = ela_res.get("uniformity", 0.5)
+    periodic = fft_res.get("periodic_artifacts", False)
+
+    # Heuristic fingerprinting
+    if nl < 0.5 and uniformity > 0.85:
+        return "Likely: Nano Banana / Gemini Image (very smooth, near-zero noise)"
+    if periodic:
+        return "Likely: GAN-based (StyleGAN / older SD) — periodic grid artifacts"
+    if uniformity > 0.75 and nl < 3:
+        return "Likely: Diffusion model (Flux / DALL-E / SD) — low noise, uniform ELA"
+    if uniformity > 0.6:
+        return "Likely: AI-generated (model unknown) — moderate uniformity"
+
+    return "Cannot identify specific generator — signals inconclusive"
+
+
+# ════════════════════════════════════
+# MAIN DETECTION FUNCTION
+# ════════════════════════════════════
+
+def analyze_image(image, filename="uploaded_image.jpg"):
+    if image is None:
+        return "❌ No image provided", None, "{}"
+
+    img = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+    fname = filename if filename else "uploaded_image"
+
+    # Run all signals
+    s1 = run_classifier(img)
+    s2 = run_ela(img)
+    s3 = run_fft(img)
+    s4 = run_noise_analysis(img)
+    s5 = run_metadata_analysis(img, fname)
+
+    # Ensemble
+    fusion = fuse_scores(s1, s2, s3, s4, s5)
+    generator_id = identify_generator({"fft": s3, "ela": s2, "noise": s4, "metadata": s5})
+
+    # Build report
+    verdict = fusion["verdict"]
+    score_pct = f"{fusion['final_score']*100:.1f}%"
+
+    report = f"""
+# 🛡️ ImageShield — Forensic Report
+
+## {verdict}
+
+**AI Probability Score: {score_pct}**
+**Detection Confidence: {fusion['confidence']}**
+**Signals in agreement: {fusion['agreement_count']}/5**
+
+---
+
+## 🔍 Generator Identification
+{generator_id}
+
+### Nano Banana (Gemini) Note
+{s5.get('synthid_note', 'No SynthID markers detected in metadata.')}
+
+---
+
+## 📊 Signal Breakdown
+
+| Method | AI Score | Interpretation |
+|--------|----------|----------------|
+| Neural Classifier | {fusion['individual_scores']['neural']*100:.1f}% | {s1.get('label', 'N/A')} |
+| ELA Analysis | {fusion['individual_scores']['ela']*100:.1f}% | {s2.get('interpretation', 'N/A')} |
+| FFT Frequency | {fusion['individual_scores']['fft']*100:.1f}% | {s3.get('interpretation', 'N/A')} |
+| PRNU Noise | {fusion['individual_scores']['noise']*100:.1f}% | {s4.get('interpretation', 'N/A')} |
+| Metadata/EXIF | {fusion['individual_scores']['metadata']*100:.1f}% | {s5.get('interpretation', 'N/A')} |
+
+---
+
+## 🔬 Technical Details
+
+**ELA:** Mean={s2.get('mean_ela','N/A')} | Std={s2.get('std_ela','N/A')} | Uniformity={s2.get('uniformity','N/A')}
+**FFT:** Freq Ratio={s3.get('freq_ratio','N/A')} | Periodic artifacts={s3.get('periodic_artifacts','N/A')}
+**Noise:** Level={s4.get('noise_level','N/A')}
+**EXIF fields found:** {', '.join(s5.get('exif_fields', [])) or 'None'}
+{('**AI markers:** ' + ' | '.join(s5.get('markers_found', []))) if s5.get('markers_found') else ''}
+
+---
+
+## 📚 Known Generator Signatures
+{chr(10).join(f"**{k}:** {v}" for k, v in list(GENERATORS.items())[:4])}
+
+---
+*ImageShield v2.0 · NOBODY204/ImageShield · S2T Ariana, Tunisia*
+*Multi-signal forensic detection: Neural + ELA + FFT + PRNU + Metadata*
+    """.strip()
+
+    ela_img = s2.get("ela_image", None)
+
+    json_out = json.dumps({
+        "verdict": verdict,
+        "ai_probability": fusion["final_score"],
+        "generator": generator_id,
+        "signals": fusion["individual_scores"],
+        "metadata_markers": s5.get("markers_found", []),
+    }, indent=2)
+
+    return report, ela_img, json_out
+
+
+# ════════════════════════════════════
+# GRADIO UI
+# ════════════════════════════════════
+
+CSS = """
+.container { max-width: 900px; margin: auto; }
+.verdict-box { font-size: 1.4em; font-weight: bold; padding: 12px; border-radius: 8px; }
+footer { display: none !important; }
+"""
+
+with gr.Blocks(
+    title="🛡️ ImageShield — AI Image Detector",
+    theme=gr.themes.Base(primary_hue="blue", neutral_hue="slate"),
+    css=CSS
+) as demo:
+
+    gr.HTML("""
+    <div style="text-align:center; padding:20px 0 10px 0;">
+      <h1 style="font-size:2em; margin:0;">🛡️ ImageShield</h1>
+      <p style="color:#888; margin:4px 0 0 0; font-size:1em;">
+        AI Image Forensic Detector · Nano Banana · DALL-E · Midjourney · Flux · SD & more
+      </p>
+      <p style="color:#555; font-size:0.85em;">
+        Multi-signal pipeline: Neural + ELA + FFT + PRNU + Metadata/SynthID
+      </p>
+    </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(
+                label="📤 Upload Image",
+                type="pil",
+                height=300,
+            )
+            filename_input = gr.Textbox(
+                label="Filename (optional)",
+                placeholder="image.jpg",
+                value=""
+            )
+            analyze_btn = gr.Button("🔍 Analyze Image", variant="primary", size="lg")
+
+            gr.HTML("""
+            <div style="font-size:0.8em; color:#666; margin-top:10px;">
+            <b>Detects:</b> Nano Banana (Gemini 2.5 Flash), Nano Banana Pro (Gemini 3 Pro),
+            GPT-Image-1, DALL-E 3, Midjourney v6/v7, Flux 1.0/1.1, Stable Diffusion XL/3.5,
+            Adobe Firefly, Grok 2, Ideogram 3.0, StyleGAN variants, and more.
+            </div>
+            """)
+
+        with gr.Column(scale=2):
+            report_output = gr.Markdown(label="📋 Forensic Report")
+
     with gr.Row():
-        with gr.Column():
-            in_img = gr.Image(type="numpy")
-            btn = gr.Button("DÉMARRER L'ANALYSE", variant="primary")
-        with gr.Column():
-            out_plt = gr.Plot()
-            out_txt = gr.Textbox(label="Résultat Forensic", lines=10)
-    btn.click(analyze_image, in_img, [out_plt, out_txt])
+        ela_output = gr.Image(label="🔬 ELA Visualization (bright = inconsistent blocks)", type="pil", height=250)
+        json_output = gr.Code(label="📊 Raw Scores (JSON)", language="json", lines=15)
+
+    gr.HTML("""
+    <div style="text-align:center; padding:16px 0 8px 0; color:#555; font-size:0.8em;">
+      <b>About SynthID & Nano Banana:</b> Images generated by Google Gemini (Nano Banana / Nano Banana Pro)
+      contain an invisible SynthID watermark. For definitive Google AI verification, upload the image to
+      the Gemini app and ask "Was this created with Google AI?" · ImageShield detects via forensic signals.
+      <br><br>
+      🛡️ <b>ImageShield v2.0</b> · NOBODY204 · S2T Ariana, Tunisia · MediaShield Suite 2026
+    </div>
+    """)
+
+    def run_analysis(img, fname):
+        if img is None:
+            return "❌ Please upload an image.", None, "{}"
+        return analyze_image(img, fname or "image.jpg")
+
+    analyze_btn.click(
+        fn=run_analysis,
+        inputs=[image_input, filename_input],
+        outputs=[report_output, ela_output, json_output]
+    )
+
+    gr.Examples(
+        examples=[],
+        inputs=[image_input],
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=False)