Upload 4 files

.gitignore

@@ -0,0 +1,40 @@
+# Documentación local (no subir a HF)
+docs/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Entornos virtuales
+venv/
+env/
+ENV/
+
+# Base de datos local
+*.db
+
+# Archivos temporales
+temp/
+tmp/
+*.tmp
+
+# Variables de entorno
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Sistema
+.DS_Store
+Thumbs.db
+
+# Datos temporales
+data/
+videos/

api.py

@@ -1,16 +1,21 @@
 from __future__ import annotations
-from fastapi import FastAPI, UploadFile, File, Form
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pathlib import Path
 import shutil
 import uvicorn
 import json
+import uuid
+from datetime import datetime
+from typing import Dict
+from enum import Enum
 
 from video_processing import process_video_pipeline
 from casting_loader import ensure_chroma, build_faces_index, build_voices_index
 from narration_system import NarrationSystem
 from llm_router import load_yaml, LLMRouter
+from character_detection import detect_characters_from_video
 
 app = FastAPI(title="Veureu Engine API", version="0.2.0")
 app.add_middleware(
@@ -28,6 +33,15 @@ TEMP_ROOT.mkdir(parents=True, exist_ok=True)
 VIDEOS_ROOT = Path("/tmp/data/videos")
 VIDEOS_ROOT.mkdir(parents=True, exist_ok=True)
 
+# Sistema de jobs asíncronos
+class JobStatus(str, Enum):
+    QUEUED = "queued"
+    PROCESSING = "processing"
+    DONE = "done"
+    FAILED = "failed"
+
+jobs: Dict[str, dict] = {}
+
 @app.get("/")
 def root():
     return {"ok": True, "service": "veureu-engine"}
@@ -47,34 +61,147 @@ async def process_video(
 
 @app.post("/create_initial_casting")
 async def create_initial_casting(
+    background_tasks: BackgroundTasks,
     video: UploadFile = File(...),
     epsilon: float = Form(...),
     min_cluster_size: int = Form(...),
 ):
+    """
+    Crea un job para procesar el vídeo de forma asíncrona.
+    Devuelve un job_id inmediatamente.
+    """
     # Guardar vídeo en carpeta de datos
     video_name = Path(video.filename).stem
     dst_video = VIDEOS_ROOT / f"{video_name}.mp4"
     with dst_video.open("wb") as f:
         shutil.copyfileobj(video.file, f)
 
-    # Crear estructura de carpetas en temp/<uploaded-video>/...
-    base = TEMP_ROOT / video_name
-    for sub in ("sources", "faces", "voices", "backgrounds"):
-        (base / sub).mkdir(parents=True, exist_ok=True)
-
-    # Aquí en el futuro se puede disparar la lógica real de detección
-    return {
-        "ok": True,
-        "video": str(dst_video),
+    # Crear job_id único
+    job_id = str(uuid.uuid4())
+    
+    # Inicializar el job
+    jobs[job_id] = {
+        "id": job_id,
+        "status": JobStatus.QUEUED,
+        "video_path": str(dst_video),
+        "video_name": video_name,
         "epsilon": float(epsilon),
         "min_cluster_size": int(min_cluster_size),
-        "temp_dirs": {
-            "sources": str(base / "sources"),
-            "faces": str(base / "faces"),
-            "voices": str(base / "voices"),
-            "backgrounds": str(base / "backgrounds"),
-        },
+        "created_at": datetime.now().isoformat(),
+        "results": None,
+        "error": None
+    }
+    
+    print(f"[{job_id}] Job creado para vídeo: {video_name}")
+    
+    # Iniciar procesamiento en background
+    background_tasks.add_task(process_video_job, job_id)
+    
+    # Devolver job_id inmediatamente
+    return {"job_id": job_id}
+
+@app.get("/jobs/{job_id}/status")
+def get_job_status(job_id: str):
+    """
+    Devuelve el estado actual de un job.
+    El UI hace polling de este endpoint cada 5 segundos.
+    """
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    
+    job = jobs[job_id]
+    
+    response = {
+        "status": job["status"]
     }
+    
+    # Si está completado, incluir resultados
+    if job["status"] == JobStatus.DONE:
+        response["results"] = job["results"]
+    
+    # Si falló, incluir error
+    elif job["status"] == JobStatus.FAILED:
+        response["error"] = job["error"]
+    
+    return response
+
+def process_video_job(job_id: str):
+    """
+    Procesa el vídeo de forma asíncrona.
+    Esta función se ejecuta en background.
+    """
+    try:
+        job = jobs[job_id]
+        print(f"[{job_id}] Iniciando procesamiento...")
+        
+        # Cambiar estado a processing
+        job["status"] = JobStatus.PROCESSING
+        
+        video_path = job["video_path"]
+        video_name = job["video_name"]
+        epsilon = job["epsilon"]
+        min_cluster_size = job["min_cluster_size"]
+        
+        # Crear estructura de carpetas
+        base = TEMP_ROOT / video_name
+        base.mkdir(parents=True, exist_ok=True)
+        
+        print(f"[{job_id}] Directorio base: {base}")
+        
+        # Detección real de personajes usando el código de Ana
+        try:
+            print(f"[{job_id}] Iniciando detección de personajes...")
+            result = detect_characters_from_video(
+                video_path=video_path,
+                output_base=str(base),
+                epsilon=epsilon,
+                min_cluster_size=min_cluster_size
+            )
+            
+            characters = result.get("characters", [])
+            analysis_path = result.get("analysis_path", "")
+            
+            print(f"[{job_id}] Personajes detectados: {len(characters)}")
+            for char in characters:
+                print(f"[{job_id}]   - {char['name']}: {char['num_faces']} caras")
+            
+            # Marcar como completado
+            job["status"] = JobStatus.DONE
+            job["results"] = {
+                "characters": characters,
+                "num_characters": len(characters),
+                "analysis_path": analysis_path,
+                "base_dir": str(base)
+            }
+            
+        except Exception as e_detect:
+            # Si falla la detección, intentar modo fallback
+            print(f"[{job_id}] Error en detección: {e_detect}")
+            print(f"[{job_id}] Usando modo fallback (carpetas vacías)")
+            
+            # Crear carpetas básicas como fallback
+            for sub in ("sources", "faces", "voices", "backgrounds"):
+                (base / sub).mkdir(parents=True, exist_ok=True)
+            
+            job["status"] = JobStatus.DONE
+            job["results"] = {
+                "characters": [],
+                "num_characters": 0,
+                "temp_dirs": {
+                    "sources": str(base / "sources"),
+                    "faces": str(base / "faces"),
+                    "voices": str(base / "voices"),
+                    "backgrounds": str(base / "backgrounds"),
+                },
+                "warning": f"Detección falló, usando modo fallback: {str(e_detect)}"
+            }
+        
+        print(f"[{job_id}] ✓ Job completado exitosamente")
+        
+    except Exception as e:
+        print(f"[{job_id}] ✗ Error en el procesamiento: {e}")
+        jobs[job_id]["status"] = JobStatus.FAILED
+        jobs[job_id]["error"] = str(e)
 
 @app.post("/load_casting")
 async def load_casting(

character_detection.py

@@ -0,0 +1,360 @@
+"""
+Character Detection Module
+Integra el trabajo de Ana para detección de personajes mediante:
+1. Extracción de caras y embeddings
+2. Extracción de voces y embeddings
+3. Clustering con DBSCAN
+4. Generación de carpetas por personaje
+"""
+import cv2
+import os
+import json
+import logging
+import shutil
+from pathlib import Path
+from sklearn.cluster import DBSCAN
+import numpy as np
+from typing import List, Dict, Any, Tuple
+
+# Imports de las herramientas de vision y audio
+# Nota: Estos imports asumen que los archivos están en originales/
+# y que tienen las dependencias necesarias instaladas
+try:
+    import sys
+    sys.path.insert(0, str(Path(__file__).parent / "originales"))
+    from vision_tools_salamandra_2 import FaceOfImageEmbedding_video_nuevo, ImageEmbedding, keyframe_conditional_extraction_ana
+    from audio_tools_ana_2 import extract_audio_ffmpeg, diarize_audio, embed_voice_segments
+    TOOLS_AVAILABLE = True
+except Exception as e:
+    TOOLS_AVAILABLE = False
+    logging.warning(f"No se pudieron importar las herramientas de Ana: {e}")
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class CharacterDetector:
+    """
+    Detector de personajes que integra el trabajo de Ana.
+    """
+    
+    def __init__(self, video_path: str, output_base: Path):
+        """
+        Args:
+            video_path: Ruta al archivo de vídeo
+            output_base: Directorio base para guardar resultados (ej: /tmp/temp/video_name)
+        """
+        self.video_path = video_path
+        self.output_base = Path(output_base)
+        self.output_base.mkdir(parents=True, exist_ok=True)
+        
+        # Crear subdirectorios
+        self.faces_dir = self.output_base / "faces"
+        self.voices_dir = self.output_base / "voices"
+        self.scenes_dir = self.output_base / "scenes"
+        
+        for d in [self.faces_dir, self.voices_dir, self.scenes_dir]:
+            d.mkdir(parents=True, exist_ok=True)
+    
+    def extract_faces_embeddings(self) -> List[Dict[str, Any]]:
+        """
+        Extrae caras del vídeo y calcula sus embeddings.
+        Basado en faces_embedding_extraction de Ana.
+        
+        Returns:
+            Lista de dicts con {"embeddings": [...], "path": "..."}
+        """
+        if not TOOLS_AVAILABLE:
+            logger.warning("Herramientas no disponibles, retornando lista vacía")
+            return []
+        
+        logger.info("Extrayendo caras del vídeo...")
+        extract_every = 1.0  # segundos
+        embedder = FaceOfImageEmbedding_video_nuevo()
+        video = cv2.VideoCapture(self.video_path)
+        fps = int(video.get(cv2.CAP_PROP_FPS))
+        frame_interval = int(fps * extract_every)
+        frame_count = 0
+        saved_count = 0
+        
+        embeddings_caras = []
+        
+        while True:
+            ret, frame = video.read()
+            if not ret:
+                break
+            
+            if frame_count % frame_interval == 0:
+                temp_path = self.faces_dir / "temp_frame.jpg"
+                cv2.imwrite(str(temp_path), frame)
+                resultados = embedder.encode_image(temp_path)
+                
+                if resultados:
+                    for i, r in enumerate(resultados):
+                        embedding = r['embedding']
+                        cara = r['face_crop']
+                        save_path = self.faces_dir / f"frame_{saved_count:04d}.jpg"
+                        cv2.imwrite(str(save_path), cv2.cvtColor(cara, cv2.COLOR_RGB2BGR))
+                        embeddings_caras.append({
+                            "embeddings": embedding,
+                            "path": str(save_path),
+                            "frame": frame_count
+                        })
+                        saved_count += 1
+                
+                if temp_path.exists():
+                    os.remove(temp_path)
+            
+            frame_count += 1
+        
+        video.release()
+        logger.info(f"Caras extraídas: {len(embeddings_caras)}")
+        return embeddings_caras
+    
+    def extract_voices_embeddings(self) -> List[Dict[str, Any]]:
+        """
+        Extrae voces del vídeo y calcula sus embeddings.
+        Basado en voices_embedding_extraction de Ana.
+        
+        Returns:
+            Lista de dicts con {"embeddings": [...], "path": "..."}
+        """
+        if not TOOLS_AVAILABLE:
+            logger.warning("Herramientas no disponibles, retornando lista vacía")
+            return []
+        
+        logger.info("Extrayendo voces del vídeo...")
+        sr = 16000
+        fmt = "wav"
+        
+        wav_path = extract_audio_ffmpeg(
+            self.video_path,
+            self.voices_dir / f"{Path(self.video_path).stem}.{fmt}",
+            sr=sr
+        )
+        
+        min_dur = 0.5
+        max_dur = 10.0
+        
+        clip_paths, diar_segs = diarize_audio(
+            wav_path,
+            self.voices_dir,
+            "clips",
+            min_dur,
+            max_dur
+        )
+        
+        embeddings_voices = []
+        embeddings = embed_voice_segments(clip_paths)
+        
+        for i, emb in enumerate(embeddings):
+            embeddings_voices.append({
+                "embeddings": emb,
+                "path": str(clip_paths[i])
+            })
+        
+        logger.info(f"Voces extraídas: {len(embeddings_voices)}")
+        return embeddings_voices
+    
+    def extract_scenes_embeddings(self) -> List[Dict[str, Any]]:
+        """
+        Extrae escenas clave del vídeo y calcula sus embeddings.
+        Basado en scenes_embedding_extraction de Ana.
+        
+        Returns:
+            Lista de dicts con {"embeddings": [...], "path": "..."}
+        """
+        if not TOOLS_AVAILABLE:
+            logger.warning("Herramientas no disponibles, retornando lista vacía")
+            return []
+        
+        logger.info("Extrayendo escenas del vídeo...")
+        keyframes_final = keyframe_conditional_extraction_ana(
+            video_path=self.video_path,
+            output_dir=self.scenes_dir,
+            threshold=30.0,
+        )
+        
+        image_embedder = ImageEmbedding()
+        embeddings_escenas = []
+        
+        for keyframe in keyframes_final:
+            frame_path = keyframe["path"]
+            embedding = image_embedder.encode_image(frame_path)
+            embeddings_escenas.append({
+                "embeddings": embedding,
+                "path": str(frame_path)
+            })
+        
+        logger.info(f"Escenas extraídas: {len(embeddings_escenas)}")
+        return embeddings_escenas
+    
+    def cluster_faces(self, embeddings_caras: List[Dict], epsilon: float, min_samples: int) -> np.ndarray:
+        """
+        Agrupa caras similares usando DBSCAN.
+        Basado en get_face_clusters de Ana.
+        
+        Args:
+            embeddings_caras: Lista de embeddings de caras
+            epsilon: Parámetro eps de DBSCAN
+            min_samples: Parámetro min_samples de DBSCAN
+        
+        Returns:
+            Array de labels (cluster asignado a cada cara)
+        """
+        if not embeddings_caras:
+            return np.array([])
+        
+        logger.info(f"Clustering {len(embeddings_caras)} caras con eps={epsilon}, min_samples={min_samples}")
+        
+        # Extraer solo los embeddings
+        X = np.array([cara['embeddings'] for cara in embeddings_caras])
+        
+        # DBSCAN clustering
+        clustering = DBSCAN(eps=epsilon, min_samples=min_samples, metric='euclidean').fit(X)
+        labels = clustering.labels_
+        
+        # Contar clusters (excluyendo ruido -1)
+        n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
+        n_noise = list(labels).count(-1)
+        
+        logger.info(f"Clusters encontrados: {n_clusters}, Ruido: {n_noise}")
+        return labels
+    
+    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.
+        
+        Args:
+            embeddings_caras: Lista de embeddings de caras
+            labels: Array de labels de clustering
+        
+        Returns:
+            Lista de personajes detectados con metadata
+        """
+        characters = []
+        
+        # Agrupar caras por cluster
+        clusters = {}
+        for idx, label in enumerate(labels):
+            if label == -1:  # Ignorar ruido
+                continue
+            if label not in clusters:
+                clusters[label] = []
+            clusters[label].append(idx)
+        
+        logger.info(f"Creando carpetas para {len(clusters)} personajes...")
+        
+        # Crear carpeta para cada personaje
+        for cluster_id, face_indices in clusters.items():
+            char_id = f"char{cluster_id + 1}"
+            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'])
+                dst_path = char_dir / f"face_{i:03d}.jpg"
+                if src_path.exists():
+                    shutil.copy(src_path, dst_path)
+            
+            # 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)
+            
+            # Metadata del personaje
+            characters.append({
+                "id": char_id,
+                "name": f"Personatge {cluster_id + 1}",
+                "image_path": str(char_dir / "representative.jpg"),
+                "num_faces": len(face_indices),
+                "folder": str(char_dir)
+            })
+        
+        logger.info(f"Carpetas creadas para {len(characters)} personajes")
+        return characters
+    
+    def save_analysis_json(self, embeddings_caras: List[Dict], embeddings_voices: List[Dict], 
+                          embeddings_escenas: List[Dict]) -> Path:
+        """
+        Guarda el análisis completo en un archivo JSON.
+        Similar al analysis.json de Ana.
+        
+        Returns:
+            Path al archivo JSON guardado
+        """
+        analysis_data = {
+            "caras": embeddings_caras,
+            "voices": embeddings_voices,
+            "escenas": embeddings_escenas
+        }
+        
+        analysis_path = self.output_base / "analysis.json"
+        
+        try:
+            with open(analysis_path, "w", encoding="utf-8") as f:
+                json.dump(analysis_data, f, indent=2, ensure_ascii=False)
+            logger.info(f"Analysis JSON guardado: {analysis_path}")
+        except Exception as e:
+            logger.warning(f"Error al guardar analysis JSON: {e}")
+        
+        return analysis_path
+    
+    def detect_characters(self, epsilon: float = 0.5, min_cluster_size: int = 2) -> Tuple[List[Dict], Path]:
+        """
+        Pipeline completo de detección de personajes.
+        
+        Args:
+            epsilon: Parámetro epsilon para DBSCAN
+            min_cluster_size: Tamaño mínimo de cluster
+        
+        Returns:
+            Tuple de (lista de personajes, path al analysis.json)
+        """
+        # 1. Extraer caras y embeddings
+        embeddings_caras = self.extract_faces_embeddings()
+        
+        # 2. Extraer voces y embeddings (opcional, por ahora)
+        embeddings_voices = self.extract_voices_embeddings()
+        
+        # 3. Extraer escenas y embeddings (opcional, por ahora)
+        embeddings_escenas = self.extract_scenes_embeddings()
+        
+        # 4. Guardar análisis completo
+        analysis_path = self.save_analysis_json(embeddings_caras, embeddings_voices, embeddings_escenas)
+        
+        # 5. Clustering de caras
+        labels = self.cluster_faces(embeddings_caras, epsilon, min_cluster_size)
+        
+        # 6. Crear carpetas de personajes
+        characters = self.create_character_folders(embeddings_caras, labels)
+        
+        return characters, analysis_path
+
+
+# Función de conveniencia para usar en el API
+def detect_characters_from_video(video_path: str, output_base: str, 
+                                 epsilon: float = 0.5, min_cluster_size: int = 2) -> Dict[str, Any]:
+    """
+    Función de alto nivel para detectar personajes en un vídeo.
+    
+    Args:
+        video_path: Ruta al vídeo
+        output_base: Directorio base para guardar resultados
+        epsilon: Parámetro epsilon para DBSCAN
+        min_cluster_size: Tamaño mínimo de cluster
+    
+    Returns:
+        Dict con resultados: {"characters": [...], "analysis_path": "..."}
+    """
+    detector = CharacterDetector(video_path, Path(output_base))
+    characters, analysis_path = detector.detect_characters(epsilon, min_cluster_size)
+    
+    return {
+        "characters": characters,
+        "analysis_path": str(analysis_path),
+        "num_characters": len(characters)
+    }

requirements.txt

@@ -33,7 +33,7 @@ pytesseract>=0.3
 easyocr>=1.7
 Pillow>=10.4
 # face-recognition>=1.3.0  # Requires dlib/cmake - optional, handled gracefully in code
-# deepface>=0.0.79  # Heavy dependency - optional, handled gracefully in code
+deepface>=0.0.79  # Necesario para detección de personajes
 
 # Embeddings / ML
 scikit-learn==1.4.2