Update app.py

app.py

@@ -2,109 +2,407 @@ import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 import cv2
-from PIL import Image
-from skimage import feature # Ajout pour l'analyse de texture profonde
-
-# ─────────────────────────────────────────────
-# 🔬 ANALYSE THERMIQUE ET TEXTURE (LBP)
-# ─────────────────────────────────────────────
-def advanced_forensic_analysis(img):
-    # 1. Analyse Infrarouge (YCrCb)
+from scipy import ndimage
+
+# ═══════════════════════════════════════════════════
+# 🔬 MEDIASHIELD PRO v2.0 – CORRECTION DES DÉTECTIONS
+# ═══════════════════════════════════════════════════
+
+def analyze_chrominance_noise(img):
+    """
+    Détecte l'uniformité anormale du bruit chromatique.
+    Les IA génèrent souvent du bruit trop régulier.
+    """
     ycrcb = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)
-    thermal = ycrcb[:, :, 1]
-    infrared_map = cv2.applyColorMap(thermal, cv2.COLORMAP_JET)
+    cr = ycrcb[:, :, 1].astype(np.float32)
+    cb = ycrcb[:, :, 2].astype(np.float32)
     
-    # 2. Analyse LBP (Local Binary Pattern) - Détecte les faux pixels
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    lbp = feature.local_binary_pattern(gray, P=8, R=1, method="uniform")
-    # Si l'image est générée, le LBP est souvent "trop parfait"
-    lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, 12), density=True)
-    lbp_consistency = np.max(lbp_hist) 
+    # Variance locale sur des fenêtres 5x5
+    cr_var = ndimage.generic_filter(cr, np.var, size=5)
+    cb_var = ndimage.generic_filter(cb, np.var, size=5)
+    
+    # Ratio: écart-type des variances / moyenne des variances
+    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
 
-    return infrared_map, np.std(thermal), lbp_consistency
+def find_peaks(signal, threshold_factor=0.3):
+    """Trouve les pics dans un signal 1D (pour détecter les grilles)"""
+    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
 
-# ─────────────────────────────────────────────
-# 📊 ANALYSE FRÉQUENTIELLE (FFT)
-# ─────────────────────────────────────────────
-def frequency_analysis(img):
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+def compute_radial_profile(image):
+    """Calcule la moyenne radiale du spectre FFT"""
+    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):
+    """
+    Détecte les oscillations (ringing) dans le profil radial.
+    Caractéristique des modèles de diffusion (SD, Midjourney).
+    """
+    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):
+    """
+    Détecte:
+    1. Les patterns de grille (StyleGAN, GANs)
+    2. Les artefacts circulaires (Diffusion models)
+    """
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    
+    # FFT
     f = np.fft.fft2(gray)
     fshift = np.fft.fftshift(f)
-    magnitude = 20 * np.log(np.abs(fshift) + 1)
-    # Les IA laissent des traces dans les hautes fréquences (les coins du spectre)
-    h, w = magnitude.shape
-    center_void = np.mean(magnitude[0:10, 0:10]) # Analyse des coins
-    return np.mean(magnitude), center_void
-
-# ─────────────────────────────────────────────
-# 🧠 SCORE GLOBAL "ANTI-TRICHE"
-# ─────────────────────────────────────────────
+    magnitude = np.abs(fshift)
+    
+    # Masquer le centre (basse fréquence)
+    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
+    
+    # Détection de grille via projection
+    proj_x = np.sum(magnitude, axis=0)
+    proj_y = np.sum(magnitude, axis=1)
+    peaks_x = len(find_peaks(proj_x, 0.2))
+    peaks_y = len(find_peaks(proj_y, 0.2))
+    grid_score = (peaks_x + peaks_y) / 2
+    
+    # Détection du ringing
+    radial = compute_radial_profile(magnitude)
+    ringing = detect_ringing(radial)
+    
+    # Visualisation
+    fft_vis = np.log(magnitude + 1)
+    fft_vis = (fft_vis - fft_vis.min()) / (fft_vis.max() - fft_vis.min()) * 255
+    fft_vis = cv2.applyColorMap(fft_vis.astype(np.uint8), cv2.COLORMAP_VIRIDIS)
+    
+    return grid_score, ringing, fft_vis
+
+def detect_noise_characteristics(img):
+    """
+    Analyse le bruit local (les images IA ont des statistiques de bruit anormales)
+    """
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    
+    # Différence entre image et version lissée
+    blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    noise = cv2.absdiff(gray, blur)
+    
+    # Statistiques
+    noise_mean = np.mean(noise)
+    noise_std = np.std(noise)
+    
+    # Analyse des gradients (Sobel)
+    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+    grad_mag = np.sqrt(sobelx**2 + sobely**2)
+    
+    # Distribution des gradients
+    hist = np.histogram(grad_mag, bins=50, range=(0, 255))[0]
+    grad_uniformity = np.std(hist) / (np.mean(hist) + 1e-8)
+    
+    # Hautes fréquences (Laplacian)
+    laplacian = cv2.Laplacian(gray, cv2.CV_64F).var()
+    
+    return {
+        'noise_mean': noise_mean,
+        'noise_std': noise_std,
+        'grad_uniformity': grad_uniformity,
+        'laplacian': laplacian
+    }
+
+def error_level_analysis(img, quality=85):
+    """
+    ELA: Recompresser l'image et comparer.
+    Les zones générées par IA ont souvent des niveaux d'erreur anormaux.
+    """
+    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_score = np.mean(diff)
+    
+    # Améliorer la visualisation
+    ela_enhanced = cv2.convertScaleAbs(diff, alpha=5.0)
+    
+    return ela_score, ela_enhanced
+
+# ═══════════════════════════════════════════════════
+# 🧠 ALGORITHME DE SCORING CORRIGÉ
+# ═══════════════════════════════════════════════════
+
+def compute_ai_score(metrics):
+    """
+    Système de scoring pondéré avec logique floue.
+    Seuils calibrés pour minimiser les faux positifs.
+    """
+    score = 0
+    reasons = []
+    confidence = 0
+    
+    # 1. GRID PATTERNS (GANs like StyleGAN) - Poids fort
+    if metrics['grid_score'] > 15:
+        score += 30
+        reasons.append("⚠️ Strong grid patterns (GAN signature)")
+        confidence += 1
+    elif metrics['grid_score'] > 8:
+        score += 15
+        reasons.append("⚡ Weak grid patterns detected")
+    
+    # 2. RINGING (Diffusion Models) - Poids fort
+    if metrics['ringing'] > 0.25:
+        score += 25
+        reasons.append("⚠️ Circular artifacts (Stable Diffusion/Midjourney)")
+        confidence += 1
+    elif metrics['ringing'] > 0.15:
+        score += 12
+        reasons.append("⚡ Possible diffusion artifacts")
+    
+    # 3. CHROMINANCE (Natural vs AI noise)
+    if metrics['chrom_uniformity'] < 1.0:  # Trop uniforme = suspect
+        score += 15
+        reasons.append("⚡ Unnatural chrominance uniformity")
+    elif metrics['chrom_uniformity'] < 0.5:
+        score += 25
+        reasons.append("⚠️ Artificial color noise detected")
+        confidence += 1
+    
+    # 4. NOISE LEVEL
+    if metrics['noise_mean'] < 2.5:  # Trop propre
+        score += 15
+        reasons.append("⚡ Suspiciously low noise (over-smoothed)")
+    elif metrics['noise_mean'] > 40:  # Bruit artificiel
+        score += 10
+        reasons.append("⚡ Artificial noise pattern")
+    
+    # 5. GRADIENT DISTRIBUTION
+    if metrics['grad_uniformity'] < 2.0:
+        score += 10
+        reasons.append("⚡ Unnatural edge distribution")
+    
+    # 6. LAPLACIAN (Texture)
+    if metrics['laplacian'] < 50:
+        score += 10
+        reasons.append("⚡ Lack of fine texture details")
+    elif metrics['laplacian'] > 500000:  # Images très détaillées (possible upscaling IA)
+        score += 10
+        reasons.append("⚡ Excessive sharpness (AI upscaling?)")
+    
+    # 7. ELA
+    if metrics['ela_score'] < 1.5:
+        score += 15
+        reasons.append("⚠️ Suspicious compression history")
+        confidence += 1
+    
+    # Ajuster selon la confiance
+    if confidence >= 3:
+        score = min(score + 10, 100)  # Bonus si plusieurs indicateurs forts
+    
+    return min(score, 100), reasons
+
+# ═══════════════════════════════════════════════════
+# 🎯 FONCTION PRINCIPALE CORRIGÉE
+# ═══════════════════════════════════════════════════
+
 def analyze_image(img_input):
-    if img_input is None: return None, "Erreur"
-    
-    # Exécution des analyses
-    ir_map, thermal_std, lbp_score = advanced_forensic_analysis(img_input)
-    freq_mean, corner_freq = frequency_analysis(img_input)
-    
-    # CALCUL DU SCORE DURCI
-    # On pénalise si l'image est "trop lisse" (LBP élevé) ou "thermique plate"
-    ai_score = 0
-    if lbp_score > 0.25: ai_score += 35  # Texture trop répétitive (IA)
-    if thermal_std < 6: ai_score += 25    # Chaleur trop uniforme
-    if corner_freq > 15: ai_score += 20   # Artefacts de grille IA
-    if freq_mean < 55: ai_score += 20     # Manque de détails naturels
-    
-    ai_score = min(ai_score, 100)
-    
-    # Verdict
-    if ai_score > 65:
-        status = "🚨 DEEPFAKE DÉTECTÉ (High Probability)"
-        color = "red"
-    elif ai_score > 40:
-        status = "⚠️ IMAGE SUSPECTE (Manipulation probable)"
-        color = "orange"
+    if img_input is None:
+        return None, "Erreur : aucune image fournie"
+    
+    # Conversion RGBA → RGB si nécessaire
+    if img_input.shape[2] == 4:
+        img = cv2.cvtColor(img_input, cv2.COLOR_RGBA2RGB)
+    else:
+        img = img_input.copy()
+    
+    # Limiter la taille pour accélérer (mais garder la qualité)
+    h, w = img.shape[:2]
+    if max(h, w) > 1024:
+        scale = 1024 / max(h, w)
+        img = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
+    
+    # Exécuter les analyses
+    chrom_uniformity, chrom_vis = analyze_chrominance_noise(img)
+    grid_score, ringing, fft_vis = detect_grid_and_ringing(img)
+    noise_data = detect_noise_characteristics(img)
+    ela_score, ela_vis = error_level_analysis(img)
+    
+    metrics = {
+        'chrom_uniformity': chrom_uniformity,
+        'grid_score': grid_score,
+        'ringing': ringing,
+        'noise_mean': noise_data['noise_mean'],
+        'noise_std': noise_data['noise_std'],
+        'grad_uniformity': noise_data['grad_uniformity'],
+        'laplacian': noise_data['laplacian'],
+        'ela_score': ela_score
+    }
+    
+    # Calcul du score
+    ai_score, reasons = compute_ai_score(metrics)
+    
+    # Classification avec nuance
+    if ai_score >= 80:
+        status = "🚨 AI GENERATED (High Confidence)"
+        color = "#ff4444"
+    elif ai_score >= 60:
+        status = "⚠️ LIKELY AI / HEAVILY EDITED"
+        color = "#ff8844"
+    elif ai_score >= 40:
+        status = "🔍 SUSPICIOUS – Manual Review Recommended"
+        color = "#ffaa44"
+    elif ai_score >= 20:
+        status = "✓ PROBABLY REAL (Low Confidence)"
+        color = "#88cc44"
+    else:
+        status = "✅ AUTHENTIC IMAGE"
+        color = "#44aa44"
+    
+    # Détection du type
+    if grid_score > 10 and ringing > 0.2:
+        model_type = "StyleGAN or ProGAN (grid + ringing)"
+    elif ringing > 0.25:
+        model_type = "Stable Diffusion / Midjourney / DALL-E"
+    elif grid_score > 10:
+        model_type = "GAN-based (StyleGAN legacy)"
+    elif ai_score > 50:
+        model_type = "Unknown AI / Heavy processing"
     else:
-        status = "✅ IMAGE AUTHENTIQUE"
-        color = "green"
-
-    # Rapport technique pour Mauro Barni
-    report = f"""🔬 MEDIASHIELD PRO - FORENSIC REPORT v3
---------------------------------------
-VERDICT FINAL : {status}
-INDICE DE FAUX : {ai_score:.2f}%
-
-DÉTAILS TECHNIQUES :
-- Cohérence LBP (Texture) : {lbp_score:.4f} {"(Anomalie IA)" if lbp_score > 0.25 else "(OK)"}
-- Déviation Thermique : {thermal_std:.2f} {"(Trop stable/IA)" if thermal_std < 6 else "(OK)"}
-- Fréquences de grille : {corner_freq:.2f} {"(Signal synthétique)" if corner_freq > 15 else "(OK)"}
-
-CONCLUSION :
-L'analyse des micro-textures (LBP) montre des motifs de répétition non-organiques. 
-La signature thermique confirme l'absence de bruit de capteur physique.
---------------------------------------
-Trusted Sound 2026 - ACoNum Tunisia"""
-
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 7))
-    ax1.imshow(img_input)
-    ax1.set_title("Image Source")
-    ax1.axis('off')
-    ax2.imshow(ir_map)
-    ax2.set_title("Analyse Infrarouge & Texture")
-    ax2.axis('off')
+        model_type = "Natural/Camera capture"
+    
+    # Visualisations
+    fig, axes = plt.subplots(2, 2, figsize=(14, 12))
+    fig.patch.set_facecolor('#f0f0f0')
+    
+    # Original
+    axes[0,0].imshow(img)
+    axes[0,0].set_title('📸 Original Image', fontsize=12, fontweight='bold')
+    axes[0,0].axis('off')
+    
+    # FFT
+    axes[0,1].imshow(fft_vis)
+    axes[0,1].set_title(f'🔮 Frequency Analysis\nGrid: {grid_score:.1f} | Ringing: {ringing:.2f}', 
+                        fontsize=11, fontweight='bold')
+    axes[0,1].axis('off')
+    
+    # ELA
+    axes[1,0].imshow(ela_vis)
+    axes[1,0].set_title(f'🔍 Error Level Analysis\nScore: {ela_score:.2f}', 
+                        fontsize=11, fontweight='bold')
+    axes[1,0].axis('off')
+    
+    # Chrominance
+    im = axes[1,1].imshow(chrom_vis, cmap='hot')
+    axes[1,1].set_title(f'🌈 Chrominance Noise\nUniformity: {chrom_uniformity:.2f}', 
+                        fontsize=11, fontweight='bold')
+    axes[1,1].axis('off')
+    plt.colorbar(im, ax=axes[1,1], fraction=0.046)
+    
+    plt.tight_layout()
+    
+    # Rapport détaillé
+    report = f"""
+╔══════════════════════════════════════════════════════════╗
+║     🛡️  MEDIASHIELD PRO – FORENSIC ANALYSIS v2.0        ║
+╚══════════════════════════════════════════════════════════╝
+
+📊 FINAL VERDICT: {status}
+🎯 AI PROBABILITY SCORE: {ai_score}/100
+
+🔬 DETAILED METRICS:
+   ├─ Grid Pattern Score:    {grid_score:>6.2f}  {'⚠️' if grid_score > 8 else '✓'}
+   ├─ Circular Artifacts:    {ringing:>6.3f}  {'⚠️' if ringing > 0.15 else '✓'}
+   ├─ Chrominance Uniformity: {chrom_uniformity:>6.2f}  {'⚠️' if chrom_uniformity < 1.0 else '✓'}
+   ├─ Noise Level:           {noise_data['noise_mean']:>6.2f}  ±{noise_data['noise_std']:.2f}
+   ├─ Gradient Uniformity:   {noise_data['grad_uniformity']:>6.2f}
+   ├─ Texture (Laplacian):   {noise_data['laplacian']:>6.0f}
+   └─ ELA Score:             {ela_score:>6.2f}  {'⚠️' if ela_score < 1.5 else '✓'}
+
+📝 DETECTED INDICATORS:"""
+    
+    if reasons:
+        for reason in reasons:
+            report += f"\n   {reason}"
+    else:
+        report += "\n   ✅ No suspicious patterns detected"
+    
+    report += f"""
+
+🤖 ESTIMATED SOURCE: {model_type}
+
+💡 INTERPRETATION:
+"""
+    
+    if ai_score >= 80:
+        report += "This image exhibits multiple strong indicators of AI generation."
+    elif ai_score >= 60:
+        report += "This image likely contains AI-generated elements or heavy manipulation."
+    elif ai_score >= 40:
+        report += "Some anomalies detected. Recommend expert verification."
+    else:
+        report += "Image characteristics consistent with natural photography."
+    
+    report += """
+
+═══════════════════════════════════════════════════════════
+MediaShield Pro – Trusted Sound 2026 – Tunisia
+═══════════════════════════════════════════════════════════"""
     
     return fig, report
 
-# ─────────────────────────────────────────────
-# INTERFACE
-# ─────────────────────────────────────────────
-with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# 🛡️ ImageShield PRO - Forensic Suite")
+# ═══════════════════════════════════════════════════
+# 🎨 INTERFACE GRADIO
+# ═══════════════════════════════════════════════════
+
+css = """
+.output_text { font-family: 'Courier New', monospace; white-space: pre-line; }
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    gr.Markdown("""
+    # 🛡️ MediaShield PRO – AI Image Detection v2.0
+    ### Détection avancée de Deepfakes, Stable Diffusion, Midjourney et GANs
+    """)
+    
     with gr.Row():
-        in_img = gr.Image(label="Upload image")
-        out_plot = gr.Plot()
-    out_txt = gr.Textbox(label="Expert Report", lines=12)
-    btn = gr.Button("🔍 ANALYSER MAINTENANT", variant="primary")
-    btn.click(analyze_image, in_img, [out_plot, out_txt])
+        with gr.Column(scale=1):
+            input_img = gr.Image(label="📤 Upload Image", type="numpy")
+            analyze_btn = gr.Button("🔍 START FORENSIC ANALYSIS", variant="primary", size="lg")
+            
+            gr.Markdown("""
+            **ℹ️ Guide d'interprétation:**
+            - 🚨 **80-100**: Image clairement générée par IA
+            - ⚠️ **60-79**: Probablement IA ou très retouchée  
+            - 🔍 **40-59**: Suspecte – vérification manuelle recommandée
+            - ✅ **0-39**: Image probablement authentique
+            """)
+        
+        with gr.Column(scale=2):
+            output_plot = gr.Plot(label="🔬 Forensic Visualizations")
+            output_text = gr.Textbox(label="📋 Analysis Report", lines=25, elem_classes=["output_text"])
+    
+    analyze_btn.click(
+        fn=analyze_image,
+        inputs=input_img,
+        outputs=[output_plot, output_text]
+    )
 
 if __name__ == "__main__":
     demo.launch()