Upload api.py

api.py

@@ -181,26 +181,158 @@ def process_video_job(job_id: str):
         
         print(f"[{job_id}] Directorio base: {base}")
         
-        # Detección real de personajes usando el código de Ana
+        # Detección de caras y embeddings (CPU), alineado con 'originales'
         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,
-                video_name=video_name,
-                start_offset_sec=0.5,
-                extract_every_sec=0.25
-            )
-            
-            print(f"[{job_id}] DEBUG - result completo: {result}")
-            
-            characters = result.get("characters", [])
-            analysis_path = result.get("analysis_path", "")
-            face_labels = result.get("face_labels", [])
-            num_face_embeddings = int(result.get("num_face_embeddings", 0))
+            print(f"[{job_id}] Iniciando detección de personajes (CPU, originales)...")
+            import cv2
+            import numpy as np
+            try:
+                import face_recognition  # CPU
+                _use_fr = True
+                print(f"[{job_id}] face_recognition disponible: CPU")
+            except Exception:
+                face_recognition = None  # type: ignore
+                _use_fr = False
+                print(f"[{job_id}] face_recognition no disponible. Intentando DeepFace fallback.")
+                try:
+                    from deepface import DeepFace  # type: ignore
+                except Exception:
+                    DeepFace = None  # type: ignore
             
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise RuntimeError("No se pudo abrir el vídeo para extracción de caras")
+            fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+            step = max(1, int(3))  # cada ~3 frames para CPU
+            print(f"[{job_id}] Total frames: {total_frames}, FPS: {fps:.2f}, Procesando cada {step} frames")
+
+            # Salidas
+            faces_root = base / "faces_raw"
+            faces_root.mkdir(parents=True, exist_ok=True)
+            embeddings: list[list[float]] = []
+            crops_meta: list[dict] = []
+
+            frame_idx = 0
+            saved_count = 0
+            while True:
+                ret = cap.grab()
+                if not ret:
+                    break
+                if frame_idx % step == 0:
+                    ret2, frame = cap.retrieve()
+                    if not ret2:
+                        break
+                    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+                    if _use_fr and face_recognition is not None:
+                        boxes = face_recognition.face_locations(rgb, model="hog")  # CPU HOG
+                        encs = face_recognition.face_encodings(rgb, boxes)
+                        for (top, right, bottom, left), e in zip(boxes, encs):
+                            crop = frame[top:bottom, left:right]
+                            if crop.size == 0:
+                                continue
+                            fn = f"face_{frame_idx:06d}_{saved_count:03d}.jpg"
+                            cv2.imwrite(str(faces_root / fn), crop)
+                            # Normalizar embedding
+                            e = np.array(e, dtype=float)
+                            e = e / (np.linalg.norm(e) + 1e-9)
+                            embeddings.append(e.astype(float).tolist())
+                            crops_meta.append({
+                                "file": fn,
+                                "frame": frame_idx,
+                                "box": [int(top), int(right), int(bottom), int(left)],
+                            })
+                            saved_count += 1
+                    else:
+                        # DeepFace fallback: no siempre devuelve boxes fácilmente; intentamos representaciones
+                        if DeepFace is None:
+                            pass
+                        else:
+                            try:
+                                tmp_path = faces_root / f"frame_{frame_idx:06d}.jpg"
+                                cv2.imwrite(str(tmp_path), frame)
+                                reps = DeepFace.represent(img_path=str(tmp_path), model_name="Facenet512", enforce_detection=False)
+                                # reps puede ser lista de embeddings; no tenemos boxes -> guardamos frame completo como proxy
+                                for k, r in enumerate(reps or []):
+                                    emb = r.get("embedding") if isinstance(r, dict) else r
+                                    if emb is None:
+                                        continue
+                                    emb = np.array(emb, dtype=float)
+                                    emb = emb / (np.linalg.norm(emb) + 1e-9)
+                                    embeddings.append(emb.astype(float).tolist())
+                                    crops_meta.append({"file": tmp_path.name, "frame": frame_idx, "box": None})
+                                    saved_count += 1
+                            except Exception as _e_df:
+                                print(f"[{job_id}] DeepFace fallback error: {_e_df}")
+                frame_idx += 1
+            cap.release()
+
+            print(f"[{job_id}] ✓ Caras detectadas (embeddings): {len(embeddings)}")
+
+            # Clustering DBSCAN de caras como en 'originales'
+            from sklearn.cluster import DBSCAN
+            if embeddings:
+                Xf = np.array(embeddings)
+                f_eps = float(epsilon)
+                f_min = max(1, int(min_cluster_size))
+                labels = DBSCAN(eps=f_eps, min_samples=f_min, metric='euclidean').fit(Xf).labels_.tolist()
+            else:
+                labels = []
+
+            # Construir carpetas por clúster y representative
+            characters = []
+            cluster_map: dict[int, list[int]] = {}
+            for i, lbl in enumerate(labels):
+                if isinstance(lbl, int) and lbl >= 0:
+                    cluster_map.setdefault(lbl, []).append(i)
+
+            chars_dir = base / "characters"
+            chars_dir.mkdir(parents=True, exist_ok=True)
+            import shutil as _sh
+            for ci, idxs in sorted(cluster_map.items(), key=lambda x: x[0]):
+                char_id = f"char_{ci:02d}"
+                out_dir = chars_dir / char_id
+                out_dir.mkdir(parents=True, exist_ok=True)
+                files = []
+                for k, j in enumerate(idxs[:24]):  # limitar a 24
+                    fname = crops_meta[j]["file"]
+                    src = faces_root / fname
+                    dst = out_dir / fname
+                    try:
+                        _sh.copy2(src, dst)
+                        files.append(fname)
+                    except Exception:
+                        pass
+                rep = files[0] if files else None
+                if rep:
+                    rep_src = out_dir / rep
+                    rep_dst = out_dir / "representative.jpg"
+                    try:
+                        _sh.copy2(rep_src, rep_dst)
+                    except Exception:
+                        pass
+                characters.append({
+                    "id": char_id,
+                    "name": f"Personatge {ci+1}",
+                    "folder": str(out_dir),
+                    "num_faces": len(files),
+                    "image_url": f"/files/{video_name}/{char_id}/representative.jpg" if rep else "",
+                })
+
+            # Escribir analysis.json compatible con 'originales'
+            analysis = {
+                "caras": [{"embeddings": e} for e in embeddings],
+                "voices": [],
+                "escenas": [],
+            }
+            analysis_path = str(base / "analysis.json")
+            with open(analysis_path, "w", encoding="utf-8") as f:
+                json.dump(analysis, f, ensure_ascii=False)
+
+            face_labels = labels
+            num_face_embeddings = len(embeddings)
+
             print(f"[{job_id}] Personajes detectados: {len(characters)}")
             for char in characters:
                 print(f"[{job_id}]   - {char['name']}: {char['num_faces']} caras")