MediaPipe: Guia Completo para Visão Computacional

O MediaPipe é uma biblioteca open source desenvolvida pelo Google que facilita a criação de aplicações de visão computacional e de processamento multimídia.

1. Instalação e Configuração

# Instalação das dependências
pip install mediapipe opencv-python numpy

# Importação das bibliotecas necessárias
import mediapipe as mp
import cv2
import numpy as np

2. Detecção de Pose

2.1 Configuração Básica

# Inicialização do 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):
    # Conversão para RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Detecção da pose
    results = pose.process(image_rgb)
    
    # Desenhar os pontos de referência
    if results.pose_landmarks:
        mp_draw.draw_landmarks(
            image,
            results.pose_landmarks,
            mp_pose.POSE_CONNECTIONS
        )
    
    return image

2.2 Análise de Movimentos

def analyze_movement(landmarks):
    # Extração dos pontos-chave
    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
    ])
    
    # Cálculo do ângulo dos ombros
    shoulder_angle = np.arctan2(
        right_shoulder[1] - left_shoulder[1],
        right_shoulder[0] - left_shoulder[0]
    )
    
    return shoulder_angle

3. Detecção de Rosto

3.1 Configuração

# Inicialização do 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):
    # Conversão para RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Detecção dos rostos
    results = face_detection.process(image_rgb)
    
    # Desenhar as caixas de detecção
    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álise de Expressões

def analyze_expression(landmarks):
    # Extração dos pontos do rosto
    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
    ])
    
    # Cálculo da abertura dos olhos
    eye_distance = np.linalg.norm(right_eye - left_eye)
    
    return eye_distance

4. Detecção de Mãos

4.1 Configuração

# Inicialização do 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):
    # Conversão para RGB
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Detecção das mãos
    results = hands.process(image_rgb)
    
    # Desenhar os pontos de referência
    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 Reconhecimento de Gestos

def recognize_gesture(hand_landmarks):
    # Extração dos pontos dos dedos
    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
    ])
    
    # Cálculo da distância entre o polegar e o indicador
    pinch_distance = np.linalg.norm(thumb_tip - index_tip)
    
    return pinch_distance

5. Aplicação Completa

def main():
    # Inicialização da câmera
    cap = cv2.VideoCapture(0)
    
    while cap.isOpened():
        success, image = cap.read()
        if not success:
            continue
            
        # Detecção de pose
        image = detect_pose(image)
        
        # Detecção de rosto
        image = detect_faces(image)
        
        # Detecção de mãos
        image = detect_hands(image)
        
        # Exibição
        cv2.imshow('MediaPipe Demo', image)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

6. Otimização de Desempenho

6.1 Redução da Latência

def optimize_performance():
    # Configuração para melhor desempenho
    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 Gerenciamento de Memória

def manage_memory():
    # Limpeza dos recursos
    pose.close()
    face_detection.close()
    hands.close()

7. Boas Práticas

1. Pré-processamento das Imagens

   • Redimensionar as imagens para obter melhor desempenho
   • Normalizar os valores dos pixels
   • Tratar os diferentes formatos de imagem

2. Tratamento de Erros

   • Verificar a disponibilidade da câmera
   • Tratar os casos em que nenhuma detecção é possível
   • Implementar timeouts apropriados

3. Otimização

   • Usar o modo lite em dispositivos móveis
   • Reduzir a frequência de detecção, se necessário
   • Implementar um sistema de cache para os resultados

Conclusão

Pontos principais:

• Detecção precisa de pose, rosto e mãos
• API simples e intuitiva
• Excelente desempenho
• Suporte multiplataforma

Recomendações:

• Adaptar a complexidade do modelo conforme as necessidades
• Otimizar o desempenho para dispositivos móveis
• Implementar um tratamento de erros robusto
• Usar o modo lite em aplicações em tempo real