Update services/video_service.py

services/video_service.py

@@ -1,68 +1,87 @@
 import cv2
-import numpy as np
+import os
 import logging
-from typing import List, Dict, Any
 
-# Configure logging
+# Setup logging
 logging.basicConfig(
     filename="app.log",
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
-def overlay_boxes(frame: np.ndarray, detected_items: List[Dict[str, Any]]) -> np.ndarray:
-    """
-    Overlay bounding boxes and labels on the frame for detected items.
+# Global video capture object
+video_cap = None
+current_frame_index = 0
 
+def preload_video(video_path):
+    """
+    Preload the video file.
     Args:
-        frame (np.ndarray): Input frame in BGR format.
-        detected_items (List[Dict[str, Any]]): List of detected items with coordinates and labels.
-
+        video_path: Path to the video file
     Returns:
-        np.ndarray: Frame with overlaid bounding boxes and labels.
+        str: Status message
     """
-    # Validate inputs
-    if not isinstance(frame, np.ndarray) or frame.size == 0:
-        logging.error("Invalid input frame provided to overlay_service.")
-        return frame
-    if not isinstance(detected_items, list):
-        logging.error("Detected items must be a list.")
-        return frame
-
+    global video_cap, current_frame_index
     try:
-        for item in detected_items:
-            # Check for required keys
-            if "coordinates" not in item or "label" not in item:
-                logging.warning(f"Skipping item without coordinates or label: {item}")
-                continue
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found at {video_path}")
+
+        video_cap = cv2.VideoCapture(video_path)
+        if not video_cap.isOpened():
+            raise RuntimeError("Failed to open video file.")
 
-            # Extract coordinates and label
-            x_min, y_min, x_max, y_max = item["coordinates"]
-            label = item["label"]
+        current_frame_index = 0
+        total_frames = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        logging.info(f"Preloaded video: {video_path} with {total_frames} frames.")
+        return f"Successfully loaded video: {video_path} ({total_frames} frames)"
+    except Exception as e:
+        logging.error(f"Error preloading video: {str(e)}")
+        return f"Error loading video: {str(e)}"
 
-            # Define colors based on detection type
-            type_colors = {
-                "crack": (147, 112, 219),    # Light purple (green + pink mix)
-                "pothole": (255, 127, 80),   # Coral (red + orange mix)
-                "signage": (0, 191, 255),    # DeepSkyBlue
-                "default": (0, 255, 255)     # Yellow
-            }
-            color = type_colors.get(item.get("type", "default"), type_colors["default"])
+def get_next_video_frame():
+    """
+    Get the next frame from the video.
+    Returns:
+        numpy array: Frame if successful, None otherwise
+    """
+    global video_cap, current_frame_index
+    if video_cap is None or not video_cap.isOpened():
+        logging.error("Video capture not initialized.")
+        return None
 
-            # Draw bounding box and label
-            cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), color, 2)
-            cv2.putText(
-                frame,
-                label,
-                (x_min, y_min - 10),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                color,
-                2
-            )
+    try:
+        # Set frame position
+        video_cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_index)
+        ret, frame = video_cap.read()
+        if not ret:
+            # Loop back to the start
+            current_frame_index = 0
+            video_cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_index)
+            ret, frame = video_cap.read()
+            if not ret:
+                raise RuntimeError("Failed to read frame from video.")
 
-        logging.info(f"Overlaid {len(detected_items)} items on frame.")
+        current_frame_index += 1
+        logging.debug(f"Retrieved frame {current_frame_index} from video.")
         return frame
     except Exception as e:
-        logging.error(f"Error overlaying boxes: {str(e)}")
-        return frame
+        logging.error(f"Error retrieving frame: {str(e)}")
+        return None
+
+def reset_video_index():
+    """
+    Reset the frame index to the beginning.
+    """
+    global current_frame_index
+    current_frame_index = 0
+    logging.info("Reset video frame index to 0.")
+
+def release_video():
+    """
+    Release the video capture object.
+    """
+    global video_cap
+    if video_cap is not None:
+        video_cap.release()
+        video_cap = None
+        logging.info("Released video capture object.")