Update app.py

app.py

@@ -5,62 +5,50 @@ import cv2
 from scipy import ndimage
 
 # ═══════════════════════════════════════════════════
-# 🛡️ IMAGESHIELD PRO v2.4 – AUTHENTICITY & DEEPFAKE DETECTOR
+# 🛡️ IMAGESHIELD PRO v2.5 – AUTHENTICITY & DEEPFAKE DETECTOR
 # ACoNum / Trusted Sound 2026 — Sami Meddeb
-# Fix v2.4 : seuils recalibrés pour éviter les faux positifs
-# (photos studio professionnelles, éclairage fort, JPEG haute qualité)
+# 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é
 # ═══════════════════════════════════════════════════
 
-# ── SEUILS CALIBRÉS v2.4 ────────────────────────────────────
-# Problème v2.3 : photos studio → grain faible → détecté comme IA
-# Solution : seuils plus stricts + score combiné obligatoire
+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
 
-NOISE_THRESHOLD   = 0.55   # était 1.8 — studio pro légit peut avoir < 1.0
-FREQ_THRESHOLD    = 500    # était 150 — trop sensible aux JPEG
-ELA_THRESHOLD     = 0.25   # était 1.0 — photos JPEG légit ont ELA faible
-MIN_SIGNALS       = 2      # il faut AU MOINS 2 signaux pour crier deepfake
 
+# ─────────────────────────────────────────────────────────────
+# SIGNAUX EXISTANTS (inchangés)
+# ─────────────────────────────────────────────────────────────
 
 def get_sensor_noise_fingerprint(img):
     """
-    Extrait le bruit hautes fréquences pour vérifier si c'est un capteur physique.
-    IMPORTANT : photos studio avec éclairage professionnel ont naturellement
-    moins de grain — ne pas confondre avec signature IA.
-    On normalise par la luminosité moyenne pour corriger ce biais.
+    Extrait le bruit hautes fréquences du capteur.
+    Corrige le biais luminosité (studio pro).
     """
     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)
-
-    # Normalisation par la luminosité pour compenser l'éclairage studio
     mean_lum = np.mean(gray)
     noise_density = np.std(noise)
-    # Correction : photo très lumineuse → grain naturellement réduit
-    # On ramène à une base commune
     corrected_density = noise_density * (128.0 / (mean_lum + 1e-8))
-
     return corrected_density, noise
 
 
 def analyze_frequency_domain(img):
     """
-    Analyse FFT pour détecter les grilles de génération IA.
-    Les GAN/Diffusion produisent des pics très réguliers à fréquences spécifiques.
-    Une photo JPEG légitime même compressée n'a PAS ces pics réguliers.
+    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
     cy, cx = h // 2, w // 2
     mag[cy - 20:cy + 20, cx - 20:cx + 20] = 0
-
-    # Ratio max/mean : un vrai GAN a des pics TRÈS anormaux (> 500)
-    # Une photo réelle même avec artefacts JPEG reste < 400
     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)
     return peak_score, cv2.applyColorMap(vis, cv2.COLORMAP_VIRIDIS)
@@ -68,11 +56,8 @@ def analyze_frequency_domain(img):
 
 def error_level_analysis(img, quality=92):
     """
-    ELA : détecte les manipulations locales.
-    IMPORTANT : une photo JPEG légit, même haute qualité, a une ELA faible.
-    On cherche une ELA ANORMALEMENT basse (image purement synthétique)
-    OU des zones avec ELA irrégulière (copier-coller, manipulation locale).
-    Seuil abaissé à 0.25 pour ne pas pénaliser les vraies photos.
+    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),
@@ -81,124 +66,225 @@ def error_level_analysis(img, quality=92):
     dec = cv2.imdecode(enc, 1)
     diff = cv2.absdiff(img, cv2.cvtColor(dec, cv2.COLOR_BGR2RGB))
     ela_score = np.mean(diff)
-
-    # Variance spatiale : une image IA a souvent une ELA trop UNIFORME
     ela_variance = np.std(diff)
-
     return ela_score, ela_variance, cv2.convertScaleAbs(diff, alpha=5.0)
 
 
 def detect_face_artifacts(img):
     """
-    Détecte les artefacts typiques des deepfakes sur les visages :
-    - Bords flous autour du visage
-    - Transition peau/arrière-plan trop nette (upsampling)
-    - Symétrie excessive
+    Gradients Sobel : trop uniforme = deepfake facial.
+    ratio std/mean < 1.2 = texture synthétique.
     """
     gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-    # Gradient de Sobel pour détecter les discontinuités anormales
     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)
-
-    # Un deepfake facial a des gradients trop lisses dans les zones de peau
-    # et trop nets aux bords du visage généré
     gradient_std = np.std(gradient_mag)
     gradient_mean = np.mean(gradient_mag)
     ratio = gradient_std / (gradient_mean + 1e-8)
-
-    # Ratio < 1.2 = trop uniforme = suspect
     return ratio
 
 
-def detect_deepfake(img):
-    # 1. Bruit de capteur (corrigé pour éclairage studio)
-    noise_density, noise_map = get_sensor_noise_fingerprint(img)
+# ─────────────────────────────────────────────────────────────
+# NOUVEAUX SIGNAUX v2.5
+# ─────────────────────────────────────────────────────────────
 
-    # 2. Analyse fréquentielle FFT
-    freq_score, fft_map = analyze_frequency_domain(img)
+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
+    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)))
+
+    inter_block_var = float(np.std(block_stds)) if block_stds else 0.0
+
+    # Carte visuelle : zones silencieuses en rouge sur fond gris
+    vis = cv2.cvtColor((noise_norm * 255).astype(np.uint8), cv2.COLOR_GRAY2RGB)
+    vis[silent_mask == 1] = [220, 50, 50]   # rouge = zone suspecte
+
+    return silent_ratio, inter_block_var, vis
+
+
+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
+    skin_mask = (
+        (h_ch >= 0) & (h_ch <= 25) &
+        (s_ch >= 40) & (s_ch <= 200) &
+        (v_ch >= 80)
+    ).astype(np.uint8)
+
+    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)
+
+    if skin_ratio < 0.02:
+        return -1.0, skin_ratio, skin_vis   # pas assez de peau
+
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32)
+    lap = np.abs(cv2.Laplacian(gray, cv2.CV_64F))
+    skin_texture = lap[skin_mask == 1]
 
-    # 3. ELA + variance
-    ela_s, ela_var, ela_map = error_level_analysis(img)
+    if len(skin_texture) < 100:
+        return -1.0, skin_ratio, skin_vis
 
-    # 4. Artefacts de gradient (visage/bords)
-    gradient_ratio = detect_face_artifacts(img)
+    texture_std = float(np.std(skin_texture))
+    return texture_std, skin_ratio, skin_vis
 
-    # ─── LOGIQUE DE SCORING v2.4 ─────────────────────────────
-    # Règle : au moins 2 signaux positifs pour déclarer "deepfake"
-    # Chaque signal contribue des points SEULEMENT s'il est significatif
 
+# ─────────────────────────────────────────────────────────────
+# 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)
+    silent_ratio, inter_block_var, retouche_vis = detect_local_retouching(img, noise_map)
+    skin_std, skin_ratio, skin_vis  = detect_skin_smoothing(img)
+
+    # ── Scoring ──────────────────────────────────────────────
     signals_triggered = 0
     ai_confidence = 0
     reasons = []
 
-    # Signal 1 — Bruit de capteur anormalement faible
-    # Seuil 0.55 (corrigé luminosité) — les vrais studios restent > 0.6
+    # Signal 1 — Bruit capteur absent
     if noise_density < NOISE_THRESHOLD:
         ai_confidence += 35
         signals_triggered += 1
         reasons.append(
-            f"⚠️ Bruit photonique absent (densité={noise_density:.2f} < {NOISE_THRESHOLD}) — "
-            "Absence de grain capteur physique"
+            f"⚠️ Bruit photonique absent "
+            f"(densité={noise_density:.2f} < {NOISE_THRESHOLD}) — "
+            "aucun grain capteur physique"
         )
 
-    # Signal 2 — Pics de fréquence GAN (grille de diffusion)
-    # Seuil 500 — uniquement les vraies grilles IA
+    # Signal 2 — Grille FFT GAN
     if freq_score > FREQ_THRESHOLD:
         ai_confidence += 30
         signals_triggered += 1
         reasons.append(
-            f"⚠️ Grille IA détectée en FFT (score={freq_score:.0f} > {FREQ_THRESHOLD}) — "
-            "Pattern de génération diffusion/GAN"
+            f"⚠️ Grille IA en FFT "
+            f"(score={freq_score:.0f} > {FREQ_THRESHOLD}) — "
+            "pattern de génération diffusion/GAN"
         )
 
-    # Signal 3 — ELA trop parfaite ET variance nulle
-    # Seuil 0.25 + variance < 0.5 = image purement synthétique
+    # Signal 3 — ELA trop parfaite + variance nulle
     if ela_s < ELA_THRESHOLD and ela_var < 0.5:
         ai_confidence += 25
         signals_triggered += 1
         reasons.append(
-            f"⚠️ Compression parfaite ELA={ela_s:.3f} σ={ela_var:.3f} — "
-            "Image non issue d'un capteur optique réel"
+            f"⚠️ Compression parfaite "
+            f"ELA={ela_s:.3f} σ={ela_var:.3f} — "
+            "image non issue d'un capteur optique réel"
         )
 
-    # Signal 4 — Gradient trop uniforme (deepfake facial)
+    # Signal 4 — Gradients trop lisses (deepfake facial)
     if gradient_ratio < 1.2:
         ai_confidence += 20
         signals_triggered += 1
         reasons.append(
-            f"⚠️ Gradients trop lisses (ratio={gradient_ratio:.2f} < 1.2) — "
-            "Absence de texture naturelle du capteur"
+            f"⚠️ Gradients trop uniformes "
+            f"(ratio={gradient_ratio:.2f} < 1.2) — "
+            "absence de texture naturelle"
+        )
+
+    # Signal 5 — Retouche locale (composite / fond remplacé) [NOUVEAU v2.5]
+    # Critère : > 20 % zones silencieuses ET forte hétérogénéité entre blocs
+    if silent_ratio > 0.20 and inter_block_var > 0.08:
+        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"
+        )
+
+    # Signal 6 — Skin smoothing [NOUVEAU v2.5]
+    # Texture peau std < 8.0 = lissage artificiel (Facetune, Remini, FaceApp…)
+    if skin_ratio >= 0.02 and 0 <= skin_std < 8.0:
+        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"
         )
 
-    # ─── RÈGLE DE SÉCURITÉ : minimum 2 signaux ──────────────
+    # Règle de sécurité : min 2 signaux pour crier deepfake
     if signals_triggered < MIN_SIGNALS:
-        # Un seul signal → suspicieux mais pas deepfake
         ai_confidence = min(ai_confidence, 28)
 
     final_score = min(ai_confidence, 100)
 
-    # ─── VERDICT ─────────────────────────────────────────────
     if final_score > 55:
-        label = "🚨 DEEPFAKE / GENERATED"
-        color = "red"
+        label = "🚨 DEEPFAKE / GÉNÉRÉ / RETOUCHÉ"
     elif final_score > 28:
         label = "⚖️ SUSPICIEUX / MODIFIÉ"
-        color = "orange"
     else:
         label = "✅ AUTHENTIQUE (CAMERA)"
-        color = "green"
 
     return (
         final_score, label, reasons,
         fft_map, ela_map, noise_map,
-        noise_density, freq_score, ela_s, signals_triggered
+        retouche_vis, skin_vis,
+        noise_density, freq_score, ela_s,
+        signals_triggered,
+        silent_ratio, inter_block_var,
+        skin_std, skin_ratio
     )
 
 
-# ═══════════════════════════════════════════════════
-# 🎨 GRADIO INTERFACE
-# ═══════════════════════════════════════════════════
+# ─────────────────────────────────────────────────────────────
+# INTERFACE GRADIO
+# ─────────────────────────────────────────────────────────────
 
 def process(input_img):
     if input_img is None:
@@ -206,46 +292,78 @@ def process(input_img):
 
     (score, label, reasons,
      fft, ela, noise,
-     noise_val, freq_val, ela_val, n_signals) = detect_deepfake(input_img)
+     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 ──────────────────────
+    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, 1].imshow(fft)
+    axes[0, 1].set_title("FFT — Grilles IA (Signal 2)", fontsize=11)
+
+    axes[0, 2].imshow(ela)
+    axes[0, 2].set_title("ELA — Compression (Signal 3)", fontsize=11)
+
+    axes[1, 0].imshow(noise, cmap='gray')
+    axes[1, 0].set_title("Bruit Capteur Corrigé (Signal 1)", fontsize=11)
+
+    axes[1, 1].imshow(retouche_vis)
+    axes[1, 1].set_title("Zones Sans Bruit — Retouche (Signal 5)", fontsize=11)
+
+    axes[1, 2].imshow(skin_vis)
+    axes[1, 2].set_title("Zones Peau — Skin Smoothing (Signal 6)", fontsize=11)
 
-    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
-    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("Bruit Capteur Corrigé")
     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'))
     plt.tight_layout()
 
+    # ── Rapport texte ─────────────────────────────────────────
     report  = f"RÉSULTAT : {label}\n"
-    report += f"Probabilité IA : {score}%  |  Signaux déclenchés : {n_signals}/{MIN_SIGNALS} minimum\n"
+    report += f"Probabilité manipulation : {score}%  |  Signaux : {n_signals}/{MIN_SIGNALS} minimum\n"
     report += f"\nMesures brutes :\n"
-    report += f"  • Bruit capteur corrigé : {noise_val:.3f} (seuil < {NOISE_THRESHOLD})\n"
-    report += f"  • Pic FFT : {freq_val:.0f} (seuil > {FREQ_THRESHOLD})\n"
-    report += f"  • ELA moyenne : {ela_val:.4f} (seuil < {ELA_THRESHOLD})\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"
+    else:
+        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 génération synthétique détectée."
-    report += "\n\n── ImageShield PRO v2.4 · ACoNum / Trusted Sound 2026 ──"
+    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 ──"
 
     return fig, report
 
 
+# ─────────────────────────────────────────────────────────────
+# LANCEMENT
+# ─────────────────────────────────────────────────────────────
+
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown(
-        "# 🛡️ ImageShield PRO v2.4\n"
-        "### Analyse Forensic : Authentique vs Deepfake\n"
-        "_Fix v2.4 : seuils recalibrés — photos studio, éclairage fort et JPEG haute qualité correctement classifiés_"
+        "# 🛡️ 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)_"
     )
     with gr.Row():
         with gr.Column():
             in_img  = gr.Image(label="Charger une image (JPG/PNG)", type="numpy")
-            run_btn = gr.Button("LANCER L'ANALYSE", variant="primary")
+            run_btn = gr.Button("🔍 LANCER L'ANALYSE", variant="primary")
         with gr.Column():
             out_plot = gr.Plot()
-            out_text = gr.Textbox(label="Rapport d'Expertise", lines=12)
+            out_text = gr.Textbox(label="Rapport d'Expertise", lines=18)
 
     run_btn.click(process, inputs=in_img, outputs=[out_plot, out_text])
 
 demo.launch()
-        
-