Upload 3 files

api.py

@@ -520,8 +520,10 @@ def process_video_job(job_id: str):
             else:
                 labels = []
 
-            # Construir carpetas por clúster y representative
-            characters = []
+            # Construir carpetas por clúster con validación DeepFace
+            from face_classifier import validate_and_classify_face, get_random_catalan_name_by_gender, FACE_CONFIDENCE_THRESHOLD
+            
+            characters_validated = []
             cluster_map: dict[int, list[int]] = {}
             for i, lbl in enumerate(labels):
                 if isinstance(lbl, int) and lbl >= 0:
@@ -530,20 +532,85 @@ def process_video_job(job_id: str):
             chars_dir = base / "characters"
             chars_dir.mkdir(parents=True, exist_ok=True)
             import shutil as _sh
+            
+            original_cluster_count = len(cluster_map)
+            print(f"[{job_id}] Procesando {original_cluster_count} clusters detectados...")
+            
             for ci, idxs in sorted(cluster_map.items(), key=lambda x: x[0]):
                 char_id = f"char_{ci:02d}"
+                
+                # PASO 1: Ordenar caras por área del bounding box (mejor calidad)
+                face_detections = []
+                for j in idxs:
+                    meta = crops_meta[j]
+                    box = meta.get("box", [0, 0, 0, 0])
+                    if len(box) >= 4:
+                        top, right, bottom, left = box
+                        w = abs(right - left)
+                        h = abs(bottom - top)
+                        area_score = w * h
+                    else:
+                        area_score = 0
+                    
+                    face_detections.append({
+                        'index': j,
+                        'score': area_score,
+                        'file': meta['file'],
+                        'box': box
+                    })
+                
+                # Ordenar por score descendente
+                face_detections_sorted = sorted(
+                    face_detections,
+                    key=lambda x: x['score'],
+                    reverse=True
+                )
+                
+                if not face_detections_sorted:
+                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: sense deteccions, eliminant")
+                    continue
+                
+                # PASO 2: Validar SOLO la mejor cara del cluster
+                best_face = face_detections_sorted[0]
+                best_face_path = faces_root / best_face['file']
+                
+                print(f"[{job_id}] [VALIDATION] Cluster {char_id}: validant millor cara (score={best_face['score']:.0f}px²)")
+                
+                validation = validate_and_classify_face(str(best_face_path))
+                
+                if not validation:
+                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: error en validació, eliminant")
+                    continue
+                
+                # PASO 3: Verificar si és una cara vàlida
+                if not validation['is_valid_face'] or validation['face_confidence'] < FACE_CONFIDENCE_THRESHOLD:
+                    print(f"[{job_id}] [VALIDATION] ✗ Cluster {char_id}: score baix ({validation['face_confidence']:.2f}), eliminant tot el clúster")
+                    continue
+                
+                # PASO 4: És una cara vàlida! Crear carpeta
                 out_dir = chars_dir / char_id
                 out_dir.mkdir(parents=True, exist_ok=True)
+                
+                # PASO 5: Limitar caras a mostrar (primera meitat + 1)
+                total_faces = len(face_detections_sorted)
+                max_faces_to_show = (total_faces // 2) + 1
+                face_detections_limited = face_detections_sorted[:max_faces_to_show]
+                
+                # Copiar solo las caras limitadas
                 files = []
-                for k, j in enumerate(idxs[:24]):  # limitar a 24
-                    fname = crops_meta[j]["file"]
+                face_files_urls = []
+                for k, face_det in enumerate(face_detections_limited):
+                    fname = face_det['file']
                     src = faces_root / fname
                     dst = out_dir / fname
                     try:
                         _sh.copy2(src, dst)
                         files.append(fname)
+                        face_files_urls.append(f"/files/{video_name}/{char_id}/{fname}")
                     except Exception:
                         pass
+                
+                # Imagen representativa (la mejor)
                 rep = files[0] if files else None
                 if rep:
                     rep_src = out_dir / rep
@@ -552,13 +619,38 @@ def process_video_job(job_id: str):
                         _sh.copy2(rep_src, rep_dst)
                     except Exception:
                         pass
-                characters.append({
+                
+                # PASO 6: Generar nombre según género
+                gender = validation['gender']
+                character_name = get_random_catalan_name_by_gender(gender, char_id)
+                
+                character_data = {
                     "id": char_id,
-                    "name": f"Personatge {ci+1}",
+                    "name": character_name,
+                    "gender": gender,
+                    "gender_confidence": validation['gender_confidence'],
+                    "face_confidence": validation['face_confidence'],
+                    "man_prob": validation['man_prob'],
+                    "woman_prob": validation['woman_prob'],
                     "folder": str(out_dir),
                     "num_faces": len(files),
+                    "total_faces_detected": total_faces,
                     "image_url": f"/files/{video_name}/{char_id}/representative.jpg" if rep else "",
-                })
+                    "face_files": face_files_urls,
+                }
+                
+                characters_validated.append(character_data)
+                
+                print(f"[{job_id}] [VALIDATION] ✓ Cluster {char_id}: cara vàlida! "
+                      f"Nom={character_name}, Gender={gender} (conf={validation['gender_confidence']:.2f}), "
+                      f"Mostrant {len(files)}/{total_faces} cares")
+            
+            # Estadístiques finals
+            eliminated_count = original_cluster_count - len(characters_validated)
+            print(f"[{job_id}] [VALIDATION] Total: {len(characters_validated)} clústers vàlids "
+                  f"(eliminats {eliminated_count} falsos positius)")
+            
+            characters = characters_validated
 
             # Escribir analysis.json compatible con 'originales'
             analysis = {

character_detection.py

@@ -247,16 +247,19 @@ class CharacterDetector:
     
     def create_character_folders(self, embeddings_caras: List[Dict], labels: np.ndarray) -> List[Dict[str, Any]]:
         """
-        Crea carpetas para cada personaje detectado y guarda las caras.
+        Crea carpetas para cada personaje detectado, valida caras y guarda metadata.
+        Integra validación con DeepFace para filtrar falsos positivos y detectar género.
         
         Args:
             embeddings_caras: Lista de embeddings de caras
             labels: Array de labels de clustering
         
         Returns:
-            Lista de personajes detectados con metadata
+            Lista de personajes detectados con metadata (solo clusters válidos)
         """
-        characters = []
+        from face_classifier import validate_and_classify_face, get_random_catalan_name_by_gender, FACE_CONFIDENCE_THRESHOLD
+        
+        characters_validated = []
         
         # Agrupar caras por cluster
         clusters = {}
@@ -267,43 +270,117 @@ class CharacterDetector:
                 clusters[label] = []
             clusters[label].append(idx)
         
-        logger.info(f"Creando carpetas para {len(clusters)} personajes...")
+        logger.info(f"Procesando {len(clusters)} clusters detectados...")
+        original_cluster_count = len(clusters)
         
-        # Crear carpeta para cada personaje
+        # Procesar cada cluster
         for cluster_id, face_indices in clusters.items():
-            char_id = f"char{cluster_id + 1}"
+            char_id = f"char_{cluster_id:02d}"
+            
+            # PASO 1: Ordenar caras por score (usar área como proxy de calidad)
+            # Caras más grandes = mejor detección
+            face_detections = []
+            for face_idx in face_indices:
+                face_data = embeddings_caras[face_idx]
+                facial_area = face_data.get('facial_area', {})
+                w = facial_area.get('w', 0)
+                h = facial_area.get('h', 0)
+                area_score = w * h  # Score basado en área
+                
+                face_detections.append({
+                    'index': face_idx,
+                    'score': area_score,
+                    'facial_area': facial_area,
+                    'path': face_data['path']
+                })
+            
+            # Ordenar por score descendente (mejores primero)
+            face_detections_sorted = sorted(
+                face_detections,
+                key=lambda x: x['score'],
+                reverse=True
+            )
+            
+            if not face_detections_sorted:
+                logger.info(f"[VALIDATION] ✗ Cluster {char_id}: sense deteccions, eliminant")
+                continue
+            
+            # PASO 2: Validar SOLO la mejor cara del cluster
+            best_face = face_detections_sorted[0]
+            best_face_path = best_face['path']
+            
+            logger.info(f"[VALIDATION] Cluster {char_id}: validant millor cara (score={best_face['score']:.0f}px²)")
+            
+            validation = validate_and_classify_face(best_face_path)
+            
+            if not validation:
+                logger.info(f"[VALIDATION] ✗ Cluster {char_id}: error en validació, eliminant")
+                continue
+            
+            # PASO 3: Verificar si és una cara vàlida
+            if not validation['is_valid_face'] or validation['face_confidence'] < FACE_CONFIDENCE_THRESHOLD:
+                logger.info(f"[VALIDATION] ✗ Cluster {char_id}: score baix ({validation['face_confidence']:.2f}), eliminant tot el clúster")
+                continue
+            
+            # PASO 4: És una cara vàlida! Crear carpeta
             char_dir = self.output_base / char_id
             char_dir.mkdir(parents=True, exist_ok=True)
             
-            # Copiar todas las caras del personaje
-            for i, face_idx in enumerate(face_indices):
-                src_path = Path(embeddings_caras[face_idx]['path'])
+            # PASO 5: Limitar caras a mostrar (primera meitat + 1)
+            total_faces = len(face_detections_sorted)
+            max_faces_to_show = (total_faces // 2) + 1
+            face_detections_limited = face_detections_sorted[:max_faces_to_show]
+            
+            # Copiar solo las caras limitadas
+            face_files = []
+            for i, face_det in enumerate(face_detections_limited):
+                src_path = Path(face_det['path'])
                 dst_path = char_dir / f"face_{i:03d}.jpg"
                 if src_path.exists():
                     shutil.copy(src_path, dst_path)
+                    face_files.append(f"/files/{self.video_name}/{char_id}/face_{i:03d}.jpg")
             
-            # Seleccionar imagen representativa (primera cara)
-            if face_indices:
-                representative_src = Path(embeddings_caras[face_indices[0]]['path'])
-                representative_dst = char_dir / "representative.jpg"
-                if representative_src.exists():
-                    shutil.copy(representative_src, representative_dst)
+            # Imagen representativa (la mejor)
+            representative_src = Path(best_face_path)
+            representative_dst = char_dir / "representative.jpg"
+            if representative_src.exists():
+                shutil.copy(representative_src, representative_dst)
+            
+            # PASO 6: Generar nombre según género
+            gender = validation['gender']
+            character_name = get_random_catalan_name_by_gender(gender, char_id)
             
             # Metadata del personaje
-            # Construir URL relativa para la imagen
             image_url = f"/files/{self.video_name}/{char_id}/representative.jpg"
             
-            characters.append({
+            character_data = {
                 "id": char_id,
-                "name": f"Personatge {cluster_id + 1}",
-                "image_path": str(char_dir / "representative.jpg"),  # Ruta local
-                "image_url": image_url,  # URL para el API
-                "num_faces": len(face_indices),
+                "name": character_name,
+                "gender": gender,
+                "gender_confidence": validation['gender_confidence'],
+                "face_confidence": validation['face_confidence'],
+                "man_prob": validation['man_prob'],
+                "woman_prob": validation['woman_prob'],
+                "image_path": str(representative_dst),
+                "image_url": image_url,
+                "face_files": face_files,
+                "num_faces": len(face_detections_limited),
+                "total_faces_detected": total_faces,
                 "folder": str(char_dir)
-            })
+            }
+            
+            characters_validated.append(character_data)
+            
+            logger.info(f"[VALIDATION] ✓ Cluster {char_id}: cara vàlida! "
+                       f"Nom={character_name}, Gender={gender} (conf={validation['gender_confidence']:.2f}), "
+                       f"Mostrant {len(face_detections_limited)}/{total_faces} cares")
+        
+        # Estadístiques finals
+        eliminated_count = original_cluster_count - len(characters_validated)
+        logger.info(f"[VALIDATION] Total: {len(characters_validated)} clústers vàlids "
+                   f"(eliminats {eliminated_count} falsos positius)")
         
-        logger.info(f"Carpetas creadas para {len(characters)} personajes")
-        return characters
+        return characters_validated
     
     def save_analysis_json(self, embeddings_caras: List[Dict], embeddings_voices: List[Dict], 
                           embeddings_escenas: List[Dict]) -> Path:

face_classifier.py

@@ -0,0 +1,158 @@
+"""
+Face Classifier Module
+Valida caras y detecta género usando DeepFace para filtrar falsos positivos
+y asignar nombres automáticos según el género detectado.
+"""
+import logging
+from typing import Optional, Dict, Any
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuración de thresholds
+FACE_CONFIDENCE_THRESHOLD = 0.3  # Mínimo para considerar cara válida
+GENDER_NEUTRAL_THRESHOLD = 0.2   # Diferencia mínima para género neutro
+
+
+def validate_and_classify_face(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Valida si és una cara real i detecta el gènere usant DeepFace.
+    
+    Args:
+        image_path: Ruta a la imagen de la cara
+    
+    Returns:
+        Dict amb: {
+            'is_valid_face': bool,          # True si és una cara amb confiança alta
+            'face_confidence': float,        # Score de detecció de cara (0-1)
+            'gender': 'Man' | 'Woman' | 'Neutral',
+            'gender_confidence': float,      # Score de confiança del gènere (0-1)
+            'man_prob': float,
+            'woman_prob': float
+        }
+        o None si falla completament
+    """
+    try:
+        from deepface import DeepFace
+        
+        logger.info(f"[DeepFace] Analitzant: {image_path}")
+        
+        # Analitzar gènere amb detecció de cara
+        result = DeepFace.analyze(
+            img_path=image_path,
+            actions=['gender'],
+            enforce_detection=True,  # Intentar detectar cara
+            detector_backend='opencv',
+            silent=True
+        )
+        
+        # DeepFace pot retornar llista si detecta múltiples cares
+        if isinstance(result, list):
+            result = result[0] if result else None
+        
+        if not result:
+            logger.info(f"[DeepFace] No s'ha detectat cap cara")
+            return {
+                'is_valid_face': False,
+                'face_confidence': 0.0,
+                'gender': 'Neutral',
+                'gender_confidence': 0.0,
+                'man_prob': 0.0,
+                'woman_prob': 0.0
+            }
+        
+        # Extreure informació de gènere
+        gender_info = result.get('gender', {})
+        
+        if isinstance(gender_info, dict):
+            # DeepFace retorna percentatges, convertir a 0-1
+            man_prob = gender_info.get('Man', 0) / 100.0
+            woman_prob = gender_info.get('Woman', 0) / 100.0
+        else:
+            # Fallback si el format és diferent
+            man_prob = 0.5
+            woman_prob = 0.5
+        
+        # Determinar gènere basat en les probabilitats
+        gender_diff = abs(man_prob - woman_prob)
+        
+        # Si la diferència és petita (< threshold), considerar neutre
+        if gender_diff < GENDER_NEUTRAL_THRESHOLD:
+            gender = 'Neutral'
+            gender_confidence = 0.5
+        else:
+            gender = 'Man' if man_prob > woman_prob else 'Woman'
+            gender_confidence = max(man_prob, woman_prob)
+        
+        # Confiança de detecció de cara
+        # DeepFace no proporciona score directament, però si va retornar resultat
+        # assumim que és cara vàlida amb confiança alta
+        face_confidence = result.get('face_confidence', 0.9)  # Default alt si detecta
+        
+        # Si DeepFace va retornar resultat, assumir que és cara vàlida
+        is_valid_face = True
+        
+        logger.info(f"[DeepFace] Resultat: gender={gender}, confidence={gender_confidence:.2f}, "
+              f"man={man_prob:.2f}, woman={woman_prob:.2f}")
+        
+        return {
+            'is_valid_face': is_valid_face,
+            'face_confidence': face_confidence,
+            'gender': gender,
+            'gender_confidence': gender_confidence,
+            'man_prob': man_prob,
+            'woman_prob': woman_prob
+        }
+        
+    except ValueError as e:
+        # ValueError significa que no es va detectar cara
+        logger.info(f"[DeepFace] No s'ha detectat cara (ValueError): {e}")
+        return {
+            'is_valid_face': False,
+            'face_confidence': 0.0,
+            'gender': 'Neutral',
+            'gender_confidence': 0.0,
+            'man_prob': 0.0,
+            'woman_prob': 0.0
+        }
+    except Exception as e:
+        logger.warning(f"[DeepFace] Error validant cara: {e}")
+        return None
+
+
+def get_random_catalan_name_by_gender(gender: str, seed_value: str = "") -> str:
+    """
+    Genera un nom català aleatori basat en el gènere.
+    
+    Args:
+        gender: 'Man', 'Woman', o 'Neutral'
+        seed_value: Valor per fer el random determinista (opcional)
+    
+    Returns:
+        Nom català
+    """
+    noms_home = [
+        "Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Guillem", "Albert",
+        "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"
+    ]
+    noms_dona = [
+        "Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
+        "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"
+    ]
+    noms_neutre = ["Àlex", "Andrea", "Francis", "Cris", "Noa"]
+    
+    # Seleccionar llista segons gènere
+    if gender == 'Woman':
+        noms = noms_dona
+    elif gender == 'Man':
+        noms = noms_home
+    else:  # Neutral
+        noms = noms_neutre
+    
+    # Usar hash del seed per seleccionar nom de forma determinista
+    if seed_value:
+        hash_val = hash(seed_value)
+        return noms[abs(hash_val) % len(noms)]
+    else:
+        import random
+        return random.choice(noms)