Update app.py

app.py

@@ -1,151 +1,103 @@
+import matplotlib
+matplotlib.use('Agg')  # OBLIGATOIRE avant tout import plt — évite crash HF Spaces
+import matplotlib.pyplot as plt
+
 import gradio as gr
 import numpy as np
-import matplotlib.pyplot as plt
 import cv2
-from scipy import ndimage
 
-# ═══════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════
 # 🛡️ IMAGESHIELD PRO v2.5 – AUTHENTICITY & DEEPFAKE DETECTOR
 # ACoNum / Trusted Sound 2026 — Sami Meddeb
-# v2.5 : +2 signaux — retouche locale (composite / skin smoothing)
-#         Détecte les photos très retouchées (Remini, Facetune, FaceApp…)
-#         même si bruit capteur global reste élevé
-# ═══════════════════════════════════════════════════
-
-NOISE_THRESHOLD      = 0.55   # bruit capteur corrigé
-FREQ_THRESHOLD       = 500    # pic FFT GAN
-ELA_THRESHOLD        = 0.25   # ELA trop parfaite
-MIN_SIGNALS          = 2      # seuil de déclenchement
+# v2.5 : +2 signaux retouche locale + skin smoothing
+#         Fix skin_vis numpy, try/except robuste
+# ═══════════════════════════════════════════════════════════════
 
+NOISE_THRESHOLD  = 0.55
+FREQ_THRESHOLD   = 500
+ELA_THRESHOLD    = 0.25
+MIN_SIGNALS      = 2
 
-# ─────────────────────────────────────────────────────────────
-# SIGNAUX EXISTANTS (inchangés)
-# ─────────────────────────────────────────────────────────────
 
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 1 — Bruit de capteur (corrigé luminosité studio)
+# ──────────────────────────────────────────────────────────────
 def get_sensor_noise_fingerprint(img):
-    """
-    Extrait le bruit hautes fréquences du capteur.
-    Corrige le biais luminosité (studio pro).
-    """
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    gray    = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
     blurred = cv2.medianBlur(gray.astype(np.uint8), 3).astype(np.float32)
-    noise = cv2.absdiff(gray, blurred)
-    mean_lum = np.mean(gray)
-    noise_density = np.std(noise)
-    corrected_density = noise_density * (128.0 / (mean_lum + 1e-8))
+    noise   = cv2.absdiff(gray, blurred)
+    mean_lum          = np.mean(gray)
+    corrected_density = np.std(noise) * (128.0 / (mean_lum + 1e-8))
     return corrected_density, noise
 
 
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 2 — FFT : grille GAN/Diffusion
+# ──────────────────────────────────────────────────────────────
 def analyze_frequency_domain(img):
-    """
-    FFT : détecte les grilles de génération GAN/Diffusion.
-    Ratio max/mean > 500 = pic anormal = signature IA.
-    """
-    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    f = np.fft.fft2(gray)
-    fshift = np.fft.fftshift(f)
-    mag = np.abs(fshift)
-    h, w = gray.shape
+    gray   = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    fshift = np.fft.fftshift(np.fft.fft2(gray))
+    mag    = np.abs(fshift)
+    h, w   = gray.shape
     cy, cx = h // 2, w // 2
     mag[cy - 20:cy + 20, cx - 20:cx + 20] = 0
     peak_score = np.max(mag) / (np.mean(mag) + 1e-8)
-    vis = np.log(mag + 1)
-    vis = cv2.normalize(vis, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+    vis = cv2.normalize(np.log(mag + 1), None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
     return peak_score, cv2.applyColorMap(vis, cv2.COLORMAP_VIRIDIS)
 
 
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 3 — ELA : manipulation locale
+# ──────────────────────────────────────────────────────────────
 def error_level_analysis(img, quality=92):
-    """
-    ELA : détecte manipulations locales.
-    ELA très basse + variance nulle = image synthétique pure.
-    """
-    _, enc = cv2.imencode(
-        '.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR),
-        [int(cv2.IMWRITE_JPEG_QUALITY), quality]
-    )
-    dec = cv2.imdecode(enc, 1)
+    _, enc = cv2.imencode('.jpg', cv2.cvtColor(img, cv2.COLOR_RGB2BGR),
+                          [int(cv2.IMWRITE_JPEG_QUALITY), quality])
+    dec  = cv2.imdecode(enc, 1)
     diff = cv2.absdiff(img, cv2.cvtColor(dec, cv2.COLOR_BGR2RGB))
-    ela_score = np.mean(diff)
-    ela_variance = np.std(diff)
-    return ela_score, ela_variance, cv2.convertScaleAbs(diff, alpha=5.0)
+    return np.mean(diff), np.std(diff), cv2.convertScaleAbs(diff, alpha=5.0)
 
 
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 4 — Gradients Sobel : texture trop lisse
+# ──────────────────────────────────────────────────────────────
 def detect_face_artifacts(img):
-    """
-    Gradients Sobel : trop uniforme = deepfake facial.
-    ratio std/mean < 1.2 = texture synthétique.
-    """
     gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
-    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
-    gradient_mag = np.sqrt(sobelx**2 + sobely**2)
-    gradient_std = np.std(gradient_mag)
-    gradient_mean = np.mean(gradient_mag)
-    ratio = gradient_std / (gradient_mean + 1e-8)
-    return ratio
+    sx   = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    sy   = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+    mag  = np.sqrt(sx**2 + sy**2)
+    return np.std(mag) / (np.mean(mag) + 1e-8)
 
 
-# ─────────────────────────────────────────────────────────────
-# NOUVEAUX SIGNAUX v2.5
-# ─────────────────────────────────────────────────────────────
-
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 5 — Retouche locale : composite / fond remplacé
+# ──────────────────────────────────────────────────────────────
 def detect_local_retouching(img, noise_map):
-    """
-    Signal 5 — Retouche locale : composite, background replacement, skin smoothing.
-
-    Principe : une vraie photo a un bruit de capteur COHÉRENT sur toute l'image.
-    Une image retouchée crée des "îles de silence" (bruit ≈ 0) dans une mer de bruit,
-    typique d'un masquage par zone (fond remplacé, visage lissé, objet inséré).
-
-    Deux métriques :
-      - silent_ratio     : pourcentage de pixels avec bruit < 4% du max
-      - inter_block_var  : variance de bruit entre blocs 32×32
-                           (grande variance = zones hétérogènes = composite)
-    """
-    noise_f = noise_map.astype(np.float32)
-    noise_max = np.max(noise_f) + 1e-8
-    noise_norm = noise_f / noise_max
-
-    # Zones quasi sans bruit
+    noise_norm  = noise_map.astype(np.float32) / (np.max(noise_map) + 1e-8)
     silent_mask = (noise_norm < 0.04).astype(np.uint8)
     silent_ratio = float(np.mean(silent_mask))
 
-    # Variance inter-blocs 32×32
     h, w = noise_norm.shape
-    block_stds = []
-    for y in range(0, h - 32, 32):
-        for x in range(0, w - 32, 32):
-            block = noise_norm[y:y + 32, x:x + 32]
-            block_stds.append(float(np.std(block)))
-
+    block_stds = [
+        float(np.std(noise_norm[y:y + 32, x:x + 32]))
+        for y in range(0, h - 32, 32)
+        for x in range(0, w - 32, 32)
+    ]
     inter_block_var = float(np.std(block_stds)) if block_stds else 0.0
 
-    # Carte visuelle : zones silencieuses en rouge sur fond gris
+    # Visualisation : zones suspectes en rouge
     vis = cv2.cvtColor((noise_norm * 255).astype(np.uint8), cv2.COLOR_GRAY2RGB)
-    vis[silent_mask == 1] = [220, 50, 50]   # rouge = zone suspecte
+    vis[silent_mask == 1] = [220, 50, 50]
 
     return silent_ratio, inter_block_var, vis
 
 
+# ──────────────────────────────────────────────────────────────
+# SIGNAL 6 — Skin smoothing : Facetune / Remini / FaceApp
+# ──────────────────────────────────────────────────────────────
 def detect_skin_smoothing(img):
-    """
-    Signal 6 — Skin smoothing (Remini, Facetune, FaceApp, Photoshop liquify…).
-
-    Principe : la peau humaine réelle a une micro-texture naturelle mesurable
-    via la variance du Laplacien dans les zones chair.
-    Après lissage artificiel, cette variance s'effondre (< 8.0).
-
-    Retourne :
-      skin_texture_std  : variance de texture (< 8.0 = suspect)
-      skin_ratio        : pourcentage de zones chair dans l'image
-      skin_vis          : carte de chaleur des zones analysées
-    """
-    hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
-    h_ch = hsv[:, :, 0].astype(np.float32)
-    s_ch = hsv[:, :, 1].astype(np.float32)
-    v_ch = hsv[:, :, 2].astype(np.float32)
-
-    # Masque peau : teinte chair, saturation modérée, luminosité > 80
+    hsv  = cv2.cvtColor(img, cv2.COLOR_RGB2HSV).astype(np.float32)
+    h_ch, s_ch, v_ch = hsv[:, :, 0], hsv[:, :, 1], hsv[:, :, 2]
+
     skin_mask = (
         (h_ch >= 0) & (h_ch <= 25) &
         (s_ch >= 40) & (s_ch <= 200) &
@@ -154,111 +106,76 @@ def detect_skin_smoothing(img):
 
     skin_ratio = float(np.mean(skin_mask))
 
-    # Visualisation
-    skin_vis = img.copy()
-    skin_vis[skin_mask == 0] = (skin_vis[skin_mask == 0] * 0.35).astype(np.uint8)
-    skin_vis[skin_mask == 1, 0] = np.clip(
-        skin_vis[skin_mask == 1, 0].astype(np.int32) + 60, 0, 255
-    ).astype(np.uint8)
+    # Visualisation sûre (pas d'assignment sur copie)
+    darkened = (img * 0.35).astype(np.uint8)
+    skin_vis = darkened.copy()
+    skin_vis[skin_mask == 1] = img[skin_mask == 1]   # ← fix numpy : vue directe
 
     if skin_ratio < 0.02:
-        return -1.0, skin_ratio, skin_vis   # pas assez de peau
+        return -1.0, skin_ratio, skin_vis
 
     gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
-    lap = np.abs(cv2.Laplacian(gray, cv2.CV_64F))
+    lap  = np.abs(cv2.Laplacian(gray, cv2.CV_64F))
     skin_texture = lap[skin_mask == 1]
 
     if len(skin_texture) < 100:
         return -1.0, skin_ratio, skin_vis
 
-    texture_std = float(np.std(skin_texture))
-    return texture_std, skin_ratio, skin_vis
+    return float(np.std(skin_texture)), skin_ratio, skin_vis
 
 
-# ─────────────────────────────────────────────────────────────
+# ──────────────────────────────────────────────────────────────
 # MOTEUR PRINCIPAL
-# ─────────────────────────────────────────────────────────────
-
+# ──────────────────────────────────────────────────────────────
 def detect_deepfake(img):
-
-    # ── Calcul des 6 signaux ─────────────────────────────────
-    noise_density, noise_map        = get_sensor_noise_fingerprint(img)
-    freq_score, fft_map             = analyze_frequency_domain(img)
-    ela_s, ela_var, ela_map         = error_level_analysis(img)
-    gradient_ratio                  = detect_face_artifacts(img)
+    noise_density, noise_map                   = get_sensor_noise_fingerprint(img)
+    freq_score,    fft_map                     = analyze_frequency_domain(img)
+    ela_s, ela_var, ela_map                    = error_level_analysis(img)
+    gradient_ratio                             = detect_face_artifacts(img)
     silent_ratio, inter_block_var, retouche_vis = detect_local_retouching(img, noise_map)
-    skin_std, skin_ratio, skin_vis  = detect_skin_smoothing(img)
+    skin_std, skin_ratio, skin_vis             = detect_skin_smoothing(img)
 
-    # ── Scoring ──────────────────────────────────────────────
     signals_triggered = 0
-    ai_confidence = 0
-    reasons = []
+    ai_confidence     = 0
+    reasons           = []
 
-    # Signal 1 — Bruit capteur absent
+    # S1 — Bruit capteur absent
     if noise_density < NOISE_THRESHOLD:
-        ai_confidence += 35
-        signals_triggered += 1
-        reasons.append(
-            f"⚠️ Bruit photonique absent "
-            f"(densité={noise_density:.2f} < {NOISE_THRESHOLD}) — "
-            "aucun grain capteur physique"
-        )
+        ai_confidence += 35;  signals_triggered += 1
+        reasons.append(f"⚠️ Bruit photonique absent (densité={noise_density:.2f} < {NOISE_THRESHOLD})")
 
-    # Signal 2 — Grille FFT GAN
+    # S2 — Grille IA FFT
     if freq_score > FREQ_THRESHOLD:
-        ai_confidence += 30
-        signals_triggered += 1
-        reasons.append(
-            f"⚠️ Grille IA en FFT "
-            f"(score={freq_score:.0f} > {FREQ_THRESHOLD}) — "
-            "pattern de génération diffusion/GAN"
-        )
+        ai_confidence += 30;  signals_triggered += 1
+        reasons.append(f"⚠️ Grille IA en FFT (score={freq_score:.0f} > {FREQ_THRESHOLD})")
 
-    # Signal 3 — ELA trop parfaite + variance nulle
+    # S3 — ELA trop parfaite
     if ela_s < ELA_THRESHOLD and ela_var < 0.5:
-        ai_confidence += 25
-        signals_triggered += 1
-        reasons.append(
-            f"⚠️ Compression parfaite "
-            f"ELA={ela_s:.3f} σ={ela_var:.3f} — "
-            "image non issue d'un capteur optique réel"
-        )
+        ai_confidence += 25;  signals_triggered += 1
+        reasons.append(f"⚠️ ELA parfaite={ela_s:.3f} σ={ela_var:.3f} — image synthétique")
 
-    # Signal 4 — Gradients trop lisses (deepfake facial)
+    # S4 — Gradients trop uniformes
     if gradient_ratio < 1.2:
-        ai_confidence += 20
-        signals_triggered += 1
-        reasons.append(
-            f"⚠️ Gradients trop uniformes "
-            f"(ratio={gradient_ratio:.2f} < 1.2) — "
-            "absence de texture naturelle"
-        )
+        ai_confidence += 20;  signals_triggered += 1
+        reasons.append(f"⚠️ Gradients trop lisses (ratio={gradient_ratio:.2f} < 1.2)")
 
-    # Signal 5 — Retouche locale (composite / fond remplacé) [NOUVEAU v2.5]
-    # Critère : > 20 % zones silencieuses ET forte hétérogénéité entre blocs
+    # S5 — Retouche locale
     if silent_ratio > 0.20 and inter_block_var > 0.08:
-        ai_confidence += 30
-        signals_triggered += 1
+        ai_confidence += 30;  signals_triggered += 1
         reasons.append(
-            f"⚠️ Retouche locale détectée — "
-            f"{silent_ratio * 100:.0f}% zones sans bruit, "
-            f"variance inter-blocs={inter_block_var:.3f} — "
-            "composite, fond remplacé ou masquage par zone"
+            f"⚠️ Retouche locale — {silent_ratio*100:.0f}% zones sans bruit, "
+            f"variance inter-blocs={inter_block_var:.3f}"
         )
 
-    # Signal 6 — Skin smoothing [NOUVEAU v2.5]
-    # Texture peau std < 8.0 = lissage artificiel (Facetune, Remini, FaceApp…)
+    # S6 — Skin smoothing
     if skin_ratio >= 0.02 and 0 <= skin_std < 8.0:
-        ai_confidence += 25
-        signals_triggered += 1
+        ai_confidence += 25;  signals_triggered += 1
         reasons.append(
-            f"⚠️ Skin smoothing détecté — "
-            f"texture peau std={skin_std:.1f} < 8.0 "
-            f"(zone peau={skin_ratio * 100:.0f}%) — "
-            "filtrage Facetune / Remini / FaceApp"
+            f"⚠️ Skin smoothing — texture peau std={skin_std:.1f} < 8.0 "
+            f"(zone={skin_ratio*100:.0f}%)"
         )
 
-    # Règle de sécurité : min 2 signaux pour crier deepfake
+    # Règle sécurité : min 2 signaux
     if signals_triggered < MIN_SIGNALS:
         ai_confidence = min(ai_confidence, 28)
 
@@ -282,63 +199,66 @@ def detect_deepfake(img):
     )
 
 
-# ─────────────────────────────────────────────────────────────
-# INTERFACE GRADIO
-# ─────────────────────────────────────────────────────────────
-
+# ──────────────────────────────────────────────────────────────
+# CALLBACK GRADIO
+# ──────────────────────────────────────────────────────────────
 def process(input_img):
     if input_img is None:
-        return None, "Veuillez charger une image."
+        return None, "⚠️ Veuillez charger une image."
 
-    (score, label, reasons,
-     fft, ela, noise,
-     retouche_vis, skin_vis,
-     noise_val, freq_val, ela_val,
-     n_signals,
-     silent_ratio, inter_block_var,
-     skin_std, skin_ratio) = detect_deepfake(input_img)
+    try:
+        (score, label, reasons,
+         fft, ela, noise,
+         retouche_vis, skin_vis,
+         noise_val, freq_val, ela_val,
+         n_signals,
+         silent_ratio, inter_block_var,
+         skin_std, skin_ratio) = detect_deepfake(input_img)
 
-    # ── Figure 3×2 : 6 vues forensiques ──────────────────────
+    except Exception as e:
+        return None, f"❌ Erreur d'analyse : {str(e)}"
+
+    # ── Figure 2×3 ──────────────────────────────────────────
     fig, axes = plt.subplots(2, 3, figsize=(16, 10))
 
     axes[0, 0].imshow(input_img)
-    axes[0, 0].set_title("Original", fontsize=11)
+    axes[0, 0].set_title("Original")
 
     axes[0, 1].imshow(fft)
-    axes[0, 1].set_title("FFT — Grilles IA (Signal 2)", fontsize=11)
+    axes[0, 1].set_title("FFT — Grille IA [S2]")
 
     axes[0, 2].imshow(ela)
-    axes[0, 2].set_title("ELA — Compression (Signal 3)", fontsize=11)
+    axes[0, 2].set_title("ELA — Compression [S3]")
 
     axes[1, 0].imshow(noise, cmap='gray')
-    axes[1, 0].set_title("Bruit Capteur Corrigé (Signal 1)", fontsize=11)
+    axes[1, 0].set_title("Bruit Capteur Corrigé [S1]")
 
     axes[1, 1].imshow(retouche_vis)
-    axes[1, 1].set_title("Zones Sans Bruit — Retouche (Signal 5)", fontsize=11)
+    axes[1, 1].set_title("Zones Sans Bruit — Retouche [S5]")
 
     axes[1, 2].imshow(skin_vis)
-    axes[1, 2].set_title("Zones Peau — Skin Smoothing (Signal 6)", fontsize=11)
+    axes[1, 2].set_title("Zones Peau — Skin Smoothing [S6]")
 
     for ax in axes.flatten():
         ax.axis('off')
 
-    plt.suptitle(f"{label}  —  {score}%", fontsize=13, fontweight='bold',
-                 color='red' if score > 55 else ('orange' if score > 28 else 'green'))
+    color = 'red' if score > 55 else ('orange' if score > 28 else 'green')
+    plt.suptitle(f"{label}  —  {score}%", fontsize=13, fontweight='bold', color=color)
     plt.tight_layout()
 
-    # ── Rapport texte ─────────────────────────────────────────
+    # ── Rapport ─────────────────────────────────────────────
     report  = f"RÉSULTAT : {label}\n"
     report += f"Probabilité manipulation : {score}%  |  Signaux : {n_signals}/{MIN_SIGNALS} minimum\n"
     report += f"\nMesures brutes :\n"
-    report += f"  [S1] Bruit capteur corrigé   : {noise_val:.3f}  (seuil < {NOISE_THRESHOLD})\n"
-    report += f"  [S2] Pic FFT                 : {freq_val:.0f}     (seuil > {FREQ_THRESHOLD})\n"
-    report += f"  [S3] ELA moyenne             : {ela_val:.4f}  (seuil < {ELA_THRESHOLD})\n"
-    report += f"  [S5] Zones sans bruit        : {silent_ratio * 100:.1f}%   (seuil > 20%)\n"
-    report += f"  [S5] Variance inter-blocs    : {inter_block_var:.3f}  (seuil > 0.08)\n"
+    report += f"  [S1] Bruit capteur corrigé  : {noise_val:.3f}  (seuil < {NOISE_THRESHOLD})\n"
+    report += f"  [S2] Pic FFT                : {freq_val:.0f}     (seuil > {FREQ_THRESHOLD})\n"
+    report += f"  [S3] ELA moyenne            : {ela_val:.4f}  (seuil < {ELA_THRESHOLD})\n"
+    report += f"  [S5] Zones sans bruit       : {silent_ratio*100:.1f}%   (seuil > 20%)\n"
+    report += f"  [S5] Variance inter-blocs   : {inter_block_var:.3f}  (seuil > 0.08)\n"
     if skin_ratio >= 0.02:
-        report += f"  [S6] Texture peau (std)      : {skin_std:.1f}     (seuil < 8.0, zone={skin_ratio * 100:.0f}%)\n"
+        report += f"  [S6] Texture peau (std)     : {skin_std:.1f}    (seuil < 8.0, zone={skin_ratio*100:.0f}%)\n"
     else:
-        report += f"  [S6] Texture peau            : zone chair insuffisante (<2%)\n"
+        report += f"  [S6] Texture peau           : zone chair insuffisante (<2%)\n"
     report += f"\nSignaux actifs :\n"
     report += "\n".join(reasons) if reasons else "  Aucune trace de manipulation détectée."
     report += "\n\n── ImageShield PRO v2.5 · ACoNum / Trusted Sound 2026 ──"
@@ -346,15 +266,14 @@ def process(input_img):
     return fig, report
 
 
-# ─────────────────────────────────────────────────────────────
-# LANCEMENT
-# ─────────────────────────────────────────────────────────────
-
+# ──────────────────────────────────────────────────────────────
+# INTERFACE GRADIO
+# ──────────────────────────────────────────────────────────────
 with gr.Blocks() as demo:
     gr.Markdown(
         "# 🛡️ ImageShield PRO v2.5\n"
         "### Analyse Forensic : Authentique vs Deepfake / Retouche\n"
-        "_v2.5 : +2 signaux — retouche locale (composite, fond remplacé) + skin smoothing (Remini, Facetune, FaceApp)_"
+        "_v2.5 : 6 signaux — bruit capteur, FFT, ELA, gradients, retouche locale, skin smoothing_"
     )
     with gr.Row():
         with gr.Column():