Upload api.py

api.py

@@ -205,8 +205,13 @@ def process_video_job(job_id: str):
                 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")
+            max_samples = 100
+            # Índices de frames equiespaciados (hasta 100)
+            if total_frames > 0:
+                frame_indices = sorted(set(np.linspace(0, max(0, total_frames - 1), num=min(max_samples, max(1, total_frames)), dtype=int).tolist()))
+            else:
+                frame_indices = []
+            print(f"[{job_id}] Total frames: {total_frames}, FPS: {fps:.2f}, Muestreando {len(frame_indices)} frames equiespaciados (máx {max_samples})")
 
             # Salidas
             faces_root = base / "faces_raw"
@@ -214,94 +219,74 @@ def process_video_job(job_id: str):
             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
+            for frame_idx in frame_indices:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, int(frame_idx))
+                ret2, frame = cap.read()
+                if not ret2:
+                    continue
+                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 con detección de bounding boxes vía Haar Cascade (OpenCV)
+                    if DeepFace is None:
+                        pass
                     else:
-                        # DeepFace fallback con detección de bounding boxes vía Haar Cascade (OpenCV)
-                        if DeepFace is None:
-                            pass
-                        else:
+                        try:
+                            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                             try:
-                                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-                                try:
-                                    haar_path = getattr(cv2.data, 'haarcascades', None) or ''
-                                    face_cascade = cv2.CascadeClassifier(os.path.join(haar_path, 'haarcascade_frontalface_default.xml'))
-                                except Exception:
-                                    face_cascade = None
-                                boxes_haar = []
-                                if face_cascade is not None and not face_cascade.empty():
-                                    faces_haar = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
-                                    for (x, y, w, h) in faces_haar:
-                                        top, left, bottom, right = max(0, y), max(0, x), min(frame.shape[0], y+h), min(frame.shape[1], x+w)
-                                        boxes_haar.append((top, right, bottom, left))
-                                if boxes_haar:
-                                    for (top, right, bottom, left) in boxes_haar:
-                                        crop = frame[top:bottom, left:right]
-                                        if crop.size == 0:
-                                            continue
-                                        fn = f"face_{frame_idx:06d}_{saved_count:03d}.jpg"
-                                        crop_path = faces_root / fn
-                                        cv2.imwrite(str(crop_path), crop)
-                                        reps = DeepFace.represent(img_path=str(crop_path), model_name="Facenet512", enforce_detection=False)
-                                        for r in (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": fn,
-                                                "frame": frame_idx,
-                                                "box": [int(top), int(right), int(bottom), int(left)],
-                                            })
-                                            saved_count += 1
-                                else:
-                                    # Fallback mínimo: emb del frame completo
-                                    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)
-                                    for r in (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
+                                haar_path = getattr(cv2.data, 'haarcascades', None) or ''
+                                face_cascade = cv2.CascadeClassifier(os.path.join(haar_path, 'haarcascade_frontalface_default.xml'))
+                            except Exception:
+                                face_cascade = None
+                            boxes_haar = []
+                            if face_cascade is not None and not face_cascade.empty():
+                                faces_haar = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
+                                for (x, y, w, h) in faces_haar:
+                                    top, left, bottom, right = max(0, y), max(0, x), min(frame.shape[0], y+h), min(frame.shape[1], x+w)
+                                    boxes_haar.append((top, right, bottom, left))
+                            for (top, right, bottom, left) in boxes_haar:
+                                crop = frame[top:bottom, left:right]
+                                if crop.size == 0:
+                                    continue
+                                fn = f"face_{frame_idx:06d}_{saved_count:03d}.jpg"
+                                crop_path = faces_root / fn
+                                cv2.imwrite(str(crop_path), crop)
+                                reps = DeepFace.represent(img_path=str(crop_path), model_name="Facenet512", enforce_detection=False)
+                                for r in (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": fn,
+                                        "frame": frame_idx,
+                                        "box": [int(top), int(right), int(bottom), int(left)],
+                                    })
+                                    saved_count += 1
+                        except Exception as _e_df:
+                            print(f"[{job_id}] DeepFace fallback error: {_e_df}")
             cap.release()
 
             print(f"[{job_id}] ✓ Caras detectadas (embeddings): {len(embeddings)}")