framesource 0.3.0__py3-none-any.whl

framesource/sources/huateng_capture.py

@@ -0,0 +1,245 @@
+import logging
+import platform
+from typing import Any, Optional
+
+import numpy as np
+
+from ..errors import MissingDependencyError
+from .video_capture_base import VideoCaptureBase
+
+logger = logging.getLogger(__name__)
+
+# The Huateng/MindVision SDK loads a vendor driver DLL at import time, which is
+# only present when the camera drivers are installed. Guard the import so the
+# module can still be imported (and the class referenced) without the SDK.
+_MVSDK_IMPORT_ERROR: Optional[str] = None
+try:
+    from . import mvsdk
+except (ImportError, OSError) as e:
+    mvsdk = None
+    _MVSDK_IMPORT_ERROR = str(e)
+    logger.warning(f"Huateng mvsdk SDK unavailable: {e}")
+
+
+class HuatengCapture(VideoCaptureBase):
+    supports_exposure = True
+    supports_gain = True
+
+    """Huateng camera capture using mvsdk."""
+
+    def __init__(self, source: Any = None, *, is_mono: Optional[bool] = None, **kwargs):
+        """Initialize the Huateng (MindVision) capture.
+
+        Args:
+            source: Reserved for future multi-device selection; the first
+                enumerated camera is currently always used regardless of
+                this value.
+            is_mono: Stored for parity with other vendor sources (default:
+                False). Whether the stream is mono or color is auto-detected
+                from the device capability in :meth:`connect`, so this flag
+                currently has no effect.
+            **kwargs: Additional passthrough options stored on ``self.config``.
+        """
+        # Preserve the historical ``self.config`` contents: only forward an
+        # explicitly-provided value.
+        if is_mono is not None:
+            kwargs["is_mono"] = is_mono
+        super().__init__(source, **kwargs)
+        self.hCamera = -1
+        self.nDev = 0
+        self.capability = None
+        self.pFrameBuffer = None
+        self.frame = None
+        self.DevInfo = None
+        self.is_mono = self.config.get("is_mono", False)
+        self.current_exp = 0
+        self.current_gain = 0
+        self.prop_frame_height = None
+        self.prop_frame_width = None
+        self.is_new_frame = False
+        self.read_count = 0
+
+    def connect(self) -> bool:
+        if mvsdk is None:
+            raise MissingDependencyError(
+                "mvsdk (Huateng/MindVision SDK)",
+                extra=None,
+                details=_MVSDK_IMPORT_ERROR,
+            )
+        try:
+            self.DevList = mvsdk.CameraEnumerateDevice()
+            self.nDev = len(self.DevList)
+            if self.nDev < 1:
+                logger.error("No Huateng cameras found!")
+                return False
+            i = 0  # Always pick the first camera for now
+            self.DevInfo = self.DevList[i]
+            self.hCamera = mvsdk.CameraInit(self.DevInfo, -1, -1)
+            self.capability = mvsdk.CameraGetCapability(self.hCamera)
+            monoCamera = self.capability.sIspCapacity.bMonoSensor != 0
+            if monoCamera:
+                mvsdk.CameraSetIspOutFormat(self.hCamera, mvsdk.CAMERA_MEDIA_TYPE_MONO8)
+            else:
+                mvsdk.CameraSetIspOutFormat(self.hCamera, mvsdk.CAMERA_MEDIA_TYPE_BGR8)
+            mvsdk.CameraSetTriggerMode(self.hCamera, 0)
+            mvsdk.CameraSetAeState(self.hCamera, 1)
+            mvsdk.CameraPlay(self.hCamera)
+            FrameBufferSize = (
+                self.capability.sResolutionRange.iWidthMax
+                * self.capability.sResolutionRange.iHeightMax
+                * (1 if monoCamera else 3)
+            )
+            self.pFrameBuffer = mvsdk.CameraAlignMalloc(FrameBufferSize, 16)
+            self.prop_frame_height = self.capability.sResolutionRange.iHeightMax
+            self.prop_frame_width = self.capability.sResolutionRange.iWidthMax
+            self.is_connected = True
+            logger.info("Connected to Huateng camera")
+            return True
+        except Exception as e:
+            logger.error(f"Error connecting to Huateng camera: {e}")
+            return False
+
+    def disconnect(self) -> bool:
+        try:
+            if self.hCamera != -1:
+                mvsdk.CameraUnInit(self.hCamera)
+                self.hCamera = -1
+            if self.pFrameBuffer is not None:
+                mvsdk.CameraAlignFree(self.pFrameBuffer)
+                self.pFrameBuffer = None
+            self.is_connected = False
+            logger.info("Disconnected from Huateng camera")
+            return True
+        except Exception as e:
+            logger.error(f"Error disconnecting from Huateng camera: {e}")
+            return False
+
+    def _read_implementation(self) -> tuple[bool, Optional[np.ndarray]]:
+        if not self.is_connected or self.hCamera == -1:
+            return False, None
+        try:
+            pRawData, FrameHead = mvsdk.CameraGetImageBuffer(self.hCamera, 10)
+            mvsdk.CameraImageProcess(self.hCamera, pRawData, self.pFrameBuffer, FrameHead)
+            mvsdk.CameraReleaseImageBuffer(self.hCamera, pRawData)
+            if platform.system() == "Windows":
+                mvsdk.CameraFlipFrameBuffer(self.pFrameBuffer, FrameHead, 1)
+            frame_data = (mvsdk.c_ubyte * FrameHead.uBytes).from_address(self.pFrameBuffer)
+            frame = np.frombuffer(frame_data, dtype=np.uint8)
+            frame = frame.reshape(
+                (
+                    FrameHead.iHeight,
+                    FrameHead.iWidth,
+                    1 if FrameHead.uiMediaType == mvsdk.CAMERA_MEDIA_TYPE_MONO8 else 3,
+                )
+            )
+            return True, frame
+        except Exception as e:
+            logger.error(f"Error reading from Huateng camera: {e}")
+            return False, None
+
+    def set_exposure(self, value: float) -> bool:
+        try:
+            mvsdk.CameraSetAeState(self.hCamera, False)
+            mvsdk.CameraSetExposureTime(self.hCamera, int(value))
+            self.current_exp = int(value)
+            return True
+        except Exception as e:
+            logger.error(f"Error setting exposure: {e}")
+            return False
+
+    def get_exposure(self) -> Optional[float]:
+        try:
+            return float(mvsdk.CameraGetExposureTime(self.hCamera))
+        except Exception:
+            return self.current_exp
+
+    def set_gain(self, value: float) -> bool:
+        try:
+            mvsdk.CameraSetAeState(self.hCamera, False)
+            mvsdk.CameraSetAnalogGainX(self.hCamera, int(value))
+            self.current_gain = int(value)
+            return True
+        except Exception as e:
+            logger.error(f"Error setting gain: {e}")
+            return False
+
+    def get_gain(self) -> Optional[float]:
+        try:
+            return float(mvsdk.CameraGetAnalogGainX(self.hCamera))
+        except Exception:
+            return self.current_gain
+
+    def enable_auto_exposure(self, enable: bool = True) -> bool:
+        try:
+            mvsdk.CameraSetAeState(self.hCamera, bool(enable))
+            logger.info(f"Set Huateng auto exposure to {enable}")
+            return True
+        except Exception as e:
+            logger.error(f"Error setting auto exposure: {e}")
+            return False
+
+    def get_exposure_range(self) -> Optional[tuple[float, float]]:
+        try:
+            min_exp = 5
+            max_exp = 31 * 1000
+            return (min_exp, max_exp)
+        except Exception:
+            return None
+
+    def get_gain_range(self) -> Optional[tuple[float, float]]:
+        try:
+            min_gain = 2
+            max_gain = 6
+            return (min_gain, max_gain)
+        except Exception:
+            return None
+
+    def get_frame_size(self) -> Optional[tuple[int, int]]:
+        if self.prop_frame_width and self.prop_frame_height:
+            return (self.prop_frame_width, self.prop_frame_height)
+        return None
+
+    def set_frame_size(self, width: int, height: int) -> bool:
+        try:
+            imageres = mvsdk.tSdkImageResolution(width, height)
+            mvsdk.CameraSetImageResolution(self.hCamera, imageres)
+            self.prop_frame_width = width
+            self.prop_frame_height = height
+            logger.info(f"Set Huateng camera resolution to {width}x{height}")
+            return True
+        except Exception as e:
+            logger.error(f"Error setting Huateng camera resolution: {e}")
+            return False
+
+    def get_fps(self) -> Optional[float]:
+        # Not directly supported in mvsdk, return None
+        return None
+
+    def set_fps(self, fps: float) -> bool:
+        # Not directly supported in mvsdk, return False
+        return False
+
+
+if __name__ == "__main__":
+    # Example usage
+    import cv2
+
+    camera = HuatengCapture(is_mono=False)
+    if camera.connect():
+        print("Webcam connected successfully.")
+        print(f"Exposure: {camera.get_exposure()}")
+        print(f"Gain: {camera.get_gain()}")
+        print(f"Frame size: {camera.get_frame_size()}")
+
+        # Read a few frames
+        while camera.is_connected:
+            ret, frame = camera.read()
+            if ret and frame is not None:
+                cv2.imshow("camera", frame)
+                if cv2.waitKey(1) & 0xFF == ord("q"):
+                    break
+
+        camera.stop()
+        camera.disconnect()
+    else:
+        print("Failed to connect to webcam.")

framesource/sources/ipcamera_capture.py

@@ -0,0 +1,254 @@
+import logging
+import warnings
+from typing import Any, Optional
+
+import cv2
+import numpy as np
+
+from .video_capture_base import VideoCaptureBase
+
+logger = logging.getLogger(__name__)
+
+
+class IPCameraCapture(VideoCaptureBase):
+    has_discovery = False  # Requires manual URL/credential configuration
+    supports_exposure = False  # set_exposure() is a no-op stub (returns False)
+    supports_gain = False  # set_gain() is a no-op stub (returns False)
+
+    """IP Camera capture using OpenCV with RTSP/HTTP streams."""
+
+    def __init__(
+        self,
+        source: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        *,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        fps: Optional[float] = None,
+        **kwargs,
+    ):
+        """Initialize the IP camera capture.
+
+        Args:
+            source: RTSP/HTTP stream URL.
+            username: Optional login username; when given together with
+                ``password`` it is injected into the stream URL.
+            password: Optional login password (see ``username``).
+            width: Optional frame width hint (if supported by the camera),
+                stored on ``self.config``.
+            height: Optional frame height hint (see ``width``).
+            fps: Optional expected frame rate (informational), stored on
+                ``self.config``.
+            **kwargs: Additional passthrough options stored on ``self.config``.
+        """
+        # Forward the promoted options into ``self.config`` exactly as before
+        # (they were previously accepted via ``**kwargs``); only include
+        # explicitly-provided values so config keys are unchanged.
+        for _key, _val in (("width", width), ("height", height), ("fps", fps)):
+            if _val is not None:
+                kwargs[_key] = _val
+        super().__init__(source, **kwargs)
+        self.username = username
+        self.password = password
+        self.cap = None
+        if username is not None and password is not None:
+            self.stream_url = self._build_stream_url()
+        else:
+            self.stream_url = source
+
+    def _build_stream_url(self) -> str:
+        """Build stream URL with authentication if provided."""
+        if self.username and self.password:
+            # Insert credentials into URL
+            if "://" in self.source:
+                protocol, rest = self.source.split("://", 1)
+                return f"{protocol}://{self.username}:{self.password}@{rest}"
+        return self.source
+
+    def connect(self) -> bool:
+        """Connect to IP camera."""
+        try:
+            self.cap = cv2.VideoCapture(self.stream_url)
+            if not self.cap.isOpened():
+                logger.error(f"Failed to open IP camera stream: {self.stream_url}")
+                return False
+
+            # Set buffer size to reduce latency
+            self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+
+            self.is_connected = True
+            logger.info(f"Connected to IP camera: {self.source}")
+            return True
+        except Exception as e:
+            logger.error(f"Error connecting to IP camera: {e}")
+            return False
+
+    def disconnect(self) -> bool:
+        """Disconnect from IP camera."""
+        try:
+            if self.cap is not None:
+                self.cap.release()
+                self.cap = None
+            self.is_connected = False
+            logger.info("Disconnected from IP camera")
+            return True
+        except Exception as e:
+            logger.error(f"Error disconnecting from IP camera: {e}")
+            return False
+
+    def _read_implementation(self) -> tuple[bool, Optional[np.ndarray]]:
+        """
+        Read a single frame from the IP camera.
+        Returns:
+            Tuple[bool, Optional[np.ndarray]]: (success, frame)
+        """
+        if not self.is_connected or self.cap is None:
+            return False, None
+        ret, frame = self.cap.read()
+        return ret, frame if ret else None
+
+    def set_exposure(self, value: float) -> bool:
+        """Set exposure (may not be supported by all IP cameras)."""
+        logger.warning("Exposure control may not be supported by IP cameras")
+        self._exposure = value
+        return False
+
+    def get_exposure(self) -> Optional[float]:
+        """Get exposure."""
+        return self._exposure
+
+    def set_gain(self, value: float) -> bool:
+        """Set gain (may not be supported by all IP cameras)."""
+        logger.warning("Gain control may not be supported by IP cameras")
+        self._gain = value
+        return False
+
+    def get_gain(self) -> Optional[float]:
+        """Get gain."""
+        return self._gain
+
+    def enable_auto_exposure(self, enable: bool = True) -> bool:
+        """
+        Enable or disable auto exposure (not generally supported for IP cameras).
+        """
+        logger.warning("Auto exposure control may not be supported by IP cameras")
+        return False
+
+    def set_frame_size(self, width: int, height: int) -> bool:
+        """Set frame size (may not be supported by all IP cameras)."""
+        if not self.is_connected or self.cap is None:
+            return False
+        result1 = self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, width)
+        result2 = self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
+        logger.info(
+            f"Set IP camera resolution to {width}x{height} (success: {result1 and result2})"
+        )
+        return result1 and result2
+
+    @classmethod
+    def discover(cls) -> list:
+        """
+        Discover method for IP camera capture.
+
+        Returns:
+            list: Empty list, as IP cameras require manual configuration with URLs/credentials.
+                Use this class directly with RTSP/HTTP URLs as the source parameter.
+        """
+        # IP cameras require manual configuration - cannot be auto-discovered easily
+        logger.info("IPCameraCapture requires manual configuration with URLs and credentials.")
+        return []
+
+    @classmethod
+    def get_config_schema(cls) -> dict[str, Any]:
+        """Get configuration schema for IP camera capture"""
+        warnings.warn(
+            "get_config_schema() is deprecated and will be removed in a future release; "
+            "UI form schemas belong in the consuming application.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return {
+            "title": "IP Camera Configuration",
+            "description": "Configure IP camera with RTSP/HTTP stream settings",
+            "fields": [
+                {
+                    "name": "source",
+                    "label": "Stream URL",
+                    "type": "text",
+                    "placeholder": "rtsp://192.168.1.100:554/stream1",
+                    "description": "RTSP or HTTP stream URL",
+                    "required": True,
+                },
+                {
+                    "name": "username",
+                    "label": "Username",
+                    "type": "text",
+                    "placeholder": "admin",
+                    "description": "Camera login username (optional)",
+                    "required": False,
+                },
+                {
+                    "name": "password",
+                    "label": "Password",
+                    "type": "password",
+                    "placeholder": "password",
+                    "description": "Camera login password (optional)",
+                    "required": False,
+                },
+                {
+                    "name": "width",
+                    "label": "Width",
+                    "type": "number",
+                    "min": 160,
+                    "max": 4096,
+                    "placeholder": "1920",
+                    "description": "Frame width in pixels (if supported)",
+                    "required": False,
+                },
+                {
+                    "name": "height",
+                    "label": "Height",
+                    "type": "number",
+                    "min": 120,
+                    "max": 2160,
+                    "placeholder": "1080",
+                    "description": "Frame height in pixels (if supported)",
+                    "required": False,
+                },
+                {
+                    "name": "fps",
+                    "label": "Frame Rate (FPS)",
+                    "type": "number",
+                    "min": 1,
+                    "max": 60,
+                    "placeholder": "25",
+                    "description": "Expected frame rate (informational)",
+                    "required": False,
+                    "default": 25,
+                },
+            ],
+        }
+
+
+if __name__ == "__main__":
+    # Example usage
+    camera = IPCameraCapture(
+        source="rtsp://192.168.1.153:554/h264Preview_01_sub", username="admin", password="password"
+    )
+
+    if camera.connect():
+        print("IP Camera connected successfully.")
+        print(f"Exposure: {camera.get_exposure()}")
+        print(f"Gain: {camera.get_gain()}")
+        print(f"Frame size: {camera.get_frame_size()}")
+
+        # Read a few frames
+        while camera.is_connected:
+            ret, frame = camera.read()
+            if ret:
+                cv2.imshow("IP Camera", frame)  # type: ignore
+                if cv2.waitKey(1000) & 0xFF == ord("q"):
+                    break
+        camera.stop()
+        camera.disconnect()