Upload api.py

api.py

@@ -72,6 +72,8 @@ async def create_initial_casting(
     video: UploadFile = File(...),
     epsilon: float = Form(...),
     min_cluster_size: int = Form(...),
+    voice_epsilon: float = Form(0.5),
+    voice_min_cluster_size: int = Form(2),
 ):
     """
     Crea un job para procesar el vídeo de forma asíncrona.
@@ -94,6 +96,8 @@ async def create_initial_casting(
         "video_name": video_name,
         "epsilon": float(epsilon),
         "min_cluster_size": int(min_cluster_size),
+        "voice_epsilon": float(voice_epsilon),
+        "voice_min_cluster_size": int(voice_min_cluster_size),
         "created_at": datetime.now().isoformat(),
         "results": None,
         "error": None
@@ -168,6 +172,8 @@ def process_video_job(job_id: str):
         video_name = job["video_name"]
         epsilon = job["epsilon"]
         min_cluster_size = job["min_cluster_size"]
+        v_epsilon = float(job.get("voice_epsilon", epsilon))
+        v_min_cluster = int(job.get("voice_min_cluster_size", min_cluster_size))
         
         # Crear estructura de carpetas
         base = TEMP_ROOT / video_name
@@ -283,8 +289,8 @@ def process_video_job(job_id: str):
             if voice_embeddings:
                 try:
                     Xv = np.array(voice_embeddings)
-                    v_eps = float(epsilon)
-                    v_min = max(1, int(min_cluster_size))
+                    v_eps = float(v_epsilon)
+                    v_min = max(1, int(v_min_cluster))
                     v_labels = DBSCAN(eps=v_eps, min_samples=v_min, metric='euclidean').fit(Xv).labels_.tolist()
                 except Exception as _e:
                     print(f"[{job_id}] WARN - Voice clustering failed: {_e}")
@@ -480,6 +486,113 @@ async def finalize_casting(
         "voice_identities": voice_identities,
     }
 
+@app.get("/files_scene/{video_name}/{scene_id}/{filename}")
+def serve_scene_file(video_name: str, scene_id: str, filename: str):
+    file_path = TEMP_ROOT / video_name / "scenes" / scene_id / filename
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(file_path)
+
+@app.post("/detect_scenes")
+async def detect_scenes(
+    video: UploadFile = File(...),
+    epsilon: float = Form(0.5),
+    min_cluster_size: int = Form(2),
+    frame_interval_sec: float = Form(0.5),
+):
+    """
+    Detecta clústers d'escenes mitjançant clustering de histogrames de color.
+    Retorna una llista de scene_clusters estructurada de forma similar a characters.
+    """
+    import cv2
+    import numpy as np
+    from sklearn.cluster import DBSCAN
+
+    # Guardar el vídeo temporalment
+    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)
+
+    cap = cv2.VideoCapture(str(dst_video))
+    if not cap.isOpened():
+        raise HTTPException(status_code=400, detail="Cannot open video")
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    step = max(1, int(frame_interval_sec * fps))
+
+    frames = []
+    metas = []
+    idx = 0
+    while True:
+        ret = cap.grab()
+        if not ret:
+            break
+        if idx % step == 0:
+            ret2, frame = cap.retrieve()
+            if not ret2:
+                break
+            # Reduir mida per estabilitat i càlcul ràpid
+            small = cv2.resize(frame, (160, 90))
+            hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV)
+            # Histograma per canal
+            h_hist = cv2.calcHist([hsv],[0],None,[32],[0,180]).flatten()
+            s_hist = cv2.calcHist([hsv],[1],None,[32],[0,256]).flatten()
+            v_hist = cv2.calcHist([hsv],[2],None,[32],[0,256]).flatten()
+            hist = np.concatenate([h_hist, s_hist, v_hist])
+            hist = hist / (np.linalg.norm(hist) + 1e-8)
+            frames.append(hist)
+            metas.append({"index": idx, "time_sec": idx/float(fps)})
+        idx += 1
+    cap.release()
+
+    if not frames:
+        return {"scene_clusters": []}
+
+    X = np.array(frames)
+    labels = DBSCAN(eps=float(epsilon), min_samples=int(min_cluster_size), metric='euclidean').fit(X).labels_.tolist()
+
+    # Agrupar per etiqueta (>=0)
+    clusters = {}
+    for i, lbl in enumerate(labels):
+        if lbl is None or lbl < 0:
+            continue
+        clusters.setdefault(int(lbl), []).append(i)
+
+    # Escriure imatges representatives per a cada clúster
+    base = TEMP_ROOT / video_name / "scenes"
+    base.mkdir(parents=True, exist_ok=True)
+    scene_list = []
+    cap = cv2.VideoCapture(str(dst_video))
+    for lbl, idxs in sorted(clusters.items(), key=lambda x: x[0]):
+        scene_id = f"scene_{int(lbl):02d}"
+        out_dir = base / scene_id
+        out_dir.mkdir(parents=True, exist_ok=True)
+        frame_files = []
+        # Guardar fins a 12 frames per clúster
+        for k, fi in enumerate(idxs[:12]):
+            frame_num = metas[fi]["index"]
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+            ret2, frame = cap.read()
+            if not ret2:
+                continue
+            fn = f"frame_{k:03d}.jpg"
+            cv2.imwrite(str(out_dir / fn), frame)
+            frame_files.append(fn)
+        # Representative
+        rep = frame_files[0] if frame_files else None
+        image_url = f"/files_scene/{video_name}/{scene_id}/{rep}" if rep else ""
+        scene_list.append({
+            "id": scene_id,
+            "folder": str(out_dir),
+            "num_frames": len(frame_files),
+            "image_url": image_url,
+            "frame_files": frame_files,
+        })
+    cap.release()
+
+    return {"scene_clusters": scene_list, "base_dir": str(base)}
+
 @app.post("/refine_narration")
 async def refine_narration(
     dialogues_srt: str = Form(...),