refactor

Author: robgee86

src/arduino/app_internal/pipeline/pipeline.py

@@ -177,11 +177,13 @@ def _run_loop(self, loop_ready_event: threading.Event):
                     self._loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
 
                 self._loop.run_until_complete(self._loop.shutdown_asyncgens())
-                self._loop.close()
-                logger.debug("Internal event loop stopped.")
             except Exception as e:
                 logger.exception(f"Error during event loop cleanup: {e}")
-            self._loop = None
+            finally:
+                if self._loop and not self._loop.is_closed():
+                    self._loop.close()
+                self._loop = None
+                logger.debug("Internal event loop stopped.")
 
     async def _async_run_pipeline(self):
         """The main async logic using Adapters."""

src/arduino/app_peripherals/camera/README.md

@@ -61,16 +61,13 @@ camera = Camera(source, **options)
   - `str`: Camera index, device path, or URL
 - `resolution`: Tuple `(width, height)` or `None` for default
 - `fps`: Target frames per second (default: 10)
-- `compression`: Enable PNG compression (default: False)  
-- `letterbox`: Make images square with padding (default: False)
+- `transformer`: Pipeline of transformers that adjust the captured image
 
 **Methods:**
 - `start()`: Initialize and start camera
 - `stop()`: Stop camera and release resources
-- `capture()`: Capture frame as PIL Image
-- `capture_bytes()`: Capture frame as bytes
+- `capture()`: Capture frame as Numpy array
 - `is_started()`: Check if camera is running
-- `get_camera_info()`: Get camera properties
 
 ### Context Manager
 

src/arduino/app_peripherals/camera/__init__.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (C) 2025 ARDUINO SA <http://www.arduino.cc>
+#
+# SPDX-License-Identifier: MPL-2.0
+
 from .camera import Camera
 
 __all__ = ["Camera"]

src/arduino/app_peripherals/camera/base_camera.py

@@ -4,16 +4,13 @@
 
 import threading
 import time
-import io
 from abc import ABC, abstractmethod
-from typing import Optional, Tuple
-from PIL import Image
-import cv2
+from typing import Optional, Tuple, Callable
 import numpy as np
 
 from arduino.app_utils import Logger
 
-from .errors import CameraOpenError
+from .errors import CameraOpenError, CameraTransformError
 
 logger = Logger("Camera")
 
@@ -27,21 +24,19 @@ class BaseCamera(ABC):
     """
 
     def __init__(self, resolution: Optional[Tuple[int, int]] = None, fps: int = 10, 
-                 compression: bool = False, letterbox: bool = False, **kwargs):
+                 transformer: Optional[Callable[[np.ndarray], np.ndarray]] = None, **kwargs):
         """
         Initialize the camera base.
 
         Args:
-            resolution: Resolution as (width, height). None uses default resolution.
-            fps: Frames per second for the camera.
-            compression: Whether to compress captured images to PNG format.
-            letterbox: Whether to apply letterboxing to make images square.
+            resolution (tuple, optional): Resolution as (width, height). None uses default resolution.
+            fps (int): Frames per second for the camera.
+            transformer (callable, optional): Function to transform frames that takes a numpy array and returns a numpy array. Default: None
             **kwargs: Additional camera-specific parameters.
         """
         self.resolution = resolution
         self.fps = fps
-        self.compression = compression
-        self.letterbox = letterbox
+        self.transformer = transformer
         self._is_started = False
         self._cap_lock = threading.Lock()
         self._last_capture_time = time.monotonic()
@@ -74,52 +69,17 @@ def stop(self) -> None:
             except Exception as e:
                 logger.warning(f"Error stopping camera: {e}")
 
-    def capture(self) -> Optional[Image.Image]:
+    def capture(self) -> Optional[np.ndarray]:
         """
         Capture a frame from the camera, respecting the configured FPS.
 
         Returns:
-            PIL Image or None if no frame is available.
+            Numpy array or None if no frame is available.
         """
         frame = self._extract_frame()
         if frame is None:
             return None
-        
-        try:
-            if self.compression:
-                # Convert to PNG bytes first, then to PIL Image
-                success, encoded = cv2.imencode('.png', frame)
-                if success:
-                    return Image.open(io.BytesIO(encoded.tobytes()))
-                else:
-                    return None
-            else:
-                # Convert BGR to RGB for PIL
-                if len(frame.shape) == 3 and frame.shape[2] == 3:
-                    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                else:
-                    rgb_frame = frame
-                return Image.fromarray(rgb_frame)
-        except Exception as e:
-            logger.exception(f"Error converting frame to PIL Image: {e}")
-            return None
-
-    def capture_bytes(self) -> Optional[bytes]:
-        """
-        Capture a frame and return as bytes.
-
-        Returns:
-            Frame as bytes or None if no frame is available.
-        """
-        frame = self._extract_frame()
-        if frame is None:
-            return None
-        
-        if self.compression:
-            success, encoded = cv2.imencode('.png', frame)
-            return encoded.tobytes() if success else None
-        else:
-            return frame.tobytes()
+        return frame
 
     def _extract_frame(self) -> Optional[np.ndarray]:
         """Extract a frame with FPS throttling and post-processing."""
@@ -140,45 +100,24 @@ def _extract_frame(self) -> Optional[np.ndarray]:
 
             self._last_capture_time = time.monotonic()
 
-            # Apply post-processing
-            if self.letterbox:
-                frame = self._letterbox(frame)
+            if self.transformer is None:
+                return frame
+            
+            try:
+                frame = frame | self.transformer
+            except Exception as e:
+                raise CameraTransformError(f"Frame transformation failed ({self.transformer}): {e}")
 
             return frame
 
-    def _letterbox(self, frame: np.ndarray) -> np.ndarray:
-        """Apply letterboxing to make the frame square."""
-        h, w = frame.shape[:2]
-        if w != h:
-            size = max(h, w)
-            return cv2.copyMakeBorder(
-                frame,
-                top=(size - h) // 2,
-                bottom=(size - h + 1) // 2,
-                left=(size - w) // 2,
-                right=(size - w + 1) // 2,
-                borderType=cv2.BORDER_CONSTANT,
-                value=(114, 114, 114)
-            )
-        return frame
-
     def is_started(self) -> bool:
         """Check if the camera is started."""
         return self._is_started
 
-    def produce(self) -> Optional[Image.Image]:
+    def produce(self) -> Optional[np.ndarray]:
         """Alias for capture method for compatibility."""
         return self.capture()
 
-    def __enter__(self):
-        """Context manager entry."""
-        self.start()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        self.stop()
-
     @abstractmethod
     def _open_camera(self) -> None:
         """Open the camera connection. Must be implemented by subclasses."""
@@ -193,3 +132,12 @@ def _close_camera(self) -> None:
     def _read_frame(self) -> Optional[np.ndarray]:
         """Read a single frame from the camera. Must be implemented by subclasses."""
         pass
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()

src/arduino/app_peripherals/camera/camera.py

@@ -32,9 +32,8 @@ def __new__(cls, source: Union[str, int] = 0, **kwargs) -> BaseCamera:
                     resolution (tuple, optional): Frame resolution as (width, height). 
                         Default: None (auto)
                     fps (int, optional): Target frames per second. Default: 10
-                    compression (bool, optional): Enable frame compression. Default: False
-                    letterbox (bool, optional): Enable letterboxing for resolution changes. 
-                        Default: False
+                    transformer (callable, optional): Function to transform frames that takes a
+                        numpy array and returns a numpy array. Default: None
                 V4L Camera Parameters:
                     device_index (int, optional): V4L device index override
                     capture_format (str, optional): Video capture format (e.g., 'MJPG', 'YUYV')
@@ -43,20 +42,12 @@ def __new__(cls, source: Union[str, int] = 0, **kwargs) -> BaseCamera:
                     username (str, optional): Authentication username
                     password (str, optional): Authentication password
                     timeout (float, optional): Connection timeout in seconds. Default: 10.0
-                    retry_attempts (int, optional): Number of connection retry attempts. 
-                        Default: 3
-                    headers (dict, optional): Additional HTTP headers
-                    verify_ssl (bool, optional): Verify SSL certificates. Default: True
                 WebSocket Camera Parameters:
-                    host (str, optional): WebSocket server host. Default: "localhost"
+                    host (str, optional): WebSocket server host. Default: "0.0.0.0"
                     port (int, optional): WebSocket server port. Default: 8080
+                    timeout (float, optional): Connection timeout in seconds. Default: 10.0
                     frame_format (str, optional): Expected frame format ("base64", "binary", 
                         "json"). Default: "base64"
-                    max_queue_size (int, optional): Maximum frames to buffer. Default: 10
-                    ping_interval (int, optional): WebSocket ping interval in seconds. 
-                        Default: 20
-                    ping_timeout (int, optional): WebSocket ping timeout in seconds. 
-                        Default: 10
             
         Returns:
             BaseCamera: Appropriate camera implementation instance

src/arduino/app_peripherals/camera/errors.py

@@ -20,3 +20,8 @@ class CameraReadError(CameraError):
 class CameraConfigError(CameraError):
     """Exception raised when camera configuration is invalid."""
     pass
+
+
+class CameraTransformError(CameraError):
+    """Exception raised when frame transformation fails."""
+    pass