Version finale fonctionnelle commentée

coquille/Jalon2OPTI.py

@@ -1,45 +1,66 @@
 import time
-import cv2
+import cv2                              # OpenCV : lecture/écriture vidéo et dessin
 from mediapipe.tasks import python
 from mediapipe.tasks.python import vision
 from mediapipe import Image, ImageFormat
-import numpy as np
+import numpy as np                      # Calculs mathématiques/matrices
 import urllib.request
 import csv
-import os
-import sys
+import os                               # Manip de chemins et fichiers
+import sys                              # Accès aux arguments de la ligne de commande
 import subprocess
 import shutil
 
+### LECTURE DES ARGUMENTS ET DES CHEMINS ###
+
+# On s'assure qu'on a bien mis la vidéo en argument
 if len(sys.argv) < 2:
     print("Usage: python Jalon2OPTI.py <video_file> [nom_personnalise]")
     sys.exit(1)
 
+# Récupération du chemin absolu vers la vidéo d'entrée
 video_path = sys.argv[1]
 if not os.path.exists(video_path):
     print(f"Erreur: Le fichier '{video_path}' n'existe pas.")
     sys.exit(1)
 
+# On extrait le nom de fichier et son extension pour construire les sorties
 video_name_with_ext = os.path.basename(video_path)
 video_ext = os.path.splitext(video_name_with_ext)[1]
 
+
+# Si un nom personnalisé est fourni en 2eme argument on l'utilise
+# sinon on prend le nom du fichier sans extension
 if len(sys.argv) >= 3 and sys.argv[2].strip():
     video_name = sys.argv[2].strip()
 else:
     video_name = os.path.splitext(video_name_with_ext)[0]
 
+# Dossier où se trouve ce code
 dossier = os.path.dirname(os.path.abspath(sys.argv[0]))
 
+# Vidéo landmarkée (format final h264 pour le navigateur)
 output_video_path = os.path.join(dossier, f"./liste/landmarks/{video_name}(landmarks){video_ext}")
+
+# Fichier CSV contenant tous les signaux extraits image par image
 output_csv_path = os.path.join(dossier, f"./liste/csv/{video_name}.csv")
+
+# Vidéo temporaire en mp4v brut (avant conversion h264 par ffmpeg)
 temp_video_path = os.path.join(dossier, f"{video_name}_temp_raw.mp4")
+
+# Audio extrait de la vidéo source (format WAV car Reachy mini ne lit que les .wav)
 output_wav_path = os.path.join(dossier, f"./liste/audio/{video_name}.wav")
 
 print(f"Vidéo d'entrée   : {video_path}")
 print(f"CSV de sortie    : {output_csv_path}")
 print(f"Vidéo annotée    : {output_video_path}")
 
+### CHARGER LE MODÈLE MEDIAPIPE ###
+
+# Chemin local du modèle
 model_path = os.path.join(dossier, "face_landmarker.task")
+
+# Téléchargement auto si le fichier est absent
 if not os.path.exists(model_path):
     print("Téléchargement du modèle face_landmarker...")
     urllib.request.urlretrieve(
@@ -47,28 +68,40 @@ if not os.path.exists(model_path):
         model_path
     )
 
+### CONFIGURATION DU MODÈLE ###
+
 options = vision.FaceLandmarkerOptions(
     base_options=python.BaseOptions(model_asset_path=model_path),
-    running_mode=vision.RunningMode.VIDEO,
-    num_faces=1,
-    min_face_detection_confidence=0.7,
-    min_tracking_confidence=0.5
+    running_mode=vision.RunningMode.VIDEO,   # Mode vidéo : images séquentielles
+    num_faces=1,                             # On ne suit qu'un seul visage à la fois
+    min_face_detection_confidence=0.7,       # Seuil de détection initiale à 70%
+    min_tracking_confidence=0.5              # Seuil de suivi entre les frames à 50%
 )
 detector = vision.FaceLandmarker.create_from_options(options)
 
-cap = cv2.VideoCapture(video_path)
-fps = cap.get(cv2.CAP_PROP_FPS)
-frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-frame_index = 0
+### CHARGER LA VIDÉO ###
+
+cap = cv2.VideoCapture(video_path)          # Ouvre la vidéo en lecture
+fps = cap.get(cv2.CAP_PROP_FPS)             # Récupère le nombre de fps
+frame_width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))   # Largeur en pixels
+frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))  # Hauteur en pixels
+frame_index  = 0                            # Compteur d'image (pour le calcul du timestamp)
 
+
+# VideoWriter : écrit les frames annotées dans un fichier mp4v temporaire
+# On utilise mp4v puis ffmpeg pour le recompresser en h264 ensuite
 fourcc = cv2.VideoWriter_fourcc(*'mp4v')
 out = cv2.VideoWriter(temp_video_path, fourcc, fps, (frame_width, frame_height))
 
+### CRÉATION DU FICHIER CSV ###
+
+# Le CSV contient une ligne par image avec tous les signaux extraits
+# C'est ce fichier que reachy mini va lire dans main.py pour pouvoir bouger
 csv_file = open(output_csv_path, "w", newline="", encoding="utf-8")
 csv_writer = csv.writer(csv_file)
 csv_writer.writerow(["timestamp", "bouche", "oeil_g", "oeil_d", "pitch", "yaw", "roll", "norm_x", "norm_y"])
 
+### FONCTIONS UTILITAIRES ###
 
 def generic_optic(width, height):
     focal_length = width
@@ -78,18 +111,31 @@ def generic_optic(width, height):
 
 
 def compute_head_pose(landmarks, frame_w, frame_h):
+    # Coordonnées 3D d'un modèle de visage générique
     model_points = np.array([
-        [0.0, 0.0, 0.0], [0.0, -330.0, -65.0], [-225.0, 170.0, -135.0],
-        [225.0, 170.0, -135.0], [-150.0, -150.0, -125.0], [150.0, -150.0, -125.0]
+        [0.0,    0.0,    0.0  ],   # bout du nez (référence)
+        [0.0, -330.0, -65.0],  # menton
+        [-225.0, 170.0, -135.0],   # coin oeil gauche
+        [225.0,  170.0, -135.0],   # coin oeil droit
+        [-150.0, -150.0, -125.0],  # coin bouche gauche
+        [150.0, -150.0, -125.0],   # coin bouche droit
     ], dtype=np.float64)
     indices = [1, 152, 33, 263, 61, 291]
+
+    # Coordonnées 2D correspondantes dans l'image courante
     image_points = np.array([[landmarks[i].x * frame_w, landmarks[i].y * frame_h] for i in indices], dtype=np.float64)
     camera_matrix, dist_coeffs = generic_optic(frame_w, frame_h)
+
+    # solvePnP résout des problème de pose : trouve R et t de façon à ce que image_point = K * [R|t] * model_point
     success, rotation_vec, translation_vec = cv2.solvePnP(model_points, image_points, camera_matrix, dist_coeffs,
                                                           flags=cv2.SOLVEPNP_ITERATIVE)
     if not success:
         return None, None, None, None, None
+
+    # Conversion du vecteur de rotation (Rodrigues) en matrice 3x3
     rotation_mat, _ = cv2.Rodrigues(rotation_vec)
+
+    # Décomposition de la matrice pour obtenir les angles d'Euler
     pose_mat = cv2.hconcat([rotation_mat, translation_vec])
     _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)
     return euler_angles[0, 0], euler_angles[1, 0], euler_angles[2, 0], rotation_vec, translation_vec
@@ -100,9 +146,13 @@ def compute_face_position(landmarks, frame_w, frame_h):
     ys = [lm.y for lm in landmarks]
     x_min, x_max = min(xs), max(xs)
     y_min, y_max = min(ys), max(ys)
+
+    # Centre du visage
     center_x = int(((x_min + x_max) / 2) * frame_w)
     center_y = int(((y_min + y_max) / 2) * frame_h)
-    norm_x = ((x_min + x_max) / 2 - 0.5) * 2
+
+    # 0.5 correspond au centre de l'image qui est ramené à 0
+    norm_x = ((x_min + x_max) / 2 - 0.5) * 2 # dans [-1, 1]
     norm_y = ((y_min + y_max) / 2 - 0.5) * 2
     face_w = int((x_max - x_min) * frame_w)
     face_h = int((y_max - y_min) * frame_h)
@@ -112,67 +162,134 @@ def compute_face_position(landmarks, frame_w, frame_h):
 
 
 def draw_axes(frame, rotation_vec, translation_vec, camera_matrix, dist_coeffs, origin):
-    axis_points = np.array([[160.0, 0.0, 0.0], [0.0, 160.0, 0.0], [0.0, 0.0, -160.0]], dtype=np.float64)
+
+    # Points 3D représentant le bout de chaque axe
+    axis_points = np.array([
+        [160.0,   0.0,    0.0  ],   # axe X
+        [0.0, 160.0, 0.0],  # axe Y
+        [0.0,     0.0, -160.0  ],   # axe Z (vers l'avant = Z négatif)
+], dtype=np.float64)
+
+    # Projection des points 3D en coordonnées 2D image
     projected, _ = cv2.projectPoints(axis_points, rotation_vec, translation_vec, camera_matrix, dist_coeffs)
     o = (int(origin[0]), int(origin[1]))
-    cv2.arrowedLine(frame, o, (int(projected[0][0][0]), int(projected[0][0][1])), (0, 0, 255), 2, tipLength=0.3)
-    cv2.arrowedLine(frame, o, (int(projected[1][0][0]), int(projected[1][0][1])), (0, 255, 0), 2, tipLength=0.3)
-    cv2.arrowedLine(frame, o, (int(projected[2][0][0]), int(projected[2][0][1])), (255, 0, 0), 2, tipLength=0.3)
+    cv2.arrowedLine(frame, o, (int(projected[0][0][0]), int(projected[0][0][1])), (0, 0, 255), 2, tipLength=0.3) # Rouge x
+    cv2.arrowedLine(frame, o, (int(projected[1][0][0]), int(projected[1][0][1])), (0, 255, 0), 2, tipLength=0.3) # Vert Y
+    cv2.arrowedLine(frame, o, (int(projected[2][0][0]), int(projected[2][0][1])), (255, 0, 0), 2, tipLength=0.3) # Bleu Z
+
+
+### CRÉATION DES LISTES POUR STOCKER LES SIGNAUX ###
 
+# Ces listes stockent les valeurs extraites image par image.
+# Elles seront normalisées APRÈS la boucle principale (on a besoin du min/max
+# global pour la normalisation donc on ne peut pas le faire tel quel).
 
-list_timestamp, list_mouth_open, list_left_eye_open = [], [], []
-list_right_eye_open, list_pitch, list_yaw = [], [], []
-list_roll, list_norm_x, list_norm_y = [], [], []
+list_timestamp = []   # Temps en s depuis le début de la vidéo
+list_mouth_open = []   # Ouverture de la bouche
+list_left_eye_open = []   # Ouverture oeil gauche
+list_right_eye_open = []   # Ouverture oeil droit
+list_pitch = []   # Inclinaison avant/arrière de la tête
+list_yaw = []   # Rotation gauche/droite de la tête        # pitch, yaw et roll sont en degrés
+list_roll = []   # Inclinaison latérale de la tête
+list_norm_x = []   # Position horizontale normalisée du visage
+list_norm_y = []   # Position verticale normalisée du visage
+
+### BOUCLE PRINCIPALE ###
 
 while True:
-    ret, frame = cap.read()
+    ret, frame = cap.read() # Lit la prochaine frame de la vidéo
     if not ret:
         break
 
+    # Calcul du timestamp en s
     timestamp = frame_index / fps
     frame_index += 1
-    h, w, _ = frame.shape
+    h, w, _ = frame.shape # Dimensions de la frame courante
 
+    # Conversion BGR -> RGB pour MediaPipe car Mediapipe veut du RGB
     rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
     mp_image = Image(image_format=ImageFormat.SRGB, data=rgb_frame)
+
+    # Détection des landmarks, envoi du timestamp en ms
     results = detector.detect_for_video(mp_image, int(timestamp * 1000))
 
-    if results.face_landmarks:
-        landmarks = results.face_landmarks[0]
-        mouth_open = abs(landmarks[13].y - landmarks[14].y)
-        left_eye_open = abs(landmarks[159].y - landmarks[145].y)
+    if results.face_landmarks:  # Si un visage est détécté :
+        landmarks = results.face_landmarks[0]  # Récupère le premier et le seul visage détécté
+
+        mouth_open = abs(landmarks[13].y - landmarks[14].y)  # Ouverture de la bouche
+
+        left_eye_open = abs(landmarks[159].y - landmarks[145].y)  # Ouverture des yeux
         right_eye_open = abs(landmarks[386].y - landmarks[374].y)
-        pitch, yaw, roll, rot_vec, trans_vec = compute_head_pose(landmarks, w, h)
-        center_x, center_y, norm_x, norm_y, face_w, face_h, face_size_ratio, bbox = compute_face_position(landmarks, w,
-                                                                                                          h)
-
-        if pitch is not None:
-            yaw = -yaw
-            pitch = ((pitch + 180) % 360)
-            roll = max(-40, min(40, roll))
-            pitch = max(-40, min(40, pitch))
-            yaw = max(-180, min(180, yaw))
-
-            list_timestamp.append(round(timestamp, 2))
-            list_mouth_open.append(round(mouth_open, 3))
-            list_left_eye_open.append(round(left_eye_open, 3))
-            list_right_eye_open.append(round(right_eye_open, 3))
-            list_pitch.append(round(pitch, 1))
-            list_yaw.append(round(yaw, 1))
-            list_roll.append(round(roll, 1))
-            list_norm_x.append(round(norm_x, 2))
-            list_norm_y.append(round(norm_y, 2))
-
-            for landmark in landmarks:
-                cv2.circle(frame, (int(landmark.x * w), int(landmark.y * h)), 1, (0, 255, 0), -1)
-            cv2.rectangle(frame, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (255, 165, 0), 1)
-            cv2.circle(frame, (center_x, center_y), 5, (0, 165, 255), -1)
-            cv2.drawMarker(frame, (w // 2, h // 2), (128, 128, 128), cv2.MARKER_CROSS, 20, 1)
-            if rot_vec is not None:
-                camera_matrix, dist_coeffs = generic_optic(w, h)
-                draw_axes(frame, rot_vec, trans_vec, camera_matrix, dist_coeffs,
-                          (int(landmarks[1].x * w), int(landmarks[1].y * h)))
+
+        pitch, yaw, roll, rot_vec, trans_vec = compute_head_pose(landmarks, w, h)  # Orientation complète de la tête (pitch / yaw / roll)
+
+        (center_x, center_y,	# Position et taille du visage dans l'image
+         norm_x, norm_y,
+         face_w, face_h,
+         face_size_ratio,
+         bbox) = compute_face_position(landmarks, w, h)
+
+        yaw = -yaw
+        if pitch < 0:
+            pitch += 180
+        else:
+            pitch -= 180			# Convertit yaw et pitch pour que reachy mini les lise correctement
+
+        # Reachy Mini a des valeurs en roll et pitch comprises entre -40 et 40, et entre -180 et 180 pour yaw donc
+        if roll < (-40):
+            roll = -40
+        if roll > (40):
+            roll = 40
+
+        if pitch < (-40):
+            pitch = -40
+        if pitch > (40):
+            pitch = 40
+
+        if yaw < (-180):
+            yaw = -180
+        if yaw > (180):
+            yaw = 180
+
+        print(
+            f"t={timestamp:.2f}s | "
+            f"bouche={mouth_open:.3f} | "
+            f"oeil_g={left_eye_open:.3f} | oeil_d={right_eye_open:.3f} | "
+            f"pitch={pitch:+.1f}° | yaw={yaw:+.1f}° | roll={roll:+.1f}° | "
+            f"pos=({norm_x:+.2f}, {norm_y:+.2f})"
+        )
+
+        list_timestamp.append(round(timestamp, 2))
+        list_mouth_open.append(round(mouth_open, 3))
+        list_left_eye_open.append(round(left_eye_open, 3))
+        list_right_eye_open.append(round(right_eye_open, 3))
+        list_pitch.append(round(pitch, 1))
+        list_yaw.append(round(yaw, 1))
+        list_roll.append(round(roll, 1))
+        list_norm_x.append(round(norm_x, 2))
+        list_norm_y.append(round(norm_y, 2))
+
+        for landmark in landmarks:  # Affichage des landmarks
+            x = int(landmark.x * w)
+            y = int(landmark.y * h)
+            cv2.circle(frame, (x, y), 1, (0, 255, 0), -1)
+
+        x1, y1, x2, y2 = bbox  # Dessine le rectangle autour du visage
+        cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 165, 0), 1)
+
+        cv2.circle(frame, (center_x, center_y), 5, (0, 165, 255), -1)  # Dessine le centre du visage en orange
+
+        cv2.drawMarker(frame, (w // 2, h // 2), (128, 128, 128),  # Croix au centre de l'image
+                       cv2.MARKER_CROSS, 20, 1)
+
+        if rot_vec is not None:  # Si compute_head_pose réussit on execute sinon on arrête pour éviter le crash
+            camera_matrix, dist_coeffs = generic_optic(w, h)
+
+            nose_tip = (int(landmarks[1].x * w), int(landmarks[1].y * h))  # Calcule la position du nez
+            draw_axes(frame, rot_vec, trans_vec, camera_matrix, dist_coeffs, nose_tip)  # Dessine les axes
     elif list_mouth_open:
+
+        # Gestion des erreurs : visage perdu pendant un court instant donc on repete la dernière valeur connue pour que Reachy ne fasse pas de mouvements bizarres
         list_timestamp.append(round(timestamp, 2))
         list_mouth_open.append(list_mouth_open[-1])
         list_left_eye_open.append(list_left_eye_open[-1])
@@ -183,6 +300,8 @@ while True:
         list_norm_x.append(list_norm_x[-1])
         list_norm_y.append(list_norm_y[-1])
     else:
+
+        # Gestion des erreurs : pas de visage détéctés donc on initialise tout à 0
         list_timestamp.append(round(timestamp, 2))
         list_mouth_open.append(0.0)
         list_left_eye_open.append(0.0)
@@ -193,8 +312,10 @@ while True:
         list_norm_x.append(0.0)
         list_norm_y.append(0.0)
 
+    # Écrit la frame landmarkée
     out.write(frame)
 
+# Vérification qu'on ait au moins un visage dans la vidéo
 if not list_mouth_open:
     print("Erreur : aucun visage détecté.")
     cap.release()
@@ -204,36 +325,56 @@ if not list_mouth_open:
     csv_file.close()
     sys.exit(1)
 
+### CONVERSION DES SIGNAUX ###
 
-def norm_list(lst, mi, ma, n_mi, n_ma):
-    return [((i - mi) / (ma - mi)) * (n_ma - n_mi) + n_mi if ma != mi else 0.0 for i in lst]
+def convert_for_rm(values, min_value, max_value, window, gap):
+    if min_value != max_value:
+        return [((i - min_value) / (max_value - min_value)) * window - gap for i in values]
+    return [0.0 for _ in values]
 
+# Normalisation pour Reachy Mini
 
-list_mouth_open = norm_list(list_mouth_open, min(list_mouth_open), max(list_mouth_open), -0.01, 0.01)
-list_norm_x = norm_list(list_norm_x, min(list_norm_x), max(list_norm_x), -0.03, 0.03)
-list_norm_y = norm_list(list_norm_y, min(list_norm_y), max(list_norm_y), -0.0075, 0.0075)
-list_left_eye_open = norm_list(list_left_eye_open, min(list_left_eye_open), max(list_left_eye_open), 0, -50.0)
-list_right_eye_open = norm_list(list_right_eye_open, min(list_right_eye_open), max(list_right_eye_open), 0, 50.0)
+# Ouverture de la bouche comprise entre -0.01 et 0.01
+list_mouth_open = convert_for_rm(list_mouth_open, min(list_mouth_open), max(list_mouth_open), 0.02, 0.01)
 
+# Position horizontale du visage comprise entre -0.03 et 0.03
+list_norm_x = convert_for_rm(list_norm_x, min(list_norm_x), max(list_norm_x), 0.06, 0.03)
+
+# Position verticale du visage comprise entre -0.0075 et 0.0075
+list_norm_y = convert_for_rm(list_norm_y, min(list_norm_y), max(list_norm_y), 0.015 , 0.0075)
+
+# Ouverture oeil gauche comprise entre 0 et 50 degrés (convertis en radian
+list_left_eye_open = convert_for_rm(list_left_eye_open, min(list_left_eye_open), max(list_left_eye_open), 50.0, 0.0)
+
+# Inversion : oeil fermé = antenne baissée, oeil ouvert = antenne levée
+list_left_eye_open = [-i for i in list_left_eye_open]
+
+# Ouverture oeil droit comprise entre 0 et 50 degrés (convertis en radian
+list_right_eye_open = convert_for_rm(list_right_eye_open, min(list_right_eye_open), max(list_right_eye_open), 50.0, 0.0)
+
+
+# Une ligne pour chaque frame analysée du csv
 for i in range(len(list_timestamp)):
     csv_writer.writerow([list_timestamp[i], list_mouth_open[i], list_left_eye_open[i],
                          list_right_eye_open[i], list_pitch[i], list_yaw[i],
                          list_roll[i], list_norm_x[i], list_norm_y[i]])
 
+# on libère les ressources OpenCV et mediapipe en fermant le lecteur vidéo, son writer/ Ferme les fenêtres opencv/ Libère le detecteur mediapipe puis ferme le csv
 cap.release()
 out.release()
 cv2.destroyAllWindows()
 detector.close()
 csv_file.close()
 
+### CONVERSION EN H264 POUR LE NAVIGATEUR ###
 print("\n[H264] Conversion pour compatibilité navigateur...")
 
+# Recherche de ffmpeg dans des chemins systèmes
 ffmpeg_cmd = shutil.which("ffmpeg")
 if not ffmpeg_cmd:
     candidates = [
         r"C:\ffmpeg\bin\ffmpeg.exe",
         r"C:\Program Files\ffmpeg\bin\ffmpeg.exe",
-        r"C:\Users\adril\scoop\shims\ffmpeg.exe",
     ]
     for c in candidates:
         if os.path.exists(c):
@@ -243,6 +384,14 @@ if not ffmpeg_cmd:
 if ffmpeg_cmd:
     safe_output = os.path.join(dossier, f"{video_name}_landmarks_h264.mp4")
 
+    # Options ffmpeg :
+    #   -c:v libx264            pour le h264
+    #   -preset fast            bon compromis vitesse/qualité
+    #   -crf 23                 qualité constante (0=lossless, 51=dégradé max)
+    #   -pix_fmt yuv420p        format de pixel universel (obligatoire pour Safari/iOS)
+    #   -movflags +faststart    place les métadonnées en début de fichier (streaming)
+    #   -an                     supprime la piste audio (elle sera gérée séparément)
+
     result = subprocess.run(
         [ffmpeg_cmd, "-y", "-i", temp_video_path,
          "-c:v", "libx264", "-preset", "fast", "-crf", "23",
@@ -251,15 +400,20 @@ if ffmpeg_cmd:
         capture_output=True, text=True
     )
     if result.returncode == 0:
-        os.remove(temp_video_path)
+        os.remove(temp_video_path)      # Supprime la vidéo temp
         if os.path.exists(output_video_path):
             os.remove(output_video_path)
-        os.rename(safe_output, output_video_path)
+        os.rename(safe_output, output_video_path)   # La déplace vers le dossier
         print("[H264] Succès.")
     else:
+
+        # Si ffmpeg a pas marché, alors il y aura simplement le mp4v
         os.rename(temp_video_path, output_video_path)
         print(f"[H264] ffmpeg a échoué : {result.stderr[-300:]}")
 
+
+### EXTRACTION DE L'AUDIO ###
+
 if ffmpeg_cmd:
     wav_result = subprocess.run(
         [ffmpeg_cmd, "-y", "-i", video_path, "-vn", "-acodec", "pcm_s16le",
@@ -271,4 +425,9 @@ if ffmpeg_cmd:
     else:
         print(f"[WAV] Échec extraction audio : {wav_result.stderr[-200:]}")
 else:
-    print("[WAV] ffmpeg introuvable, pas d'extraction audio.")
+    print("[WAV] ffmpeg introuvable, pas d'extraction audio.")
+
+# Suppression de la vidéo temp
+if os.path.basename(video_path) == "video_temp.mp4":
+    os.remove(video_path)
+    print("[CLEANUP] video_temp.mp4 supprimé.")

coquille/Jalon3.py

@@ -45,20 +45,8 @@ class Test(ReachyMiniApp):
             reachy_mini.media.start_playing()
             reachy_mini.media.push_audio_sample(audio)
 
-            # Tout est pret : signaler au serveur que la lecture commence
-            try:
-                req = urllib.request.Request(
-                    f"{SERVER_URL}/ready",
-                    data=b"{}",
-                    headers={"Content-Type": "application/json"},
-                    method="POST"
-                )
-                urllib.request.urlopen(req, timeout=2)
-                print("[READY] Signal envoye au serveur")
-            except Exception as e:
-                print(f"[READY] Echec signal : {e}")
-
             last_timestamp = 0
+            _ready_sent = False
             for row in rows:
                 if stop_event.is_set():
                     break
@@ -75,6 +63,21 @@ class Test(ReachyMiniApp):
                 head_pose = create_head_pose(x=x_pos, y=y_pos, z=z_pos, pitch=pitch_deg, yaw=yaw_deg, roll=roll_deg)
                 reachy_mini.set_target(head=head_pose, antennas=antennas_rad)
 
+                # Signaler au serveur juste apres le premier set_target
+                if not _ready_sent:
+                    _ready_sent = True
+                    try:
+                        req = urllib.request.Request(
+                            f"{SERVER_URL}/ready",
+                            data=b"{}",
+                            headers={"Content-Type": "application/json"},
+                            method="POST"
+                        )
+                        urllib.request.urlopen(req, timeout=2)
+                        print("[READY] Signal envoye au serveur (premier set_target)")
+                    except Exception as e:
+                        print(f"[READY] Echec signal : {e}")
+
                 time.sleep(float(row['timestamp']) - last_timestamp)
                 last_timestamp = float(row['timestamp'])
 

coquille/main.py

@@ -1,19 +1,20 @@
-# -*- coding: utf-8 -*-
+import threading    # Lancement du thread de lecture CSV sans bloquer le serveur
+import subprocess   # Exécution de Jalon2OPTI.py comme sous-processus Python
 import sys
-import io
-
-# Force la sortie UTF-8 pour éviter les crashs de décodage Unicode avec le daemon Reachy
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
-sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
-
-import threading
-import subprocess
 import os
-import time
-from fastapi import Request
-from fastapi.responses import JSONResponse, FileResponse, StreamingResponse, Response
-from fastapi.staticfiles import StaticFiles
+import time         # Gestion précise du timing pour la synchronisation
+import csv
+from fastapi import Request                                         # Objet requête HTTP
+from fastapi.responses import JSONResponse, FileResponse, StreamingResponse, Response        # Différents types de réponses
+from fastapi.staticfiles import StaticFiles                                                  # Fichiers statiques
 from reachy_mini import ReachyMini, ReachyMiniApp
+from reachy_mini.utils import create_head_pose
+import numpy as np          # Conversion degrés → radians pour les antennes
+import soundfile as sf      # Lecture de fichiers audio WAV
+import scipy.signal
+import yt_dlp               # Téléchargement de vidéos YouTube
+
+### CHEMINS DE SAUVEGARDE ###
 
 DOSSIER = os.path.dirname(os.path.abspath(__file__))
 STATIC = os.path.join(DOSSIER, "static")
@@ -21,56 +22,203 @@ DOSSIER_CSV = os.path.join(DOSSIER, "liste", "csv")
 DOSSIER_LANDMARKS = os.path.join(DOSSIER, "liste", "landmarks")
 DOSSIER_AUDIO = os.path.join(DOSSIER, "liste", "audio")
 
-# Création automatique des dossiers si absents
+# Crée les dossiers si jamais ils sont absents
 os.makedirs(DOSSIER_CSV, exist_ok=True)
 os.makedirs(DOSSIER_LANDMARKS, exist_ok=True)
 os.makedirs(DOSSIER_AUDIO, exist_ok=True)
 
-_apply_proc: subprocess.Popen | None = None
-_ready_event = threading.Event()
-_play_start_time: float = 0.0
-
+### CLASSE PRINCIPALE POUR L'APP ###
 
 class Coquille(ReachyMiniApp):
-    custom_app_url: str | None = "http://localhost:8042"
+    custom_app_url: str | None = "http://localhost:8042"  # URL interne ouverte en local
     request_media_backend: str | None = None
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.robot = None
-        self.stop_event = threading.Event()
+        self.robot: ReachyMini | None = None        # Instance du robot
+
+        # Le robot et la lecture de la vidéo sont prets à démarrer
+        self.robot_ready = threading.Event()
+        self.playback_ready = threading.Event()
+        self.playback_paused = False    # Lecture en pause
+        self.playback_stop = False      # Arret
 
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
         self.robot = reachy_mini
-        self.stop_event = stop_event
-        while not stop_event.is_set():
-            time.sleep(0.1)
+        self.robot_ready.set()
+        print("[ROBOT] Connecté et prêt")
+        stop_event.wait()       # Bloque jusqu'à l'arret de l'app
+
+
+### FONCTIONS UTILITAIRES ###
+
+def interruptible_sleep(seconds: float, app_instance: Coquille):
+    deadline = time.perf_counter() + seconds
+    while time.perf_counter() < deadline:
+        if app_instance.playback_stop:
+            return
+        if app_instance.playback_paused:
+            deadline += 0.01
+        time.sleep(0.01)
+
+
+### PERMET D'ATTENDRE QUE LE ROBOT SOIT LA 2PUIS EXECUTE LE REJEU DE LA LOGIQUE DU JALON 3 ###
+def execute_jalon3_thread(csv_path: str, wav_path: str, app_instance: Coquille):
+
+    # Attente que le robot robot soit là
+    if not app_instance.robot_ready.wait(timeout=15):
+        print("[JALON3] Timeout : robot non connecté")
+        app_instance.playback_ready.set()
+        return
+
+    robot = app_instance.robot
+    if robot is None:
+        print("[JALON3] Robot None — abandon")
+        app_instance.playback_ready.set()
+        return
+
+    try:
+
+        # Chargement du csv
+        with open(csv_path, newline='') as f:
+            rows = list(csv.DictReader(f))
+
+        # Préparer l'audio
+        audio_ok = False
+        if os.path.exists(wav_path):
+            try:
+                # Lecture du .wav
+                audio, samplerate_in = sf.read(wav_path, dtype="float32")
+
+                # Conversion stéréo mono
+                if audio.ndim > 1:
+                    audio = np.mean(audio, axis=1)
+
+
+                output_sr = robot.media.get_output_audio_samplerate()
+                if samplerate_in != output_sr:
+                    audio = scipy.signal.resample(
+                        audio,
+                        int(len(audio) * (output_sr / samplerate_in))
+                    )
+                audio_ok = True
+                print(f"[JALON3] Audio chargé ({len(audio)} samples)")
+            except Exception as e:
+                print(f"[JALON3] Erreur chargement audio : {e}")
+        else:
+            print(f"[JALON3] Pas de fichier WAV : {wav_path}")
+
+        print(f"[JALON3] {len(rows)} frames — signal prêt envoyé")
+
+        # Signaler au JS que tout est prêt
+        app_instance.playback_ready.set()
+
+        # Démarrer l'audio
+        if audio_ok:
+            try:
+                robot.media.start_playing()
+                robot.media.push_audio_sample(audio)
+                print("[JALON3] Audio lancé")
+            except Exception as e:
+                print(f"[JALON3] Erreur démarrage audio : {e}")
+
+        # Boucle de lecture image par image
+        start_time = time.perf_counter()    # T0 de référence pour la synchronisation
 
+        for idx, row in enumerate(rows):
 
+            # Vérification de l'arrêt demandé
+            if app_instance.playback_stop:
+                print(f"[JALON3] Stop à frame {idx}")
+                break
+
+            # Attente de la reprise en pause
+            while app_instance.playback_paused and not app_instance.playback_stop:
+                time.sleep(0.01)
+
+            if app_instance.playback_stop:
+                break
+
+            try:
+                # Construction de la pose de la tête
+                # x = ouverture de bouche (lèvre du robot)
+                # y = position horizontale du visage
+                # z = position verticale du visage
+                # pitch = inclinaison avant/arrière
+                # yaw = rotation gauche/droite
+                # roll = inclinaison latérale
+                head_pose = create_head_pose(
+                    x=float(row["bouche"]),
+                    y=float(row["norm_x"]),
+                    z=float(row["norm_y"]),
+                    pitch=float(row["pitch"]),
+                    yaw=float(row["yaw"]),
+                    roll=float(row["roll"]),
+                )
+
+                # Angles des antennes
+                # oeil g (antenne gauche) et d (antenne droite) en degrés puis conversion en radian pour Reachy
+                antennas_rad = np.deg2rad(np.array([float(row["oeil_g"]), float(row["oeil_d"])]))
+
+                # Envoi de la commande au robot
+                robot.set_target(head=head_pose, antennas=antennas_rad)
+
+                # Syncrhonisation temporelle
+                # Calcul en fonction du tps réel et du timestamp csv avant d'envoyer la prochaine frame
+                ts = float(row["timestamp"])
+                elapsed = time.perf_counter() - start_time
+                sleep_time = ts - elapsed
+                if sleep_time > 0.001:
+                    interruptible_sleep(sleep_time, app_instance)
+
+            except Exception as e:
+                print(f"[JALON3] Erreur frame {idx}: {e}")
+
+        # Arrêter l'audio proprement
+        if audio_ok:
+            try:
+                robot.media.stop_playing()
+            except Exception as e:
+                print(f"[JALON3] Erreur arrêt audio : {e}")
+
+        print("[JALON3] Terminé")
+
+    except Exception as e:
+        print(f"[JALON3] Erreur générale: {e}")
+        app_instance.playback_ready.set()   # Evite le blocage du JS
+
+
+### APP ###
 app = Coquille()
 
+# Appelle le dossier static pour le navigateur
 app.settings_app.mount("/static", StaticFiles(directory=STATIC), name="static")
 
 
 @app.settings_app.get("/")
 def index():
+    # Appelle la page index.html du dossier static
     return FileResponse(os.path.join(STATIC, "index.html"))
 
 
 @app.settings_app.get("/favicon.ico")
 def favicon():
+    # Evite les erreurs 404
     return Response(status_code=204)
 
 
 @app.settings_app.get("/liste")
 def liste():
-    fichiers = os.listdir(DOSSIER_CSV)
-    noms = [f.replace(".csv", "") for f in fichiers if f.endswith(".csv") and f != "resultats.csv"]
+    # Retourne la liste des enregistrements en scannant le dossier csv pour avoir les noms de chaque enregistrement
+    noms = [f[:-4] for f in os.listdir(DOSSIER_CSV) if f.endswith(".csv")]
     return JSONResponse({"noms": noms})
 
 
 @app.settings_app.post("/charger")
 async def charger(request: Request):
+    # Recoit une video locale pour lancer le pipeline ensuite
+    # Sauvegarde la vidéo sur le disque en vdieo_temp.mp4
+    # Lance le Jalon2OPTI puis retourne succès ou erreur en fonction
     form = await request.form()
     video_file = form.get("video")
     nom = (form.get("nom") or "").strip()
@@ -78,194 +226,206 @@ async def charger(request: Request):
     if not video_file or not nom:
         return JSONResponse({"succes": False, "message": "Vidéo ou nom manquant."}, status_code=400)
 
+    # Sauvegarde temporaire de la vidéo chargée
     video_path = os.path.join(DOSSIER, "video_temp.mp4")
-    contents = await video_file.read()
     with open(video_path, "wb") as f:
-        f.write(contents)
+        f.write(await video_file.read())
 
     try:
-        result = subprocess.run(
+        subprocess.run(
             [sys.executable, os.path.join(DOSSIER, "Jalon2OPTI.py"), video_path, nom],
-            cwd=DOSSIER,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            check=True
+            cwd=DOSSIER, capture_output=True, text=True, check=True, timeout=300
         )
-        print(f"[PIPELINE OK]\n{result.stdout}")
-    except subprocess.CalledProcessError as e:
-        print(f"[PIPELINE ERREUR]\nstdout: {e.stdout}\nstderr: {e.stderr}")
-        return JSONResponse({
-            "succes": False,
-            "message": f"Pipeline échoué : {e.stderr or e.stdout or 'erreur inconnue'}"
-        }, status_code=500)
+        print(f"[PIPELINE] OK pour {nom}")
+    except subprocess.CalledProcessError:
+        return JSONResponse({"succes": False, "message": "Pipeline échoué"}, status_code=500)
+    except subprocess.TimeoutExpired:
+        return JSONResponse({"succes": False, "message": "Pipeline timeout"}, status_code=500)
 
     return JSONResponse({"succes": True, "nom": nom})
 
 
-def _kill_apply():
-    global _apply_proc
-    if _apply_proc and _apply_proc.poll() is None:
-        _apply_proc.terminate()
-        try:
-            _apply_proc.wait(timeout=3)
-        except subprocess.TimeoutExpired:
-            _apply_proc.kill()
+@app.settings_app.post("/supprimer")
+async def supprimer(request: Request):
+    # Supprime les fichiers wav video landmarkée et csv d'un enregistrement
+    # Si une vidéo n'a par exemple pas d'audio on l'ignore
+    data = await request.json()
+    nom = data.get("nom")
+    if not nom:
+        return JSONResponse({"succes": False, "message": "Nom manquant"}, status_code=400)
+
+    # Suppression de chaque fichier
+    for path in [
+        os.path.join(DOSSIER_CSV, f"{nom}.csv"),
+        os.path.join(DOSSIER_LANDMARKS, f"{nom}(landmarks).mp4"),
+        os.path.join(DOSSIER_AUDIO, f"{nom}.wav"),
+    ]:
+        if os.path.exists(path):
+            os.remove(path)
+
+    print(f"[DELETE] {nom} supprimé")
+    return JSONResponse({"succes": True})
 
 
 @app.settings_app.post("/play")
 async def play(request: Request):
-    global _apply_proc, _play_start_time
+    # Lance un enregistrement sur le robot
+    # Dans un premier tps, vérifie sur le csv est présent
+    # Réinitialise les play et pause
+    # Remet à 0 l'évent du robot pret
+    # Lance le rejeu dans un thread pour reachy mini
+
+    # Le JS interroge le /is-ready pour savoir quand commencer la vidéo
     data = await request.json()
     nom = data.get("nom", "").strip()
 
     if not nom:
-        return JSONResponse({"succes": False, "message": "Nom manquant."}, status_code=400)
+        return JSONResponse({"succes": False, "message": "Nom manquant"}, status_code=400)
 
     csv_path = os.path.join(DOSSIER_CSV, f"{nom}.csv")
     wav_path = os.path.join(DOSSIER_AUDIO, f"{nom}.wav")
 
     if not os.path.exists(csv_path):
-        return JSONResponse({"succes": False, "message": f"CSV introuvable : {csv_path}"}, status_code=404)
-    if not os.path.exists(wav_path):
-        return JSONResponse({"succes": False, "message": f"WAV introuvable : {wav_path}"}, status_code=404)
-
-    # Nettoyage de l'ancien processus avant d'en ouvrir un nouveau
-    _kill_apply()
-    _ready_event.clear()
-    _play_start_time = time.time()
-
-    apply_script = os.path.join(DOSSIER, "Jalon3.py")
-    _apply_proc = subprocess.Popen(
-        [sys.executable, apply_script, csv_path, wav_path],
-        cwd=DOSSIER,
-    )
-
-    print(f"[PLAY] apply_signals PID {_apply_proc.pid} pour '{nom}'")
-    return JSONResponse({"succes": True, "nom": nom})
+        return JSONResponse({"succes": False, "message": f"CSV introuvable : {nom}"}, status_code=404)
+
+    # Réinitialisation de l'état de lecture
+    app.playback_paused = False
+    app.playback_stop = False
+    app.playback_ready.clear()  # Reset de l'évent pour pouvoir relancer
+
+    thread = threading.Thread(target=execute_jalon3_thread, args=(csv_path, wav_path, app), daemon=True)
+    thread.start()
+
+    print(f"[PLAY] Thread lancé pour {nom}")
+    return JSONResponse({"succes": True})
 
 
 @app.settings_app.get("/is-ready")
 async def is_ready():
-    ready = _ready_event.is_set()
-    delay_ms = int((time.time() - _play_start_time) * 1000) if ready else 0
-    return JSONResponse({"ready": ready, "delay_ms": delay_ms})
+    # Vérifie si on peut lancer la lecture
+    # Si ready=True le JS lance la vidéo en même tps que le rejeu de reachy
+    return JSONResponse({"ready": app.playback_ready.is_set()})
+
+
+@app.settings_app.post("/pause")
+async def pause(request: Request):
+    # Met la lecture en pause
+    app.playback_paused = True
+    return JSONResponse({"succes": True})
 
 
-@app.settings_app.post("/ready")
-async def ready():
-    elapsed = time.time() - _play_start_time
-    _ready_event.set()
-    print(f"[READY] Signal reçu après {elapsed:.2f}s")
-    return JSONResponse({"succes": True, "delay_ms": int(elapsed * 1000)})
+@app.settings_app.post("/resume")
+async def resume(request: Request):
+    # Reprend la lecture après une pause
+    app.playback_paused = False
+    return JSONResponse({"succes": True})
 
 
 @app.settings_app.post("/stop")
-async def stop():
-    _kill_apply()
-    print("[STOP] apply_signals arrêté.")
+async def stop(request: Request):
+    # Arret complet de la lecture
+    app.playback_stop = True
     return JSONResponse({"succes": True})
 
 
 @app.settings_app.get("/video/{nom}")
 def video(nom: str, request: Request):
-    path = None
-    target = f"{nom}(landmarks)"
-    for f in os.listdir(DOSSIER_LANDMARKS):
-        name_no_ext, _ = os.path.splitext(f)
-        if name_no_ext == target:
-            path = os.path.join(DOSSIER_LANDMARKS, f)
-            break
-
-    print(f"[VIDEO] Recherche : {path} | Existe : {path is not None and os.path.exists(path)}")
-    if not path or not os.path.exists(path):
-        mp4s = [f for f in os.listdir(DOSSIER_LANDMARKS) if f.endswith(".mp4")]
-        print(f"[VIDEO] MP4 disponibles : {mp4s}")
-        return JSONResponse({"succes": False, "message": f"Vidéo introuvable pour : {nom}"}, status_code=404)
+    # lis la vidéo landmarkée
+    path = os.path.join(DOSSIER_LANDMARKS, f"{nom}(landmarks).mp4")
+    if not os.path.exists(path):
+        return JSONResponse({"succes": False, "message": f"Vidéo introuvable : {nom}"}, status_code=404)
 
     file_size = os.path.getsize(path)
     range_header = request.headers.get("range")
 
     if range_header:
-        range_val = range_header.replace("bytes=", "")
-        parts = range_val.split("-")
-        start = int(parts[0])
-        end = int(parts[1]) if parts[1] else file_size - 1
+        start, _, end_str = range_header.replace("bytes=", "").partition("-")
+        start = int(start)
+        end = int(end_str) if end_str else file_size - 1
         end = min(end, file_size - 1)
-        chunk_size = end - start + 1
+        chunk = end - start + 1
 
-        def iter_file():
+        def stream():
             with open(path, "rb") as f:
                 f.seek(start)
-                remaining = chunk_size
-                while remaining > 0:
-                    chunk = f.read(min(65536, remaining))
-                    if not chunk:
+                rem = chunk
+                while rem > 0:
+                    data = f.read(min(65536, rem))
+                    if not data:
                         break
-                    remaining -= len(chunk)
-                    yield chunk
-
-        return StreamingResponse(
-            iter_file(),
-            status_code=206,
-            headers={
-                "Content-Range": f"bytes {start}-{end}/{file_size}",
-                "Accept-Ranges": "bytes",
-                "Content-Length": str(chunk_size),
-            },
-            media_type="video/mp4"
-        )
-    else:
-        return FileResponse(path, media_type="video/mp4", headers={"Accept-Ranges": "bytes"})
+                    rem -= len(data)
+                    yield data
 
+        return StreamingResponse(stream(), status_code=206, media_type="video/mp4", headers={
+            "Content-Range": f"bytes {start}-{end}/{file_size}",
+            "Accept-Ranges": "bytes",
+            "Content-Length": str(chunk),
+        })
 
-@app.settings_app.post("/supprimer")
-async def supprimer(request: Request):
+    return FileResponse(path, media_type="video/mp4", headers={"Accept-Ranges": "bytes"})
+
+
+@app.settings_app.post("/telecharger")
+async def telecharger(request: Request):
+    # Télécharge une vidéo YouTube dans video_temp.mp4 via yt_dlp
+    # la vidéo est sauvegardée en vidéo_temp qu'on utilisera pour la lancer dans le navigateur
+    data = await request.json()
+    url = data.get("url", "").strip()
+    if not url:
+        return JSONResponse({"succes": False, "message": "URL manquante."}, status_code=400)
+
+    video_path = os.path.join(DOSSIER, "video_temp.mp4")
+    if os.path.exists(video_path):
+        os.remove(video_path)       # Supprime une ancienne vidéo temp pour qu'elle soit bien temporaire
     try:
-        data = await request.json()
-    except Exception:
-        return JSONResponse({"succes": False, "message": "Body JSON invalide."}, status_code=400)
+        ydl_opts = {
+            "outtmpl": video_path,  # Chemin de sortie
+            # Fusion de l'audio et de la vidéo et choix des meilleurs qualités de vidéo
+            "format": "mp4/bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]",
+            "merge_output_format": "mp4",
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+    except Exception as e:
+        return JSONResponse({"succes": False, "message": str(e)}, status_code=500)
+
+    return JSONResponse({"succes": True})
 
+
+@app.settings_app.post("/lancer-youtube")
+async def lancer_youtube(request: Request):
+    # Lance Jalon2OPTI sur la video_temp.mp4 déjà téléchargée
+    # Séparé de /telecharger pour permettre au JS d'attendre la fin du téléchargement avant de demander le traitement (qui peut être long).
+    data = await request.json()
     nom = (data.get("nom") or "").strip()
     if not nom:
         return JSONResponse({"succes": False, "message": "Nom manquant."}, status_code=400)
 
-    csv_path = os.path.join(DOSSIER_CSV, f"{nom}.csv")
-    audio_path = os.path.join(DOSSIER_AUDIO, f"{nom}.wav")
-
-    # Recherche dynamique de la vidéo pour s'adapter à toutes les extensions (.mp4, .avi, etc.)
-    video_path = None
-    target = f"{nom}(landmarks)"
-    for f in os.listdir(DOSSIER_LANDMARKS):
-        name_no_ext, _ = os.path.splitext(f)
-        if name_no_ext == target:
-            video_path = os.path.join(DOSSIER_LANDMARKS, f)
-            break
-
-    supprime = []
-    chemins_a_verifier = [csv_path, audio_path]
-    if video_path:
-        chemins_a_verifier.append(video_path)
-
-    for p in chemins_a_verifier:
-        if os.path.exists(p):
-            try:
-                os.remove(p)
-                supprime.append(p)
-            except PermissionError:
-                return JSONResponse({
-                    "succes": False,
-                    "message": f"Fichier verrouillé (fermez la vidéo ou attendez la fin de l'animation) : {os.path.basename(p)}"
-                }, status_code=500)
+    video_path = os.path.join(DOSSIER, "video_temp.mp4")
+    if not os.path.exists(video_path):
+        return JSONResponse({"succes": False, "message": "Aucune vidéo téléchargée."}, status_code=404)
 
-    if supprime:
-        print(f"[DELETE] Éléments supprimés pour '{nom}': {supprime}")
-        return JSONResponse({"succes": True})
+    try:
+        subprocess.run(
+            [sys.executable, os.path.join(DOSSIER, "Jalon2OPTI.py"), video_path, nom],
+            cwd=DOSSIER, capture_output=True, text=True,
+            encoding="utf-8", errors="replace", check=True
+        )
+        print(f"[PIPELINE] OK pour {nom}")
+    except subprocess.CalledProcessError as e:
+        return JSONResponse({
+            "succes": False,
+            "message": e.stderr or e.stdout or "erreur inconnue"
+        }, status_code=500)
 
-    return JSONResponse({"succes": False, "message": f"Aucun fichier trouvé pour : {nom}"}, status_code=404)
+    return JSONResponse({"succes": True, "nom": nom})
 
 
 if __name__ == "__main__":
     import uvicorn
+
+    # Lance le thread de connexion robot en arrière-plan (daemon=True : s'arrête automatiquement à la fermeture du processus principal)
+    threading.Thread(target=app.wrapped_run, daemon=True).start()
+
+    # Démarre le serveur HTTP FastAPI sur le port 8042
     uvicorn.run(app.settings_app, host="127.0.0.1", port=8042)

coquille/static/index.html

@@ -8,18 +8,14 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=DM+Mono:wght@300;400;500&family=Syne:wght@400;600;700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="/static/style.css">
+
 </head>
 <body>
 
     <header>
         <div class="header-left">
             <span class="logo-mark"></span>
-            <span class="logo-text">reachy<em>pipeline</em></span>
-        </div>
-        <div class="header-right">
-            <span class="status-indicator" id="daemon-status">
-                <span class="dot"></span>daemon offline
-            </span>
+            <span class="logo-text">les<em>tal</em></span>
         </div>
     </header>
 
@@ -27,29 +23,43 @@
 
         <section class="panel" id="panel-source">
             <div class="panel-label">01 — source</div>
+            <div id = "local-or-video">
+                <button class = "btn" id = "local-video">Vidéo locale</button>
+                <button class = "btn" id = "youtube-video">Vidéo youtube</button>
+            </div>
 
             <div class="video-zone" id="video-zone">
                 <div class="video-placeholder" id="video-placeholder">
                     <svg width="36" height="36" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.2">
                         <path d="M15 10l4.553-2.069A1 1 0 0121 8.87v6.26a1 1 0 01-1.447.894L15 14M3 8a2 2 0 012-2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V8z"/>
                     </svg>
-                    <span>aucune vidéo</span>
+                    <span>Aucune vidéo</span>
                 </div>
                 <video id="video-preview" style="display:none;" controls></video>
             </div>
 
+            <input type="text" id="video-link" placeholder="Lien de la vidéo" autocomplete="off" />
+
             <div class="input-row">
-                <input type="text" id="recording-name" placeholder="nom de l'enregistrement" autocomplete="off" />
-                <label class="btn btn-ghost" for="file-input">
-                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4M17 8l-5-5-5 5M12 3v12"/></svg>
-                    charger
-                </label>
-                <input type="file" id="file-input" accept="video/*" style="display:none;" />
+                <input type="text" id="recording-name" placeholder="Nom de l'enregistrement" autocomplete="off" />
+                <div id = load-local>
+                    <label class="btn btn-ghost" for="file-input">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4M17 8l-5-5-5 5M12 3v12"/></svg>
+                        Charger
+                    </label>
+                    <input type="file" id="file-input" accept="video/*" style="display:none;" />
+                </div>
+                <button id = load-youtube>
+                    <label class="btn btn-ghost">
+                        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4M17 8l-5-5-5 5M12 3v12"/></svg>
+                        Charger
+                    </label>
+                </button>
             </div>
 
             <button class="btn btn-primary" id="btn-run" disabled>
                 <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="5 3 19 12 5 21 5 3"/></svg>
-                lancer le pipeline
+                Lancer le pipeline
             </button>
         </section>
 
@@ -62,7 +72,7 @@
     </main>
 
     <footer>
-        <div class="status-line" id="status-line">en attente</div>
+        <div class="status-line" id="status-line">En attente</div>
         <div class="progress-bar" id="progress-bar"></div>
     </footer>
 

coquille/static/main.js

@@ -1,36 +1,88 @@
 document.addEventListener("DOMContentLoaded", () => {
+    // Récup de tous les éléments du HTML
     const fileInput = document.getElementById('file-input');
     const runBtn = document.getElementById('btn-run');
     const nameInput = document.getElementById('recording-name');
     const preview = document.getElementById('video-preview');
     const placeholder = document.getElementById('video-placeholder');
-
+    const localVideo =  document.getElementById('local-video');
+    const youtubeVideo =  document.getElementById('youtube-video');
+    const videoLink = document.getElementById('video-link');
+    const loadLocal = document.getElementById('load-local');
+    const loadYoutube = document.getElementById('load-youtube');
     let selectedFile = null;
 
-    // Chargement initial des éléments enregistrés
+    // Charge la bibliothèque des vidéos déjà analysées
     chargerBibliotheque();
 
-    // 1. Sélection et prévisualisation de la vidéo source brute
+    // Affichage selection entre mode local et yt
+    localVideo.addEventListener('click', () =>{
+        videoLink.style.display = "none";
+        loadLocal.style.display = "block";
+        loadYoutube.style.display = "none";
+    });
+
+    youtubeVideo.addEventListener('click', () =>{
+        videoLink.style.display = "block";
+        loadLocal.style.display = "none";
+        loadYoutube.style.display = "block";
+    });
+
+    // Permet de télécharger une vidéo yt
+    loadYoutube.addEventListener('click', async () => {
+        const link = videoLink.value.trim();
+        if (!link) return updateStatus("Entrez le lien d'une vidéo youtube", 'error');
+
+        updateStatus("Téléchargement en cours...", 'active');
+        setProgress(20);
+        loadYoutube.disabled = true;
+
+        try {
+            // Appelle l'api python pour télécharger
+            const response = await fetch('/telecharger', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ url: link }) // On envoie l'url au serveur
+            });
+            const data = await response.json();
+            if (data.succes) {
+                setProgress(60);
+                updateStatus("Vidéo téléchargée — donnez un nom et lancez le pipeline", 'done');
+                runBtn.disabled = false; // le bouton lancer le pipeline est débloqué
+            } else {
+                setProgress(0);
+                updateStatus(`Erreur téléchargement : ${data.message}`, 'error');
+            }
+        } catch (err) {
+            setProgress(0);
+            updateStatus(`Erreur : ${err.message}`, 'error');
+        } finally {
+            loadYoutube.disabled = false;
+        }
+    });
+
+    // Charger une vidéo sur son pc en local
     fileInput.addEventListener('change', (e) => {
         const file = e.target.files[0];
         if (!file) return;
-
         selectedFile = file;
+        // Permet de lire la vidéo dans le navigateur
         preview.src = URL.createObjectURL(file);
         preview.style.display = 'block';
         placeholder.style.display = 'none';
-
         runBtn.disabled = false;
         updateStatus(`Vidéo prête : ${file.name}`, 'active');
     });
 
-    // 2. Traitement et envoi au pipeline Jalon2OPTI
+    // Lancer le pipeline
     runBtn.addEventListener('click', async () => {
+        // Différentes vérif : si la vidéo est chargée, a un nom ou si c'est un double
         const nom = nameInput.value.trim();
         if (!nom) return updateStatus("Donnez un nom à l'enregistrement", 'error');
-        if (!selectedFile) return updateStatus("Chargez une vidéo d'abord", 'error');
 
-        // [AJOUT DU COLLÈGUE] : Vérification anti-doublon avant de lancer le traitement
+        const isYoutube = loadYoutube.style.display === "block";
+        if (!isYoutube && !selectedFile) return updateStatus("Chargez une vidéo d'abord", 'error');
+
         try {
             const responsescv = await fetch('/liste');
             if (!responsescv.ok) throw new Error();
@@ -46,41 +98,45 @@ document.addEventListener("DOMContentLoaded", () => {
         updateStatus("Extraction des landmarks et génération des mouvements...", 'active');
         setProgress(30);
 
-        const formData = new FormData();
-        formData.append('video', selectedFile);
-        formData.append('nom', nom);
+        let response;
+        // Si vidéo yt
+        if (isYoutube) {
+            // lance la vidéo car déjà sur le serv
+            response = await fetch('/lancer-youtube', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ nom })
+            });
+        } else {
+            // sinon fichier local donc il faut l'envoyer sur le serveur (upload)
+            const formData = new FormData();
+            formData.append('video', selectedFile);
+            formData.append('nom', nom);
+            response = await fetch('/charger', { method: 'POST', body: formData });
+        }
 
         try {
-            console.log("[DEBUG] Envoi POST à /charger...");
-            const response = await fetch('/charger', { method: 'POST', body: formData });
-            console.log("[DEBUG] Réponse reçue, status:", response.status);
-
             if (!response.ok) {
-                console.error("[ERROR] Serveur retourne:", response.status, response.statusText);
                 const text = await response.text();
-                console.error("[ERROR] Body:", text);
                 updateStatus(`Erreur serveur (${response.status}): ${text}`, 'error');
                 runBtn.disabled = false;
                 return;
             }
 
             const data = await response.json();
-            console.log("[DEBUG] Données reçues:", data);
 
             if (data.succes) {
                 setProgress(100);
                 updateStatus(`Enregistrement "${nom}" ajouté ! Lancement de la vidéo...`, 'done');
 
-                // Petit délai pour s'assurer que le fichier vidéo est bien écrit
+                // Mise à jour du cadre vidéo : le lecteur va lire la vidéo analysée avec les landmarks
                 setTimeout(() => {
                     preview.src = `/video/${encodeURIComponent(nom)}?t=${Date.now()}`;
                     preview.style.display = 'block';
                     placeholder.style.display = 'none';
 
                     const playVideo = () => {
-                        preview.play().catch(() => {
-                            preview.controls = true;
-                        });
+                        preview.play().catch(() => { preview.controls = true; });
                     };
 
                     if (preview.readyState >= 3) {
@@ -91,7 +147,7 @@ document.addEventListener("DOMContentLoaded", () => {
 
                     nameInput.value = '';
                     selectedFile = null;
-                    chargerBibliotheque();
+                    chargerBibliotheque(); // Bibliothèque rafraichieavec le nouvel enregistrement
                 }, 500);
             } else {
                 setProgress(0);
@@ -99,7 +155,6 @@ document.addEventListener("DOMContentLoaded", () => {
             }
         } catch (err) {
             setProgress(0);
-            console.error("[ERROR] Exception:", err);
             updateStatus(`Erreur: ${err.message}`, 'error');
         } finally {
             runBtn.disabled = false;
@@ -107,8 +162,9 @@ document.addEventListener("DOMContentLoaded", () => {
     });
 });
 
-// --- Fonctions Globales de la Bibliothèque ---
+// Bibliothèque sur le côté droit
 
+// Récupère la liste des vidéos enregistrées sur le serveur pour ajouter des éléments li HTML
 async function chargerBibliotheque() {
     try {
         const response = await fetch('/liste');
@@ -122,7 +178,6 @@ async function chargerBibliotheque() {
             data.noms.forEach((nom, i) => {
                 const item = document.createElement('li');
                 item.className = 'library-item';
-                // [AJOUT DU COLLÈGUE] : Intégration des deux boutons côte à côte avec ses classes CSS
                 item.innerHTML = `
                     <span class="item-index">${String(i + 1).padStart(2, '0')}</span>
                     <span class="item-name">${nom}</span>
@@ -133,10 +188,12 @@ async function chargerBibliotheque() {
             });
         }
     } catch (err) {
-        console.error("Erreur de chargement de la bibliothèque graphique", err);
+        console.error("Erreur de chargement de la bibliothèque", err);
     }
 }
 
+
+// Jouer la vidéo qu'on veut sur le robot
 async function playRecording(nom, btn) {
     document.querySelectorAll('.library-item').forEach(el => el.classList.remove('playing'));
     document.querySelectorAll('.btn-play').forEach(b => {
@@ -153,20 +210,18 @@ async function playRecording(nom, btn) {
     const preview = document.getElementById('video-preview');
     const placeholder = document.getElementById('video-placeholder');
 
-    // [TA MODIF] : Masquer la vidéo pendant l'attente, on retire le src
     preview.pause();
     preview.removeAttribute('src');
     preview.load();
 
-    // 1. Lancer apply_signals côté serveur
-    let simData;
+    // Le serveur prépare le robot avec le fichier qu'on veut
     try {
         const simResp = await fetch('/play', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ nom: nom })
+            body: JSON.stringify({ nom })
         });
-        simData = await simResp.json();
+        const simData = await simResp.json();
         if (!simData.succes) {
             setProgress(0);
             updateStatus(`Erreur simulation : ${simData.message}`, 'error');
@@ -184,10 +239,9 @@ async function playRecording(nom, btn) {
         return;
     }
 
-    console.log('[PLAY] Polling /is-ready — ' + new Date().toISOString());
     updateStatus(`En attente du signal robot...`, 'active');
 
-    // 2. [TA MODIF] : Polling de sécurit�� /is-ready jusqu'à ce que Reachy soit prêt (timeout 60s)
+    // Toutes les 250ms on demande au serveur si il y'a un Reachy, ça va permettre d'avoir un rejeu de Reachy synchronisée avec le lancement de la vidéo
     const POLL_INTERVAL = 250;
     const POLL_TIMEOUT  = 60000;
     const pollStart = Date.now();
@@ -196,19 +250,15 @@ async function playRecording(nom, btn) {
         await new Promise((resolve, reject) => {
             const poll = async () => {
                 if (Date.now() - pollStart > POLL_TIMEOUT) {
-                    return reject(new Error('Timeout : le robot n\'a pas répondu dans les 60s'));
+                    return reject(new Error("Timeout : le robot n'a pas répondu dans les 60s"));
                 }
                 try {
                     const r = await fetch('/is-ready');
                     const d = await r.json();
                     const elapsed = ((Date.now() - pollStart) / 1000).toFixed(1);
-                    updateStatus(`En attente du signal robot\u2026 ${elapsed}s`, 'active');
-                    if (d.ready) {
-                        console.log(`[PLAY] Robot prêt après ${d.delay_ms}ms`);
-                        resolve();
-                    } else {
-                        setTimeout(poll, POLL_INTERVAL);
-                    }
+                    updateStatus(`En attente du signal robot… ${elapsed}s`, 'active');
+                    if (d.ready) resolve(); // le robot est pret
+                    else setTimeout(poll, POLL_INTERVAL); // Sinon on lui redemande
                 } catch (e) {
                     setTimeout(poll, POLL_INTERVAL);
                 }
@@ -224,9 +274,7 @@ async function playRecording(nom, btn) {
         return;
     }
 
-    console.log('[PLAY] Signal reçu, chargement vidéo — ' + new Date().toISOString());
-
-    // Attribution finale de la source après le feu vert du serveur
+    // Le robot est pret donc on lance la vidéo landmarkée dans le navigateur
     preview.src = `/video/${encodeURIComponent(nom)}`;
     preview.style.display = 'block';
     placeholder.style.display = 'none';
@@ -237,12 +285,11 @@ async function playRecording(nom, btn) {
         preview.load();
     });
 
-    console.log('[PLAY] Lancement preview.play() — ' + new Date().toISOString());
-    preview.play().catch(e => { console.error('[PLAY] play() refusé:', e); preview.controls = true; });
+    preview.play().catch(e => { preview.controls = true; });
     setProgress(100);
     updateStatus(`Lecture en cours...`, 'done');
 
-    // Reset quand la vidéo se termine + arrêt du daemon
+    // Quand la vidéo est finie, le robot s'arrête
     preview.onended = () => {
         btn.classList.remove('active');
         btn.textContent = 'play';
@@ -252,31 +299,26 @@ async function playRecording(nom, btn) {
     };
 }
 
+
+// Infos et barre de progression sur l'avancement de l'action qu'on effectue,
 function updateStatus(msg, type) {
     const el = document.getElementById('status-line');
-    if (el) {
-        el.textContent = msg;
-        el.className = `status-line ${type}`;
-    }
+    if (el) { el.textContent = msg; el.className = `status-line ${type}`; }
 }
 
-// Gestion de la barre de progression
 function setProgress(pct) {
     const bar = document.getElementById('progress-bar');
     if (bar) {
         bar.style.width = `${pct}%`;
-        if (pct === 100) {
-            setTimeout(() => { bar.style.width = '0%'; }, 1200);
-        }
+        if (pct === 100) setTimeout(() => { bar.style.width = '0%'; }, 1200);
     }
 }
 
-// [AJOUT DU COLLÈGUE] : Fonction globale pour supprimer un enregistrement
+// Supprimer un enregistrement de la bibliothèque
 async function deleteRecording(nom) {
     const preview = document.getElementById('video-preview');
     const placeholder = document.getElementById('video-placeholder');
 
-    // Si la vidéo en train d'être jouée est supprimée, on réinitialise l'affichage
     if (preview.src.includes(encodeURIComponent(nom))) {
         preview.pause();
         preview.src = '';
@@ -291,16 +333,16 @@ async function deleteRecording(nom) {
         const response = await fetch('/supprimer', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ nom: nom })
+            body: JSON.stringify({ nom })
         });
         const data = await response.json();
         if (data.succes) {
-            updateStatus('"' + nom + '" supprimé.', 'done');
-            chargerBibliotheque();
+            updateStatus(`"${nom}" supprimé.`, 'done');
+            chargerBibliotheque();  // Refresh de la bibliothèque
         } else {
-            updateStatus('Erreur suppression : ' + data.message, 'error');
+            updateStatus(`Erreur suppression : ${data.message}`, 'error');
         }
     } catch (err) {
-        updateStatus('Erreur : ' + err.message, 'error');
+        updateStatus(`Erreur : ${err.message}`, 'error');
     }
 }

coquille/static/style.css

@@ -68,26 +68,6 @@ header {
     color: var(--accent);
 }
 
-.status-indicator {
-    display: flex;
-    align-items: center;
-    gap: 7px;
-    font-size: 11px;
-    color: var(--text-secondary);
-    letter-spacing: 0.04em;
-}
-
-.status-indicator .dot {
-    width: 6px;
-    height: 6px;
-    border-radius: 50%;
-    background: var(--text-muted);
-    transition: background 0.3s;
-}
-
-.status-indicator.online .dot { background: var(--accent); }
-.status-indicator.online { color: var(--accent-dim); }
-
 main {
     display: grid;
     grid-template-columns: 1fr 1fr;
@@ -121,7 +101,7 @@ main {
     border-radius: var(--radius-lg);
     overflow: hidden;
     position: relative;
-    min-height: 0;
+    min-height: 0
 }
 
 .video-placeholder {
@@ -140,7 +120,7 @@ main {
 #video-preview {
     width: 100%;
     height: 100%;
-    object-fit: cover;
+    object-fit: contain;
     display: block;
 }
 
@@ -171,6 +151,15 @@ input[type="text"]::placeholder {
     color: var(--text-muted);
 }
 
+#video-link{
+    display: none;
+    flex: 0.1;
+}
+
+#load-youtube{
+    display:none;
+}
+
 .btn {
     display: inline-flex;
     align-items: center;
@@ -223,6 +212,14 @@ input[type="text"]::placeholder {
     background: transparent;
 }
 
+#local-or-video{
+    display: flex;
+    justify-content: space-around;
+    button{
+        width: 48%;
+    }
+}
+
 .library-list {
     list-style: none;
     display: flex;
@@ -297,13 +294,6 @@ input[type="text"]::placeholder {
     background: var(--accent-bg);
 }
 
-/* Petit ajout pour différencier le bouton de suppression au survol */
-.btn-delete:hover {
-    border-color: #f56565;
-    color: #f56565;
-    background: rgba(245, 101, 101, 0.1);
-}
-
 footer {
     height: 48px;
     border-top: 1px solid var(--border);
@@ -334,4 +324,17 @@ footer {
     width: 0%;
     background: var(--accent);
     transition: width 0.4s ease;
-}
+}
+.sim-badge {
+            display: none;
+            font-family: var(--font-mono);
+            font-size: 10px;
+            font-weight: 500;
+            letter-spacing: 0.12em;
+            color: #f6ad55;
+            background: rgba(246,173,85,0.1);
+            border: 1px solid rgba(246,173,85,0.35);
+            border-radius: 4px;
+            padding: 2px 7px;
+            margin-right: 10px;
+        }