Create app.py

app.py

@@ -0,0 +1,384 @@
+import gradio as gr
+import cv2
+import numpy as np
+import hashlib
+import datetime
+import json
+import os
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 1 — EXTRACTION DES FRAMES
+# ═══════════════════════════════════════════════════════════
+
+def extract_frames(video_path, max_seconds=20, n_frames=16):
+    """
+    Extrait n_frames images équidistantes dans les max_seconds premières secondes.
+    Retourne : liste de frames (numpy BGR), métadonnées dict
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError("Impossible d'ouvrir la vidéo.")
+
+    fps       = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    total_fr  = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    width     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height    = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    duration  = total_fr / fps
+
+    analyse_end = min(duration, max_seconds)
+    end_frame   = int(analyse_end * fps)
+    indices     = np.linspace(0, max(end_frame - 1, 0), n_frames, dtype=int)
+
+    frames = []
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
+        ret, frame = cap.read()
+        if ret:
+            frames.append(frame)
+    cap.release()
+
+    meta = {
+        "fps": round(fps, 2),
+        "resolution": f"{width}x{height}",
+        "duree_totale_s": round(duration, 2),
+        "duree_analysee_s": round(analyse_end, 2),
+        "frames_extraites": len(frames),
+    }
+    return frames, meta
+
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 2 — DÉTECTION DE VISAGE
+# ═══════════════════════════════════════════════════════════
+
+face_cascade = cv2.CascadeClassifier(
+    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+)
+
+def detect_faces(frame):
+    """
+    Retourne la liste des ROI (Region Of Interest) des visages détectés.
+    Chaque ROI = frame croppée sur le visage avec marge de 20%.
+    """
+    gray  = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    faces = face_cascade.detectMultiScale(
+        gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60)
+    )
+    rois = []
+    h_img, w_img = frame.shape[:2]
+    for (x, y, w, h) in faces:
+        margin = int(max(w, h) * 0.20)
+        x1 = max(0, x - margin)
+        y1 = max(0, y - margin)
+        x2 = min(w_img, x + w + margin)
+        y2 = min(h_img, y + h + margin)
+        rois.append(frame[y1:y2, x1:x2])
+    return rois
+
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 3A — TEST BRUIT (Noise Level)
+# ═══════════════════════════════════════════════════════════
+
+def test_noise(roi):
+    """
+    Analyse le niveau de bruit dans la ROI.
+    Une face deepfake a souvent un bruit anormalement bas (lissage GAN)
+    ou anormalement élevé sur certains canaux.
+
+    Retourne un score d'authenticité [0-1].
+    1 = très probablement authentique
+    0 = suspect (trop lisse ou trop bruité)
+    """
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY).astype(np.float32)
+
+    # Laplacien : mesure la variance du bruit
+    laplacian = cv2.Laplacian(gray, cv2.CV_32F)
+    variance  = laplacian.var()
+
+    # Une variance très basse (<20) = GAN over-smoothing suspect
+    # Une variance normale = 50–500 pour une caméra réelle
+    if variance < 15:
+        return 0.25   # très lisse → suspect
+    elif variance < 40:
+        return 0.55   # légèrement lisse → incertain
+    elif variance < 600:
+        return 0.90   # plage normale → authentique
+    else:
+        return 0.60   # très bruitée → peut être compression
+
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 3B — TEST FRÉQUENCES (FFT Artifacts)
+# ═══════════════════════════════════════════════════════════
+
+def test_fft(roi):
+    """
+    Analyse le spectre fréquentiel via FFT.
+    Les GANs laissent des artefacts caractéristiques dans les hautes fréquences
+    (pics réguliers dans le spectre = pattern artificiel).
+
+    Retourne un score d'authenticité [0-1].
+    """
+    gray   = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY).astype(np.float32)
+    f      = np.fft.fft2(gray)
+    fshift = np.fft.fftshift(f)
+    mag    = 20 * np.log(np.abs(fshift) + 1)
+
+    # Ratio énergie centre / périphérie
+    h, w       = mag.shape
+    cy, cx     = h // 2, w // 2
+    r          = min(h, w) // 6
+    center_mask = np.zeros_like(mag, dtype=bool)
+    for i in range(h):
+        for j in range(w):
+            if (i - cy)**2 + (j - cx)**2 < r**2:
+                center_mask[i, j] = True
+
+    center_energy = mag[center_mask].mean()
+    outer_energy   = mag[~center_mask].mean()
+
+    if outer_energy == 0:
+        return 0.5
+
+    ratio = center_energy / outer_energy
+
+    # Vidéo réelle : ratio typiquement > 3.5
+    # GAN : distribue l'énergie différemment → ratio anormal
+    if ratio > 4.0:
+        return 0.92
+    elif ratio > 2.5:
+        return 0.70
+    elif ratio > 1.5:
+        return 0.45
+    else:
+        return 0.25
+
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 3C — TEST CONTOURS (Blending Mask / Bord du visage)
+# ═══════════════════════════════════════════════════════════
+
+def test_contours(roi):
+    """
+    Analyse la régularité des contours autour du visage.
+    Un deepfake par face-swap laisse souvent une frontière artificielle
+    autour du visage (blending imparfait).
+
+    Retourne un score d'authenticité [0-1].
+    """
+    gray   = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges  = cv2.Canny(blurred, 50, 150)
+
+    h, w = edges.shape
+    if h < 10 or w < 10:
+        return 0.5
+
+    # Zone de bordure = 15% du bord de la ROI
+    border = int(min(h, w) * 0.15)
+    border_region = np.zeros_like(edges)
+    border_region[:border, :]  = edges[:border, :]
+    border_region[-border:, :] = edges[-border:, :]
+    border_region[:, :border]  = edges[:, :border]
+    border_region[:, -border:] = edges[:, -border:]
+
+    center_region = edges[border:-border, border:-border]
+
+    border_density  = border_region.mean()
+    center_density  = center_region.mean() if center_region.size > 0 else 1
+
+    # Un deepfake a souvent plus de contours en bordure (blending visible)
+    if center_density == 0:
+        return 0.5
+
+    ratio = border_density / (center_density + 1e-5)
+
+    if ratio > 2.5:
+        return 0.30   # bords suspectes
+    elif ratio > 1.5:
+        return 0.60
+    else:
+        return 0.88   # bords naturels
+
+
+# ═══════════════════════════════════════════════════════════
+#  ÉTAPE 4 — SCORE FINAL + VERDICT
+# ═══════════════════════════════════════════════════════════
+
+WEIGHTS = {
+    "bruit":     0.35,
+    "fft":       0.40,
+    "contours":  0.25,
+}
+
+def score_face(roi):
+    """Calcule le score d'authenticité pondéré pour une face."""
+    s_bruit    = test_noise(roi)
+    s_fft      = test_fft(roi)
+    s_contours = test_contours(roi)
+
+    score = (
+        s_bruit    * WEIGHTS["bruit"] +
+        s_fft      * WEIGHTS["fft"] +
+        s_contours * WEIGHTS["contours"]
+    )
+    return round(score, 4), {
+        "bruit":    round(s_bruit * 100, 1),
+        "fft":      round(s_fft * 100, 1),
+        "contours": round(s_contours * 100, 1),
+    }
+
+def get_verdict(score_pct):
+    if score_pct >= 80:
+        return "✅ AUTHENTIQUE", "Aucun artefact deepfake détecté."
+    elif score_pct >= 55:
+        return "⚠️ SUSPECT", "Des incohérences ont été détectées. Vérification manuelle recommandée."
+    else:
+        return "🚨 DEEPFAKE DÉTECTÉ", "Score d'authenticité très bas. Contenu probablement falsifié."
+
+
+# ═══════════════════════════════════════════════════════════
+#  FONCTION PRINCIPALE GRADIO
+# ═══════════════════════════════════════════════════════════
+
+def analyze_deepfake(video_path):
+    if video_path is None:
+        return "⚠️ Veuillez charger un fichier vidéo.", "{}"
+
+    # ── Étape 1 : Extraction ─────────────────
+    try:
+        frames, meta = extract_frames(video_path, max_seconds=20, n_frames=16)
+    except Exception as e:
+        return f"❌ Erreur extraction : {e}", "{}"
+
+    if not frames:
+        return "❌ Aucune frame extraite. Format non supporté.", "{}"
+
+    # ── Étape 2 : Détection visages ──────────
+    all_face_scores = []
+    detail_scores   = []
+    frames_with_face = 0
+
+    for i, frame in enumerate(frames):
+        rois = detect_faces(frame)
+        if not rois:
+            continue
+        frames_with_face += 1
+        for roi in rois:
+            if roi.size == 0:
+                continue
+            sc, details = score_face(roi)
+            all_face_scores.append(sc)
+            detail_scores.append(details)
+
+    # ── Étape 3 : Score global ───────────────
+    if not all_face_scores:
+        rapport = (
+            f"🛡️ VideoShield v3.0 — Rapport d'Authenticité\n"
+            f"{'─'*48}\n"
+            f"⚠️  Aucun visage détecté dans la vidéo.\n"
+            f"La détection deepfake nécessite un visage visible.\n"
+            f"{'─'*48}\n"
+            f"Durée analysée  : {meta['duree_analysee_s']}s / {meta['duree_totale_s']}s\n"
+            f"Frames analysées: {meta['frames_extraites']}\n"
+            f"Résolution      : {meta['resolution']}\n"
+        )
+        json_data = {"statut": "Aucun visage détecté", **meta}
+        return rapport, json.dumps(json_data, indent=2, ensure_ascii=False)
+
+    global_score     = np.mean(all_face_scores)
+    global_score_pct = round(global_score * 100, 1)
+    verdict, explication = get_verdict(global_score_pct)
+
+    # Moyennes des détails
+    avg_details = {
+        "bruit_authenticite_%":    round(np.mean([d["bruit"]    for d in detail_scores]), 1),
+        "fft_authenticite_%":      round(np.mean([d["fft"]      for d in detail_scores]), 1),
+        "contours_authenticite_%": round(np.mean([d["contours"] for d in detail_scores]), 1),
+    }
+
+    # ── Rapport texte ────────────────────────
+    rapport = (
+        f"🛡️  VideoShield v3.0 — Rapport d'Authenticité\n"
+        f"{'─'*48}\n"
+        f"VERDICT  : {verdict}\n"
+        f"SCORE    : {global_score_pct}%\n"
+        f"ANALYSE  : {explication}\n"
+        f"{'─'*48}\n"
+        f"DÉTAIL DES TESTS :\n"
+        f"  • Analyse bruit (Laplacien)  : {avg_details['bruit_authenticite_%']}%\n"
+        f"  • Analyse fréq. (FFT)        : {avg_details['fft_authenticite_%']}%\n"
+        f"  • Analyse contours (Canny)   : {avg_details['contours_authenticite_%']}%\n"
+        f"{'─'*48}\n"
+        f"Visages analysés : {len(all_face_scores)} détection(s) / {frames_with_face} frame(s)\n"
+        f"Durée analysée   : {meta['duree_analysee_s']}s / {meta['duree_totale_s']}s\n"
+        f"Résolution       : {meta['resolution']} @ {meta['fps']} fps\n"
+        f"{'─'*48}\n"
+        f"Standard  : IASA TC-04 | Trusted Sound 2026\n"
+        f"Développé par S2T — Smart Tunisian Technoparks"
+    )
+
+    # ── JSON ─────────────────────────────────
+    json_data = {
+        "timestamp": datetime.datetime.now().isoformat(),
+        "verdict": verdict,
+        "score_global_%": global_score_pct,
+        "tests_detail": avg_details,
+        "visages_detectes": len(all_face_scores),
+        "metadata_video": meta,
+        "standard": "IASA TC-04 / C2PA v1.3"
+    }
+
+    return rapport, json.dumps(json_data, indent=2, ensure_ascii=False)
+
+
+# ═══════════════════════════════════════════════════════════
+#  INTERFACE GRADIO
+# ═══════════════════════════════════════════════════════════
+
+with gr.Blocks(theme=gr.themes.Soft(), title="VideoShield v3.0") as demo:
+
+    gr.Markdown("""
+    # 🛡️ VideoShield v3.0 — Deepfake Detection
+    **Analyse par Bruit · FFT · Contours — Aucun GPU requis**
+    > Projet *Trusted Sound 2026* — Creative Europe CREA-CULT-2026-COOP-1 | S2T Tunisia
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            video_input = gr.Video(label="📹 Charger la vidéo (MP4, MKV, AVI, MOV)")
+            submit_btn  = gr.Button("🔍 Analyser", variant="primary", size="lg")
+            gr.Markdown("""
+            **Méthode :**
+            - 🎯 Extraction des 20 premières secondes
+            - 👤 Détection des visages (Haar Cascade)
+            - 🔬 3 tests : Bruit · FFT · Contours
+            - 📊 Score global pondéré
+            """)
+
+        with gr.Column(scale=1):
+            rapport_output = gr.Textbox(
+                label="📋 Rapport d'Authenticité",
+                lines=18,
+                show_copy_button=True
+            )
+            json_output = gr.Code(
+                label="📦 Données JSON",
+                language="json"
+            )
+
+    gr.Markdown("""
+    ---
+    🔗 [Antigravity Shield — Audio Deepfake](https://huggingface.co/spaces/NOBODY204/Music) | 
+    📐 Standards : IASA TC-04 · C2PA v1.3
+    """)
+
+    submit_btn.click(
+        fn=analyze_deepfake,
+        inputs=[video_input],
+        outputs=[rapport_output, json_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()