Upload 2 files

character_detection.py

@@ -18,20 +18,12 @@ from typing import List, Dict, Any, Tuple
 
 # Imports de las herramientas de vision y audio desde los módulos de la raíz
 try:
-    # Vision tools del engine (ya incluye DeepFace y face_recognition)
-    from vision_tools import FaceOfImageEmbedding
-    VISION_TOOLS_AVAILABLE = True
+    # DeepFace para detección y embeddings de caras
+    from deepface import DeepFace
+    DEEPFACE_AVAILABLE = True
 except Exception as e:
-    VISION_TOOLS_AVAILABLE = False
-    logging.warning(f"Vision tools no disponibles: {e}")
-
-try:
-    # Audio tools del engine
-    from audio_tools import extract_audio_ffmpeg_simple, diarize_with_pyannote, get_speaker_embeddings
-    AUDIO_TOOLS_AVAILABLE = True
-except Exception as e:
-    AUDIO_TOOLS_AVAILABLE = False
-    logging.warning(f"Audio tools no disponibles: {e}")
+    DEEPFACE_AVAILABLE = False
+    logging.warning(f"DeepFace no disponible: {e}")
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -62,29 +54,29 @@ class CharacterDetector:
     
     def extract_faces_embeddings(self) -> List[Dict[str, Any]]:
         """
-        Extrae caras del vídeo y calcula sus embeddings usando FaceOfImageEmbedding.
+        Extrae caras del vídeo y calcula sus embeddings usando DeepFace directamente.
         
         Returns:
             Lista de dicts con {"embeddings": [...], "path": "..."}
         """
-        if not VISION_TOOLS_AVAILABLE:
-            logger.warning("Vision tools no disponibles, retornando lista vacía")
+        if not DEEPFACE_AVAILABLE:
+            logger.warning("DeepFace no disponible, retornando lista vacía")
             return []
         
-        logger.info("Extrayendo caras del vídeo...")
-        
-        # Inicializar el embedder (usa face_recognition o DeepFace automáticamente)
-        embedder = FaceOfImageEmbedding(deepface_model='Facenet512')
+        logger.info("Extrayendo caras del vídeo con DeepFace...")
         
         extract_every = 1.0  # segundos
         video = cv2.VideoCapture(self.video_path)
         fps = int(video.get(cv2.CAP_PROP_FPS))
+        total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
         frame_interval = int(fps * extract_every)
         frame_count = 0
         saved_count = 0
         
         embeddings_caras = []
         
+        logger.info(f"Total frames: {total_frames}, FPS: {fps}, Procesando cada {frame_interval} frames")
+        
         while True:
             ret, frame = video.read()
             if not ret:
@@ -95,35 +87,34 @@ class CharacterDetector:
                 cv2.imwrite(str(temp_path), frame)
                 
                 try:
-                    # Extraer embeddings usando FaceOfImageEmbedding
-                    # Devuelve una lista de embeddings (uno por cada cara detectada)
-                    embeddings_list = embedder.encode_image(temp_path)
+                    # Extraer embeddings con DeepFace
+                    # represent() devuelve una lista de dicts, uno por cada cara detectada
+                    face_objs = DeepFace.represent(
+                        img_path=str(temp_path),
+                        model_name='Facenet512',
+                        detector_backend='opencv',
+                        enforce_detection=False
+                    )
                     
-                    if embeddings_list:
-                        # Si es una lista de listas (múltiples caras)
-                        if isinstance(embeddings_list[0], list):
-                            for i, embedding in enumerate(embeddings_list):
-                                save_path = self.faces_dir / f"frame_{saved_count:04d}.jpg"
-                                # Guardar el frame completo (la extracción de cara ya se hizo internamente)
-                                cv2.imwrite(str(save_path), frame)
-                                
-                                embeddings_caras.append({
-                                    "embeddings": embedding,
-                                    "path": str(save_path),
-                                    "frame": frame_count
-                                })
-                                saved_count += 1
-                        else:
-                            # Si es un solo embedding
+                    if face_objs:
+                        for i, face_obj in enumerate(face_objs):
+                            embedding = face_obj['embedding']
+                            facial_area = face_obj.get('facial_area', {})
+                            
+                            # Guardar el frame completo
                             save_path = self.faces_dir / f"frame_{saved_count:04d}.jpg"
                             cv2.imwrite(str(save_path), frame)
                             
                             embeddings_caras.append({
-                                "embeddings": embeddings_list,
+                                "embeddings": embedding,
                                 "path": str(save_path),
-                                "frame": frame_count
+                                "frame": frame_count,
+                                "facial_area": facial_area
                             })
                             saved_count += 1
+                        
+                        if frame_count % (frame_interval * 10) == 0:
+                            logger.info(f"Progreso: frame {frame_count}/{total_frames}, caras detectadas: {saved_count}")
                 
                 except Exception as e:
                     logger.debug(f"No se detectaron caras en frame {frame_count}: {e}")
@@ -134,7 +125,7 @@ class CharacterDetector:
             frame_count += 1
         
         video.release()
-        logger.info(f"Caras extraídas: {len(embeddings_caras)}")
+        logger.info(f"✓ Caras extraídas: {len(embeddings_caras)}")
         return embeddings_caras
     
     def extract_voices_embeddings(self) -> List[Dict[str, Any]]: