delete face_tracking.py

face_tracking.py

@@ -1,346 +0,0 @@
-"""
-Módulo de rastreamento facial para crop inteligente de vídeos.
-Usa OpenCV e detecção de rostos para manter pessoas centralizadas ao redimensionar.
-"""
-
-import cv2
-import numpy as np
-from typing import Tuple, Optional, List
-from dataclasses import dataclass
-
-@dataclass
-class FaceBox:
-    """Representa uma detecção de rosto."""
-    x: int
-    y: int
-    w: int
-    h: int
-    center_x: int
-    center_y: int
-    confidence: float = 1.0
-
-class FaceTracker:
-    """Rastreador de rostos para crop inteligente de vídeos."""
-    
-    def __init__(self):
-        """Inicializa o detector de rostos usando Haar Cascades do OpenCV."""
-        # Tenta carregar diferentes cascades (frontal e perfil)
-        cascade_paths = [
-            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml',
-            cv2.data.haarcascades + 'haarcascade_frontalface_alt.xml',
-        ]
-        
-        self.face_cascade = None
-        for path in cascade_paths:
-            try:
-                self.face_cascade = cv2.CascadeClassifier(path)
-                if not self.face_cascade.empty():
-                    break
-            except:
-                continue
-        
-        if self.face_cascade is None or self.face_cascade.empty():
-            print("⚠️ Aviso: Não foi possível carregar detector de rostos. Crop será centralizado.")
-            self.enabled = False
-        else:
-            self.enabled = True
-            print("✓ Detector de rostos carregado com sucesso")
-    
-    def detect_faces(self, frame: np.ndarray) -> List[FaceBox]:
-        """
-        Detecta rostos em um frame.
-        
-        Args:
-            frame: Frame do vídeo (BGR ou RGB)
-            
-        Returns:
-            Lista de FaceBox com rostos detectados
-        """
-        if not self.enabled:
-            return []
-        
-        # Converte para escala de cinza para detecção
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        
-        # Detecta rostos
-        faces = self.face_cascade.detectMultiScale(
-            gray,
-            scaleFactor=1.1,
-            minNeighbors=5,
-            minSize=(30, 30),
-            flags=cv2.CASCADE_SCALE_IMAGE
-        )
-        
-        # Converte para FaceBox
-        face_boxes = []
-        for (x, y, w, h) in faces:
-            center_x = x + w // 2
-            center_y = y + h // 2
-            face_boxes.append(FaceBox(x, y, w, h, center_x, center_y))
-        
-        return face_boxes
-    
-    def get_primary_face(self, faces: List[FaceBox], frame_width: int, frame_height: int) -> Optional[FaceBox]:
-        """
-        Seleciona o rosto principal (mais central e maior).
-        
-        Args:
-            faces: Lista de rostos detectados
-            frame_width: Largura do frame
-            frame_height: Altura do frame
-            
-        Returns:
-            FaceBox do rosto principal ou None
-        """
-        if not faces:
-            return None
-        
-        # Se só há um rosto, retorna ele
-        if len(faces) == 1:
-            return faces[0]
-        
-        # Calcula score para cada rosto (baseado em tamanho e centralização)
-        frame_center_x = frame_width / 2
-        frame_center_y = frame_height / 2
-        
-        scored_faces = []
-        for face in faces:
-            # Score por tamanho (normalizado)
-            size_score = (face.w * face.h) / (frame_width * frame_height)
-            
-            # Score por distância ao centro (normalizado e invertido)
-            dx = abs(face.center_x - frame_center_x) / frame_width
-            dy = abs(face.center_y - frame_center_y) / frame_height
-            center_score = 1 - (dx + dy) / 2
-            
-            # Score final (peso maior para centralização)
-            total_score = (size_score * 0.3) + (center_score * 0.7)
-            scored_faces.append((total_score, face))
-        
-        # Retorna o rosto com maior score
-        scored_faces.sort(reverse=True, key=lambda x: x[0])
-        return scored_faces[0][1]
-    
-    def calculate_smart_crop(
-        self, 
-        frame: np.ndarray, 
-        target_width: int, 
-        target_height: int
-    ) -> Tuple[int, int, int, int]:
-        """
-        Calcula coordenadas de crop inteligente baseado em detecção facial.
-        
-        Args:
-            frame: Frame do vídeo
-            target_width: Largura desejada
-            target_height: Altura desejada
-            
-        Returns:
-            Tupla (x, y, w, h) das coordenadas de crop
-        """
-        frame_h, frame_w = frame.shape[:2]
-        
-        # Detecta rostos
-        faces = self.detect_faces(frame)
-        primary_face = self.get_primary_face(faces, frame_w, frame_h)
-        
-        # Calcula aspect ratio alvo
-        target_ar = target_width / target_height
-        frame_ar = frame_w / frame_h
-        
-        if primary_face:
-            # Crop baseado no rosto detectado
-            face_center_x = primary_face.center_x
-            face_center_y = primary_face.center_y
-            
-            # Ajusta centro baseado no rosto com margens de segurança
-            if target_ar < frame_ar:  # Crop vertical (9:16, 1:1, 4:5)
-                crop_w = int(frame_h * target_ar)
-                crop_h = frame_h
-                
-                # Centraliza horizontalmente no rosto
-                crop_x = max(0, min(face_center_x - crop_w // 2, frame_w - crop_w))
-                crop_y = 0
-            else:  # Crop horizontal ou quadrado
-                crop_w = frame_w
-                crop_h = int(frame_w / target_ar)
-                
-                # Centraliza verticalmente no rosto (com leve offset para cima)
-                offset = int(crop_h * 0.1)  # 10% offset para dar espaço acima da cabeça
-                crop_x = 0
-                crop_y = max(0, min(face_center_y - crop_h // 2 - offset, frame_h - crop_h))
-        else:
-            # Fallback: crop centralizado tradicional
-            if target_ar < frame_ar:  # Mais alto que largo
-                crop_w = int(frame_h * target_ar)
-                crop_h = frame_h
-                crop_x = (frame_w - crop_w) // 2
-                crop_y = 0
-            else:  # Mais largo que alto
-                crop_w = frame_w
-                crop_h = int(frame_w / target_ar)
-                crop_x = 0
-                crop_y = (frame_h - crop_h) // 2
-        
-        return (crop_x, crop_y, crop_w, crop_h)
-
-
-def apply_smart_crop_to_video(
-    input_path: str,
-    output_path: str,
-    target_width: int,
-    target_height: int,
-    sample_frames: int = 10
-) -> bool:
-    """
-    Aplica crop inteligente com rastreamento facial a um vídeo.
-    
-    Args:
-        input_path: Caminho do vídeo de entrada
-        output_path: Caminho do vídeo de saída
-        target_width: Largura desejada
-        target_height: Altura desejada
-        sample_frames: Número de frames para amostragem (para calcular posição média)
-        
-    Returns:
-        True se sucesso, False caso contrário
-    """
-    tracker = FaceTracker()
-    
-    # Abre vídeo de entrada
-    cap = cv2.VideoCapture(input_path)
-    if not cap.isOpened():
-        print(f"❌ Erro ao abrir vídeo: {input_path}")
-        return False
-    
-    # Propriedades do vídeo
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    
-    # Amostra alguns frames para determinar melhor posição de crop
-    sample_positions = []
-    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, frame_count), dtype=int)
-    
-    for idx in frame_indices:
-        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
-        ret, frame = cap.read()
-        if ret:
-            crop_coords = tracker.calculate_smart_crop(frame, target_width, target_height)
-            sample_positions.append(crop_coords)
-    
-    # Calcula posição média de crop (suaviza movimento)
-    if sample_positions:
-        avg_x = int(np.median([p[0] for p in sample_positions]))
-        avg_y = int(np.median([p[1] for p in sample_positions]))
-        crop_w = sample_positions[0][2]
-        crop_h = sample_positions[0][3]
-        final_crop = (avg_x, avg_y, crop_w, crop_h)
-    else:
-        # Fallback
-        frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        frame_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        target_ar = target_width / target_height
-        frame_ar = frame_w / frame_h
-        
-        if target_ar < frame_ar:
-            crop_w = int(frame_h * target_ar)
-            crop_h = frame_h
-            final_crop = ((frame_w - crop_w) // 2, 0, crop_w, crop_h)
-        else:
-            crop_w = frame_w
-            crop_h = int(frame_w / target_ar)
-            final_crop = (0, (frame_h - crop_h) // 2, crop_w, crop_h)
-    
-    # Reseta para início do vídeo
-    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-    
-    # Configura writer de saída
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (target_width, target_height))
-    
-    if not out.isOpened():
-        print(f"❌ Erro ao criar vídeo de saída: {output_path}")
-        cap.release()
-        return False
-    
-    # Processa cada frame
-    print(f"🎬 Processando vídeo com crop inteligente: {final_crop}")
-    frame_num = 0
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        
-        # Aplica crop
-        x, y, w, h = final_crop
-        cropped = frame[y:y+h, x:x+w]
-        
-        # Redimensiona para tamanho final
-        resized = cv2.resize(cropped, (target_width, target_height), interpolation=cv2.INTER_LANCZOS4)
-        
-        # Escreve frame
-        out.write(resized)
-        frame_num += 1
-        
-        # Progress
-        if frame_num % 30 == 0:
-            progress = (frame_num / frame_count) * 100
-            print(f"  Progresso: {progress:.1f}% ({frame_num}/{frame_count} frames)")
-    
-    # Finaliza
-    cap.release()
-    out.release()
-    
-    print(f"✓ Vídeo processado com sucesso: {output_path}")
-    return True
-
-
-def get_aspect_ratio_dimensions(ar_mode: str, base_height: int = 1080) -> Tuple[int, int]:
-    """
-    Retorna dimensões (width, height) baseado no modo de aspect ratio.
-    
-    Args:
-        ar_mode: Modo do aspect ratio ("Original", "Vertical 9:16", "Quadrado 1:1", "Retrato 4:5")
-        base_height: Altura base para cálculos (padrão: 1080p)
-        
-    Returns:
-        Tupla (width, height)
-    """
-    ar_map = {
-        "Original": None,  # Mantém original
-        "Vertical 9:16": (9, 16),
-        "Quadrado 1:1": (1, 1),
-        "Retrato 4:5": (4, 5),
-    }
-    
-    if ar_mode not in ar_map or ar_map[ar_mode] is None:
-        return None
-    
-    w_ratio, h_ratio = ar_map[ar_mode]
-    
-    # Calcula width baseado na altura
-    width = int((base_height / h_ratio) * w_ratio)
-    
-    return (width, base_height)
-
-
-# Exemplo de uso:
-if __name__ == "__main__":
-    # Teste básico
-    tracker = FaceTracker()
-    
-    # Simula um frame de teste
-    test_frame = np.zeros((1080, 1920, 3), dtype=np.uint8)
-    
-    # Detecta rostos
-    faces = tracker.detect_faces(test_frame)
-    print(f"Rostos detectados: {len(faces)}")
-    
-    # Calcula crop para 9:16
-    crop_coords = tracker.calculate_smart_crop(test_frame, 1080, 1920)
-    print(f"Coordenadas de crop (9:16): {crop_coords}")
-    
-    # Testa diferentes aspect ratios
-    for ar_mode in ["Vertical 9:16", "Quadrado 1:1", "Retrato 4:5"]:
-        dims = get_aspect_ratio_dimensions(ar_mode)
-        print(f"{ar_mode}: {dims}")