feat: adding testing

api/routers/camera_stream.py

@@ -85,8 +85,12 @@ async def websocket_detect(
             while True:
                 frame_bytes = await frame_queue.get()
 
-
-                results = await pipeline.run(camera_id, frame_bytes, next(step_counter))
+                try:
+                    results = await pipeline.run(camera_id, frame_bytes, next(step_counter))
+                except Exception as e:
+                    logger.warn(f"Error happened while processing a frame in {camera_id}: {e}")
+                    logger.exception(e)
+                    continue
 
                 # Note that JSONResponse doesn't work here, as it is for HTTP
                 await websocket.send_json(results)

domain/detection_box_center.py

@@ -2,7 +2,7 @@ def calculate_detection_box_center(detections, image_width:float):
 
     boxes_center = []
     boxes_center_ratio = []
-    for box in detections.detections:
+    for box in detections:
         xmin, ymin, xmax, ymax = box.xyxy
         xcenter = (xmax + xmin) / 2
         ycenter = (ymax + ymin) / 2

services/pipeline.py

@@ -11,13 +11,13 @@ import numpy as np
 
 
 class ProcessingPipeline:
-    def __init__(self, detector, depth_model, safety_detector, redis_client):
+    def __init__(self, detector, depth_model, safety_detector, redis):
         self.detector = detector
         self.depth_model = depth_model
         self.safety_detector = safety_detector
-        self.redis_client = redis_client
+        self.redis = redis
 
-    def _decode_frame(fb):
+    def _decode_frame(self, fb):
         return cv.imdecode(np.frombuffer(fb, np.uint8), cv.IMREAD_COLOR)
 
     def _camera_metadata(self, camera_id, safety_detection, depth_points, boxes_center_ratio) -> CameraMetadata:
@@ -31,23 +31,23 @@ class ProcessingPipeline:
         )
         return metadata
 
-    async def run(self, camera_id:str, image_array, frame_count):
+    async def run(self, camera_id:str, frame_bytes, frame_count):
         loop = asyncio.get_running_loop()
 
         with profile_step("frame_processing_time", decode_duration_seconds, camera_id, frame_count):
-            image_array = await loop.run_in_executor(None, self._decode_frame, image_array)
+            frame_bytes = await loop.run_in_executor(None, self._decode_frame, frame_bytes)
 
         with profile_step("detection_duration_seconds", detection_duration_seconds, camera_id, frame_count):
-            detection_task = loop.run_in_executor(None, self.detector.detect, image_array)
-            safety_task = loop.run_in_executor(None, self.safety_detector.detect, image_array)
+            detection_task = loop.run_in_executor(None, self.detector.detect, frame_bytes)
+            safety_task = loop.run_in_executor(None, self.safety_detector.detect, frame_bytes)
             detections, safety_detection = await asyncio.gather(detection_task, safety_task)
 
-        boxes_center, boxes_center_ratio = calculate_detection_box_center(detections.detections, image_array.shape[1])
+        boxes_center, boxes_center_ratio = calculate_detection_box_center(detections.detections, frame_bytes.shape[1])
 
         depth_points = []
         if boxes_center: 
             with profile_step("depth_duration_seconds", depth_duration_seconds, camera_id, frame_count):
-                depth_points = await loop.run_in_executor(None, self.depth_model.calculate_depth, image_array, boxes_center)
+                depth_points = await loop.run_in_executor(None, self.depth_model.calculate_depth, frame_bytes, boxes_center)
 
         metadata = self._camera_metadata(camera_id, safety_detection, depth_points, boxes_center_ratio)