commentaire et moins de fonctions inutiles

jericho/main.py

@@ -1,15 +1,5 @@
-"""
-face_analysis.py  –  compatible MediaPipe 0.10+ (nouvelle API Tasks)
-Audio preservé via FFmpeg en fin de traitement.
-======================================================================
-Usage :
-  python face_analysis.py --video chemin/video.mp4
-  python face_analysis.py --video chemin/video.mp4 --output_dir resultats/
-"""
-
 import argparse
 import csv
-import json
 import math
 import os
 import subprocess
@@ -19,17 +9,14 @@ import urllib.request
 import cv2
 import mediapipe as mp
 import numpy as np
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
 
 from mediapipe.tasks import python as mp_python
 from mediapipe.tasks.python import vision as mp_vision
 from mediapipe.tasks.python.vision import FaceLandmarkerOptions, FaceLandmarker
 
-# ──────────────────────────────────────────────
-# Modèle MediaPipe
-# ──────────────────────────────────────────────
+
+# MediaPipe
+
 MODEL_URL  = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
 MODEL_PATH = "face_landmarker.task"
 
@@ -39,53 +26,52 @@ def ensure_model():
         urllib.request.urlretrieve(MODEL_URL, MODEL_PATH)
         print("  Modele telecharge.")
 
-# ──────────────────────────────────────────────
-# Indices landmarks
-# ──────────────────────────────────────────────
-LEFT_EYE    = [362, 385, 387, 263, 373, 380]
+# Indices visage
+
+LEFT_EYE    = [362, 385, 387, 263, 373, 380] # point qui contoure l oeil
 RIGHT_EYE   = [33,  160, 158, 133, 153, 144]
 MOUTH_OUTER = [61,  291,   0,  17,  37, 267]
 MOUTH_L, MOUTH_R = 61, 291
 LEFT_PUP,  RIGHT_PUP  = 468, 473
 
-EAR_THRESHOLD = 0.20  # en dessous de ce seuil = œil considéré fermé
-
+EAR_THRESHOLD = 0.20  # en dessous de ce seuil  l'oeil considéré fermé
+#EAR = eye aspect ratio
 HEAD_POSE_IDX = [1, 152, 226, 446, 57, 287]
-MODEL_3D = np.array([
+MODEL_3D = np.array([# genere un model 3D d'une tete d'humain
     [ 0.0,    0.0,    0.0 ],
     [ 0.0,  -63.6,  -12.5],
     [-43.3,  32.7,  -26.0],
     [ 43.3,  32.7,  -26.0],
     [-28.9, -28.9,  -24.1],
     [ 28.9, -28.9,  -24.1],
-], dtype=np.float64)
+], dtype=np.float64)#float 64 oblige a etre tres orecis 
+
 
-# ──────────────────────────────────────────────
 # Calculs
-# ──────────────────────────────────────────────
 
-def _pts(lms, indices, w, h):
+
+def _pts(lms, indices, w, h): # convertit les coordonnées en pixel 
     return np.array([[lms[i].x * w, lms[i].y * h] for i in indices])
 
-def ear(lms, indices, w, h):
-    p = _pts(lms, indices, w, h)
-    A = np.linalg.norm(p[1]-p[5]); B = np.linalg.norm(p[2]-p[4])
+def ear(lms, indices, w, h): # ca calule le degres d'ouverture de l'oeil
+    p = _pts(lms, indices, w, h)# recupere les pixels de l oeil
+    A = np.linalg.norm(p[1]-p[5]); B = np.linalg.norm(p[2]-p[4]) # distance verticale des paupiere
     return (A+B) / (2*np.linalg.norm(p[0]-p[3])+1e-6)
 
-def mar(lms, indices, w, h):
+def mar(lms, indices, w, h):# calcul le degres d'ouverture de la bouche
     p = _pts(lms, indices, w, h)
     A = np.linalg.norm(p[1]-p[5]); B = np.linalg.norm(p[2]-p[4])
     return (A+B) / (2*np.linalg.norm(p[0]-p[3])+1e-6)
 
-def smile_index(lms, w, h):
-    ml = np.array([lms[MOUTH_L].x*w, lms[MOUTH_L].y*h])
+def smile_index(lms, w, h):# calcul a quel point la personne sourit
+    ml = np.array([lms[MOUTH_L].x*w, lms[MOUTH_L].y*h])# coordonne coin de bouche droit et gauche
     mr = np.array([lms[MOUTH_R].x*w, lms[MOUTH_R].y*h])
-    pl = np.array([lms[LEFT_PUP].x*w,  lms[LEFT_PUP].y*h])
+    pl = np.array([lms[LEFT_PUP].x*w,  lms[LEFT_PUP].y*h])#coordonne pupilles
     pr = np.array([lms[RIGHT_PUP].x*w, lms[RIGHT_PUP].y*h])
-    return np.linalg.norm(mr-ml) / (np.linalg.norm(pr-pl)+1e-6)
+    return np.linalg.norm(mr-ml) / (np.linalg.norm(pr-pl)+1e-6)# divise largeur bouche par largeur pupille car elle se dilate en souriant
 
-def head_pose(lms, w, h):
-    img_pts = np.array([[lms[i].x*w, lms[i].y*h] for i in HEAD_POSE_IDX], dtype=np.float64)
+def head_pose(lms, w, h): # fonction qui estime l'orientation de la tete
+    img_pts = np.array([[lms[i].x*w, lms[i].y*h] for i in HEAD_POSE_IDX], dtype=np.float64)# extrait les coordonnées des points de references 
     cam  = np.array([[w,0,w/2],[0,w,h/2],[0,0,1]], dtype=np.float64)
     dist = np.zeros((4,1))
     ok, rvec, _ = cv2.solvePnP(MODEL_3D, img_pts, cam, dist, flags=cv2.SOLVEPNP_ITERATIVE)
@@ -103,75 +89,43 @@ def head_pose(lms, w, h):
         yaw   = 0.0
     return yaw, pitch, roll
 
-def face_bbox(lms, w, h):
-    xs = [lm.x for lm in lms]; ys = [lm.y for lm in lms]
+def face_bbox(lms, w, h): # focntion pour calculer une boite qui enveloppe le visage
+    xs = [lm.x for lm in lms]; ys = [lm.y for lm in lms]# ca creer une liste de tout les X et Y du visage
     xmn,xmx,ymn,ymx = min(xs),max(xs),min(ys),max(ys)
-    return (xmn+xmx)/2,(ymn+ymx)/2,xmx-xmn,ymx-ymn,xmn,ymn,xmx,ymx
+    return (xmn+xmx)/2,(ymn+ymx)/2,xmx-xmn,ymx-ymn,xmn,ymn,xmx,ymx # retourne tout les infos sur la boites
 
-# ──────────────────────────────────────────────
 # Annotation
-# ──────────────────────────────────────────────
 
-def annotate_frame(frame, lms, sig, w, h):
+
+def annotate_frame(frame, lms, sig, w, h): # fonction qui va dessiner sur l video
     x1,y1 = int(sig["bbox_xmin"]*w), int(sig["bbox_ymin"]*h)
     x2,y2 = int(sig["bbox_xmax"]*w), int(sig["bbox_ymax"]*h)
-    cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0),2)
-    for idx in LEFT_EYE+RIGHT_EYE+MOUTH_OUTER:
+    cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0),2) # fait un carre vert autour du visage
+    for idx in LEFT_EYE+RIGHT_EYE+MOUTH_OUTER: # dessine des points sur les differents endroit du visage
         cv2.circle(frame,(int(lms[idx].x*w),int(lms[idx].y*h)),2,(255,0,255),-1)
     for idx in [LEFT_PUP, RIGHT_PUP]:
         cv2.circle(frame,(int(lms[idx].x*w),int(lms[idx].y*h)),3,(0,200,255),-1)
-    lines = [
+    lines = [ # affiche  les lignes texte qui contient les differents 
         f"Yaw:{sig['yaw']:+.1f} Pitch:{sig['pitch']:+.1f} Roll:{sig['roll']:+.1f}",
         f"EAR L:{sig['ear_left']:.3f}  R:{sig['ear_right']:.3f}",
         f"MAR:{sig['mar']:.3f}  Smile:{sig['smile']:.3f}",
         f"T:{sig['timestamp_s']:.2f}s",
     ]
-    for i, line in enumerate(lines):
+    for i, line in enumerate(lines):#  ecrit les ligne de texte au dessus de la boite
         cv2.putText(frame, line, (x1, max(y1-10-i*18, 14)),
                     cv2.FONT_HERSHEY_SIMPLEX, 0.48, (0,255,0), 1, cv2.LINE_AA)
     nose = (int(lms[1].x*w), int(lms[1].y*h))
     tip  = (int(nose[0]+60*math.sin(math.radians(sig["yaw"]))),
             int(nose[1]-60*math.sin(math.radians(sig["pitch"]))))
-    cv2.arrowedLine(frame, nose, tip, (0,100,255), 2, tipLength=0.3)
+    cv2.arrowedLine(frame, nose, tip, (0,100,255), 2, tipLength=0.3)# dessine feche partant du nez montrant orientation tete
     return frame
 
-# ──────────────────────────────────────────────
-# Tracés temporels
-# ──────────────────────────────────────────────
-
-def make_plots(records, path):
-    ts = [r["timestamp_s"] for r in records]
-    fig, axes = plt.subplots(4,1, figsize=(14,12), sharex=True)
-    fig.suptitle("Signaux faciaux extraits", fontsize=14, fontweight="bold")
-    axes[0].plot(ts,[r["yaw"]   for r in records],label="Yaw")
-    axes[0].plot(ts,[r["pitch"] for r in records],label="Pitch")
-    axes[0].plot(ts,[r["roll"]  for r in records],label="Roll")
-    axes[0].set_ylabel("Orientation (deg)"); axes[0].legend(); axes[0].grid(alpha=.3)
-    axes[1].plot(ts,[r["ear_left"]  for r in records],label="EAR gauche")
-    axes[1].plot(ts,[r["ear_right"] for r in records],label="EAR droite")
-    axes[1].axhline(0.20,ls="--",color="gray",label="seuil ~0.20")
-    axes[1].set_ylabel("EAR"); axes[1].legend(); axes[1].grid(alpha=.3)
-    axes[2].plot(ts,[r["mar"]   for r in records],label="MAR bouche")
-    axes[2].plot(ts,[r["smile"] for r in records],label="Sourire")
-    axes[2].set_ylabel("MAR / Sourire"); axes[2].legend(); axes[2].grid(alpha=.3)
-    axes[3].plot(ts,[r["face_cx"] for r in records],label="Centre X")
-    axes[3].plot(ts,[r["face_cy"] for r in records],label="Centre Y")
-    axes[3].set_ylabel("Position (norm.)"); axes[3].set_xlabel("Temps (s)")
-    axes[3].legend(); axes[3].grid(alpha=.3)
-    plt.tight_layout(); plt.savefig(path, dpi=130); plt.close(fig)
-    print(f"  -> Traces : {path}")
-
-# ──────────────────────────────────────────────
+
 # Fusion audio via FFmpeg
-# ──────────────────────────────────────────────
-
-def merge_audio(original_video, silent_video, output_path):
-    """
-    Copie la piste audio de original_video dans silent_video.
-    Nécessite que ffmpeg soit dans le PATH.
-    Produit output_path.
-    """
-    # Vérifie si ffmpeg est disponible
+
+
+def merge_audio(original_video, silent_video, output_path):# fonction qui reassemble le son de la video avec la video
+  
     try:
         subprocess.run(
             ["ffmpeg", "-version"],
@@ -203,60 +157,60 @@ def merge_audio(original_video, silent_video, output_path):
         print(f"  [ERREUR FFmpeg] {result.stderr[-300:]}")
         return False
 
-# ──────────────────────────────────────────────
+
 # Pipeline principal
-# ──────────────────────────────────────────────
+
 
 def process_video(video_path, output_dir):
     os.makedirs(output_dir, exist_ok=True)
-    ensure_model()
+    ensure_model() # telecharge le modele si il n'est pas deja present
 
-    cap = cv2.VideoCapture(video_path)
+    cap = cv2.VideoCapture(video_path) # ouvre le fichier video pour le lire image par image
     if not cap.isOpened():
         sys.exit(f"[ERREUR] Impossible d'ouvrir : {video_path}")
-    fps   = cap.get(cv2.CAP_PROP_FPS) or 30.0
-    W     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    fps   = cap.get(cv2.CAP_PROP_FPS) or 30.0   # nombre d'image par seconde
+    W     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) # dimension de la video 
     H     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # nombre total d'image dans la video
     print(f"Video : {W}x{H}  {fps:.1f} fps  {total} frames")
 
-    base_opts = mp_python.BaseOptions(model_asset_path=MODEL_PATH)
+    base_opts = mp_python.BaseOptions(model_asset_path=MODEL_PATH) # charge MediaPipe et configure les options du modele
     options   = FaceLandmarkerOptions(
         base_options=base_opts,
         running_mode=mp_vision.RunningMode.VIDEO,
-        num_faces=1,
+        num_faces=1, # cherche qu'un seul visage
         min_face_detection_confidence=0.5,
         min_face_presence_confidence=0.5,
         min_tracking_confidence=0.5,
         output_face_blendshapes=False,
         output_facial_transformation_matrixes=False,
     )
-    landmarker = FaceLandmarker.create_from_options(options)
+    landmarker = FaceLandmarker.create_from_options(options) # cree le detecteur de visage
 
     # Fichier intermédiaire sans audio
     silent_path = os.path.join(output_dir, "_annotated_silent.mp4")
     final_path  = os.path.join(output_dir, "output_annotated.mp4")
 
     writer = cv2.VideoWriter(
-        silent_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H)
+        silent_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H) # ouvre un fichier de sortie pour ecrire les frames annotées sans audio
     )
 
-    records   = []
-    frame_idx = 0
+    records   = [] # liste pour stocker les données extraites de chaque frame
+    frame_idx = 0 # index de la frame actuelle
 
     while True:
-        ret, frame = cap.read()
+        ret, frame = cap.read() # lit la frame suivante de la video
         if not ret:
             break
 
-        ts_ms = int(frame_idx * 1000 / fps)
-        ts_s  = frame_idx / fps
+        ts_ms = int(frame_idx * 1000 / fps) # calcule le timestamp en millisecondes pour la frame actuelle
+        ts_s  = frame_idx / fps # calcule le timestamp en secondes pour la frame actuelle
 
         rgb      = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
-        result   = landmarker.detect_for_video(mp_image, ts_ms)
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb) # convertit la frame en format RGB et crée une image MediaPipe à partir de celle-ci
+        result   = landmarker.detect_for_video(mp_image, ts_ms) # applique le modèle de détection de visage à l'image et obtient les résultats pour la frame actuelle
 
-        if result.face_landmarks:
+        if result.face_landmarks: # si un visage est détecté, extraire les informations et les stocker dans un dictionnaire
             lms = result.face_landmarks[0]
             cx,cy,bw,bh,xmn,ymn,xmx,ymx = face_bbox(lms, W, H)
             yaw,pitch,roll = head_pose(lms, W, H)
@@ -290,7 +244,7 @@ def process_video(video_path, output_dir):
             pct = 100*frame_idx//total if total else 0
             print(f"  Frame {frame_idx}/{total} ({pct}%)")
 
-    cap.release(); writer.release(); landmarker.close()
+    cap.release(); writer.release(); landmarker.close() # libère les ressources utilisées pour la lecture de la vidéo, l'écriture de la vidéo annotée et le modèle de détection de visage
     print(f"  -> Video sans audio : {silent_path}")
 
     # ── Recoller l'audio avec FFmpeg ──────────────
@@ -313,17 +267,6 @@ def process_video(video_path, output_dir):
         wc.writeheader(); wc.writerows(records)
     print(f"  -> CSV : {csv_path}")
 
-    # ── JSON ─────────────────────────────────────
-    json_path = os.path.join(output_dir, "signals.json")
-    with open(json_path,"w",encoding="utf-8") as f:
-        json.dump(records, f, indent=2, ensure_ascii=False)
-    print(f"  -> JSON : {json_path}")
-
-    # ── Tracés ───────────────────────��───────────
-    detected = [r for r in records if r.get("face_detected")]
-    if detected:
-        make_plots(detected, os.path.join(output_dir, "plots.png"))
-
     print("\n  Traitement termine.")
     print(f"  Fichiers dans : {os.path.abspath(output_dir)}/")