Upload 2 files

utils/mediapipe_utils.py

@@ -0,0 +1,86 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+from tqdm import tqdm
+
+class MediaPipeProcessor:
+    def __init__(self, config):
+        self.config = config.get('mediapipe_config', {})
+        self.setup_mediapipe()
+    
+    def setup_mediapipe(self):
+        """Configura os modelos do MediaPipe"""
+        self.mp_holistic = mp.solutions.holistic
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+        
+        self.holistic = self.mp_holistic.Holistic(
+            static_image_mode=self.config.get('static_image_mode', False),
+            model_complexity=self.config.get('model_complexity', 1),
+            smooth_landmarks=self.config.get('smooth_landmarks', True),
+            min_detection_confidence=self.config.get('min_detection_confidence', 0.5),
+            min_tracking_confidence=self.config.get('min_tracking_confidence', 0.5)
+        )
+    
+    def process_video(self, video_path):
+        """Processa o vídeo e extrai keypoints"""
+        cap = cv2.VideoCapture(video_path)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        keypoints_data = []
+        
+        print(f"Extraindo keypoints de {total_frames} frames...")
+        
+        for frame_idx in tqdm(range(total_frames), desc="Processando frames"):
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Converter BGR para RGB
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = self.holistic.process(frame_rgb)
+            
+            frame_keypoints = self.extract_frame_keypoints(results)
+            frame_keypoints['frame_index'] = frame_idx
+            frame_keypoints['timestamp'] = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
+            
+            keypoints_data.append(frame_keypoints)
+        
+        cap.release()
+        return keypoints_data
+    
+    def extract_frame_keypoints(self, results):
+        """Extrai keypoints de um frame"""
+        keypoints = {}
+        
+        # Face landmarks
+        if results.face_landmarks:
+            keypoints['face_landmarks'] = self.landmarks_to_array(
+                results.face_landmarks.landmark, 468
+            )
+        
+        # Pose landmarks
+        if results.pose_landmarks:
+            keypoints['pose_landmarks'] = self.landmarks_to_array(
+                results.pose_landmarks.landmark, 33
+            )
+        
+        # Left hand landmarks
+        if results.left_hand_landmarks:
+            keypoints['left_hand_landmarks'] = self.landmarks_to_array(
+                results.left_hand_landmarks.landmark, 21
+            )
+        
+        # Right hand landmarks
+        if results.right_hand_landmarks:
+            keypoints['right_hand_landmarks'] = self.landmarks_to_array(
+                results.right_hand_landmarks.landmark, 21
+            )
+        
+        return keypoints
+    
+    def landmarks_to_array(self, landmarks, expected_count):
+        """Converte landmarks do MediaPipe para array numpy"""
+        if not landmarks or len(landmarks) != expected_count:
+            return np.zeros((expected_count, 3))
+        
+        return np.array([[lm.x, lm.y, lm.z] for lm in landmarks])

utils/video_processor.py

@@ -0,0 +1,92 @@
+import cv2
+import numpy as np
+from tqdm import tqdm
+import subprocess
+import os
+
+class VideoProcessor:
+    def __init__(self, config):
+        self.config = config.get('video_normalization', {})
+    
+    def normalize_video(self, input_path, output_path):
+        """Normaliza o vídeo usando OpenCV"""
+        cap = cv2.VideoCapture(input_path)
+        
+        # Obter propriedades do vídeo original
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        # Configurações de saída
+        target_resolution = self.config.get('target_resolution', (width, height))
+        target_fps = self.config.get('target_fps', fps)
+        
+        # Definir codec e writer
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(
+            output_path, fourcc, target_fps, target_resolution
+        )
+        
+        print(f"Processando {total_frames} frames...")
+        
+        for _ in tqdm(range(total_frames), desc="Normalizando vídeo"):
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Redimensionar
+            frame = cv2.resize(frame, target_resolution)
+            
+            # Normalização de cor e brilho
+            if self.config.get('normalize_brightness', True):
+                frame = self.normalize_brightness(frame)
+            
+            if self.config.get('enhance_contrast', True):
+                frame = self.enhance_contrast(frame)
+            
+            out.write(frame)
+        
+        cap.release()
+        out.release()
+        
+        # Usar FFmpeg para melhor compressão (opcional)
+        self.optimize_with_ffmpeg(output_path)
+        
+        return output_path
+    
+    def normalize_brightness(self, frame):
+        """Normaliza o brilho do frame"""
+        # Converter para YUV e normalizar canal Y (luminância)
+        yuv = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV)
+        yuv[:,:,0] = cv2.equalizeHist(yuv[:,:,0])
+        return cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
+    
+    def enhance_contrast(self, frame):
+        """Melhora o contraste usando CLAHE"""
+        lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+        l = clahe.apply(l)
+        lab = cv2.merge((l, a, b))
+        return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+    
+    def optimize_with_ffmpeg(self, input_path):
+        """Otimiza o vídeo com FFmpeg"""
+        temp_path = input_path.replace('.mp4', '_temp.mp4')
+        
+        cmd = [
+            'ffmpeg', '-i', input_path,
+            '-c:v', 'libx264', '-preset', 'medium', '-crf', '23',
+            '-c:a', 'aac', '-b:a', '128k',
+            '-movflags', '+faststart',
+            '-y', temp_path
+        ]
+        
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            os.replace(temp_path, input_path)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            # Fallback se FFmpeg não estiver disponível
+            if os.path.exists(temp_path):
+                os.remove(temp_path)