Update core/process.py

core/process.py

@@ -40,7 +40,91 @@ DEPTH_MODEL_MAP = {
     "DPT Beit Large 512": "dpt_beit_large_512"
 }
 
+def process_video(
+    video_path: str,
+    run_det: bool,
+    det_model: str,
+    det_confidence: float,
+    run_seg: bool,
+    seg_model: str,
+    run_depth: bool,
+    depth_model: str,
+    blend: float
+):
+    """
+    Reads each frame from `video_path`, runs your existing `process_image()` on it,
+    and writes out a new MP4 in outputs/processed_<name>.mp4.
+
+    Returns:
+        (None, scene_json: dict, output_video_path: str)
+    """
+    logger.info(f"Starting video processing for {video_path}")
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Cannot open video: {video_path}")
+
+    fps    = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+
+    os.makedirs("outputs", exist_ok=True)
+    base = os.path.basename(video_path)
+    out_path = os.path.join("outputs", f"processed_{base}")
+    writer = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+    if not writer.isOpened():
+        cap.release()
+        raise RuntimeError(f"Cannot write to: {out_path}")
+
+    frame_idx = 0
+    scene_info = {"video": base, "frames_processed": 0}
+
+    while True:
+        ret, frame_bgr = cap.read()
+        if not ret:
+            break
+
+        # BGR→RGB→PIL
+        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        pil_frame = Image.fromarray(frame_rgb)
+
+        # Run your existing image pipeline
+        try:
+            processed_img, _, _ = process_image(
+                image=pil_frame,
+                run_det=run_det,
+                det_model=det_model,
+                det_confidence=det_confidence,
+                run_seg=run_seg,
+                seg_model=seg_model,
+                run_depth=run_depth,
+                depth_model=depth_model,
+                blend=blend
+            )
+        except Exception as e:
+            cap.release()
+            writer.release()
+            raise RuntimeError(f"Error on frame {frame_idx}: {e}")
+
+        # PIL→BGR numpy
+        out_bgr = cv2.cvtColor(np.array(processed_img), cv2.COLOR_RGB2BGR)
+        writer.write(out_bgr)
+
+        frame_idx += 1
+        scene_info["frames_processed"] = frame_idx
+
+    cap.release()
+    writer.release()
+    logger.info(f"Finished video. Wrote {frame_idx} frames to {out_path}")
+
+    # Minimal JSON summary
+    scene_json = {
+        "video": scene_info["video"],
+        "frames_processed": scene_info["frames_processed"]
+    }
 
+    return None, scene_json, out_path
+    
 #@timeout_decorator.timeout(35, use_signals=False)  # 35 sec limit per image
 def process_image(
     image: Image.Image,