Update app.py

app.py

@@ -1,126 +1,173 @@
 import gradio as gr
 import numpy as np
-import cv2
 import matplotlib.pyplot as plt
-from PIL import Image, ImageChops, ImageEnhance
+import cv2
 from scipy import ndimage
-import io, warnings
-
-warnings.filterwarnings("ignore")
 
 # ═══════════════════════════════════════════════════
-# 🛡️ MEDIASHIELD v3.1 — NANO BANANA EDITION
+# 🔬 MEDIASHIELD PRO v2.1 – AVEC CORRECTION LUMIÈRE
 # ═══════════════════════════════════════════════════
 
-def apply_gamma_correction(img):
-    """Prépare l'image pour l'analyse si elle est trop sombre (Archives)."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    brightness = np.mean(gray)
-    if brightness < 65:
-        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 detect_nano_signatures(img):
-    """Détecte les gradients trop parfaits et anomalies de Gemini."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    # Analyse de la variance des gradients (Laplacien)
-    laplacian = cv2.Laplacian(gray, cv2.CV_64F)
-    smoothness_score = np.var(laplacian)
+def analyze_chrominance_noise(img):
+    """Détecte l'uniformité anormale du bruit chromatique."""
+    ycrcb = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)
+    cr = ycrcb[:, :, 1].astype(np.float32)
+    cb = ycrcb[:, :, 2].astype(np.float32)
+    
+    cr_var = ndimage.generic_filter(cr, np.var, size=5)
+    cb_var = ndimage.generic_filter(cb, np.var, size=5)
     
-    # FFT pour détection de périodicité
+    uniformity_cr = np.std(cr_var) / (np.mean(cr_var) + 1e-8)
+    uniformity_cb = np.std(cb_var) / (np.mean(cb_var) + 1e-8)
+    
+    return (uniformity_cr + uniformity_cb) / 2, cr_var
+
+def find_peaks(signal, threshold_factor=0.3):
+    threshold = np.max(signal) * threshold_factor
+    peaks = []
+    for i in range(1, len(signal)-1):
+        if signal[i] > threshold and signal[i] > signal[i-1] and signal[i] > signal[i+1]:
+            peaks.append(i)
+    return peaks
+
+def compute_radial_profile(image):
+    cy, cx = np.array(image.shape) // 2
+    y, x = np.indices(image.shape)
+    r = np.sqrt((x - cx)**2 + (y - cy)**2).astype(int)
+    tbin = ndimage.mean(image, labels=r, index=np.arange(0, min(cx, cy)))
+    return tbin[~np.isnan(tbin)]
+
+def detect_ringing(radial_profile):
+    if len(radial_profile) < 10: return 0
+    diff = np.diff(radial_profile)
+    sign_changes = np.sum(diff[1:] * diff[:-1] < 0)
+    return sign_changes / len(radial_profile)
+
+def detect_grid_and_ringing(img):
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
     f = np.fft.fft2(gray)
     fshift = np.fft.fftshift(f)
-    magnitude_spectrum = 20 * np.log(np.abs(fshift) + 1)
+    magnitude = np.abs(fshift)
     
-    # Un score de smoothness < 4.5 est un fort indicateur IA
-    is_nano_candidate = (smoothness_score < 4.5)
-    return is_nano_candidate, smoothness_score, magnitude_spectrum
-
-def verify_natural_grain(img):
-    """Distingue le lissage IA du grain organique."""
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    local_var = ndimage.generic_filter(gray, np.var, size=3)
-    avg_var = np.mean(local_var)
-    return (avg_var < 0.8), avg_var
-
-def analyze_forensics(img_input):
-    if img_input is None: return None, "❌ Aucune image chargée."
+    rows, cols = gray.shape
+    crow, ccol = rows//2, cols//2
+    mask_radius = min(rows, cols) // 6
+    y, x = np.ogrid[:rows, :cols]
+    mask = (x - ccol)**2 + (y - crow)**2 <= mask_radius**2
+    magnitude[mask] = 0
     
-    # 1. Traitement Image
-    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. Détection Spécifique Nano Banana
-    is_nano, s_score, fft_map = detect_nano_signatures(img_ready)
-
-    # 3. Autres analyses Forensic
-    is_too_smooth, grain_val = verify_natural_grain(img_ready)
+    proj_x = np.sum(magnitude, axis=0)
+    proj_y = np.sum(magnitude, axis=1)
+    grid_score = (len(find_peaks(proj_x, 0.2)) + len(find_peaks(proj_y, 0.2))) / 2
     
-    # 4. Chrominance & ELA
-    ycrcb = cv2.cvtColor(img_ready, cv2.COLOR_RGB2YCrCb)
-    cr_var = ndimage.generic_filter(ycrcb[:,:,1], np.var, size=5)
-    chroma_uniformity = np.std(cr_var) / (np.mean(cr_var) + 1e-8)
+    radial = compute_radial_profile(magnitude)
+    ringing = detect_ringing(radial)
     
-    buf = io.BytesIO()
-    pil_img.save(buf, format="JPEG", quality=90)
-    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
+    fft_vis = np.log(magnitude + 1)
+    fft_vis = (fft_vis - fft_vis.min()) / (fft_vis.max() - fft_vis.min() + 1e-8) * 255
+    fft_vis = cv2.applyColorMap(fft_vis.astype(np.uint8), cv2.COLORMAP_VIRIDIS)
+    
+    return grid_score, ringing, fft_vis
+
+def error_level_analysis(img, quality=85):
+    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
+    _, enc = cv2.imencode('.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR), encode_param)
+    dec = cv2.imdecode(enc, 1)
+    dec_rgb = cv2.cvtColor(dec, cv2.COLOR_BGR2RGB)
+    diff = cv2.absdiff(img, dec_rgb)
+    ela_enhanced = cv2.convertScaleAbs(diff, alpha=5.0)
+    return np.mean(diff), ela_enhanced
+
+def compute_ai_score(metrics):
     score = 0
     reasons = []
-
-    if is_nano:
-        score += 40
-        reasons.append(f"🚨 Signature NANO BANANA : Gradients trop lisses (Score: {s_score:.2f})")
     
-    if is_too_smooth:
+    if metrics['grid_score'] > 15:
+        score += 30
+        reasons.append("⚠️ Strong grid patterns (GAN signature)")
+    if metrics['ringing'] > 0.25:
+        score += 25
+        reasons.append("⚠️ Circular artifacts (Diffusion signature)")
+    if metrics['chrom_uniformity'] < 1.0:
         score += 20
-        reasons.append(f"⚡ Texture suspecte (Grain faible: {grain_val:.2f})")
+        reasons.append("⚡ Unnatural chrominance noise")
+    if metrics['ela_score'] < 1.5:
+        score += 15
+        reasons.append("⚠️ Suspicious compression history")
+        
+    return min(score, 100), reasons
+
+# ═══════════════════════════════════════════════════
+# 🎯 FONCTION ANALYSE (AVEC GESTION IMAGES SOMBRES)
+# ═══════════════════════════════════════════════════
+
+def analyze_image(img_input):
+    if img_input is None: return None, "Erreur"
+    
+    # 1. Nettoyage format
+    if img_input.shape[2] == 4:
+        img = cv2.cvtColor(img_input, cv2.COLOR_RGBA2RGB)
     else:
-        score -= 15
-        reasons.append("✅ Grain organique détecté (Photo réelle)")
+        img = img_input.copy()
 
-    if chroma_uniformity < 0.9: 
-        score += 25
-        reasons.append("⚠️ Bruit chromatique uniforme (Signature IA)")
+    # 2. Correction Gamma pour images sombres
+    gray_check = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    mean_brightness = np.mean(gray_check)
+    
+    # Image pour l'analyse (plus claire si besoin)
+    if mean_brightness < 60:
+        gamma = 0.6
+        invGamma = 1.0 / gamma
+        table = np.array([((i / 255.0) ** invGamma) * 255 for i in np.arange(0, 256)]).astype("uint8")
+        img_analysed = cv2.LUT(img, table)
+        light_msg = f"🌙 Mode Sombre Activé (Luminosité: {mean_brightness:.1f})"
+    else:
+        img_analysed = img.copy()
+        light_msg = "☀️ Luminosité Standard"
 
-    score = max(0, min(100, score))
-    verdict = "🔴 IA DÉTECTÉE" if score > 55 else "🟠 SUSPECT" if score > 35 else "🟢 AUTHENTIQUE"
+    # 3. Traitement forensic sur l'image corrigée
+    chrom_u, chrom_v = 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)
     
-    # 6. 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_map, cmap='magma'); axes[1].set_title('Spectre Nano (FFT)')
-    axes[2].imshow(ela_vis); axes[2].set_title('Analyse ELA')
-    for ax in axes: ax.axis('off')
-    plt.tight_layout()
+    metrics = {
+        'chrom_uniformity': chrom_u, 'grid_score': grid_s,
+        'ringing': ring, 'ela_score': ela_s
+    }
+    
+    ai_score, reasons = compute_ai_score(metrics)
     
-    report = f"🛡️ RAPPORT MEDIASHIELD v3.1\nVERDICT : {verdict}\nIndice de confiance IA : {score}/100\n\nDiagnostic :\n" + "\n".join(reasons)
+    # Visualisation
+    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+    axes[0,0].imshow(img) # On montre l'originale
+    axes[0,0].set_title(f'📸 Original ({light_msg})')
+    axes[0,1].imshow(fft_v)
+    axes[0,1].set_title('🔮 FFT Frequency')
+    axes[1,0].imshow(ela_v)
+    axes[1,0].set_title('🔍 ELA Analysis')
+    axes[1,1].imshow(chrom_v, cmap='hot')
+    axes[1,1].set_title('🌈 Chrominance Noise')
+    for ax in axes.flatten(): ax.axis('off')
+    plt.tight_layout()
+
+    report = f"MEDIASHIELD REPORT\nScore: {ai_score}/100\n{light_msg}\n\nIndicateurs:\n" + "\n".join(reasons)
     return fig, report
 
 # ═══════════════════════════════════════════════════
-# INTERFACE UTILISATEUR
+# 🎨 INTERFACE GRADIO
 # ══════════════════════════════════════════��════════
 
-with gr.Blocks(title="MediaShield v3.1", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🛡️ MediaShield v3.1 (Nano Edition)")
-    gr.Markdown("Expertise Forensic optimisée pour les archives et la détection des modèles Gemini.")
-    
+with gr.Blocks() as demo:
+    gr.Markdown("# 🛡️ MediaShield PRO v2.1")
     with gr.Row():
-        with gr.Column(scale=1):
-            input_file = gr.Image(label="Charger l'archive", type="numpy")
-            run_btn = gr.Button("LANCER L'ANALYSE", variant="primary")
-        with gr.Column(scale=2):
-            output_plot = gr.Plot(label="Preuves visuelles")
-            output_text = gr.Textbox(label="Rapport d'expertise", lines=10)
-
-    run_btn.click(analyze_forensics, inputs=input_file, outputs=[output_plot, output_text])
+        with gr.Column():
+            input_img = gr.Image(label="Image", type="numpy")
+            btn = gr.Button("ANALYSER", variant="primary")
+        with gr.Column():
+            out_plot = gr.Plot()
+            out_txt = gr.Textbox(label="Rapport", lines=10)
+    
+    btn.click(analyze_image, inputs=input_img, outputs=[out_plot, out_txt])
 
 if __name__ == "__main__":
     demo.launch()