commit pour mettre en pause video et gere video sans visage

jericho/emotion.py

@@ -12,6 +12,8 @@ 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
 
@@ -37,6 +39,7 @@ 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):
@@ -51,6 +54,7 @@ class EMAFilter: # classe pour lisser les mouvements afin d eviter les micromouv
         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]) 
 
@@ -112,6 +116,7 @@ def brow_furrow(lms, w, h): #froncement des sourcils
     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é
@@ -157,21 +162,29 @@ def emotions_records(records): # fonction analyse la video pour trouver les émo
         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" 
             
@@ -193,7 +206,7 @@ def annotate_frame(frame, lms, sig, w, h): # fonction pour annoter la video
     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
+# 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) 
 
@@ -226,30 +239,83 @@ def annotate_frame(frame, lms, sig, w, h): # fonction pour annoter la video
     return frame # retourne l image annoté
 
 
-def merge_audio(original_video, silent_video, output_path): # remet son de la video original
+def _ffmpeg_available():
     try:
-        subprocess.run( # exécute une commande système pour vérifier FFmpeg
-            ["ffmpeg", "-version"], 
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True 
+        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 
-
-    # Correction de la commande pour forcer le codec H.264 (libx264)
-    cmd = [ # combine son et video
-        "ffmpeg", "-y", 
-        "-i", silent_video, 
-        "-i", original_video, 
-        "-c:v", "libx264",       # Encodage en H.264 compatible navigateurs web
-        "-pix_fmt", "yuv420p",   # Format de pixels standard pour le web
-        "-c:a", "aac",           # Encodage audio standard
-        "-map", "0:v:0", 
-        "-map", "1:a:0", 
-        "-shortest", 
-        output_path 
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("\n   ffmpeg introuvable.")
+        return False
+
+
+def _face_frame_runs(records):
+    #Retourne les blocs continus de frames où un visage est détecté
+    runs = []
+    start = None
+    previous = None
+
+    for item in records:
+        rec = item["rec"]
+        frame = int(rec.get("frame", 0))
+        if rec.get("face_detected", False):
+            if start is None:
+                start = frame
+            previous = frame
+        elif start is not None:
+            runs.append((start, previous))
+            start = None
+            previous = None
+
+    if start is not None:
+        runs.append((start, previous))
+    return runs
+
+
+def merge_filtered_audio(original_video, silent_video, output_path, face_runs, fps):
+   
+    #Recolle l'audio en supprimant les mêmes intervalles que les frames sans visage.
+    #Si l'audio n'est pas disponible, la vidéo muette reste utilisée.
+    
+    if not _ffmpeg_available():
+        return False
+
+    if not face_runs:
+        return False
+
+    # Trop de micro-coupures peut créer une commande ffmpeg très longue.
+    # Dans ce cas, on garde la vidéo synchronisée robot/visuel sans audio.
+    if len(face_runs) > 300:
+        print("   Trop de segments audio à concaténer : export vidéo muette synchronisée.")
+        return False
+
+    # aselect garde uniquement les morceaux où un visage existait, puis asetpts compacte la timeline audio.
+    expr_parts = []
+    for start, end in face_runs:
+        t0 = start / fps
+        t1 = (end + 1) / fps
+        expr_parts.append(rf"between(t\,{t0:.6f}\,{t1:.6f})")
+    select_expr = "+".join(expr_parts)
+    filter_complex = f"[1:a]aselect={select_expr},asetpts=N/SR/TB[a]"
+
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", silent_video,
+        "-i", original_video,
+        "-filter_complex", filter_complex,
+        "-map", "0:v:0",
+        "-map", "[a]",
+        "-c:v", "libx264",
+        "-pix_fmt", "yuv420p",
+        "-c:a", "aac",
+        "-shortest",
+        output_path,
     ]
-    result = subprocess.run(cmd, capture_output=True, text=True) # exécute la ligne de commande
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print("   Audio filtré impossible, export vidéo muette synchronisée.")
     return result.returncode == 0
 
 
@@ -329,76 +395,104 @@ def process_video(video_path, output_dir):
                 "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é
+                "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  dico, et les points originaux 'lms', à la liste globale
-        else: # si l'IA n'a pas trouvé de visage
-            records.append({ # ajoute un petit dicto indiquant que la tete n a pas été detecte
+            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
+        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
+    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  fonction FACS pour déduire les emotions de tous les dico d'un coup
+    # 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
 
-   
-    print("\nCréation de la vidéo avec affichage des émotions...") # informe du début de la passe graphique
-    cap = cv2.VideoCapture(video_path) # reouvre 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)
-    
-    
-    fourcc = cv2.VideoWriter_fourcc(*"avc1") # pour la compatibilité avec du web
-    writer = cv2.VideoWriter(silent_path, fourcc, fps, (W, H)) # écrit 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 est présent
-                frame = annotate_frame(frame, item["lms"], item["rec"], W, H) # on dessine tout par-dessus
-            else: 
-                cv2.putText(frame, "Visage non detecte", (20,40), #  
-                            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
+    face_runs = _face_frame_runs(records)
+    valid_count = sum(1 for item in records if item["rec"].get("face_detected", False))
+    skipped_count = len(records) - valid_count
 
-    cap.release() 
-    writer.release() 
+    if valid_count == 0:
+        sys.exit("Aucun visage détecté : impossible de créer une timeline synchronisée.")
 
-   
-    if merge_audio(video_path, silent_path, final_path): # recolle son originel
-        os.remove(silent_path) 
+
+    print("\n Création de la vidéo synchronisée avec les frames sans visage supprimées...")
+    cap = cv2.VideoCapture(video_path)
+    silent_path = os.path.join(output_dir, "_annotated_silent.mp4")
+    final_path  = os.path.join(output_dir, "output_annotated.mp4")
+
+    # Codec H.264 pour le Web ; fallback mp4v si OpenCV n'a pas avc1.
+    fourcc = cv2.VideoWriter_fourcc(*"avc1")
+    writer = cv2.VideoWriter(silent_path, fourcc, fps, (W, H))
+    if not writer.isOpened():
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(silent_path, fourcc, fps, (W, H))
+
+    compact_records = []
+    idx = 0 # Compteur d'images d'origine
+    out_idx = 0 # Compteur d'images de la vidéo finale compacte
+
+    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...
+                rec = dict(item["rec"])
+                rec["original_frame"] = rec["frame"]
+                rec["original_timestamp_s"] = rec["timestamp_s"]
+                rec["frame"] = out_idx
+                rec["timestamp_s"] = round(out_idx / fps, 4)
+
+                frame = annotate_frame(frame, item["lms"], rec, W, H) #  On dessine tout par-dessus
+                writer.write(frame) # Enregistre uniquement les frames valides
+                compact_records.append(rec)
+                out_idx += 1
+
+        idx += 1 # Passe à la suivante
+
+    cap.release() # Relâche la vidéo originale
+    writer.release() # Clôture le fichier vidéo annoté
+
+    if merge_filtered_audio(video_path, silent_path, final_path, face_runs, fps):
+        os.remove(silent_path)
     else:
-        os.replace(silent_path, final_path) 
-
-    json_path = os.path.join(output_dir, "signals.json") # save fichier json
-    with open(json_path, "w", encoding="utf-8") as f: 
-        json_records = [item["rec"] for item in records] # extrait uniquement les dicos rec
-        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 
+        os.replace(silent_path, final_path) # Vidéo muette, mais timeline visuelle/robot synchronisée
+
+    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.dump( # Exporte le tout en texte formaté JSON
+            {
+                "video": os.path.abspath(video_path),
+                "output_video": os.path.abspath(final_path),
+                "fps": round(fps, 4),
+                "width": W,
+                "height": H,
+                "total_frames": total,
+                "output_total_frames": len(compact_records),
+                "skipped_no_face_frames": skipped_count,
+                "timeline": "compact_face_only",
+                "frames": compact_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)}/") 
+    print(f"\n  fait, {skipped_count} frames sans visage supprimées. 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
+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) 
+    process_video(args.video, args.output_dir) #

jericho/main.py

@@ -7,18 +7,19 @@ import base64
 import numpy as np
 import sys
 import subprocess
-import shutil
+import shutil  
+import bisect
 from pydantic import BaseModel
 
-# FastAPI pour le site web
+
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 from fastapi import HTTPException, BackgroundTasks
 
+
 from reachy_mini import ReachyMini, ReachyMiniApp
 from reachy_mini.utils import create_head_pose
 
-# 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:
@@ -28,9 +29,6 @@ def load_signals(path: str) -> tuple[dict, list[dict]]:
     print(f"[Chargement] {len(frames)} frames avec visage.")
     return meta, frames
 
-
-# Filtre pour lisser les mouvements pour ne pas les avoir saccadés
-
 def moving_average(values: list[float], window: int = 7) -> np.ndarray:
     arr = np.asarray(values, dtype=float)
     pad = window // 2
@@ -39,24 +37,18 @@ def moving_average(values: list[float], window: int = 7) -> np.ndarray:
     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 : ±5°
-    HEAD_PITCH_MAX      = np.deg2rad(15)   # inclinaison haut/bas tête : ±15°
-    HEAD_ROLL_MAX       = np.deg2rad(15)   # inclinaison latérale tête : ±15°
-    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 : ±15°
-    ANTENNA_MAX         = np.deg2rad(120)  # débattement antennes : ±120°
+    HEAD_YAW_MAX        = np.deg2rad(5)
+    HEAD_PITCH_MAX      = np.deg2rad(15)
+    HEAD_ROLL_MAX       = np.deg2rad(15)
+    HEAD_Y_MAX          = 0.03
+    HEAD_Z_MAX          = 0.03
+    BODY_YAW_MAX        = np.deg2rad(15)
+    ANTENNA_MAX         = np.deg2rad(120)
     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
+    COMBINED_YAW_LIMIT  = np.deg2rad(60)
 
-    # Valeurs d'amplification des mouvements
     YAW_AMP        = 8.0
     PITCH_AMP      = 5.0
     ROLL_AMP       = 3.0
@@ -64,8 +56,8 @@ class SignalMapper:
     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
+    SMOOTH_WINDOW_HEAD    = 7
+    SMOOTH_WINDOW_EMOTION = 11
 
     def __init__(self, frames: list[dict]):
         self.frames = frames
@@ -73,45 +65,29 @@ class SignalMapper:
         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]))
-
-        # Écart type à 0.000001 pour éviter la division par 0 pour le z score
         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
-
-        # Étirement de la bouche
+        self.yaw_mean   = mean("yaw")
+        self.pitch_mean = mean("pitch")
+        self.roll_mean  = mean("roll")
+        self.cx_mean    = mean("face_cx")
+        self.cy_mean    = mean("face_cy")
         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étecté/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)
-
-        # Écartement 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éfinit l'émotion selon les valeurs en entrée
-
     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
@@ -119,23 +95,14 @@ class SignalMapper:
         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étectée
-
     def _compute_antennas(self, emotion, t_state):
         left_antenna, right_antenna = 0.0, 0.0
         if emotion == "TRISTESSE":
@@ -177,17 +144,6 @@ class SignalMapper:
             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])
@@ -269,97 +225,168 @@ class SignalMapper:
         return float(max(-limit, min(limit, value)))
 
 
-# Modèle de données pour la réception de la vidéo via l'API
-
 class VideoPayload(BaseModel):
-    name: str        # Nom du projet
-    file_data: str   # Contenu de la vidéo encodé en base64 pour la methode POST /api/upload car la video est en binaire et ne peut pas être envoyée directement
+    name: str
+    file_data: str
 
-
-# Application principale : contrôle du robot et serveur web
+class PlaybackPayload(BaseModel):
+    project_name: str | None = None
+    current_time: float = 0.0
+    playing: bool | None = None
+    action: str = "sync"
 
 class Jericho(ReachyMiniApp):
-
     custom_app_url: str | None = "http://0.0.0.0:8042"
     request_media_backend: str | None = None
 
-    # Refait les mouvements sur le robot en synchronisation avec le timestamp vidéo
-    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        
+        self.antennas_enabled = True
+        self.sound_play_requested = False
+        self.play_robot_requested = False
+        self.current_commands = []
+        self.current_timestamps = []
+        self.current_project_name = None
+        self.playback_lock = threading.Lock()
+        self.playback_state = {
+            "project_name": None,
+            "playing": False,
+            "current_time": 0.0,
+            "updated_at": time.time(),
+            "dirty": False,
+            "stop_requested": False,
+        }
         
-        # --- 1. DÉCLARATION DES VARIABLES D'ÉTAT SANS __init__ ---
-        antennas_enabled = True
-        sound_play_requested = False
-        play_robot_requested = False
-        current_commands = []
-
-        # Chemins vers les dossiers
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        projects_dir = os.path.join(current_dir, "projects")
-        os.makedirs(projects_dir, exist_ok=True)
-        static_dir = os.path.join(current_dir, "static")
-
-        # --- 2. CONFIGURATION DES ROUTES WEB ---
-        if os.path.exists(static_dir):
-            self.settings_app.mount("/static", StaticFiles(directory=static_dir), name="static")
-        self.settings_app.mount("/projects", StaticFiles(directory=projects_dir), name="projects")
+        self.current_dir = os.path.dirname(os.path.abspath(__file__))
+        self.projects_dir = os.path.join(self.current_dir, "projects")
+        os.makedirs(self.projects_dir, exist_ok=True)
+        self.static_dir = os.path.join(self.current_dir, "static")
+
+        self._setup_routes()
+
+    def _load_project_commands(self, project_name: str) -> int:
+       
+        with self.playback_lock:
+            if project_name == self.current_project_name and self.current_commands:
+                return len(self.current_commands)
+
+        signals_path = os.path.join(self.projects_dir, project_name, "signals.json")
+        if not os.path.exists(signals_path):
+            raise HTTPException(status_code=404, detail="Fichier signals.json introuvable.")
+
+        meta, frames = load_signals(signals_path)
+        if not frames:
+            raise HTTPException(status_code=400, detail="Aucune frame avec visage dans signals.json.")
+
+        mapper = SignalMapper(frames)
+        commands = mapper.commands
+        timestamps = [cmd["timestamp_s"] for cmd in commands]
+
+        with self.playback_lock:
+            self.current_project_name = project_name
+            self.current_commands = commands
+            self.current_timestamps = timestamps
+
+        return len(commands)
+
+    def _set_playback_state(self, project_name: str | None, current_time: float, playing: bool, *, dirty: bool = True, stop_requested: bool = False):
+        with self.playback_lock:
+            self.playback_state.update({
+                "project_name": project_name,
+                "playing": playing,
+                "current_time": max(0.0, float(current_time)),
+                "updated_at": time.time(),
+                "dirty": dirty,
+                "stop_requested": stop_requested,
+            })
+
+    def _setup_routes(self):
+        if os.path.exists(self.static_dir):
+            self.settings_app.mount("/static", StaticFiles(directory=self.static_dir), name="static")
+        self.settings_app.mount("/projects", StaticFiles(directory=self.projects_dir), name="projects")
 
         @self.settings_app.get("/")
         def serve_index():
-            return FileResponse(os.path.join(static_dir, "index.html"))
+            return FileResponse(os.path.join(self.static_dir, "index.html"))
 
         def process_in_background(video_path: str, proj_path: str, proj_name: str):
             status_file = os.path.join(proj_path, "status.txt")
             try:
                 with open(status_file, "w") as f: f.write("PROCESSING")
-                print(f"[{proj_name}] Lancement de l'ia.")
-
-                emotion_script = os.path.join(current_dir, "emotion.py")
-
+                print(f"[{proj_name}] Lancement de l'IA dans un processus isolé...")
+                
+                emotion_script = os.path.join(self.current_dir, "emotion.py")
+                
                 process = subprocess.run(
                     [sys.executable, emotion_script, "--video", video_path, "--output_dir", proj_path],
                     capture_output=True, text=True
                 )
-
+                
                 if process.returncode == 0:
-                    with open(status_file, "w") as f: f.write("DONE")
-                    print(f"[{proj_name}] Analyse terminée avec succès !")
+                    
+                    signals_path = os.path.join(proj_path, "signals.json")
+                    valid_project = False
+                    
+                    if os.path.exists(signals_path):
+                        try:
+                            with open(signals_path, "r", encoding="utf-8") as f:
+                                data = json.load(f)
+                            frames = [fr for fr in data.get("frames", []) if fr.get("face_detected", False)]
+                            
+                           
+                            if frames and (frames[-1]["timestamp_s"] - frames[0]["timestamp_s"] >= 1.0):
+                                valid_project = True
+                        except Exception:
+                            valid_project = False
+
+                    if valid_project:
+                        with open(status_file, "w") as f: f.write("DONE")
+                        print(f"[{proj_name}] Analyse terminée avec succès !")
+                    else:
+                      
+                        output_video = os.path.join(proj_path, "output_annotated.mp4")
+                        if os.path.exists(output_video):
+                            os.remove(output_video)
+                            
+                        with open(status_file, "w") as f: f.write("ERROR: NO_FACE_DETECTED")
+                        print(f"[{proj_name}]  Rejeté : pas de visage detecté")
                 else:
                     err = process.stderr.strip()
                     clean_err = err.split('\n')[-1] if err else "Crash silencieux de Mediapipe"
                     err_msg = f"ERROR: L'IA a planté. Détail: {clean_err}"
                     with open(status_file, "w") as f: f.write(err_msg)
                     print(f"[{proj_name}]  Erreur : {err_msg}\n-- Log Terminal :\n{err}")
-
+                    
             except Exception as e:
                 error_msg = f"ERROR: {type(e).__name__} - {str(e)}"
                 with open(status_file, "w") as f: f.write(error_msg)
                 print(f"[{proj_name}]  Exception système : {error_msg}")
-
         @self.settings_app.post("/api/upload")
         def upload_video(payload: VideoPayload, bg_tasks: BackgroundTasks):
-            project_path = os.path.join(projects_dir, payload.name)
+            project_path = os.path.join(self.projects_dir, payload.name)
             os.makedirs(project_path, exist_ok=True)
             input_video_path = os.path.join(project_path, "input.mp4")
-
+            
             header, encoded = payload.file_data.split(",", 1) if "," in payload.file_data else ("", payload.file_data)
             with open(input_video_path, "wb") as f:
                 f.write(base64.b64decode(encoded))
-
+            
             bg_tasks.add_task(process_in_background, input_video_path, project_path, payload.name)
             return {"status": "accepted"}
 
         @self.settings_app.get("/api/library")
         def get_library():
             projects = []
-            for folder in os.listdir(projects_dir):
-                folder_path = os.path.join(projects_dir, folder)
+            for folder in os.listdir(self.projects_dir):
+                folder_path = os.path.join(self.projects_dir, folder)
                 if os.path.isdir(folder_path):
                     status_path = os.path.join(folder_path, "status.txt")
                     status = "UNKNOWN"
                     if os.path.exists(status_path):
                         with open(status_path, "r") as f:
                             status = f.read().strip()
-
+                    
                     if os.path.exists(os.path.join(folder_path, "output_annotated.mp4")):
                         projects.append({
                             "name": folder,
@@ -374,9 +401,11 @@ class Jericho(ReachyMiniApp):
                         })
             return projects
 
+        
         @self.settings_app.delete("/api/projects/{project_name}")
         def delete_project(project_name: str):
-            project_path = os.path.join(projects_dir, project_name)
+           
+            project_path = os.path.join(self.projects_dir, project_name)
             if os.path.exists(project_path) and os.path.isdir(project_path):
                 try:
                     shutil.rmtree(project_path)
@@ -386,75 +415,122 @@ class Jericho(ReachyMiniApp):
                     raise HTTPException(status_code=500, detail=f"Erreur de suppression: {str(e)}")
             raise HTTPException(status_code=404, detail="Projet introuvable.")
 
+        @self.settings_app.post("/api/playback")
+        def sync_playback(payload: PlaybackPayload):
+          
+            action = (payload.action or "sync").lower()
+            project_name = payload.project_name or self.current_project_name
+            current_time = max(0.0, float(payload.current_time or 0.0))
+
+            if action == "stop":
+                self._set_playback_state(project_name, current_time, False, dirty=False, stop_requested=True)
+                return {"status": "ok", "action": action}
+
+            if not project_name:
+                raise HTTPException(status_code=400, detail="Aucun projet sélectionné.")
+
+            try:
+                commands_loaded = self._load_project_commands(project_name)
+            except HTTPException:
+                raise
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=str(e))
+
+            if action == "pause":
+                playing = False
+                dirty = True
+            elif action == "seek":
+                with self.playback_lock:
+                    current_playing = bool(self.playback_state.get("playing", False))
+                playing = current_playing if payload.playing is None else bool(payload.playing)
+                dirty = True
+            elif action in {"play", "start"}:
+                playing = True
+                dirty = True
+            else: 
+                playing = bool(payload.playing) if payload.playing is not None else True
+                dirty = False
+
+            self._set_playback_state(project_name, current_time, playing, dirty=dirty, stop_requested=False)
+            return {"status": "ok", "action": action, "commands_loaded": commands_loaded}
+
         @self.settings_app.post("/api/play_movement/{project_name}")
         def trigger_movement(project_name: str):
-            nonlocal current_commands, play_robot_requested
-            signals_path = os.path.join(projects_dir, project_name, "signals.json")
-            if not os.path.exists(signals_path):
-                raise HTTPException(status_code=404, detail="Fichier signals.json introuvable.")
-
+            
             try:
-                meta, frames = load_signals(signals_path)
-                mapper = SignalMapper(frames)
-                current_commands = mapper.commands
-                play_robot_requested = True
-                return {"status": "ok", "commands_loaded": len(current_commands)}
+                commands_loaded = self._load_project_commands(project_name)
+                self._set_playback_state(project_name, 0.0, True, dirty=True, stop_requested=False)
+                return {"status": "ok", "commands_loaded": commands_loaded}
+            except HTTPException:
+                raise
             except Exception as e:
                 raise HTTPException(status_code=500, detail=str(e))
 
-        # --- 3. BOUCLE DE MOUVEMENT DU ROBOT ---
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
         reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0)
         time.sleep(1.2)
 
         while not stop_event.is_set():
-            if not play_robot_requested or not current_commands:
-                time.sleep(0.1)
-                continue
-
-            play_robot_requested = False
-            commands_to_play = list(current_commands)
-
-            start_wall = time.time()
-            video_offset = commands_to_play[0]["timestamp_s"]
-            idx = 0
-            n = len(commands_to_play)
-
-            while not stop_event.is_set() and idx < n:
+            with self.playback_lock:
+                commands_to_play = list(self.current_commands)
+                timestamps = list(self.current_timestamps)
+                state = dict(self.playback_state)
 
-                if play_robot_requested:
-                    break
+            if state.get("stop_requested"):
+                reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0)
+                with self.playback_lock:
+                    self.playback_state["stop_requested"] = False
+                    self.playback_state["dirty"] = False
+                time.sleep(0.05)
+                continue
 
-                elapsed = time.time() - start_wall
-                target_t = video_offset + elapsed
+            if not commands_to_play or not timestamps:
+                time.sleep(0.05)
+                continue
 
-                while idx < n - 1 and commands_to_play[idx]["timestamp_s"] < target_t:
-                    idx += 1
+            playing = bool(state.get("playing", False))
+            dirty = bool(state.get("dirty", False))
+            if not playing and not dirty:
+                time.sleep(0.03)
+                continue
 
-                if idx >= n: break
+            now = time.time()
+            if playing:
+                target_t = float(state.get("current_time", 0.0)) + (now - float(state.get("updated_at", now)))
+            else:
+                target_t = float(state.get("current_time", 0.0))
 
-                cmd = commands_to_play[idx]
-                head_dict = cmd["head"]
+            if target_t > timestamps[-1] + 0.20:
+                self._set_playback_state(state.get("project_name"), timestamps[-1], False, dirty=False, stop_requested=True)
+                continue
 
-                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,
-                )
+            idx = bisect.bisect_left(timestamps, max(0.0, target_t))
+            if idx >= len(commands_to_play):
+                idx = len(commands_to_play) - 1
 
-                antennas_target = cmd["antennas"] if antennas_enabled else [0.0, 0.0]
+            cmd = commands_to_play[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=antennas_target, body_yaw=cmd["body_yaw"])
-                except TypeError:
-                    reachy_mini.set_target(head=head_pose, antennas=antennas_target)
+            antennas_target = cmd["antennas"] if self.antennas_enabled else [0.0, 0.0]
 
-                time.sleep(0.01)   
+            try:
+                reachy_mini.set_target(head=head_pose, antennas=antennas_target, body_yaw=cmd["body_yaw"])
+            except TypeError:
+                reachy_mini.set_target(head=head_pose, antennas=antennas_target)
 
-            if not play_robot_requested:
-                reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0)
+            if dirty:
+                with self.playback_lock:
+                    
+                    if self.playback_state.get("updated_at") == state.get("updated_at"):
+                        self.playback_state["dirty"] = False
 
+            time.sleep(0.01 if playing else 0.03)
 
-# Lancement de l'application
 if __name__ == "__main__":
     app = Jericho()
     try:

jericho/projects/fish/signals.json

@@ -0,0 +1,195 @@
+{
+  "video": "C:\\Users\\hugov\\reachy_mini\\my_apps\\jericho\\jericho\\projects\\fish\\input.mp4",
+  "output_video": "C:\\Users\\hugov\\reachy_mini\\my_apps\\jericho\\jericho\\projects\\fish\\output_annotated.mp4",
+  "fps": 29.97,
+  "width": 256,
+  "height": 144,
+  "total_frames": 6812,
+  "output_total_frames": 7,
+  "skipped_no_face_frames": 6800,
+  "timeline": "compact_face_only",
+  "frames": [
+    {
+      "frame": 0,
+      "timestamp_s": 0.0,
+      "face_detected": true,
+      "face_cx": 0.5041,
+      "face_cy": 0.5993,
+      "face_w": 0.1426,
+      "face_h": 0.2724,
+      "bbox_xmin": 0.4328,
+      "bbox_ymin": 0.4631,
+      "bbox_xmax": 0.5754,
+      "bbox_ymax": 0.7355,
+      "yaw": 20.61,
+      "pitch": -5.88,
+      "roll": -24.4,
+      "ear_left": 0.3552,
+      "ear_right": 0.3423,
+      "mar": 0.4183,
+      "smile": 0.9454,
+      "brow_raise_left": 0.0973,
+      "brow_raise_right": 0.1283,
+      "brow_furrow": 0.3575,
+      "emotion": "CONTENT",
+      "original_frame": 362,
+      "original_timestamp_s": 12.0787
+    },
+    {
+      "frame": 1,
+      "timestamp_s": 0.0334,
+      "face_detected": true,
+      "face_cx": 0.4867,
+      "face_cy": 0.5864,
+      "face_w": 0.1723,
+      "face_h": 0.2947,
+      "bbox_xmin": 0.4005,
+      "bbox_ymin": 0.439,
+      "bbox_xmax": 0.5729,
+      "bbox_ymax": 0.7337,
+      "yaw": 19.71,
+      "pitch": -2.08,
+      "roll": -39.22,
+      "ear_left": 0.3216,
+      "ear_right": 0.3117,
+      "mar": 0.3816,
+      "smile": 0.7823,
+      "brow_raise_left": 0.0676,
+      "brow_raise_right": 0.1177,
+      "brow_furrow": 0.3827,
+      "emotion": "NEUTRE",
+      "original_frame": 2441,
+      "original_timestamp_s": 81.448
+    },
+    {
+      "frame": 2,
+      "timestamp_s": 0.0667,
+      "face_detected": true,
+      "face_cx": 0.4762,
+      "face_cy": 0.5905,
+      "face_w": 0.1745,
+      "face_h": 0.2462,
+      "bbox_xmin": 0.3889,
+      "bbox_ymin": 0.4674,
+      "bbox_xmax": 0.5634,
+      "bbox_ymax": 0.7136,
+      "yaw": 43.6,
+      "pitch": 9.84,
+      "roll": -60.06,
+      "ear_left": 0.3956,
+      "ear_right": 0.3608,
+      "mar": 0.3857,
+      "smile": 1.0639,
+      "brow_raise_left": 0.0065,
+      "brow_raise_right": 0.0484,
+      "brow_furrow": 0.5031,
+      "emotion": "JOIE",
+      "original_frame": 2501,
+      "original_timestamp_s": 83.45
+    },
+    {
+      "frame": 3,
+      "timestamp_s": 0.1001,
+      "face_detected": true,
+      "face_cx": 0.4605,
+      "face_cy": 0.5879,
+      "face_w": 0.1804,
+      "face_h": 0.2179,
+      "bbox_xmin": 0.3703,
+      "bbox_ymin": 0.4789,
+      "bbox_xmax": 0.5508,
+      "bbox_ymax": 0.6969,
+      "yaw": 51.33,
+      "pitch": 1.17,
+      "roll": -72.7,
+      "ear_left": 0.4808,
+      "ear_right": 0.5752,
+      "mar": 0.3477,
+      "smile": 0.8995,
+      "brow_raise_left": 0.0225,
+      "brow_raise_right": 0.0464,
+      "brow_furrow": 0.4005,
+      "emotion": "PEUR",
+      "original_frame": 5331,
+      "original_timestamp_s": 177.8777
+    },
+    {
+      "frame": 4,
+      "timestamp_s": 0.1335,
+      "face_detected": true,
+      "face_cx": 0.4809,
+      "face_cy": 0.604,
+      "face_w": 0.1627,
+      "face_h": 0.2473,
+      "bbox_xmin": 0.3996,
+      "bbox_ymin": 0.4803,
+      "bbox_xmax": 0.5622,
+      "bbox_ymax": 0.7276,
+      "yaw": 28.46,
+      "pitch": -2.9,
+      "roll": -43.45,
+      "ear_left": 0.3534,
+      "ear_right": 0.4038,
+      "mar": 0.4107,
+      "smile": 0.8494,
+      "brow_raise_left": 0.0586,
+      "brow_raise_right": 0.0748,
+      "brow_furrow": 0.4035,
+      "emotion": "NEUTRE",
+      "original_frame": 5662,
+      "original_timestamp_s": 188.9221
+    },
+    {
+      "frame": 5,
+      "timestamp_s": 0.1668,
+      "face_detected": true,
+      "face_cx": 0.4915,
+      "face_cy": 0.6195,
+      "face_w": 0.1447,
+      "face_h": 0.2324,
+      "bbox_xmin": 0.4192,
+      "bbox_ymin": 0.5033,
+      "bbox_xmax": 0.5639,
+      "bbox_ymax": 0.7357,
+      "yaw": 27.66,
+      "pitch": -3.79,
+      "roll": -36.34,
+      "ear_left": 0.3412,
+      "ear_right": 0.448,
+      "mar": 0.3767,
+      "smile": 0.764,
+      "brow_raise_left": 0.0665,
+      "brow_raise_right": 0.099,
+      "brow_furrow": 0.3344,
+      "emotion": "NEUTRE",
+      "original_frame": 6053,
+      "original_timestamp_s": 201.9684
+    },
+    {
+      "frame": 6,
+      "timestamp_s": 0.2002,
+      "face_detected": true,
+      "face_cx": 0.4813,
+      "face_cy": 0.5952,
+      "face_w": 0.1594,
+      "face_h": 0.2209,
+      "bbox_xmin": 0.4016,
+      "bbox_ymin": 0.4848,
+      "bbox_xmax": 0.561,
+      "bbox_ymax": 0.7057,
+      "yaw": 45.55,
+      "pitch": 5.15,
+      "roll": -64.75,
+      "ear_left": 0.3412,
+      "ear_right": 0.4439,
+      "mar": 0.3823,
+      "smile": 0.8951,
+      "brow_raise_left": 0.0063,
+      "brow_raise_right": 0.0339,
+      "brow_furrow": 0.4389,
+      "emotion": "NEUTRE",
+      "original_frame": 6777,
+      "original_timestamp_s": 226.1259
+    }
+  ]
+}

jericho/projects/fish/status.txt

@@ -0,0 +1 @@
+ERROR: NO_FACE_DETECTED

jericho/projects/vid_test/status.txt

@@ -1 +0,0 @@
-DONE

jericho/static/index.html

@@ -8,10 +8,10 @@
   </head>
   <body>
     <header>
-      <h1> Jericho projet : Reachy Mini  </h1>
+      <h1>Jericho projet : Reachy Mini</h1>
       <div id="conteneurHeader">
-        <img src="./image/logoReachyMini.png" alt="Photo de reachy" width="10%"/>
-        <div id="robot-status"> Prêt</div>
+        <img src="./image/logoReachyMini.png" alt="Photo de Reachy" width="10%" />
+        <div id="robot-status">Prêt</div>
       </div>
     </header>
 
@@ -20,23 +20,13 @@
         <h2>[↓] Importer votre Vidéo</h2>
         <div class="form-group">
           <label>Nom du projet :</label>
-          <input
-            type="text"
-            id="video-name"
-            placeholder="ex: session_joie_01"
-          />
+          <input type="text" id="video-name" placeholder="ex: session_joie_01" />
         </div>
         <div class="form-group">
           <label for="video-file">Fichier Vidéo :</label>
-          <input
-            type="file"
-            id="video-file"
-            accept="video/mp4,video/quicktime"
-          />
+          <input type="file" id="video-file" accept="video/mp4,video/quicktime" />
         </div>
-        <button id="import-btn" class="btn-primary">
-          Analyser et Enregistrer
-        </button>
+        <button id="import-btn" class="btn-primary">Analyser et Enregistrer</button>
         <p id="import-msg"></p>
       </section>
 
@@ -47,22 +37,22 @@
         </div>
       </section>
 
-      <section id="player-section" class="card">
+      <section id="player-section" class="card hidden">
         <h2 id="current-video-title">Lecture</h2>
         <video id="video-player" controls width="100%"></video>
 
         <div class="sync-controls">
           <button id="launch-sync-btn" class="btn-success">
-            [->] Lancer Vidéo Annotée + Robot
-          </button>
-        </div>
-          <button id="launch-sync-btn" class="btn-success">
-            [->] Lancer Vidéo + Robot
+            [->] Lire vidéo + robot synchronisés
           </button>
+          <p class="sync-hint">
+            Les pauses, reprises et déplacements dans la vidéo sont envoyés au robot.
+            Les frames sans visage sont supprimées de la vidéo traitée et des signaux.
+          </p>
         </div>
       </section>
     </main>
 
     <script src="/static/main.js"></script>
   </body>
-</html>
+</html>

jericho/static/main.js

@@ -1,159 +1,257 @@
 let currentLoadedProject = null; // stocke le nom du projet sélectionné
-const robotStatus = document.getElementById('robot-status'); 
-const videoPlayer = document.getElementById('video-player'); 
-
-document.addEventListener("DOMContentLoaded", () => { 
-    loadLibrary(); // charge la liste des vidéos 
-    setInterval(loadLibrary, 3000); // relance le chargement toutes les 3 secondes pour eviter d avoir a recharger la page a chaque importation
-    
-    const btn = document.getElementById('launch-sync-btn'); // cherche le bouton de lancement
-    if (btn) btn.style.display = 'none'; // cache le bouton s'il est trouvé sur la page
+let syncTimer = null;
+let lastSyncSent = 0;
+const SYNC_INTERVAL_MS = 250;
+
+const robotStatus = document.getElementById('robot-status');
+const videoPlayer = document.getElementById('video-player');
+
+function escapeHtml(value) {
+    return String(value)
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#039;');
+}
+
+async function sendPlayback(action, options = {}) {
+    const projectName = options.projectName || currentLoadedProject;
+    if (!projectName) return;
+
+    const payload = {
+        project_name: projectName,
+        current_time: Number(videoPlayer.currentTime || 0),
+        playing: !videoPlayer.paused && !videoPlayer.ended,
+        action: action,
+        ...options
+    };
+    delete payload.projectName;
+
+    try {
+        const response = await fetch('/api/playback', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload)
+        });
+
+        if (!response.ok) {
+            const result = await response.json().catch(() => ({}));
+            robotStatus.textContent = `Erreur robot : ${result.detail || response.status}`;
+        }
+    } catch (error) {
+        robotStatus.textContent = 'Erreur de connexion.';
+    }
+}
+
+function startSyncLoop() {
+    stopSyncLoop();
+    syncTimer = setInterval(() => {
+        if (!videoPlayer.paused && !videoPlayer.ended) {
+            sendPlayback('sync', { playing: true });
+        }
+    }, SYNC_INTERVAL_MS);
+}
+
+function stopSyncLoop() {
+    if (syncTimer) {
+        clearInterval(syncTimer);
+        syncTimer = null;
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    loadLibrary();
+    setInterval(loadLibrary, 3000);
+
+    const btn = document.getElementById('launch-sync-btn');
+    if (btn) {
+        btn.onclick = () => {
+            if (currentLoadedProject) videoPlayer.play();
+        };
+    }
 });
 
-document.getElementById('import-btn').onclick = function() { //on recupere les infos quand on lance
-    const name = document.getElementById('video-name').value; 
-    const file = document.getElementById('video-file').files[0]; 
-    const msg = document.getElementById('import-msg'); 
+document.getElementById('import-btn').onclick = function() {
+    const name = document.getElementById('video-name').value.trim();
+    const file = document.getElementById('video-file').files[0];
+    const msg = document.getElementById('import-msg');
 
-    if (!name || !file) { // vérifie si y a un nom et un fichier sinon message d erreur
-        msg.textContent = "Erreur : Nom et fichier requis."; 
-        msg.style.color = "red"; 
-        return; 
+    if (!name || !file) {
+        msg.textContent = 'Erreur : Nom et fichier requis.';
+        msg.style.color = 'red';
+        return;
     }
 
-    msg.textContent = " envoie vid au serveur"; 
-    msg.style.color = "#d35400"; 
-    document.getElementById('import-btn').disabled = true; // désactive le bouton pour éviter un double clic
-
-    const reader = new FileReader(); // prépare un outil pour lire la vidéo
-    reader.readAsDataURL(file); // transforme la vidéo en texte
-    
-    reader.onload = async function () { // quand la transformation en texte est terminée
-        const base64data = reader.result; // stocke le résultat texte
-        
-        try { // essaie d'envoyer au serveur
-            const response = await fetch('/api/upload', { // envoie les données à python
-                method: 'POST', 
-                headers: { 'Content-Type': 'application/json' }, 
-                body: JSON.stringify({ name: name, file_data: base64data }) 
+    msg.textContent = 'Envoi vidéo au serveur';
+    msg.style.color = '#d35400';
+    document.getElementById('import-btn').disabled = true;
+
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+
+    reader.onload = async function () {
+        const base64data = reader.result;
+
+        try {
+            const response = await fetch('/api/upload', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name: name, file_data: base64data })
             });
 
-            if (response.ok) { // si python le recoit bien affiche le
-                msg.textContent = ` Vidéo en traitement`; 
-                msg.style.color = "#8269ae"; 
-                document.getElementById('video-name').value = ''; 
-                document.getElementById('video-file').value = ''; 
-            } else {// sinon ca affiche l erreur
-                const result = await response.json(); 
-                msg.textContent = ` Erreur du serveur : ${result.detail}`; 
-                msg.style.color = "red"; 
+            if (response.ok) {
+                msg.textContent = 'Vidéo en traitement';
+                msg.style.color = '#8269ae';
+                document.getElementById('video-name').value = '';
+                document.getElementById('video-file').value = '';
+                loadLibrary();
+            } else {
+                const result = await response.json();
+                msg.textContent = `Erreur du serveur : ${result.detail}`;
+                msg.style.color = 'red';
             }
-        } catch (error) { // si le serveur est injoignable
-            msg.textContent = "Erreur de connexion au serveur."; // affiche une erreur de réseau
-            msg.style.color = "red"; // en rouge
-        } finally { // dans tous les cas à la fin
-            document.getElementById('import-btn').disabled = false; // réactive le bouton importer
+        } catch (error) {
+            msg.textContent = 'Erreur de connexion au serveur.';
+            msg.style.color = 'red';
+        } finally {
+            document.getElementById('import-btn').disabled = false;
         }
     };
 };
 
+window.deleteProject = async function(event, name) {
+    event.stopPropagation();
 
-window.deleteProject = async function(event, name) { // fonction  pour supp un projet
-    event.stopPropagation(); // empêche de lancer la vidéo en même temps
-    
-    if (!confirm(`Voulez-vous vraiment supprimer la video "${name}" ?`)) { 
-        return; 
+    if (!confirm(`Voulez-vous vraiment supprimer la vidéo "${name}" ?`)) {
+        return;
     }
 
-    try { 
-        const response = await fetch(`/api/projects/${name}`, { method: 'DELETE' }); // envoie l'ordre de suppression à python
-        if (response.ok) { 
-            // si on supprime la vidéo qu'on est en train de lire, on cache le lecteur
-            if (currentLoadedProject === name) { 
+    try {
+        if (currentLoadedProject === name) {
+            await sendPlayback('stop', { projectName: name, playing: false });
+        }
+
+        const response = await fetch(`/api/projects/${encodeURIComponent(name)}`, { method: 'DELETE' });
+        if (response.ok) {
+            if (currentLoadedProject === name) {
                 document.getElementById('player-section').classList.add('hidden');
-                currentLoadedProject = null; // efface la mémoire du projet 
-                videoPlayer.pause(); 
-                videoPlayer.src = ""; // retire la source de la vidéo
+                currentLoadedProject = null;
+                videoPlayer.pause();
+                videoPlayer.removeAttribute('src');
+                videoPlayer.load();
+                stopSyncLoop();
             }
-            loadLibrary(); // rafraichit  l'affichage
-        } else { 
-            alert(" Erreur lors de la suppression."); // affiche une alerte d'erreur
+            loadLibrary();
+        } else {
+            alert('Erreur lors de la suppression.');
         }
-    } catch (error) { 
-        alert(" Erreur de connexion au serveur.");
+    } catch (error) {
+        alert('Erreur de connexion au serveur.');
     }
 };
 
-async function loadLibrary() { // fonction qui charge la liste des vidéos
-    try { 
-        const response = await fetch('/api/library'); // demande les projets à python
-        const projects = await response.json(); 
-        const container = document.getElementById('video-library'); // cible la zone d'affichage de la bibliothèque
-        
-        let newHTML = ""; 
-        if (projects.length === 0) { 
-            newHTML = '<p class="empty-text">Aucune vidéo traitée.</p>'; // affiche un message par défaut
-        } else { 
-            projects.forEach(video => { // boucle sur chaque vidéo
-                // La poubelle
-                const deleteBtn = `<span onclick="deleteProject(event, '${video.name}')" style="position:absolute; top:2px; right:4px; font-size:16px; cursor:pointer;" title="Supprimer définitivement">x</span>`;
-
-                if (video.status === "DONE") { // si l'analyse est terminée avec succès
-                    newHTML += `<div class="video-item" onclick="loadVideoPlayer('${video.name}', '${video.url}')" style="position:relative; border: 2px solid green;">
+async function loadLibrary() {
+    try {
+        const response = await fetch('/api/library');
+        const projects = await response.json();
+        const container = document.getElementById('video-library');
+
+        let newHTML = '';
+        if (projects.length === 0) {
+            newHTML = '<p class="empty-text">Aucune vidéo traitée.</p>';
+        } else {
+            projects.forEach(video => {
+                const safeName = escapeHtml(video.name);
+                const deleteBtn = `<span onclick="deleteProject(event, ${JSON.stringify(video.name).replaceAll('"', '&quot;')})" style="position:absolute; top:2px; right:4px; font-size:16px; cursor:pointer;" title="Supprimer définitivement">x</span>`;
+
+                if (video.status === 'DONE') {
+                    const nameArg = JSON.stringify(video.name).replaceAll('"', '&quot;');
+                    const urlArg = JSON.stringify(video.url).replaceAll('"', '&quot;');
+                    newHTML += `<div class="video-item" onclick="loadVideoPlayer(${nameArg}, ${urlArg})" style="position:relative; border: 2px solid green;">
                                     ${deleteBtn}
-                                    <br><strong>${video.name}</strong><br><span style="color:green; font-size:12px;"> Prêt</span>
-                                </div>`; // crée un bloc vert cliquable
-                } else if (video.status === "PROCESSING") { // si l'analyse est en cours
+                                    <br><strong>${safeName}</strong><br><span style="color:green; font-size:12px;">Prêt</span>
+                                </div>`;
+                } else if (video.status === 'PROCESSING') {
                     newHTML += `<div class="video-item" style="position:relative; opacity: 0.7; cursor: wait; border: 2px dashed orange;">
                                     ${deleteBtn}
-                                    <br><strong>${video.name}</strong><br><span style="color:#d35400; font-size:12px;">Calcul en cours</span>
-                                </div>`; // crée un bloc orange en pointillé
-                } else if (video.status && video.status.startsWith("ERROR")) { // si une erreur s'est produite côté python
-                    newHTML += `<div class="video-item" style="position:relative; border: 2px solid red; cursor: not-allowed;" title="${video.status}">
+                                    <br><strong>${safeName}</strong><br><span style="color:#d35400; font-size:12px;">Calcul en cours</span>
+                                </div>`;
+                } else if (video.status === 'ERROR: NO_FACE_DETECTED') {
+                    newHTML += `<div class="video-item" style="position:relative; border: 2px solid red; cursor: not-allowed;" title="La vidéo avec visage détecté doit faire au moins 2 secondes.">
+                                    ${deleteBtn}
+                                    <br><strong>${safeName}</strong><br><span style="color:red; font-size:11px;">Aucun visage détecté</span>
+                                </div>`;
+                } else if (video.status && video.status.startsWith('ERROR')) {
+                    newHTML += `<div class="video-item" style="position:relative; border: 2px solid red; cursor: not-allowed;" title="${escapeHtml(video.status)}">
                                     ${deleteBtn}
-                                    <br><strong>${video.name}</strong><br><span style="color:red; font-size:11px;">Échec (Survolez)</span>
-                                </div>`; // crée un bloc rouge avec erreur au survol
-                } else { // si l'état est indéterminé
+                                    <br><strong>${safeName}</strong><br><span style="color:red; font-size:11px;">Échec (survolez)</span>
+                                </div>`;
                      newHTML += `<div class="video-item" style="position:relative; opacity: 0.5; cursor: wait;">
                                     ${deleteBtn}
-                                    <br><strong>${video.name}</strong><br><span style="color:gray; font-size:12px;">En attente</span>
-                                </div>`; // crée un bloc grisé
+                                    <br><strong>${safeName}</strong><br><span style="color:gray; font-size:12px;">En attente</span>
+                                </div>`;
                 }
             });
         }
-        
-        if (container.innerHTML !== newHTML) { 
-            container.innerHTML = newHTML; 
+
+        if (container.innerHTML !== newHTML) {
+            container.innerHTML = newHTML;
         }
-    } catch (error) { 
-        console.error("Erreur de bibliothèque."); 
+    } catch (error) {
+        console.error('Erreur de bibliothèque.', error);
     }
 }
 
-window.loadVideoPlayer = function(name, url) { // charge une vidéo dans le lecteur
-    currentLoadedProject = name; // mémorise le nom du projet sélectionné
-    document.getElementById('player-section').classList.remove('hidden'); // rend le lecteur visible
-    document.getElementById('current-video-title').textContent = "Projet : " + name; 
-    videoPlayer.src = url; // donne le chemin du fichier au lecteur
-    videoPlayer.load(); // charge la video
-    
-    
-};
-
-videoPlayer.onplay = async function() { // quand la lecture de la vidéo commence
-    if (!currentLoadedProject) return; // annule si aucun projet n'est chargé
-   
-    try { // tente d'envoyer l'ordre
-        await fetch(`/api/play_movement/${currentLoadedProject}`, { method: 'POST' }); // demande à python de jouer le mouvement
-    } catch (error) { // si la communication échoue
-        robotStatus.textContent = "Erreur de connexion."; // affiche l'erreur
+window.loadVideoPlayer = async function(name, url) {
+    if (currentLoadedProject && currentLoadedProject !== name) {
+        await sendPlayback('stop', { projectName: currentLoadedProject, playing: false });
     }
-};
 
-videoPlayer.onpause = function() { // quand la vidéo est mise sur pause
-    robotStatus.textContent = " En pause"; // met à jour le texte
+    currentLoadedProject = name;
+    document.getElementById('player-section').classList.remove('hidden');
+    document.getElementById('current-video-title').textContent = 'Projet : ' + name;
+    videoPlayer.src = url;
+    videoPlayer.load();
+    robotStatus.textContent = 'Vidéo chargée';
 };
 
-videoPlayer.onended = function() { // quand la vidéo est terminée
-    robotStatus.textContent = " Terminé "; // met à jour le texte
-};
+videoPlayer.addEventListener('play', () => {
+    if (!currentLoadedProject) return;
+    robotStatus.textContent = 'Lecture synchronisée';
+    sendPlayback('play', { playing: true });
+    startSyncLoop();
+});
+
+videoPlayer.addEventListener('pause', () => {
+    if (!currentLoadedProject || videoPlayer.ended) return;
+    robotStatus.textContent = 'En pause';
+    sendPlayback('pause', { playing: false });
+    stopSyncLoop();
+});
+
+videoPlayer.addEventListener('seeking', () => {
+    if (!currentLoadedProject) return;
+    sendPlayback('seek', { playing: !videoPlayer.paused && !videoPlayer.ended });
+});
+
+videoPlayer.addEventListener('seeked', () => {
+    if (!currentLoadedProject) return;
+    sendPlayback('seek', { playing: !videoPlayer.paused && !videoPlayer.ended });
+});
+
+videoPlayer.addEventListener('timeupdate', () => {
+    if (!currentLoadedProject || videoPlayer.paused || videoPlayer.ended) return;
+
+    const now = Date.now();
+    if (now - lastSyncSent >= SYNC_INTERVAL_MS) {
+        lastSyncSent = now;
+        sendPlayback('sync', { playing: true });
+    }
+});
+
+videoPlayer.addEventListener('ended', () => {
+    robotStatus.textContent = 'Terminé';
+    sendPlayback('stop', { playing: false });
+    stopSyncLoop();
+});

jericho/static/style.css

@@ -116,4 +116,9 @@ input[type="text"], input[type="number"] {
 
 #video-file{
     color:#a34952;
-}
+}
+.sync-hint {
+    font-size: 0.9rem;
+    color: #74424a;
+    margin-bottom: 0;
+}