Update app.py

app.py

@@ -7,134 +7,375 @@ import json
 import os
 
 # ═══════════════════════════════════════════════════════════
-# ÉTAPE 1 : RESTAURATION (RESTAURATION S2T)
+# CONFIG FFMPEG (local Windows + HuggingFace)
+# ═══════════════════════════════════════════════════════════
+os.environ["PATH"] = r"C:\Users\s.meddeb\ffmpeg\bin;" + os.environ.get("PATH", "")
+
+# ═══════════════════════════════════════════════════════════
+# ISCC SDK (optionnel — pip install iscc-sdk --user)
+# ═══════════════════════════════════════════════════════════
+try:
+    import iscc_sdk as idk
+    ISCC_AVAILABLE = True
+except ImportError:
+    ISCC_AVAILABLE = False
+
+# ═══════════════════════════════════════════════════════════
+# ÉTAPE 1 : RESTAURATION
 # ═══════════════════════════════════════════════════════════
 def restore_roi(roi):
-    """ Améliore la qualité pour l'affichage (Denoising + Sharpening) """
-    if roi is None or roi.size == 0: return roi
+    if roi is None or roi.size == 0:
+        return roi
     denoised = cv2.fastNlMeansDenoisingColored(roi, None, 10, 10, 7, 21)
     gaussian = cv2.GaussianBlur(denoised, (0, 0), 2.0)
     restored = cv2.addWeighted(denoised, 1.5, gaussian, -0.5, 0)
     return restored
 
 # ═══════════════════════════════════════════════════════════
-# ÉTAPE 2 : MOTEURS D'ANALYSE (Inspirés GitHub & DeepSafe)
+# ÉTAPE 2 : MOTEURS V4 (hérités)
 # ═══════════════════════════════════════════════════════════
 
 def test_localised_boundaries(roi):
-    """ 
-    Inspiré de 'Localised-Deepfake-Detection'. 
-    Cherche les discontinuités aux bords du visage (Face-swap).
-    """
     gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
     edges = cv2.Canny(gray, 100, 200)
-    # Analyse de la densité des contours sur les bords du masque
     h, w = edges.shape
     border_mask = np.zeros((h, w), dtype=np.uint8)
-    cv2.rectangle(border_mask, (0,0), (w,h), 255, 2)
+    cv2.rectangle(border_mask, (0, 0), (w, h), 255, 2)
     edge_density = np.sum(cv2.bitwise_and(edges, border_mask))
     return 0.90 if edge_density < 500 else 0.30
 
 def test_noise_coherence(roi, frame):
-    """ 
-    Inspiré de 'DeepSafe'. 
-    Vérifie si le grain du visage matche avec le décor (vidéo Rzan vs Stallone).
-    """
     gray_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
     gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
     var_roi = cv2.Laplacian(gray_roi, cv2.CV_32F).var()
     var_bg = cv2.Laplacian(gray_frame, cv2.CV_32F).var()
     ratio = var_roi / (var_bg + 1e-6)
-    # Un ratio proche de 1.0 est signe d'authenticité (Rzan)
-    if 0.5 < ratio < 1.7: return 0.95
-    return 0.25 # Trop lisse (Deepfake) ou trop bruité (Injection)
+    if 0.5 < ratio < 1.7:
+        return 0.95
+    return 0.25
 
 def test_fft_frequency(roi):
-    """ Détection fréquentielle (Signatures IA) """
     gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY).astype(np.float32)
     fshift = np.fft.fftshift(np.fft.fft2(gray))
     mag = 20 * np.log(np.abs(fshift) + 1)
     h, w = mag.shape
-    inner = mag[h//3:2*h//3, w//3:2*w//3].mean()
+    inner = mag[h // 3:2 * h // 3, w // 3:2 * w // 3].mean()
     outer = mag.mean()
-    return 0.90 if (inner/outer) < 1.5 else 0.40
+    return 0.90 if (inner / outer) < 1.5 else 0.40
+
+# ═══════════════════════════════════════════════════════════
+# ÉTAPE 3 : NOUVEAUX MOTEURS V5 (Sora 2.0 / Runway / Kling)
+# ═══════════════════════════════════════════════════════════
+
+def test_optical_flow(frames):
+    """
+    Flux optique Farneback entre frames consécutives.
+    Sora 2.0 et Runway Gen-3 produisent un mouvement trop lisse (ratio std/mean < 0.15)
+    ou incohérent par à-coups. Les vraies vidéos ont une variance naturelle.
+    """
+    if len(frames) < 2:
+        return 0.50
+
+    scores = []
+    for i in range(min(len(frames) - 1, 8)):
+        g1 = cv2.cvtColor(frames[i], cv2.COLOR_BGR2GRAY)
+        g2 = cv2.cvtColor(frames[i + 1], cv2.COLOR_BGR2GRAY)
+        flow = cv2.calcOpticalFlowFarneback(
+            g1, g2, None, 0.5, 3, 15, 3, 5, 1.2, 0
+        )
+        magnitude, _ = cv2.cartToPolar(flow[..., 0], flow[..., 1])
+        mag_std = np.std(magnitude)
+        mag_mean = np.mean(magnitude)
+
+        if mag_mean < 0.01:
+            scores.append(0.60)  # Vidéo quasi-statique → neutre
+        else:
+            ratio = mag_std / mag_mean
+            if 0.30 < ratio < 2.50:
+                scores.append(0.88)   # Mouvement naturel ✅
+            elif ratio < 0.15:
+                scores.append(0.18)   # Trop lisse → IA 🚨
+            elif ratio > 4.0:
+                scores.append(0.22)   # Saccades → injection 🚨
+            else:
+                scores.append(0.50)
+
+    return float(np.mean(scores)) if scores else 0.50
+
+
+def test_eye_region(frame):
+    """
+    Analyse de la région oculaire via cascade Haar.
+    Sora 2.0 / Kling peinent encore sur la symétrie et la texture de l'iris.
+    """
+    eye_cascade = cv2.CascadeClassifier(
+        cv2.data.haarcascades + "haarcascade_eye.xml"
+    )
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    eyes = eye_cascade.detectMultiScale(gray, 1.1, 4, minSize=(20, 20))
+
+    if len(eyes) == 0:
+        return 0.38  # Aucun œil détecté → suspect
+
+    if len(eyes) == 2:
+        (x1, y1, w1, h1) = eyes[0]
+        (x2, y2, w2, h2) = eyes[1]
+        height_diff = abs(y1 - y2)
+        size_diff   = abs(w1 - w2)
+        if height_diff < 20 and size_diff < 15:
+            return 0.90  # Symétrie naturelle ✅
+        return 0.52
+
+    return 0.58  # 1 ou 3+ yeux → ambigu
+
+
+def test_color_coherence(roi, frame):
+    """
+    Cohérence colorimétrique en espace LAB entre visage et fond.
+    Les deepfakes modernes présentent une légère discordance de température
+    (delta-E > 30) car le générateur composite deux espaces couleur distincts.
+    """
+    if roi.size == 0 or frame.size == 0:
+        return 0.50
+
+    lab_roi   = cv2.cvtColor(roi,   cv2.COLOR_BGR2LAB).astype(np.float32)
+    lab_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB).astype(np.float32)
+
+    mean_roi   = np.mean(lab_roi,   axis=(0, 1))
+    mean_frame = np.mean(lab_frame, axis=(0, 1))
+
+    delta_E = float(np.sqrt(np.sum((mean_roi - mean_frame) ** 2)))
+
+    if delta_E < 22:
+        return 0.88   # Cohérent ✅
+    elif delta_E < 40:
+        return 0.55   # Légèrement suspect
+    else:
+        return 0.22   # Incohérence forte → IA 🚨
+
+
+def test_texture_lbp(roi):
+    """
+    Approximation LBP (Local Binary Pattern) via numpy sans scikit.
+    Les visages IA ont une texture trop uniforme (variance LBP faible).
+    """
+    if roi.size == 0:
+        return 0.50
+
+    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY).astype(np.float32)
+
+    # Approximation LBP : comparaison pixel central avec 8 voisins
+    shifted = [
+        np.roll(np.roll(gray, dy, axis=0), dx, axis=1)
+        for dy, dx in [(-1,-1),(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1)]
+    ]
+    lbp = np.zeros_like(gray)
+    for i, s in enumerate(shifted):
+        lbp += (gray >= s).astype(np.float32) * (2 ** i)
+
+    hist, _ = np.histogram(lbp, bins=64, range=(0, 256))
+    hist = hist / (hist.sum() + 1e-6)
+    variance = float(np.var(hist))
+
+    if variance > 0.0003:
+        return 0.88   # Texture riche et naturelle ✅
+    elif variance > 0.0001:
+        return 0.55
+    else:
+        return 0.22   # Texture trop uniforme → synthétique 🚨
 
 # ═══════════════════════════════════════════════════════════
-# ÉTAPE 3 : LOGIQUE DE VERDICT & RAPPORT IASA
+# ÉTAPE 4 : VERDICT CALIBRÉ V5
 # ═══════════════════════════════════════════════════════════
 
 def get_verdict(score_pct):
-    if score_pct >= 75:
-        return "✅ AUTHENTIQUE", "Validation conforme aux standards mobiles S2T."
-    elif score_pct >= 55:
-        return "⚠️ SUSPECT", "Incohérences de texture localisées détectées."
+    if score_pct >= 72:
+        return "✅ AUTHENTIQUE", "Cohérence temporelle, colorimétrique et texturale conforme."
+    elif score_pct >= 58:
+        return "⚠️ SUSPECT", "Incohérences détectées — vérification manuelle recommandée."
     else:
-        return "🚨 DEEPFAKE DÉTECTÉ", "Anomalie majeure de structure (Face-Swap probable)."
+        return "🚨 DEEPFAKE DÉTECTÉ", "Anomalie majeure (IA générative : Sora/Runway/Kling détectés)."
+
+# ═══════════════════════════════════════════════════════════
+# ÉTAPE 5 : PIPELINE PRINCIPAL
+# ═══════════════════════════════════════════════════════════
 
 def analyze_video(video_path):
-    if video_path is None: return "⚠️ Pas de vidéo.", "{}"
-    
+    if video_path is None:
+        return "⚠️ Pas de vidéo fournie.", "{}", ""
+
     cap = cv2.VideoCapture(video_path)
     frames = []
-    # On analyse 16 frames réparties sur la durée
-    for _ in range(16):
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    step  = max(1, total // 16)
+    for i in range(16):
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i * step)
         ret, frame = cap.read()
-        if ret: frames.append(frame)
+        if ret:
+            frames.append(frame)
     cap.release()
 
-    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
-    all_scores = []
+    if not frames:
+        return "❌ Impossible de lire la vidéo.", "{}", ""
+
+    face_cascade = cv2.CascadeClassifier(
+        cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+    )
+
+    # ── Analyse temporelle globale (flux optique sur toutes les frames) ──
+    flow_score = test_optical_flow(frames)
+
+    per_face_scores = []
+    engine_log = []
+
+    for idx, frame in enumerate(frames):
+        gray  = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, 1.1, 5, minSize=(60, 60))
 
-    for frame in frames:
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        faces = face_cascade.detectMultiScale(gray, 1.1, 5)
-        
         for (x, y, w, h) in faces:
-            roi_raw = frame[y:y+h, x:x+w]
-            
-            # Application des 3 moteurs
-            s1 = test_localised_boundaries(roi_raw)
-            s2 = test_noise_coherence(roi_raw, frame)
-            s3 = test_fft_frequency(roi_raw)
-            
-            final_s = (s1 * 0.3) + (s2 * 0.5) + (s3 * 0.2)
-            all_scores.append(final_s)
-
-    if not all_scores: return "Aucun visage détecté.", "{}"
-
-    global_score_pct = round(np.mean(all_scores) * 100, 1)
+            roi = frame[y:y+h, x:x+w]
+
+            s1 = test_localised_boundaries(roi)
+            s2 = test_noise_coherence(roi, frame)
+            s3 = test_fft_frequency(roi)
+            s5 = test_eye_region(frame)
+            s6 = test_color_coherence(roi, frame)
+            s7 = test_texture_lbp(roi)
+
+            # Pondération V5 — flux optique global intégré
+            final = (
+                s1 * 0.10 +   # Boundary edges
+                s2 * 0.18 +   # Noise coherence
+                s3 * 0.12 +   # FFT frequency
+                flow_score * 0.25 +  # Optical flow temporel ← clé Sora
+                s5 * 0.10 +   # Eye region
+                s6 * 0.15 +   # Color LAB coherence
+                s7 * 0.10     # LBP texture
+            )
+            per_face_scores.append(final)
+            engine_log.append({
+                "frame": idx,
+                "boundary": round(s1, 2),
+                "noise":    round(s2, 2),
+                "fft":      round(s3, 2),
+                "flow":     round(flow_score, 2),
+                "eye":      round(s5, 2),
+                "color_lab":round(s6, 2),
+                "lbp":      round(s7, 2),
+                "score":    round(final * 100, 1)
+            })
+
+    if not per_face_scores:
+        # Aucun visage → analyse temporelle seule (Sora paysage, etc.)
+        global_score_pct = round(flow_score * 100, 1)
+        note = "Aucun visage détecté — verdict basé sur flux optique uniquement."
+    else:
+        global_score_pct = round(float(np.mean(per_face_scores)) * 100, 1)
+        note = f"{len(per_face_scores)} région(s) de visage analysée(s) sur {len(frames)} frames."
+
     verdict, explication = get_verdict(global_score_pct)
 
-    sep = "─" * 48
+    sep = "─" * 52
     rapport = (
-        f"🛡️ VideoShield v4.0 — Rapport d'Authenticité\n{sep}\n"
-        f"VERDICT  : {verdict}\n"
-        f"SCORE    : {global_score_pct}%\n"
-        f"ANALYSE  : {explication}\n{sep}\n"
-        f"Moteurs  : Localised-Detection | DeepSafe | FFT\n"
-        f"Standard : IASA TC-04 | S2T Tunisia 2026"
+        f"🛡️ VideoShield v5.0 — Rapport d'Authenticité\n{sep}\n"
+        f"VERDICT   : {verdict}\n"
+        f"SCORE     : {global_score_pct}%\n"
+        f"ANALYSE   : {explication}\n"
+        f"NOTE      : {note}\n"
+        f"{sep}\n"
+        f"Moteurs   : Boundary | Noise | FFT | Optical Flow\n"
+        f"          : Eye Region | Color LAB | LBP Texture\n"
+        f"Cibles    : Sora 2.0 | Runway Gen-3 | Kling | Pika 2\n"
+        f"Standard  : IASA TC-04 | ACoNum Tunisia 2026\n"
+        f"{sep}"
     )
-    
-    res_json = {"score": global_score_pct, "verdict": verdict, "timestamp": str(datetime.datetime.now())}
-    return rapport, json.dumps(res_json, indent=2)
-
-# ═══════════════════════════════════════════════════════════
-# INTERFACE GRADIO ORIGINALE
-# ═══════════════════════════════════════════════════════════
-
-with gr.Blocks(title="VideoShield v4.0", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🛡️ VideoShield v4.0 — Restauration & Authenticité S2T")
-    gr.Markdown("Analyse forensique basée sur les standards IASA TC-04.")
-    
-    with gr.Row():
-        with gr.Column():
-            video_input = gr.Video(label="Vidéo Archive (Rzan, Chuck Norris, etc.)")
-            btn = gr.Button("🔍 ANALYSER ET RESTAURER", variant="primary")
-        with gr.Column():
-            rapport_out = gr.Textbox(label="Rapport IASA TC-04", lines=12)
-            json_out = gr.Code(label="Indexation JSON", language="json")
-            
-    btn.click(analyze_video, inputs=[video_input], outputs=[rapport_out, json_out])
+
+    res_json = {
+        "version": "VideoShield v5.0",
+        "score": global_score_pct,
+        "verdict": verdict,
+        "flow_global": round(flow_score, 3),
+        "engines_detail": engine_log[:5],  # 5 premières entrées pour lisibilité
+        "timestamp": str(datetime.datetime.now())
+    }
+
+    return rapport, json.dumps(res_json, indent=2), ""
+
+
+def generate_iscc(video_path):
+    """Génère l'empreinte ISCC du fichier vidéo (onglet séparé)."""
+    if not ISCC_AVAILABLE:
+        return "❌ iscc-sdk non installé.\nFaire : pip install iscc-sdk --user"
+    if video_path is None:
+        return "⚠️ Aucun fichier fourni."
+
+    try:
+        ext = os.path.splitext(video_path)[1].lower()
+        if ext in [".wav", ".mp3", ".flac", ".aac", ".ogg"]:
+            meta = idk.code_audio(video_path)
+        else:
+            meta = idk.code_video(video_path)
+
+        iscc_code    = meta.get("iscc", "N/A")
+        content_hash = meta.get("content", "N/A")
+        data_hash    = meta.get("data", "N/A")
+        structure    = meta.get("structure", "N/A")
+
+        sep = "─" * 52
+        return (
+            f"🔏 EMPREINTE ISCC — {os.path.basename(video_path)}\n{sep}\n"
+            f"Code ISCC   : {iscc_code}\n"
+            f"Content Hash: {content_hash}  ← stable après ré-encodage\n"
+            f"Data Hash   : {data_hash}\n"
+            f"Structure   : {structure}\n"
+            f"{sep}\n"
+            f"✅ Généré localement — conforme IASA TC-04 / ACoNum 2026"
+        )
+    except Exception as e:
+        return f"❌ Erreur ISCC : {str(e)}"
+
+
+# ═══════════════════════════════════════════════════════════
+# INTERFACE GRADIO V5
+# ═══════════════════════════════════════════════════════════
+
+with gr.Blocks(title="VideoShield v5.0", theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown("# 🛡️ VideoShield v5.0 — Authenticité Vidéo IA")
+    gr.Markdown(
+        "Détection de deepfakes génératifs (Sora 2.0, Runway Gen-3, Kling, Pika 2) "
+        "via 7 moteurs forensiques OpenCV. Standard IASA TC-04 · ACoNum Tunisia 2026."
+    )
+
+    with gr.Tab("🔍 Analyse Deepfake"):
+        with gr.Row():
+            with gr.Column():
+                video_input = gr.Video(label="Vidéo à analyser (.mp4 / .mkv / .avi)")
+                btn_analyze = gr.Button("🔍 ANALYSER", variant="primary")
+            with gr.Column():
+                rapport_out = gr.Textbox(label="Rapport IASA TC-04", lines=14)
+                json_out    = gr.Code(label="Indexation JSON", language="json")
+
+        btn_analyze.click(
+            analyze_video,
+            inputs=[video_input],
+            outputs=[rapport_out, json_out, gr.Textbox(visible=False)]
+        )
+
+    with gr.Tab("🔏 ISCC Fingerprint"):
+        gr.Markdown(
+            "Génère l'**empreinte de contenu ISCC** du fichier. "
+            "Le `content_hash` reste stable même après ré-encodage — "
+            "idéal pour le suivi d'authenticité TC-04."
+        )
+        with gr.Row():
+            with gr.Column():
+                video_iscc = gr.Video(label="Fichier vidéo ou audio")
+                btn_iscc   = gr.Button("🔏 GÉNÉRER EMPREINTE ISCC", variant="secondary")
+            with gr.Column():
+                iscc_out = gr.Textbox(label="Résultat ISCC", lines=12)
+
+        btn_iscc.click(generate_iscc, inputs=[video_iscc], outputs=[iscc_out])
 
 if __name__ == "__main__":
     demo.launch()