jalon 3

jericho/emotion.py

@@ -0,0 +1,405 @@
+import argparse # pour lire arg de ligne de commande
+import json # lire et écrire des fichiers  JSON
+import math # fonctions mathématiques 
+import os #module pour creer dossiers ect
+import subprocess #lancer des programmes externes
+import sys # pour forcer arret programme
+import urllib.request # télécharger des fichiers depuis internet
+import cv2 # importe OpenCV,  bibliothèque  pour lire, modifier et écrire des vidéos/images
+import mediapipe as mp #  IA la détection du corps/visage
+import numpy as np # calcul
+from mediapipe.tasks import python as mp_python 
+from mediapipe.tasks.python import vision as mp_vision # Importe les outils de vision par ordinateur de MediaPipe
+from mediapipe.tasks.python.vision import FaceLandmarkerOptions, FaceLandmarker # Importe spécifiquement le détecteur de visage
+
+
+
+MODEL_URL  = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task" # 
+MODEL_PATH = "face_landmarker.task" # IA save sur le pc
+
+def ensure_model(): # verifie si L'IA est sur le pc
+    if not os.path.exists(MODEL_PATH): # 
+        print(f"Téléchargement MediaPipe -> {MODEL_PATH} ...") 
+        urllib.request.urlretrieve(MODEL_URL, MODEL_PATH) 
+        print("  Modèle téléchargé.")
+
+
+# Numero des points du visage
+LEFT_EYE    = [362, 385, 387, 263, 373, 380] 
+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 
+
+LEFT_BROW  = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276]
+RIGHT_BROW = [107,  66, 105,  63,  70,  55,  53,  52,  65,  46] 
+LEFT_BROW_INNER  = 285 
+RIGHT_BROW_INNER = 55 
+
+EAR_THRESHOLD = 0.20 # valeur limite d'ouverture de l'oeil
+
+
+
+class EMAFilter: # classe pour lisser les mouvements afin d eviter les micromouvements
+   
+    def __init__(self, alpha=0.5):
+        self.alpha = alpha 
+        self.state = {} # dictionnaire memorisant valeur precedente
+
+    def __call__(self, key, value): 
+        if key not in self.state: 
+            self.state[key] = value 
+        else: 
+            self.state[key] = self.alpha * value + (1.0 - self.alpha) * self.state[key] 
+        return self.state[key] 
+
+
+
+def _pts(lms, indices, w, h): # convertit point en px
+    return np.array([[lms[i].x * w, lms[i].y * h] for i in indices]) 
+
+def ear(lms, indices, w, h): # calcule ouverture des yeaux
+    p = _pts(lms, indices, w, h) # coordonnée de l'oeil
+    A = np.linalg.norm(p[1]-p[5]) # distance vert oeil gauche
+    B = np.linalg.norm(p[2]-p[4]) # " "    "  droit
+    C = np.linalg.norm(p[0]-p[3]) # largeur oeil
+    return (A+B) / (2.0 * C + 1e-6) #formul calculant ear
+
+def mar(lms, indices, w, h): # calcule ouverture bouche
+    p = _pts(lms, indices, w, h) #  coordonnées des points de la bouche
+    A = np.linalg.norm(p[1]-p[5]) # hauteur gauche bpuche
+    B = np.linalg.norm(p[2]-p[4]) # hauteur droite bouche
+    C = np.linalg.norm(p[0]-p[3]) # Largeur de la bouche
+    return (A+B) / (2.0 * C + 1e-6) # Formule du MAR (plus la valeur est haute, plus la bouche est ouverte)
+
+def smile_index(lms, w, h): # calcul valeur sourire
+    ml = np.array([lms[MOUTH_L].x*w, lms[MOUTH_L].y*h]) # pos en px coin gauche
+    mr = np.array([lms[MOUTH_R].x*w, lms[MOUTH_R].y*h]) #pos en px coin droit
+    pl = np.array([lms[LEFT_PUP].x*w,  lms[LEFT_PUP].y*h]) # pos pupille gauche 
+    pr = np.array([lms[RIGHT_PUP].x*w, lms[RIGHT_PUP].y*h]) # pos px pupille droite
+    return np.linalg.norm(mr-ml) / (np.linalg.norm(pr-pl) + 1e-6) # calcul sourire
+
+def head_pose_from_matrix(matrix): # orientation de tete
+    R = matrix[:3, :3] 
+    sy = math.sqrt(R[0,0]**2 + R[1,0]**2) 
+    singular = sy < 1e-6 
+
+    if not singular: # Si la position de la tête est normale
+        pitch = math.degrees(math.atan2(R[2,1], R[2,2])) 
+        yaw   = math.degrees(math.atan2(-R[2,0], sy)) 
+        roll  = math.degrees(math.atan2(R[1,0], R[0,0])) 
+    else: # si tete exetrememnt tourné
+        pitch = math.degrees(math.atan2(-R[1,2], R[1,1])) 
+        yaw   = math.degrees(math.atan2(-R[2,0], sy)) 
+        roll  = 0.0 
+        
+    return yaw, pitch, roll 
+
+def face_bbox(lms, w, h): # rectangle entourant tete
+    xs = [lm.x for lm in lms]; ys = [lm.y for lm in lms] 
+    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 
+
+def brow_raise(lms, brow_indices, eye_indices, w, h, face_h): #mesure a quel point sourcil levé
+    brow_pts = _pts(lms, brow_indices, w, h) # point sourcil en px
+    eye_pts  = _pts(lms, eye_indices,  w, h) #point yeux en px
+    brow_y = brow_pts[:, 1].mean() #moyenne hauteur tt les points sourcils
+    eye_y  = eye_pts[:,  1].mean() # moyenne hauteur tt les points de l eoil
+    dist   = eye_y - brow_y # distance oeil sourcil
+    return dist / (face_h * h + 1e-6) # divise par hauteur de visage
+
+def brow_furrow(lms, w, h): #froncement des sourcils 
+    li = np.array([lms[LEFT_BROW_INNER].x*w,  lms[LEFT_BROW_INNER].y*h]) # coin intérieur gauche
+    ri = np.array([lms[RIGHT_BROW_INNER].x*w, lms[RIGHT_BROW_INNER].y*h]) # coin intérieur droit
+    pl = np.array([lms[LEFT_PUP].x*w,  lms[LEFT_PUP].y*h]) # pupille gauche
+    pr = np.array([lms[RIGHT_PUP].x*w, lms[RIGHT_PUP].y*h]) #  pupille droite
+    return np.linalg.norm(ri - li) / (np.linalg.norm(pr - pl) + 1e-6) # distance entre  sourcils divisée par écart des yeux
+
+
+
+def emotions_records(records): # fonction analyse la video pour trouver les émotions
+    
+    valid_recs = [r["rec"] for r in records if r["rec"].get("face_detected", False)] # garde image avec un visage detecté
+    if not valid_recs: 
+        return 
+
+    def get_mean(key, func=None): # calcul moyenne d'un signal
+        if func: return float(np.mean([func(r) for r in valid_recs])) 
+        return float(np.mean([r[key] for r in valid_recs])) 
+        
+    def get_std(key, func=None): # calcul ecart type signal
+        if func: return max(float(np.std([func(r) for r in valid_recs])), 1e-6) 
+        return max(float(np.std([r[key] for r in valid_recs])), 1e-6)
+
+   
+    smile_m  = get_mean("smile") # moyenne sourire
+    smile_s  = get_std("smile") # ecart-type sourire
+    ear_m    = get_mean(None, lambda r: (r["ear_left"] + r["ear_right"]) / 2) # moyenne ouverture yeux
+    ear_s    = get_std(None, lambda r: (r["ear_left"] + r["ear_right"]) / 2) # ecart-type ouverture  yeux
+    mar_m    = get_mean("mar") # moyenne ouverture bouche
+    mar_s    = get_std("mar") # ecart-type ouverture bouche
+    b_raise_m = get_mean(None, lambda r: (r["brow_raise_left"] + r["brow_raise_right"]) / 2) # moyenne huateur soucrils
+    b_raise_s = get_std(None, lambda r: (r["brow_raise_left"] + r["brow_raise_right"]) / 2) # ecart type h sourcils
+    b_furrow_m = get_mean("brow_furrow") # moyenne froncement sourcils
+    b_furrow_s = get_std("brow_furrow") # ecart type froncement sourcil
+
+    for item in records: # pour chaque image de la video
+        rec = item["rec"] # o recupere les données de l image
+        if not rec.get("face_detected", False): 
+            rec["emotion"] = "NEUTRE" # si pas d image, emotion neutre
+            continue 
+
+        smile = rec["smile"] 
+        ear = (rec["ear_left"] + rec["ear_right"]) / 2 
+        mar = rec["mar"] 
+        b_raise = (rec["brow_raise_left"] + rec["brow_raise_right"]) / 2 
+        b_furrow = rec["brow_furrow"] 
+
+        # calcul les Z-scores 
+        n_smile       = (smile - smile_m) / smile_s 
+        n_ear         = (ear - ear_m) / ear_s 
+        n_mar         = (mar - mar_m) / mar_s 
+        n_brow_raise  = (b_raise - b_raise_m) / b_raise_s 
+        n_brow_furrow = (b_furrow - b_furrow_m) / b_furrow_s 
+        
+      
+        
+       
+        if n_brow_raise > 0.8 and n_ear > 0.8:
+            emotion = "SURPRISE" 
+            
+        
+        elif n_brow_raise < -0.5 and n_smile < -0.5: 
+            emotion = "COLERE" 
+            
+    
+        elif n_brow_raise < -0.3 and n_ear < -0.5: 
+            emotion = "TRISTESSE" 
+            
+       
+        elif n_smile > 0.8:
+            emotion = "JOIE" 
+            
+       
+        elif n_ear > 0.8:
+            emotion = "PEUR"
+            
+   
+        elif n_smile > 0.3:
+            emotion = "CONTENT" 
+            
+        else: 
+            emotion = "NEUTRE" 
+
+        rec["emotion"] = emotion 
+
+
+def annotate_frame(frame, lms, sig, w, h): # fonction pour annoter la video
+
+    #coordonee boite du visage
+    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) # rectangle visage
+
+    # affiche l'emotion au dessus de la boite
+    emotion = sig.get("emotion", "NEUTRE") 
+    cv2.putText(frame, f"EMOTION: {emotion}", (x1, max(y1-15, 30)), 
+                cv2.FONT_HERSHEY_DUPLEX, 1.0, (0, 255, 255), 2)
+# dessine des points sur chaque marqueur
+    for idx in LEFT_EYE + RIGHT_EYE + MOUTH_OUTER: 
+        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) 
+
+    for idx in LEFT_BROW: 
+        cv2.circle(frame,(int(lms[idx].x*w), int(lms[idx].y*h)), 2, (0,255,255), -1) 
+    for idx in RIGHT_BROW: 
+        cv2.circle(frame,(int(lms[idx].x*w), int(lms[idx].y*h)), 2, (0,165,255), -1) 
+
+    lines = [ # toutes les info
+        f"Yaw:{sig['yaw']:+.1f} Pitch:{sig['pitch']:+.1f} Roll:{sig['roll']:+.1f}", # orientation tete
+        f"EAR L:{sig['ear_left']:.3f}  R:{sig['ear_right']:.3f}", # ouverture des yeux
+        f"MAR:{sig['mar']:.3f}  Smile:{sig['smile']:.3f}", # ouverture de la bouche et le sourire
+       # f"BrowRaise L:{sig['brow_raise_left']:.3f}  R:{sig['brow_raise_right']:.3f}", # hauteur des sourcils
+       # f"BrowFurrow:{sig['brow_furrow']:.3f}", # froncement
+        f"T:{sig['timestamp_s']:.2f}s", # Affiche le temps en secondes
+    ]
+    for i, line in enumerate(lines): # boucle pour ecrire les lignes au dessus
+        cv2.putText(frame, line, (x1, y2+25+i*18), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0,255,255), 1, cv2.LINE_AA) # 
+
+    #fleche orientation tete
+    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)
+
+    return frame # retourne l image annoté
+
+
+def merge_audio(original_video, silent_video, output_path): # remet son de la video original
+    try:
+        subprocess.run( # 
+            ["ffmpeg", "-version"], 
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True 
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError): # Si FFmpeg n'est pas installé ou plante
+        print("\n   ffmpeg introuvable. téléchargé le") 
+        return False 
+
+    cmd = [ # combine son et video
+        "ffmpeg", "-y", "-i", silent_video, "-i", original_video, 
+        "-c", "copy", "-map", "0:v:0", "-map", "1:a:0", "-shortest", output_path 
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True) # exécute la ligne de commande
+    return result.returncode == 0 
+
+
+def process_video(video_path, output_dir): 
+    os.makedirs(output_dir, exist_ok=True) 
+    ensure_model() # verifie si IA telechargé
+
+    cap = cv2.VideoCapture(video_path) # zopen cv ouvre vudei
+    if not cap.isOpened(): # 
+        sys.exit(f"impossible d'ouvrir : {video_path}") 
+        
+    fps   = cap.get(cv2.CAP_PROP_FPS) or 30.0 # nb d image par sec
+    W     = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) # largeur video en px
+    H     = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) # h en px
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # nb img vid
+    print(f"Video : {W}x{H}  {fps:.1f} fps  {total} frames") # info de la vid en console
+
+    base_opts = mp_python.BaseOptions(model_asset_path=MODEL_PATH) # 
+    options   = FaceLandmarkerOptions( # configure ia
+        base_options=base_opts, # Passe les options de base
+        running_mode=mp_vision.RunningMode.VIDEO, 
+        num_faces=1, #un visage
+        min_face_detection_confidence=0.5, # Tolérance de détection du visage à 50%
+        min_face_presence_confidence=0.5, # Tolérance de maintien du visage à 50%
+        min_tracking_confidence=0.5, # Tolérance de suivi de mouvement à 50%
+        output_face_blendshapes=False, 
+        output_facial_transformation_matrixes=True, # matrice pour suivi de l'orientation
+    )
+    landmarker = FaceLandmarker.create_from_options(options) # lance l ia
+
+   
+    print("\n Extraction des signaux faciaux...") 
+    records = [] # liste stock donnee de tte les images
+    frame_idx = 0 
+    ema = EMAFilter(alpha=0.5) 
+
+    while True:
+        ret, frame = cap.read() # lit l'image suivante.ret faux si video fini
+        if not ret: 
+            break 
+
+        ts_ms = int(frame_idx * 1000 / fps) #timestamp actuel en ms 
+        ts_s  = frame_idx / fps #timestamp en s
+
+        rgb      = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # convertit les couleur pour faire le lien entre open cv et mediapipe
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb) # transforme img pour mediapipe
+        result   = landmarker.detect_for_video(mp_image, ts_ms) # Ia trouve visage sur l img
+
+        if result.face_landmarks and result.facial_transformation_matrixes: 
+            lms = result.face_landmarks[0] # recup point du visage
+            matrix = result.facial_transformation_matrixes[0] # recupere matrice orientation du visage
+            
+            cx_raw, cy_raw, bw_raw, bh_raw, xmn_raw, ymn_raw, xmx_raw, ymx_raw = face_bbox(lms, W, H) 
+            yaw_raw, pitch_raw, roll_raw = head_pose_from_matrix(matrix) #  orientation tete
+            el_raw = ear(lms, LEFT_EYE, W, H) # ouverture oeil gauche
+            er_raw = ear(lms, RIGHT_EYE, W, H) # ouverture oiel droit
+            m_raw  = mar(lms, MOUTH_OUTER, W, H) #ouverture bouche
+            sm_raw = smile_index(lms, W, H) # largeur sourire
+            br_left_raw  = brow_raise(lms, LEFT_BROW,  LEFT_EYE,  W, H, bh_raw) # hauteur sourcil G
+            br_right_raw = brow_raise(lms, RIGHT_BROW, RIGHT_EYE, W, H, bh_raw) #  hauteur sourcill D
+            bf_raw       = brow_furrow(lms, W, H) # froncement sourcil
+
+            rec = { # dico
+                "frame":          frame_idx, # num img
+                "timestamp_s":    round(ts_s, 4), #temps en s
+                "face_detected":  True, 
+                "face_cx":        round(ema('cx', cx_raw), 4), # centre x
+                "face_cy":        round(ema('cy', cy_raw), 4), # centre Y 
+                "face_w":         round(ema('bw', bw_raw), 4), # largeur visage
+                "face_h":         round(ema('bh', bh_raw), 4), #hauteur visage
+                "bbox_xmin":      round(ema('xmn', xmn_raw), 4), # bord gauche 
+                "bbox_ymin":      round(ema('ymn', ymn_raw), 4), # bord haut 
+                "bbox_xmax":      round(ema('xmx', xmx_raw), 4), # bord droit
+                "bbox_ymax":      round(ema('ymx', ymx_raw), 4), #bord bas
+                "yaw":            round(ema('yaw', yaw_raw), 2), # rota G & D
+                "pitch":          round(ema('pitch', pitch_raw), 2), # inclinaison haut bas 
+                "roll":           round(ema('roll', roll_raw), 2), # penchement 
+                "ear_left":       round(ema('el', el_raw), 4), # oeil gauche
+                "ear_right":      round(ema('er', er_raw), 4), # oeil droit
+                "mar":            round(ema('m', m_raw), 4), # Bouche lissée
+                "smile":          round(ema('sm', sm_raw), 4), # Sourire lissé
+                "brow_raise_left":  round(ema('br_l', br_left_raw), 4), # Sourcil gauche lissé
+                "brow_raise_right": round(ema('br_r', br_right_raw), 4), # Sourcil droit lissé
+                "brow_furrow":      round(ema('bf', bf_raw), 4), # Froncement lissé
+            }
+            records.append({"rec": rec, "lms": lms}) # Ajoute ce gros dictionnaire, et les points originaux 'lms', à la liste globale
+        else: # Si l'IA n'a pas trouvé de visage
+            records.append({ # Ajoute un petit dictionnaire disant "Face Not Detected"
+                "rec": {"frame": frame_idx, "timestamp_s": round(ts_s, 4), "face_detected": False},
+                "lms": None # Et pas de points
+            })
+
+        frame_idx += 1 # Passe à l'image suivante
+        if frame_idx % 100 == 0: # Toutes les 100 images...
+            print(f"  Frame {frame_idx}/{total} ({100*frame_idx//total}%)") # ... Affiche la progression dans la console
+
+    cap.release() # Relâche le fichier vidéo pour libérer la mémoire de l'ordinateur
+    landmarker.close() # Ferme l'IA MediaPipe proprement
+
+    # Calcul des émotions globales
+    emotions_records(records) # Appelle la grosse fonction FACS pour déduire la ligne "emotion" de tous les dictionnaires d'un coup
+
+    # ======= PASSE 2 : DESSIN SUR LA VIDÉO =======
+    print("\n[Passe 2/2] Création de la vidéo avec affichage des émotions...") # Informe du début de la passe graphique
+    cap = cv2.VideoCapture(video_path) # ROUVRE la vidéo originale depuis le tout début
+    silent_path = os.path.join(output_dir, "_annotated_silent.mp4") # Prépare le nom d'un fichier vidéo temporaire (sans son)
+    final_path  = os.path.join(output_dir, "output_annotated.mp4") # Prépare le nom du fichier vidéo final (avec son)
+    writer = cv2.VideoWriter(silent_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (W, H)) # Configure l'outil pour écrire la nouvelle vidéo image par image
+
+    idx = 0 # Compteur d'images remis à 0
+    while True: # Boucle infinie
+        ret, frame = cap.read() # Lit l'image originale
+        if not ret: break # Stop à la fin de la vidéo
+
+        if idx < len(records): # Sécurité pour ne pas dépasser la taille de notre liste de données
+            item = records[idx] # Récupère les données de l'image actuelle
+            if item["rec"].get("face_detected", False): # Si un visage était présent...
+                frame = annotate_frame(frame, item["lms"], item["rec"], W, H) # ... On dessine tout par-dessus
+            else: # Sinon...
+                cv2.putText(frame, "Visage non detecte", (20,40), # ... On écrit "Visage non détecté" en rouge
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,0,255), 2)
+        
+        writer.write(frame) # Enregistre l'image modifiée dans la nouvelle vidéo
+        idx += 1 # Passe à la suivante
+
+    cap.release() # Relâche la vidéo originale
+    writer.release() # Clôture le fichier vidéo annoté (fini d'écrire)
+
+    # ── Sauvegarde ─────────────────────────────────────────────────────────────
+    if merge_audio(video_path, silent_path, final_path): # Tente de recoller le son original via FFmpeg
+        os.remove(silent_path) # Si succès, on supprime la vidéo muette temporaire
+    else: # Si échec (FFmpeg absent)
+        os.replace(silent_path, final_path) # On renomme la vidéo muette en fichier final
+
+    json_path = os.path.join(output_dir, "signals.json") # Prépare le chemin pour sauvegarder le JSON (signals.json)
+    with open(json_path, "w", encoding="utf-8") as f: # Ouvre le fichier en mode écriture ("w")
+        json_records = [item["rec"] for item in records] # Extrait uniquement les dicos "rec" (sans les 478 points 'lms' pour éviter un fichier trop lourd)
+        json.dump( # Exporte le tout en texte formaté JSON
+            {"video": os.path.abspath(video_path), "fps": round(fps, 4), "width": W, "height": H, "total_frames": total, "frames": json_records},
+            f, ensure_ascii=False, indent=2 # Avec une jolie indentation (2 espaces) pour que ça soit lisible
+        )
+    print(f"\n  fait,  fichiers dans : {os.path.abspath(output_dir)}/") 
+
+if __name__ == "__main__": # Cette ligne spéciale vérifie si on a lancé ce fichier directement depuis le terminal
+    parser = argparse.ArgumentParser() # initialise analyseur de ligne de commande
+    parser.add_argument("--video", required=True) # on doit fournir un chemin avec --video
+    parser.add_argument("--output_dir", default="output") #pour le odssier où on place les docs
+    args = parser.parse_args() # lit ce que l'utilisateur a tapé
+    process_video(args.video, args.output_dir) #

jericho/movement.py

@@ -0,0 +1,452 @@
+import json
+import time
+import threading
+import argparse
+import sys
+import math
+import numpy as np
+
+
+# Chargement signals.json en ne conservant que les frames avec un visage détecté
+
+def load_signals(path: str) -> tuple[dict, list[dict]]:
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    meta = {k: v for k, v in data.items() if k != "frames"}
+    frames = [fr for fr in data["frames"] if fr.get("face_detected", False)]
+    print(f"[Chargement] {len(frames)} frames avec visage sur "
+          f"{data.get('total_frames', '?')} total "
+          f"({data.get('fps', '?')} fps, durée ~{frames[-1]['timestamp_s']:.2f}s)")
+    return meta, frames
+
+
+# filtre pour lisser les mouvements pour ne pas les avoir saccadé
+
+def moving_average(values: list[float], window: int = 7) -> np.ndarray:
+    arr = np.asarray(values, dtype=float)
+    pad = window // 2
+    padded = np.pad(arr, pad_width=pad, mode="edge")
+    kernel = np.ones(window) / window
+    smoothed = np.convolve(padded, kernel, mode="valid")
+    return smoothed[: len(arr)]
+
+
+# Traduit les signaux faciaux en commandes pour le robot
+
+class SignalMapper:
+
+    # Limites de mouvements du robot en rad/m
+    HEAD_YAW_MAX        = np.deg2rad(5)   # rotation horizontale tête : ±35°
+    HEAD_PITCH_MAX      = np.deg2rad(15)   # inclinaison haut/bas tête : ±25°
+    HEAD_ROLL_MAX       = np.deg2rad(15)   # inclinaison latérale tête : ±25°
+    HEAD_Y_MAX          = 0.03             # déplacement latéral tête : ±3 cm
+    HEAD_Z_MAX          = 0.03             # déplacement vertical tête : ±3 cm
+    BODY_YAW_MAX        = np.deg2rad(15)   # rotation corps : ±25°
+    ANTENNA_MAX         = np.deg2rad(120)  # débattement antennes : ±45°
+    ANTENNA_MAX_alt     = np.deg2rad(45)   
+    ANTENNA_MAX_col     = np.deg2rad(110)  
+    COMBINED_YAW_LIMIT  = np.deg2rad(60)   # contrainte combinée corps + tête en yaw
+
+    # Valeurs d'amplification des mouvements
+    YAW_AMP        = 8.0
+    PITCH_AMP      = 5.0
+    ROLL_AMP       = 3.0
+    CX_TO_Y_SCALE  = 0.12
+    CX_TO_BODY_YAW = 0.8
+    CY_TO_Z_SCALE  = -0.10
+
+    SMOOTH_WINDOW_HEAD    = 7    # Lissage pour la pose tête pour réduire le "bruit" (fluidifie) et avoir une meilleure réactivité
+    SMOOTH_WINDOW_EMOTION = 11   # lissage pour les émotions pour éviter les détections sur des clignements
+
+    def __init__(self, frames: list[dict]):
+        self.frames = frames
+        self._compute_baselines()
+        self.commands = self._build_commands()
+
+
+    def _compute_baselines(self):
+
+        # Moyenne
+        def mean(key, calc_func=None):
+            if calc_func: return float(np.mean([calc_func(f) for f in self.frames]))
+            return float(np.mean([f[key] for f in self.frames]))
+            
+        # Ecart type à 0.000001 pour éviter la division par 0
+        def std(key, calc_func=None):
+            if calc_func: return max(float(np.std([calc_func(f) for f in self.frames])), 1e-6)
+            return max(float(np.std([f[key] for f in self.frames])), 1e-6)
+
+        self.yaw_mean   = mean("yaw")    # rotation gauche/droite moyenne (degrés)
+        self.pitch_mean = mean("pitch")  # inclinaison haut/bas moyenne
+        self.roll_mean  = mean("roll")   # roulis moyen
+        self.cx_mean    = mean("face_cx")  # position X moyenne du visage dans le cadre
+        self.cy_mean    = mean("face_cy")  # position Y moyenne
+
+        # Etirement de la bouche
+        self.smile_mean  = mean("smile")
+        self.smile_std   = std("smile")
+        
+        # Position des sourcils (hauteur) avec les deux sourcils au cas où un n'est pas détecter/visible
+        self.brow_raise_mean = mean(None, lambda f: (f["brow_raise_left"] + f["brow_raise_right"]) / 2)
+        self.brow_raise_std  = std(None, lambda f: (f["brow_raise_left"] + f["brow_raise_right"]) / 2)
+        
+        # Ecartement des sourcils
+        self.brow_furrow_mean = mean("brow_furrow")
+        self.brow_furrow_std  = std("brow_furrow")
+        
+
+        self.ear_mean = mean(None, lambda f: (f["ear_left"] + f["ear_right"]) / 2)
+        self.ear_std  = std(None, lambda f: (f["ear_left"] + f["ear_right"]) / 2)
+        
+        # Même chose pour la bouche
+        self.mar_mean = mean("mar")
+        self.mar_std  = std("mar")
+
+
+    # Définie l'émotion selon les valeurs en entrées
+
+    def _detect_emotion(self, smile, ear, mar, brow_raise, brow_furrow):
+        n_smile       = (smile - self.smile_mean) / self.smile_std
+        n_ear         = (ear - self.ear_mean) / self.ear_std
+        n_mar         = (mar - self.mar_mean) / self.mar_std
+        n_brow_raise  = (brow_raise - self.brow_raise_mean) / self.brow_raise_std
+        n_brow_furrow = (brow_furrow - self.brow_furrow_mean) / self.brow_furrow_std
+
+        # 1. SURPRISE : Écart yeux/sourcil élevé ET yeux grand ouverts
+        if n_brow_raise > 0.8 and n_ear > 0.8:
+            return "SURPRISE"
+            
+        # 2. COLÈRE : Écart yeux/sourcil diminué ET largeur bouche diminuée
+        if n_brow_raise < -0.5 and n_smile < -0.5:
+            return "COLERE"
+            
+        # 3. TRISTESSE : Écart yeux/sourcil réduit ET petite ouverture des yeux
+        if n_brow_raise < -0.3 and n_ear < -0.5:
+            return "TRISTESSE"
+            
+        # 4. JOIE : Grand sourire
+        if n_smile > 0.8:
+            return "JOIE"
+            
+        # 5. PEUR : Yeux écarquillés
+        if n_ear > 0.8:
+            return "PEUR"
+            
+        # 6. CONTENT : Léger sourire
+        if n_smile > 0.3:
+            return "CONTENT"
+            
+        return "NEUTRE"
+
+
+    # Mouvements des antennes selon l'émotion détéctée
+
+    def _compute_antennas(self, emotion, t_state):
+        left_antenna, right_antenna = 0.0, 0.0
+
+        if emotion == "TRISTESSE":
+            target_angle = -1.0 * (1.0 - math.exp(-1.5 * t_state)) * self.ANTENNA_MAX
+            left_antenna  = (target_angle - 0.2)
+            right_antenna = -(target_angle - 0.2)
+            
+        elif emotion == "JOIE":
+            oscillation = 0.5 * math.sin(2 * math.pi * 4.0 * t_state)
+            angle = (0.5 + oscillation) * self.ANTENNA_MAX_alt
+            left_antenna  = -(angle)
+            right_antenna = (angle)
+            
+        elif emotion == "CONTENT":
+            oscillation = 0.8 * math.sin(2 * math.pi * 0.5 * t_state)
+            angle = oscillation * self.ANTENNA_MAX_alt
+            left_antenna, right_antenna = angle, angle
+            
+        elif emotion == "SURPRISE":
+            angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * self.ANTENNA_MAX_alt
+            left_antenna  = -(angle-0.8)
+            right_antenna = (angle-0.8)
+
+        elif emotion == "NEUTRE":
+            angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * self.ANTENNA_MAX_alt
+            left_antenna  = -(angle-0.3)
+            right_antenna = (angle-0.3)
+
+        elif emotion == "COLERE":
+            if t_state < 0.15:
+                angle = -1.0 * (t_state / 0.15) * self.ANTENNA_MAX_col
+            elif t_state < 0.40:
+                angle = (-1.0 + 1.0 * ((t_state - 0.15) / 0.15)) * self.ANTENNA_MAX_col
+            elif t_state < 0.65:
+                angle = -1.0 * ((t_state - 0.3) / 0.15) * self.ANTENNA_MAX_col
+            else:
+                angle = -1.0 * self.ANTENNA_MAX_col
+            left_antenna  = (angle)
+            right_antenna = -(angle)
+            
+        elif emotion == "PEUR":
+            tremblement = 0.1 * math.sin(2 * math.pi * 15.0 * t_state)
+            angle = -1.0 *(1.0 - math.exp(-1.5 * t_state)+ tremblement) * self.ANTENNA_MAX
+            left_antenna  = (angle - 0.2)
+            right_antenna = -(angle - 0.2)
+
+        return left_antenna, right_antenna
+
+
+    """
+    1. Extraction des signaux bruts en tableaux
+    2. Lissage
+    3. Pour chaque frame :
+        a. Conversion des angles de tête (degrés en radians, amplification, clamp)
+        b. Calcul des translations de la tête (y, z) depuis la position du visage
+        c. Calcul du body_yaw avec contrainte combinée avec head_yaw
+        d. Détection de l'émotion
+        e. Mouvements des antennes
+    """
+
+    def _build_commands(self) -> list[dict]:
+        n = len(self.frames)
+
+        raw_yaw    = np.array([f["yaw"]   - self.yaw_mean   for f in self.frames])
+        raw_pitch  = np.array([f["pitch"] - self.pitch_mean for f in self.frames])
+        raw_roll   = np.array([f["roll"]  - self.roll_mean  for f in self.frames])
+        raw_cx     = np.array([f["face_cx"] - self.cx_mean  for f in self.frames])
+        raw_cy     = np.array([f["face_cy"] - self.cy_mean  for f in self.frames])
+
+        raw_smile       = np.array([f["smile"] for f in self.frames])
+        raw_ear         = np.array([(f["ear_left"] + f["ear_right"]) / 2 for f in self.frames])
+        raw_mar         = np.array([f["mar"] for f in self.frames])
+        raw_brow_raise  = np.array([(f["brow_raise_left"] + f["brow_raise_right"]) / 2 for f in self.frames])
+        raw_brow_furrow = np.array([f["brow_furrow"] for f in self.frames])
+
+        w_h = self.SMOOTH_WINDOW_HEAD
+        w_e = self.SMOOTH_WINDOW_EMOTION
+
+        s_yaw    = moving_average(raw_yaw,   w_h)
+        s_pitch  = moving_average(raw_pitch, w_h)
+        s_roll   = moving_average(raw_roll,  w_h)
+        s_cx     = moving_average(raw_cx,    w_h)
+        s_cy     = moving_average(raw_cy,    w_h)
+
+        s_smile        = moving_average(raw_smile,       w_e)
+        s_ear          = moving_average(raw_ear,         w_e)
+        s_mar          = moving_average(raw_mar,         w_e)
+        s_brow_raise   = moving_average(raw_brow_raise,  w_e)
+        s_brow_furrow  = moving_average(raw_brow_furrow, w_e)
+
+        commands = []
+        current_emotion = "NEUTRE"
+        emotion_start_time = 0.0
+
+        for i in range(n):
+            t = self.frames[i]["timestamp_s"]
+
+            head_yaw   = self._clamp(np.deg2rad(s_yaw[i] * self.YAW_AMP), self.HEAD_YAW_MAX)
+            head_pitch = self._clamp(np.deg2rad(s_pitch[i] * self.PITCH_AMP), self.HEAD_PITCH_MAX)
+            head_roll  = self._clamp(np.deg2rad(s_roll[i] * self.ROLL_AMP), self.HEAD_ROLL_MAX)
+
+            head_y = self._clamp(s_cx[i] * self.CX_TO_Y_SCALE, self.HEAD_Y_MAX)
+            head_z = self._clamp(s_cy[i] * self.CY_TO_Z_SCALE, self.HEAD_Z_MAX)
+
+            body_yaw = self._clamp(s_cx[i] * self.CX_TO_BODY_YAW, self.BODY_YAW_MAX)
+
+            diff = body_yaw - head_yaw
+            if abs(diff) > self.COMBINED_YAW_LIMIT:
+                body_yaw = head_yaw + np.sign(diff) * self.COMBINED_YAW_LIMIT
+
+            detected_emotion = self._detect_emotion(
+                s_smile[i], s_ear[i], s_mar[i], s_brow_raise[i], s_brow_furrow[i]
+            )
+
+            if detected_emotion != current_emotion:
+                current_emotion = detected_emotion
+                emotion_start_time = t
+
+            t_state = t - emotion_start_time
+            ant_left, ant_right = self._compute_antennas(current_emotion, t_state)
+
+            ant_left  = self._clamp(ant_left, self.ANTENNA_MAX)
+            ant_right = self._clamp(ant_right, self.ANTENNA_MAX)
+
+            commands.append({
+                "timestamp_s": round(t, 4),
+                "head": {
+                    "x":     0.0,
+                    "y":     round(float(head_y),    5),
+                    "z":     round(float(head_z),    5),
+                    "roll":  round(float(head_roll),  5),
+                    "pitch": round(float(head_pitch), 5),
+                    "yaw":   round(float(head_yaw),   5),
+                },
+                "body_yaw": round(float(body_yaw), 5),
+                "antennas": [
+                    round(float(ant_left),  5),
+                    round(float(ant_right), 5),
+                ],
+                "emotion": current_emotion
+            })
+
+        print(f"[Mapping] {len(commands)} commandes générées.")
+        return commands
+
+    @staticmethod
+    def _clamp(value: float, limit: float) -> float:
+        return float(max(-limit, min(limit, value)))
+    
+
+# Sauvegarde des mouvements générés
+
+def save_movement(commands: list[dict], meta: dict, output_path: str):
+    movement = {
+        "source_video": meta.get("video", "unknown"),
+        "source_fps":   meta.get("fps",   0),
+        "total_frames": len(commands),
+        "duration_s":   commands[-1]["timestamp_s"] if commands else 0,
+        "frames": commands,
+    }
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(movement, f, indent=2)
+    print(f"[Sauvegarde] Mouvement enregistré dans '{output_path}' "
+          f"({len(commands)} frames, {movement['duration_s']:.2f}s)")
+
+
+# Refait les mouvements pour le robot
+
+class SignalReplayApp:
+
+    def __init__(self, commands: list[dict]):
+        self.commands = commands
+
+    def run(self, reachy_mini, stop_event: threading.Event):
+        from reachy_mini.utils import create_head_pose
+
+        if not self.commands:
+            print("[Rejeu] Aucune commande à rejouer.")
+            return
+
+        print("[Rejeu] Initialisation de la pose de départ...")
+        reachy_mini.goto_target(
+            create_head_pose(), antennas=[0.0, 0.0], duration=1.0
+        )
+        time.sleep(1.2)
+
+        print(f"[Rejeu] Début — {len(self.commands)} frames "
+              f"sur {self.commands[-1]['timestamp_s']:.2f}s")
+
+        start_wall = time.time()
+        video_offset = self.commands[0]["timestamp_s"]
+        idx = 0
+        n = len(self.commands)
+
+        while not stop_event.is_set() and idx < n:
+            elapsed = time.time() - start_wall
+            target_t = video_offset + elapsed
+
+            # avance les frames si il y a un retard
+            while idx < n - 1 and self.commands[idx]["timestamp_s"] < target_t:
+                idx += 1
+
+            if idx >= n:
+                break
+
+            cmd = self.commands[idx]
+            head_dict = cmd["head"]
+
+            head_pose = create_head_pose(
+                x=head_dict["x"],
+                y=head_dict["y"],
+                z=head_dict["z"],
+                roll=head_dict["roll"],
+                pitch=head_dict["pitch"],
+                yaw=head_dict["yaw"],
+                degrees=False,
+                mm=False,
+            )
+
+            try:
+                reachy_mini.set_target(
+                    head=head_pose,
+                    antennas=cmd["antennas"],
+                    body_yaw=cmd["body_yaw"],
+                )
+            except TypeError:
+                reachy_mini.set_target(head=head_pose, antennas=cmd["antennas"])
+
+            time.sleep(0.01)   # 100hz
+
+        print("[Rejeu] Terminé. Retour à la pose neutre.")
+        reachy_mini.goto_target(
+            create_head_pose(), antennas=[0.0, 0.0], duration=1.0
+        )
+
+
+"""
+python signal_replay.py                               # rejeu depuis signals.json
+python signal_replay.py ma_video_signals.json         # choix de la source
+python signal_replay.py --save movement.json          # sauvegarde + rejeu
+python signal_replay.py --save out.json --no-replay   # sauvegarde seule sans le rejeu
+"""
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Rejoue les signaux faciaux sur Reachy Mini."
+    )
+    parser.add_argument(
+        "signals_path",
+        nargs="?",
+        default="signals.json",
+        help="Chemin vers signals.json (défaut: signals.json)",
+    )
+    parser.add_argument(
+        "--save",
+        metavar="OUTPUT",
+        default=None,
+        help="Sauvegarder le mouvement généré dans un fichier JSON",
+    )
+    parser.add_argument(
+        "--no-replay",
+        action="store_true",
+        help="Générer et sauvegarder sans lancer la simulation",
+    )
+    return parser.parse_args()
+
+
+"""
+1. Parse les arguments
+2. Charge les signaux faciaux
+3. Génère les commandes robot avec SignalMapper
+---Selon les arguments---
+4. Sauvegarde optionnelle
+5. Rejeu sur le robot
+"""
+
+def main():
+    args = parse_args()
+
+    meta, frames = load_signals(args.signals_path)
+    mapper = SignalMapper(frames)
+
+    if args.save:
+        save_movement(mapper.commands, meta, args.save)
+
+    if args.no_replay:
+        print("[Mode --no-replay] Génération terminée, pas de simulation.")
+        return
+
+    try:
+        from reachy_mini import ReachyMini
+    except ImportError:
+        print("[Erreur] reachy_mini non disponible. Lance avec --no-replay pour "
+              "tester sans simulation.")
+        sys.exit(1)
+
+    app = SignalReplayApp(mapper.commands)
+
+    with ReachyMini(media_backend="no_media") as robot:
+        stop_event = threading.Event()
+        try:
+            app.run(robot, stop_event)
+        except KeyboardInterrupt:
+            print("\n[Interruption] Arrêt demandé par l'utilisateur.")
+            stop_event.set()
+
+if __name__ == "__main__":
+    main()