Update app.py

app.py

@@ -34,7 +34,6 @@ def restore_roi(roi):
 # ═══════════════════════════════════════════════════════════
 # ÉTAPE 2 : MOTEURS V4 (hérités)
 # ═══════════════════════════════════════════════════════════
-
 def test_localised_boundaries(roi):
     gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
     edges = cv2.Canny(gray, 100, 200)
@@ -66,16 +65,9 @@ def test_fft_frequency(roi):
 # ═══════════════════════════════════════════════════════════
 # É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)
@@ -86,85 +78,57 @@ def test_optical_flow(frames):
         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
+            scores.append(0.60)
         else:
             ratio = mag_std / mag_mean
             if 0.30 < ratio < 2.50:
-                scores.append(0.88)   # Mouvement naturel ✅
+                scores.append(0.88)   # Mouvement naturel
             elif ratio < 0.15:
-                scores.append(0.18)   # Trop lisse → IA 🚨
+                scores.append(0.18)   # Trop lisse → IA
             elif ratio > 4.0:
-                scores.append(0.22)   # Saccades → injection 🚨
+                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
-
+        return 0.38
     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.90
         return 0.52
-
-    return 0.58  # 1 ou 3+ yeux → ambigu
-
+    return 0.58
 
 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 ✅
+        return 0.88
     elif delta_E < 40:
-        return 0.55   # Légèrement suspect
+        return 0.55
     else:
-        return 0.22   # Incohérence forte → IA 🚨
-
+        return 0.22
 
 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)]
@@ -172,22 +136,19 @@ def test_texture_lbp(roi):
     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 ✅
+        return 0.88
     elif variance > 0.0001:
         return 0.55
     else:
-        return 0.22   # Texture trop uniforme → synthétique 🚨
+        return 0.22
 
 # ═══════════════════════════════════════════════════════════
 # ÉTAPE 4 : VERDICT CALIBRÉ V5
 # ═══════════════════════════════════════════════════════════
-
 def get_verdict(score_pct):
     if score_pct >= 72:
         return "✅ AUTHENTIQUE", "Cohérence temporelle, colorimétrique et texturale conforme."
@@ -199,14 +160,17 @@ def get_verdict(score_pct):
 # ═══════════════════════════════════════════════════════════
 # ÉTAPE 5 : PIPELINE PRINCIPAL
 # ═══════════════════════════════════════════════════════════
-
 def analyze_video(video_path):
     if video_path is None:
-        return "⚠️ Pas de vidéo fournie.", "{}", ""
-
+        return "⚠️ Pas de vidéo fournie.", "{}"
+        
     cap = cv2.VideoCapture(video_path)
     frames = []
     total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    if total <= 0:
+        return "❌ Impossible de lire ou fichier vidéo invalide.", "{}"
+        
     step  = max(1, total // 16)
     for i in range(16):
         cap.set(cv2.CAP_PROP_POS_FRAMES, i * step)
@@ -214,43 +178,38 @@ def analyze_video(video_path):
         if ret:
             frames.append(frame)
     cap.release()
-
+    
     if not frames:
-        return "❌ Impossible de lire la vidéo.", "{}", ""
-
+        return "❌ Impossible de lire les frames de 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 (x, y, w, h) in faces:
             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
+                s1 * 0.10 +   
+                s2 * 0.18 +   
+                s3 * 0.12 +   
+                flow_score * 0.25 +  
+                s5 * 0.10 +   
+                s6 * 0.15 +   
+                s7 * 0.10     
             )
             per_face_scores.append(final)
             engine_log.append({
@@ -264,17 +223,15 @@ def analyze_video(video_path):
                 "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 = "─" * 52
     rapport = (
         f"🛡️ VideoShield v5.0 — Rapport d'Authenticité\n{sep}\n"
@@ -289,38 +246,33 @@ def analyze_video(video_path):
         f"Standard  : IASA TC-04 | ACoNum Tunisia 2026\n"
         f"{sep}"
     )
-
+    
     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é
+        "engines_detail": engine_log[:5] if engine_log else "Aucun log visage disponible",
         "timestamp": str(datetime.datetime.now())
     }
-
-    return rapport, json.dumps(res_json, indent=2), ""
-
+    
+    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"
@@ -334,19 +286,16 @@ def generate_iscc(video_path):
     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():
@@ -355,13 +304,13 @@ with gr.Blocks(title="VideoShield v5.0", theme=gr.themes.Soft()) as demo:
             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)]
+            outputs=[rapport_out, json_out]
         )
-
+        
     with gr.Tab("🔏 ISCC Fingerprint"):
         gr.Markdown(
             "Génère l'**empreinte de contenu ISCC** du fichier. "
@@ -374,7 +323,6 @@ with gr.Blocks(title="VideoShield v5.0", theme=gr.themes.Soft()) as demo:
                 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__":