MediaPipe : Guide Complet pour la Vision par Ordinateur

MediaPipe est une bibliothèque open-source développée par Google qui facilite la création d’applications de vision par ordinateur et de traitement multimédia.

1. Installation et Configuration

# Installation des dépendances
pip install mediapipe opencv-python numpy

# Import des bibliothèques nécessaires
import mediapipe as mp
import cv2
import numpy as np

2. Détection de Pose

2.1 Configuration de Base

# Initialisation de MediaPipe Pose
mp_pose = mp.solutions.pose
pose = mp_pose.Pose(
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
)
mp_draw = mp.solutions.drawing_utils

def detect_pose(image):
    # Conversion en RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Détection de la pose
    results = pose.process(image_rgb)
    
    # Dessiner les points de repère
    if results.pose_landmarks:
        mp_draw.draw_landmarks(
            image,
            results.pose_landmarks,
            mp_pose.POSE_CONNECTIONS
        )
    
    return image

2.2 Analyse des Mouvements

def analyze_movement(landmarks):
    # Extraction des points clés
    left_shoulder = np.array([
        landmarks.landmark[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
        landmarks.landmark[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y
    ])
    
    right_shoulder = np.array([
        landmarks.landmark[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x,
        landmarks.landmark[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y
    ])
    
    # Calcul de l'angle des épaules
    shoulder_angle = np.arctan2(
        right_shoulder[1] - left_shoulder[1],
        right_shoulder[0] - left_shoulder[0]
    )
    
    return shoulder_angle

3. Détection de Visage

3.1 Configuration

# Initialisation de MediaPipe Face Detection
mp_face_detection = mp.solutions.face_detection
face_detection = mp_face_detection.FaceDetection(
    min_detection_confidence=0.5
)

def detect_faces(image):
    # Conversion en RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Détection des visages
    results = face_detection.process(image_rgb)
    
    # Dessiner les boîtes de détection
    if results.detections:
        for detection in results.detections:
            bbox = detection.location_data.relative_bounding_box
            h, w, _ = image.shape
            x = int(bbox.xmin * w)
            y = int(bbox.ymin * h)
            width = int(bbox.width * w)
            height = int(bbox.height * h)
            
            cv2.rectangle(image, (x, y), (x + width, y + height), (0, 255, 0), 2)
    
    return image

3.2 Analyse des Expressions

def analyze_expression(landmarks):
    # Extraction des points du visage
    left_eye = np.array([
        landmarks.landmark[mp_face_detection.FaceLandmark.LEFT_EYE.value].x,
        landmarks.landmark[mp_face_detection.FaceLandmark.LEFT_EYE.value].y
    ])
    
    right_eye = np.array([
        landmarks.landmark[mp_face_detection.FaceLandmark.RIGHT_EYE.value].x,
        landmarks.landmark[mp_face_detection.FaceLandmark.RIGHT_EYE.value].y
    ])
    
    # Calcul de l'ouverture des yeux
    eye_distance = np.linalg.norm(right_eye - left_eye)
    
    return eye_distance

4. Détection de Mains

4.1 Configuration

# Initialisation de MediaPipe Hands
mp_hands = mp.solutions.hands
hands = mp_hands.Hands(
    min_detection_confidence=0.7,
    min_tracking_confidence=0.5
)

def detect_hands(image):
    # Conversion en RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Détection des mains
    results = hands.process(image_rgb)
    
    # Dessiner les points de repère
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_draw.draw_landmarks(
                image,
                hand_landmarks,
                mp_hands.HAND_CONNECTIONS
            )
    
    return image

4.2 Reconnaissance de Gestes

def recognize_gesture(hand_landmarks):
    # Extraction des points des doigts
    thumb_tip = np.array([
        hand_landmarks.landmark[mp_hands.HandLandmark.THUMB_TIP.value].x,
        hand_landmarks.landmark[mp_hands.HandLandmark.THUMB_TIP.value].y
    ])
    
    index_tip = np.array([
        hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP.value].x,
        hand_landmarks.landmark[mp_hands.HandLandmark.INDEX_FINGER_TIP.value].y
    ])
    
    # Calcul de la distance entre le pouce et l'index
    pinch_distance = np.linalg.norm(thumb_tip - index_tip)
    
    return pinch_distance

5. Application Complète

def main():
    # Initialisation de la caméra
    cap = cv2.VideoCapture(0)
    
    while cap.isOpened():
        success, image = cap.read()
        if not success:
            continue
            
        # Détection de pose
        image = detect_pose(image)
        
        # Détection de visage
        image = detect_faces(image)
        
        # Détection de mains
        image = detect_hands(image)
        
        # Affichage
        cv2.imshow('MediaPipe Demo', image)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

6. Optimisation des Performances

6.1 Réduction de la Latence

def optimize_performance():
    # Configuration pour de meilleures performances
    pose = mp_pose.Pose(
        min_detection_confidence=0.5,
        min_tracking_confidence=0.5,
        model_complexity=1,  # 0=Lite, 1=Full, 2=Heavy
        smooth_landmarks=True,
        enable_segmentation=False
    )

6.2 Gestion de la Mémoire

def manage_memory():
    # Nettoyage des ressources
    pose.close()
    face_detection.close()
    hands.close()

7. Bonnes Pratiques

1. Prétraitement des Images

   • Redimensionner les images pour de meilleures performances
   • Normaliser les valeurs des pixels
   • Gérer les différents formats d’image

2. Gestion des Erreurs

   • Vérifier la disponibilité de la caméra
   • Gérer les cas où aucune détection n’est possible
   • Implémenter des timeouts appropriés

3. Optimisation

   • Utiliser le mode lite pour les appareils mobiles
   • Réduire la fréquence de détection si nécessaire
   • Implémenter un système de cache pour les résultats

Conclusion

Points clés :

• Détection précise de la pose, du visage et des mains
• API simple et intuitive
• Excellentes performances
• Support multiplateforme

Recommandations :

• Adapter la complexité du modèle selon les besoins
• Optimiser les performances pour les appareils mobiles
• Implémenter une gestion robuste des erreurs
• Utiliser le mode lite pour les applications en temps réel