Update app.py

app.py

@@ -5,7 +5,7 @@ import cv2
 from scipy import ndimage
 
 # ═══════════════════════════════════════════════════
-# 🛡️ MEDIASHIELD PRO v2.4 – Spécial Photos Réelles / IA Partielle
+# 🛡️ MEDIASHIELD PRO v2.5 – Localized AI Detection
 # ═══════════════════════════════════════════════════
 
 def estimate_sensor_noise(img):
@@ -16,74 +16,66 @@ def estimate_sensor_noise(img):
     return np.std(noise)
 
 def analyze_local_variance(img):
-    """Compare le centre (visage) aux bords (fond) pour détecter un montage IA."""
+    """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
-    # Zone centrale vs Zone bordure
     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 = 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)
+    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, cr_var
+    return (u_cr + u_cb) / 2
 
 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)
+    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] # Filtre anti-JPEG
-    
+        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):
-    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
-    _, enc = cv2.imencode('.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR), encode_param)
-    dec_rgb = cv2.cvtColor(cv2.imdecode(enc, 1), cv2.COLOR_BGR2RGB)
-    diff = cv2.absdiff(img, dec_rgb)
+    _, 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 = 0
-    reasons = []
-
-    # 1. Signatures IA classiques
+    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")
-    
-    # 2. Analyse du grain (Bruit Capteur)
     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)")
-
-    # 3. Analyse Locale (Détection de montage)
-    if metrics['local_diff'] > 1.8: score += 30; reasons.append("🚨 Incohérence de texture (IA locale / Montage)")
-
-    # 4. Anti Faux-Positifs (Filtre compression réseaux sociaux)
+    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 typique d'une photo réelle compressée")
-
+        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):
@@ -94,36 +86,48 @@ def analyze_image(img_input):
     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()
 
-    # Calculs
-    chrom_u, chrom_map = analyze_chrominance_noise(img_analysed)
+    # 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); axes[0,0].set_title('Original')
+    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(chrom_map, cmap='hot'); axes[1,1].set_title('Bruit Chromatique')
+    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.4\nScore AI : {ai_score}/100\n\n" + ("\n".join(reasons) if reasons else "✅ Authentique")
+    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.4\nSouveraineté numérique ACoNum")
+    gr.Markdown("# 🛡️ MediaShield PRO v2.5\nSami Meddeb - ACoNum")
     with gr.Row():
         with gr.Column():
             in_img = gr.Image(type="numpy")
-            btn = gr.Button("ANALYSER", variant="primary")
+            btn = gr.Button("DÉMARRER L'ANALYSE", variant="primary")
         with gr.Column():
             out_plt = gr.Plot()
-            out_txt = gr.Textbox(label="Rapport Forensic", lines=10)
+            out_txt = gr.Textbox(label="Résultat Forensic", lines=10)
     btn.click(analyze_image, in_img, [out_plt, out_txt])
 
 if __name__ == "__main__":