MediaPipe: guía completa de visión por computador

MediaPipe es una biblioteca de código abierto desarrollada por Google que facilita la creación de aplicaciones de visión por computador y de procesamiento multimedia.

1. Instalación y configuración

# 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. Detección de pose

2.1 Configuración básica

# 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 Análisis de los movimientos

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. Detección de rostros

3.1 Configuración

# 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 Análisis de las expresiones

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. Detección de manos

4.1 Configuración

# 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 Reconocimiento de gestos

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. Aplicación completa

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. Optimización del rendimiento

6.1 Reducción de la latencia

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 Gestión de la memoria

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

7. Buenas prácticas

1. Preprocesamiento de las imágenes

   • Redimensionar las imágenes para obtener un mejor rendimiento
   • Normalizar los valores de los píxeles
   • Gestionar los distintos formatos de imagen

2. Gestión de errores

   • Comprobar la disponibilidad de la cámara
   • Gestionar los casos en los que no es posible realizar ninguna detección
   • Implementar timeouts adecuados

3. Optimización

   • Utilizar el modo lite en dispositivos móviles
   • Reducir la frecuencia de detección si es necesario
   • Implementar un sistema de caché para los resultados

Conclusión

Puntos clave:

• Detección precisa de la pose, del rostro y de las manos
• API sencilla e intuitiva
• Excelente rendimiento
• Compatibilidad multiplataforma

Recomendaciones:

• Adaptar la complejidad del modelo según las necesidades
• Optimizar el rendimiento para dispositivos móviles
• Implementar una gestión de errores robusta
• Utilizar el modo lite en aplicaciones en tiempo real