Update app.py

app.py

@@ -1,635 +1,100 @@
-"""
-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
-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
-# ════════════════════════════════════
+import cv2
+import matplotlib.pyplot as plt
+from PIL import Image, ImageChops, ImageEnhance
+from scipy import ndimage
+import io, json, warnings
 
-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")
+warnings.filterwarnings("ignore")
 
+# ═══════════════════════════════════════════════════
+# 🛡️ MEDIASHIELD X IMAGESHIELD (FUSION v3.0)
+# Calibration spéciale : Archives & Mode Sombre
+# ═══════════════════════════════════════════════════
+
+def apply_gamma_correction(img):
+    """Prépare l'image pour l'analyse si elle est trop sombre."""
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    brightness = np.mean(gray)
+    if brightness < 65:
+        # Correction pour révéler les artefacts de compression dans l'ombre
+        gamma = 0.6
+        invGamma = 1.0 / gamma
+        table = np.array([((i / 255.0) ** invGamma) * 255 for i in np.arange(0, 256)]).astype("uint8")
+        return cv2.LUT(img, table), f"🌙 Mode Sombre (Lumière: {brightness:.1f})"
+    return img, "☀️ Lumière Standard"
+
+def analyze_forensics(img_input):
+    if img_input is None: return None, "❌ Aucune image"
+    
+    # 1. Préparation (Correction de lumière S2T)
+    img_cv = cv2.cvtColor(img_input, cv2.COLOR_RGBA2RGB) if img_input.shape[2] == 4 else img_input.copy()
+    img_ready, light_msg = apply_gamma_correction(img_cv)
+    pil_img = Image.fromarray(img_ready)
+
+    # 2. Analyse de Chrominance (Signatures Nano Banana)
+    ycrcb = cv2.cvtColor(img_ready, cv2.COLOR_RGB2YCrCb)
+    cr_var = ndimage.generic_filter(ycrcb[:,:,1], np.var, size=5)
+    chroma_score = np.std(cr_var) / (np.mean(cr_var) + 1e-8)
+
+    # 3. FFT & Grid Patterns (Signatures GAN/Diffusion)
+    gray = cv2.cvtColor(img_ready, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    f_shift = np.fft.fftshift(np.fft.fft2(gray))
+    magnitude = np.abs(f_shift)
+    fft_vis = np.log(magnitude + 1)
+    
+    # 4. ELA (Error Level Analysis)
+    quality = 90
+    buf = io.BytesIO()
+    pil_img.save(buf, format="JPEG", quality=quality)
+    recomp = Image.open(io.BytesIO(buf.getvalue())).convert("RGB")
+    ela_diff = ImageChops.difference(pil_img, recomp)
+    ela_vis = ImageEnhance.Brightness(ela_diff).enhance(10)
+
+    # 5. Calcul du Score Final
+    score = 0
+    reasons = []
+    if chroma_score < 0.9: 
+        score += 35
+        reasons.append("⚠️ Bruit chromatique trop uniforme (Typique IA)")
+    if np.std(magnitude) > 100000: # Seuil simplifié
+        score += 30
+        reasons.append("🔮 Artefacts de fréquence détectés (FFT)")
+    if np.mean(np.array(ela_diff)) < 1.2:
+        score += 25
+        reasons.append("🔍 Compression suspecte (ELA trop lisse)")
+
+    final_verdict = "🔴 TRÈS PROBABLEMENT IA" if score > 60 else "🟢 PROBABLEMENT RÉEL"
+    
+    # Visualisation
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+    axes[0].imshow(img_cv); axes[0].set_title(f'Original ({light_msg})')
+    axes[1].imshow(fft_vis, cmap='viridis'); axes[1].set_title('Fréquences (FFT)')
+    axes[2].imshow(ela_vis); axes[2].set_title('Analyse ELA')
+    for ax in axes: ax.axis('off')
+    
+    report = f"🛡️ MEDIASHIELD v3.0\nVERDICT: {final_verdict}\nScore: {score}/100\n\n{light_msg}\n\n" + "\n".join(reasons)
+    return fig, report
+
+# ═══════════════════════════════════════════════════
+# UI Ariana Edition
+# ═══════════════════════════════════════════════════
+
+with gr.Blocks(title="MediaShield v3.0", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🛡️ MediaShield v3.0 — Forensic Archive Suite")
+    gr.Markdown("Fusion du moteur ImageShield et du correcteur optique MediaShield.")
+    
     with gr.Row():
-        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>
-    """)
+        with gr.Column():
+            input_file = gr.Image(label="Dépôt d'archive numérique", type="numpy")
+            run_btn = gr.Button("DÉMARRER L'ANALYSE FORENSIC", variant="primary")
+        with gr.Column():
+            output_plot = gr.Plot(label="Cartographie des signaux")
+            output_text = gr.Textbox(label="Rapport d'expertise S2T", lines=8)
 
-    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],
-    )
+    run_btn.click(analyze_forensics, inputs=input_file, outputs=[output_plot, output_text])
 
 if __name__ == "__main__":
-    demo.launch(share=False)
+    demo.launch()
+