Ajout du programme pour le jalon 2

coquille/Jalon2OPTI.py

@@ -0,0 +1,228 @@
+import cv2
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from mediapipe import Image, ImageFormat
+import numpy as np
+import urllib.request
+import csv
+
+### ÉTAPE 1 : CHARGER LE MODÈLE MEDIAPIPE ###
+
+urllib.request.urlretrieve(
+    "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
+    "face_landmarker.task"
+)
+
+### ÉTAPE 2 : CONFIGURATION DU MODÈLE ###
+
+options = vision.FaceLandmarkerOptions(                                             # Configuration d'un modèle de détection de visage
+    base_options = python.BaseOptions(model_asset_path="face_landmarker.task"),     # Indique le chemin vers le fichier du modèle
+    running_mode=vision.RunningMode.VIDEO,											# Activation du mode vidéo
+    num_faces = 1,                                                                  # Nombre de visage à détecter
+    min_face_detection_confidence = 0.7,                                            # Seuil minimum de confiance
+    min_tracking_confidence = 0.5)                                                  # Seuil de confiance dans le tracking
+
+detector = vision.FaceLandmarker.create_from_options(options)                       # Création du détecteur
+
+### ÉTAPE 3 : CHARGER LA VIDÉO ###
+
+video_path = "video.mp4"                                                           # Chemin de la vidéo
+cap = cv2.VideoCapture(video_path)                                                  # Créer un objet qui permet de lire la vidéo frame par frame
+
+fps = cap.get(cv2.CAP_PROP_FPS)                                                     # Récupère le nombre de frame par seconde de la vidéo
+frame_index = 0                                                                     # Initialise un compteur de frame
+
+### ÉTAPE 4 : CRÉATION DU FICHIER CSV ###
+
+csv_file = open("resultats.csv", "w", newline="", encoding="utf-8")					# Crée/Ouvre un fichier csv en mode écriture
+csv_writer = csv.writer(csv_file)													# Crée un objet pour écrire sur le fichier csv
+
+csv_writer.writerow([
+    "timestamp", "bouche", "oeil_g", "oeil_d",
+    "pitch", "yaw", "roll", "norm_x", "norm_y"										#Écrit l'en-tête du fichier
+])
+
+### FONCTIONS UTILITAIRES ###
+
+def generic_optic(width, height):
+    focal_length = width                                             # Estimation d'une optique générique en fonction d'une largeur et d'un centre moyens
+    cx, cy = width / 2, height / 2
+    camera_matrix = np.array([
+        [focal_length, 0,            cx],
+        [0,            focal_length, cy],
+        [0,            0,            1 ]
+    ], dtype=np.float64)
+
+    dist_coeffs = np.zeros((4, 1))                                  # Définition des distortions de l'objectif à 0
+    
+    return camera_matrix, dist_coeffs
+
+def compute_head_pose(landmarks, frame_w, frame_h):
+    
+    model_points = np.array([                                           # Modèle 3D générique d'un visage humain moyen
+        [0.0,    0.0,    0.0   ],                                       # Bout du nez
+        [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]                                # Indices des landmarks correspondant à ces derniers
+
+    image_points = np.array([                                           # Récupère la position 2D des 6 landmarks et les convertit en pixels
+        [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)
+    
+
+    success, rotation_vec, translation_vec = cv2.solvePnP(              # Permet de trouver l'orientation de la tête à partir des différents points
+        model_points, image_points, camera_matrix, dist_coeffs,
+        flags=cv2.SOLVEPNP_ITERATIVE
+    )
+
+    if not success:                                                     # Si détection ne marche pas alors ne renvoie rien
+        return None, None, None, None, None
+
+    rotation_mat, _ = cv2.Rodrigues(rotation_vec)                                   # Conversion vecteur rotation -> matrice -> angles d'Euler
+    pose_mat = cv2.hconcat([rotation_mat, translation_vec])
+    _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)
+
+    pitch = euler_angles[0, 0]                                                      # Haut / bas
+    yaw   = euler_angles[1, 0]                                                      # Gauche / droite
+    roll  = euler_angles[2, 0]                                                      # Inclinaison latérale
+
+    return pitch, yaw, roll, rotation_vec, translation_vec
+
+
+def compute_face_position(landmarks, frame_w, frame_h):                             # Calcule la position et la taille du visage dans l'image
+
+    xs = [lm.x for lm in landmarks]
+    ys = [lm.y for lm in landmarks]
+
+    x_min, x_max = min(xs), max(xs)
+    y_min, y_max = min(ys), max(ys)
+
+    center_x = int(((x_min + x_max) / 2) * frame_w)                                 # Centre du visage en pixels
+    center_y = int(((y_min + y_max) / 2) * frame_h)
+
+    norm_x = ((x_min + x_max) / 2 - 0.5) * 2                                        # Position normalisée : 0,0 = centre de l'image, +=1 = bords
+    norm_y = ((y_min + y_max) / 2 - 0.5) * 2
+
+    face_w = int((x_max - x_min) * frame_w)                                         # Taille de la boite en pixels
+    face_h = int((y_max - y_min) * frame_h)
+
+    face_size_ratio = ((x_max - x_min) * (y_max - y_min)) ** 0.5                    # Ratio taille visage / taille image
+
+    return center_x, center_y, norm_x, norm_y, face_w, face_h, face_size_ratio, \
+           (int(x_min * frame_w), int(y_min * frame_h),
+            int(x_max * frame_w), int(y_max * frame_h))                             # Renvoie la position du visage à partir des variables d'avant
+
+
+def draw_axes(frame, rotation_vec, translation_vec, camera_matrix, dist_coeffs, origin):        # Affiche les axes 3D : X=rouge, Y=vert et Z=bleu
+
+    axis_length = 160.0
+    axis_points = np.array([
+        [axis_length, 0.0,         0.0        ],  # X
+        [0.0,         axis_length, 0.0        ],  # Y
+        [0.0,         0.0,        -axis_length],  # Z (vers nous)
+    ], dtype=np.float64)
+
+    projected, _ = cv2.projectPoints(                                                           # Projette les 3 points en coordonnées 2D
+        axis_points, rotation_vec, translation_vec,
+        camera_matrix, dist_coeffs
+    )
+
+    o = (int(origin[0]), int(origin[1]))                                                        # Convertit le point d'origine en un entier
+
+    cv2.arrowedLine(frame, o, (int(projected[0][0][0]), int(projected[0][0][1])),               # Dessine l'axe X en rouge
+                    (0, 0, 255), 2, tipLength=0.3)
+    cv2.arrowedLine(frame, o, (int(projected[1][0][0]), int(projected[1][0][1])),               # Dessine l'axe Y en vert
+                    (0, 255, 0), 2, tipLength=0.3)
+    cv2.arrowedLine(frame, o, (int(projected[2][0][0]), int(projected[2][0][1])),               # Dessine l'axe Z en bleu
+                    (255, 0, 0), 2, tipLength=0.3)
+
+### ÉTAPE 5 : BOUCLE PRINCIPALE ###
+
+while True:
+    ret, frame = cap.read()                                             # Lit la frame suivante dans la vidéo
+    if not ret:
+        break
+
+    timestamp = frame_index / fps                                       # Calcule le temps en secondes de la frame actuelle
+    frame_index += 1                                                    # Incrémente le compteur de frame
+
+    h, w, _ = frame.shape                                               # Extrait les dimensions de l'image
+
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)                      # Convertit l'image BGR en RGB
+    mp_image = Image(image_format=ImageFormat.SRGB, data=rgb_frame)         # Englobe le tableau numpy dans un objet Iage Mediapipe
+
+    timestamp_ms = int(timestamp * 1000)
+    results = detector.detect_for_video(mp_image, timestamp_ms)                              # Detection des landmarks
+
+    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)       # 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)
+
+        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})"
+        )
+        csv_writer.writerow([
+            round(timestamp, 2),
+            round(mouth_open, 3),
+            round(left_eye_open, 3),
+            round(right_eye_open, 3),
+            round(pitch, 1),
+            round(yaw, 1),
+            round(roll, 1),
+            round(norm_x, 2),
+            round(norm_y, 2),
+        ])																# Sauvegarde les informations de l'image dans le fichier csv
+
+        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
+
+    cv2.imshow("Motion Capture", frame)                                                     # Affiche la frame
+    if cv2.waitKey(25) & 0xFF == ord('q'):                                                  # Quitte la vidéo avec q
+        break
+
+### ÉTAPE 6 : NETTOYAGE ###
+
+cap.release()                                           # Ferme la vidéo et libère la mémoire associée
+cv2.destroyAllWindows()                                 # Ferme la fenêtre
+detector.close()                                        # Libère le modèle
+csv_file.close()										# Ferme le ficher csv