Update app.py

app.py

@@ -5,169 +5,122 @@ import cv2
 from scipy import ndimage
 
 # ═══════════════════════════════════════════════════
-# 🔬 MEDIASHIELD PRO v2.1 – AVEC CORRECTION LUMIÈRE
+# 🛡️ MEDIASHIELD PRO v2.3 – AUTHENTICITY & DEEPFAKE DETECTOR
 # ═══════════════════════════════════════════════════
 
-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)
-    
-    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):
+def get_sensor_noise_fingerprint(img):
+    """Extrait le bruit hautes fréquences pour vérifier si c'est un capteur physique."""
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    # Filtre médian pour isoler le bruit du signal
+    blurred = cv2.medianBlur(gray.astype(np.uint8), 3).astype(np.float32)
+    noise = cv2.absdiff(gray, blurred)
+    # Une image IA a un bruit très faible ou trop régulier
+    noise_density = np.std(noise)
+    return noise_density, noise
+
+def analyze_frequency_domain(img):
+    """Analyse FFT pour détecter les grilles de génération IA."""
     gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
     f = np.fft.fft2(gray)
     fshift = np.fft.fftshift(f)
-    magnitude = np.abs(fshift)
+    mag = np.abs(fshift)
     
-    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
+    # On ignore le centre (formes) pour voir les artefacts de structure
+    h, w = gray.shape
+    cy, cx = h//2, w//2
+    mag[cy-20:cy+20, cx-20:cx+20] = 0
     
-    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
+    # Detection de pics anormaux (signatures de Nano Banana / GAN)
+    peak_score = np.max(mag) / (np.mean(mag) + 1e-8)
     
-    radial = compute_radial_profile(magnitude)
-    ringing = detect_ringing(radial)
-    
-    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
+    vis = np.log(mag + 1)
+    vis = cv2.normalize(vis, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+    return peak_score, cv2.applyColorMap(vis, cv2.COLORMAP_VIRIDIS)
 
-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)
+def error_level_analysis(img, quality=92):
+    """Détecte les manipulations locales ou l'absence de compression JPEG réelle."""
+    _, enc = cv2.imencode('.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR), [int(cv2.IMWRITE_JPEG_QUALITY), quality])
     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
+    diff = cv2.absdiff(img, cv2.cvtColor(dec, cv2.COLOR_BGR2RGB))
+    ela_score = np.mean(diff)
+    return ela_score, cv2.convertScaleAbs(diff, alpha=5.0)
 
-def compute_ai_score(metrics):
-    score = 0
+def detect_deepfake(img):
+    # 1. Analyse du bruit de capteur (Le point faible de l'IA)
+    noise_density, noise_map = get_sensor_noise_fingerprint(img)
+    
+    # 2. Analyse fréquentielle
+    freq_score, fft_map = analyze_frequency_domain(img)
+    
+    # 3. ELA
+    ela_s, ela_map = error_level_analysis(img)
+    
+    # --- LOGIQUE DE SCORING ---
+    ai_confidence = 0
     reasons = []
     
-    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("⚡ Unnatural chrominance noise")
-    if metrics['ela_score'] < 1.5:
-        score += 15
-        reasons.append("⚠️ Suspicious compression history")
+    # L'IA a souvent un bruit trop faible (< 1.5)
+    if noise_density < 1.8:
+        ai_confidence += 40
+        reasons.append("⚠️ Absence de grain photonique (Signature IA/Lissage)")
         
-    return min(score, 100), reasons
-
-# ═══════════════════════════════════════════════════
-# 🎯 FONCTION ANALYSE (AVEC GESTION IMAGES SOMBRES)
-# ═══════════════════════════════════════════════════
+    # Pics de fréquence (Grilles de diffusion)
+    if freq_score > 150:
+        ai_confidence += 30
+        reasons.append("⚠️ Artefacts de grille détectés (Pattern de génération)")
+        
+    # ELA trop homogène (Propre aux fichiers purement numériques)
+    if ela_s < 1.0:
+        ai_confidence += 20
+        reasons.append("⚠️ Compression trop parfaite (Image non-optique)")
 
-def analyze_image(img_input):
-    if img_input is None: return None, "Erreur"
+    # Plafond de sécurité
+    final_score = min(ai_confidence, 100)
     
-    # 1. Nettoyage format
-    if img_input.shape[2] == 4:
-        img = cv2.cvtColor(img_input, cv2.COLOR_RGBA2RGB)
+    if final_score > 55:
+        label = "🚨 DEEPFAKE / GENERATED"
+        color = "red"
+    elif final_score > 30:
+        label = "⚖️ SUSPICIEUX / MODIFIÉ"
+        color = "orange"
     else:
-        img = img_input.copy()
+        label = "✅ AUTHENTIQUE (CAMERA)"
+        color = "green"
+        
+    return final_score, label, reasons, fft_map, ela_map, noise_map
 
-    # 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"
+# ═══════════════════════════════════════════════════
+# 🎨 GRADIO INTERFACE
+# ═══════════════════════════════════════════════════
 
-    # 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)
-    
-    metrics = {
-        'chrom_uniformity': chrom_u, 'grid_score': grid_s,
-        'ringing': ring, 'ela_score': ela_s
-    }
+def process(input_img):
+    if input_img is None: return None, "Veuillez charger une image."
     
-    ai_score, reasons = compute_ai_score(metrics)
+    score, label, reasons, fft, ela, noise = detect_deepfake(input_img)
     
-    # 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')
+    axes[0,0].imshow(input_img); axes[0,0].set_title("Original")
+    axes[0,1].imshow(fft); axes[0,1].set_title("FFT (Grilles IA)")
+    axes[1,0].imshow(ela); axes[1,0].set_title("ELA (Compression)")
+    axes[1,1].imshow(noise, cmap='gray'); axes[1,1].set_title("Sensor Noise Fingerprint")
     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)
+    
+    report = f"RÉSULTAT : {label}\nIndice de probabilité IA : {score}%\n\nAnalyse :\n"
+    report += "\n".join(reasons) if reasons else "Aucune trace de génération détectée."
+    
     return fig, report
 
-# ═══════════════════════════════════════════════════
-# 🎨 INTERFACE GRADIO
-# ═════��═════════════════════════════════════════════
-
-with gr.Blocks() as demo:
-    gr.Markdown("# 🛡️ MediaShield PRO v2.1")
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🛡️ MediaShield PRO v2.3\n### Analyse Forensic : Authentique vs Deepfake")
     with gr.Row():
         with gr.Column():
-            input_img = gr.Image(label="Image", type="numpy")
-            btn = gr.Button("ANALYSER", variant="primary")
+            in_img = gr.Image(label="Charger une image (JPG/PNG)", type="numpy")
+            run_btn = gr.Button("LANCER L'ANALYSE", 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])
+            out_text = gr.Textbox(label="Rapport d'Expertise", lines=8)
+            
+    run_btn.click(process, inputs=in_img, outputs=[out_plot, out_text])
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()