omnicam 0.1.0__tar.gz

omnicam-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Oğuzhan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

omnicam-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: omnicam
+Version: 0.1.0
+Summary: A Python package for camera utilities
+Author-email: OguzhanUmutlu <contact@oguzhanumutlu.com>
+License: MIT License
+        
+        Copyright (c) 2025 Oğuzhan
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/OguzhanUmutlu/omnicam
+Project-URL: Issues, https://github.com/OguzhanUmutlu/omnicam/issues
+Project-URL: Documentation, https://github.com/OguzhanUmutlu/omnicam#readme
+Keywords: camera,opencv,vision,stream,capture
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Provides-Extra: opencv
+Requires-Dist: opencv-python>=4.7; extra == "opencv"
+Provides-Extra: screen
+Requires-Dist: mss>=9.0; extra == "screen"
+Provides-Extra: pi
+Requires-Dist: picamera2>=0.3; extra == "pi"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# omnicam
+
+A small, unified API for reading frames from USB cameras, IP streams, video files, screen capture, and Raspberry Pi
+cameras.
+
+## Features
+
+- Unified `BaseCamera` interface across backends
+- OpenCV-based capture for USB webcams, video files, RTSP/HTTP streams, and GStreamer pipelines
+- Optional Raspberry Pi Camera support (Picamera2)
+- Optional screen capture via `mss`
+
+## Installation
+
+```bash
+pip install omnicam
+```
+
+Optional extras:
+
+```bash
+pip install omnicam[opencv]
+pip install omnicam[screen]
+pip install omnicam[pi]
+```
+
+## Quickstart
+
+```python
+from omnicam import SimpleCamera
+
+with SimpleCamera(index=0) as cam:
+    cam.open()
+    frame = cam.read()
+    if frame is not None:
+        print(frame.shape)
+```
+
+## Camera types
+
+```python
+from omnicam import FileCapture, InternetCapture, ScreenCapture
+
+# Video file
+cam = FileCapture("/path/to/video.mp4")
+
+# IP camera or MJPEG stream
+cam = InternetCapture("http://192.168.1.10:8080/video")
+
+# Screen capture (requires omnicam[screen])
+cam = ScreenCapture(index=1)
+```
+
+## Raspberry Pi camera
+
+```python
+from omnicam import PiCamera
+
+cam = PiCamera(model="IMX219", resolution="720p")
+```
+
+## GStreamer and Gazebo
+
+```python
+from omnicam import GStreamerCapture, GazeboCamera
+
+pipeline = (
+    GStreamerCapture.GstPipeline()
+    .add("v4l2src", device="/dev/video0")
+    .add("videoconvert")
+    .add("appsink")
+)
+cam = GStreamerCapture(pipeline)
+
+# Gazebo (requires gz tools available on PATH)
+cam = GazeboCamera(topic_name="my_camera")
+```
+
+## Notes
+
+- `numpy` is required. OpenCV-based backends need `omnicam[opencv]`.
+- GStreamer and Gazebo features rely on system-level tooling.
+
+## License
+
+MIT. See `LICENSE`.

omnicam-0.1.0/README.md

@@ -0,0 +1,86 @@
+# omnicam
+
+A small, unified API for reading frames from USB cameras, IP streams, video files, screen capture, and Raspberry Pi
+cameras.
+
+## Features
+
+- Unified `BaseCamera` interface across backends
+- OpenCV-based capture for USB webcams, video files, RTSP/HTTP streams, and GStreamer pipelines
+- Optional Raspberry Pi Camera support (Picamera2)
+- Optional screen capture via `mss`
+
+## Installation
+
+```bash
+pip install omnicam
+```
+
+Optional extras:
+
+```bash
+pip install omnicam[opencv]
+pip install omnicam[screen]
+pip install omnicam[pi]
+```
+
+## Quickstart
+
+```python
+from omnicam import SimpleCamera
+
+with SimpleCamera(index=0) as cam:
+    cam.open()
+    frame = cam.read()
+    if frame is not None:
+        print(frame.shape)
+```
+
+## Camera types
+
+```python
+from omnicam import FileCapture, InternetCapture, ScreenCapture
+
+# Video file
+cam = FileCapture("/path/to/video.mp4")
+
+# IP camera or MJPEG stream
+cam = InternetCapture("http://192.168.1.10:8080/video")
+
+# Screen capture (requires omnicam[screen])
+cam = ScreenCapture(index=1)
+```
+
+## Raspberry Pi camera
+
+```python
+from omnicam import PiCamera
+
+cam = PiCamera(model="IMX219", resolution="720p")
+```
+
+## GStreamer and Gazebo
+
+```python
+from omnicam import GStreamerCapture, GazeboCamera
+
+pipeline = (
+    GStreamerCapture.GstPipeline()
+    .add("v4l2src", device="/dev/video0")
+    .add("videoconvert")
+    .add("appsink")
+)
+cam = GStreamerCapture(pipeline)
+
+# Gazebo (requires gz tools available on PATH)
+cam = GazeboCamera(topic_name="my_camera")
+```
+
+## Notes
+
+- `numpy` is required. OpenCV-based backends need `omnicam[opencv]`.
+- GStreamer and Gazebo features rely on system-level tooling.
+
+## License
+
+MIT. See `LICENSE`.

omnicam-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "omnicam"
+version = "0.1.0"
+description = "A Python package for camera utilities"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "OguzhanUmutlu", email = "contact@oguzhanumutlu.com" }
+]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.21"
+]
+keywords = ["camera", "opencv", "vision", "stream", "capture"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.optional-dependencies]
+opencv = ["opencv-python>=4.7"]
+screen = ["mss>=9.0"]
+pi = ["picamera2>=0.3"]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/OguzhanUmutlu/omnicam"
+Issues = "https://github.com/OguzhanUmutlu/omnicam/issues"
+Documentation = "https://github.com/OguzhanUmutlu/omnicam#readme"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

omnicam-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

omnicam-0.1.0/src/camerapy/__init__.py

@@ -0,0 +1,31 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .base_camera import BaseCamera
+from .cv_camera_base import CVCameraBase
+from .file_capture import FileCapture
+from .gazebo_camera import GazeboCamera
+from .gstreamer_capture import GStreamerCapture
+from .internet_capture import InternetCapture
+from .pi_camera import PiCamera
+from .readonly_camera import ReadonlyCamera
+from .screen_capture import ScreenCapture
+from .simple_camera import SimpleCamera
+
+try:
+    __version__ = version("omnicam")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__all__ = [
+    "BaseCamera",
+    "CVCameraBase",
+    "FileCapture",
+    "GazeboCamera",
+    "GStreamerCapture",
+    "InternetCapture",
+    "PiCamera",
+    "ReadonlyCamera",
+    "ScreenCapture",
+    "SimpleCamera",
+    "__version__",
+]

omnicam-0.1.0/src/camerapy/base_camera.py

@@ -0,0 +1,161 @@
+from abc import abstractmethod, ABC
+from typing import Optional, Literal
+
+import numpy as np
+
+resolutions = {
+    "240p": (426, 240),
+    "360p": (640, 360),
+    "480p": (854, 480),
+    "720p": (1280, 720),
+    "HD": (1280, 720),
+    "1080p": (1920, 1080),
+    "HD+": (1920, 1080),
+    "1440p": (2560, 1440),
+    "2160p": (3840, 2160)
+}
+
+
+class CameraInfo:
+    def __init__(
+            self,
+            name: str,
+            short_name: str,
+            focal_length_mm: tuple[float, float],
+            pixel_size_um: float,
+            max_resolution: tuple[int, int],
+            aperture_f: float,
+            hfov_deg: float,
+            focus_type: Literal["Fixed", "Autofocus", "Manual", "Unknown"],
+            has_ir_filter: bool
+    ):
+        self.name = name
+        self.short_name = short_name
+        self.focal_length_mm = focal_length_mm
+        self.pixel_size_um = pixel_size_um
+        self.max_resolution = max_resolution
+        self.aperture_f = aperture_f
+        self.hfov_deg = hfov_deg
+        self.focus_type = focus_type
+        self.has_ir_filter = has_ir_filter
+
+        pixel_size_mm = self.pixel_size_um / 1000.0
+        self.base_focal_length = (self.focal_length_mm[0] / pixel_size_mm, self.focal_length_mm[1] / pixel_size_mm)
+
+    def focal_length(self, resolution: tuple[int, int]):
+        return (
+            self.base_focal_length[0] * resolution[0] / self.max_resolution[0],
+            self.base_focal_length[1] * resolution[1] / self.max_resolution[1]
+        )
+
+    @staticmethod
+    def from_focal_length(name: str, short_name: str, focal_length: tuple[float, float],
+                          resolution: tuple[int, int] = (9999, 9999)):
+        pixel_size_mm = 0.001
+        focal_length_mm = (focal_length[0] * pixel_size_mm, focal_length[1] * pixel_size_mm)
+        return CameraInfo(
+            name=name,
+            short_name=short_name,
+            focal_length_mm=focal_length_mm,
+            pixel_size_um=pixel_size_mm * 1000,
+            max_resolution=resolution,
+            aperture_f=0.0,
+            hfov_deg=0.0,
+            focus_type="Unknown",
+            has_ir_filter=False
+        )
+
+
+class BaseCamera(ABC):
+    def __init__(self, info: Optional[CameraInfo] = None):
+        self.closed = False
+        self.roll_deg = 0.0
+        self.pitch_deg = 0.0
+        self.yaw_deg = 0.0
+        self.offset = np.array([0.0, 0.0, -0.1], dtype=np.float64)
+        self.info = info
+
+    @abstractmethod
+    def _open(self):
+        raise NotImplementedError("open method must be implemented by subclass")
+
+    @abstractmethod
+    def _read(self) -> "np.ndarray | None":
+        raise NotImplementedError("read method must be implemented by subclass")
+
+    @abstractmethod
+    def _release(self):
+        raise NotImplementedError("release method must be implemented by subclass")
+
+    @abstractmethod
+    def _size(self) -> tuple[int, int]:
+        raise NotImplementedError("size method must be implemented by subclass")
+
+    def _focus(self, rectangle: tuple[int, int, int, int]):
+        raise NotImplementedError("focus method must be implemented by subclass")
+    
+    def open(self):
+        if self.closed:
+            raise PermissionError("Attempted to open a closed camera.")
+        self._open()
+        return self
+
+    def size(self):
+        return self._size()
+
+    def focus(self, rectangle: tuple[int, int, int, int]):
+        if self.closed:
+            raise PermissionError("Attempted to focus a closed camera.")
+        if self.info is not None and self.info.focus_type in ("Fixed", "Unknown"):
+            raise ValueError(f"This camera has a {self.info.focus_type} focus and cannot be adjusted.")
+        self._focus(rectangle)
+        return self
+
+    def focal_length(self) -> tuple[float, float]:
+        if self.info is None:
+            raise ValueError("CameraInfo must be provided to calculate focal length")
+        return self.info.focal_length(self.size())
+
+    def width(self):
+        return self.size()[0]
+
+    def height(self):
+        return self.size()[1]
+
+    def fx(self):
+        return self.focal_length()[0]
+
+    def fy(self):
+        return self.focal_length()[1]
+
+    def read(self):
+        if self.closed:
+            raise PermissionError("Attempted to read from a closed camera.")
+        frame = self._read()
+        if frame is None:
+            self.closed = True
+        return frame
+
+    def release(self):
+        if not self.closed:
+            self.closed = True
+            self._release()
+
+    def frames(self):
+        while True:
+            frame = self.read()
+            if frame is None:
+                break
+            yield frame
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+
+    def readonly(self):
+        from .readonly_camera import ReadonlyCamera
+        if isinstance(self, ReadonlyCamera):
+            return self
+        return ReadonlyCamera(self)

omnicam-0.1.0/src/camerapy/cv_camera_base.py

@@ -0,0 +1,44 @@
+from .base_camera import BaseCamera, CameraInfo
+
+
+class CVCameraBase(BaseCamera):
+    def __init__(self, args: list, timeout=None, info: CameraInfo = None, open_error=None, timeout_error=None,
+                 **kwargs):
+        super().__init__(info=info)
+        try:
+            import cv2
+        except Exception as exc:
+            raise ImportError(
+                "OpenCV is required for this feature. Install with 'pip install omnicam[opencv]'.") from exc
+        self._cv2 = cv2
+        self.open_error = open_error or RuntimeError(f"Camera could not be opened with args {args}")
+        self.timeout_error = timeout_error or TimeoutError(
+            f"Failed to open camera with args {args} within {timeout} seconds")
+        self.cv_args = args
+        self.cv_kwargs = kwargs
+        self.cam = None
+        self._frame_size = None
+        self.timeout = timeout
+
+    def _open(self):
+        self.cam = self._cv2.VideoCapture(*self.cv_args, **self.cv_kwargs)
+        if self.timeout is not None:
+            start_time = self._cv2.getTickCount()
+            while not self.cam.isOpened():
+                elapsed_time = (self._cv2.getTickCount() - start_time) / self._cv2.getTickFrequency()
+                if elapsed_time > self.timeout:
+                    raise self.timeout_error
+        elif not self.cam.isOpened():
+            raise self.open_error
+        self._frame_size = int(self.cam.get(self._cv2.CAP_PROP_FRAME_WIDTH)), int(
+            self.cam.get(self._cv2.CAP_PROP_FRAME_HEIGHT))
+
+    def _read(self):
+        ret, frame = self.cam.read()
+        return frame if ret else None
+
+    def _release(self):
+        self.cam.release()
+
+    def _size(self):
+        return self._frame_size

omnicam-0.1.0/src/camerapy/file_capture.py

@@ -0,0 +1,12 @@
+import os
+
+from .base_camera import CameraInfo
+from .cv_camera_base import CVCameraBase
+
+
+class FileCapture(CVCameraBase):
+    def __init__(self, path: "os.PathLike | str", info: CameraInfo = None, open_error=None):
+        if not os.path.exists(path):
+            raise ValueError(f"File {path} does not exist")
+        super().__init__([str(path)], info=info,
+                         open_error=open_error or ValueError(f"Could not open video file {path}"))

omnicam-0.1.0/src/camerapy/gazebo_camera.py

@@ -0,0 +1,39 @@
+import subprocess
+
+from .base_camera import CameraInfo
+from .gstreamer_capture import GStreamerCapture
+
+
+class GazeboCamera(GStreamerCapture):
+    def __init__(self, port=4000, topic_name: str = None, timeout=5, info: CameraInfo = None, open_error=None,
+                 timeout_error=None):
+        self.topic_name = topic_name
+        self.port = port
+        super().__init__(
+            GStreamerCapture.GstPipeline()
+            .add("udpsrc", port=self.port)
+            .add_caps("application/x-rtp")
+            .add("rtph264depay")
+            .add("h264parse")
+            .add("avdec_h264")
+            .add("videoconvert")
+            .add("appsink", sync="false"),
+            timeout=timeout, info=info,
+            open_error=open_error or ValueError(f"Could not open Gazebo camera stream on port {self.port}"),
+            timeout_error=timeout_error or TimeoutError(
+                f"Could not open Gazebo camera stream on port {self.port} within {timeout} seconds")
+        )
+
+    def _open(self):
+        if self.topic_name is not None:
+            GazeboCamera.start_gz_stream(self.topic_name)
+        super()._open()
+
+    @staticmethod
+    def start_gz_stream(topic_name):
+        subprocess.run([
+            "gz", "topic",
+            "-t", f"/{topic_name}/image/enable_streaming",
+            "-m", "gz.msgs.Boolean",
+            "-p", "data: true"
+        ])

omnicam-0.1.0/src/camerapy/gstreamer_capture.py

@@ -0,0 +1,42 @@
+from .base_camera import CameraInfo
+from .cv_camera_base import CVCameraBase
+
+
+class GStreamerCapture(CVCameraBase):
+    class GstPipeline:
+        def __init__(self):
+            self.elements = []
+
+        def add(self, element_name, **properties):
+            if not properties:
+                self.elements.append(element_name)
+                return self
+            props_str = " ".join(f"{k}={v}" for k, v in properties.items())
+            element = f"{element_name} {props_str}".strip()
+            self.elements.append(element)
+            return self
+
+        def add_caps(self, caps: str):
+            self.elements.append(caps)
+            return self
+
+        def __str__(self):
+            return " ! ".join(self.elements)
+
+    def __init__(self, gstreamer_string: "GstPipeline | str", timeout=5, info: CameraInfo = None, open_error=None,
+                 timeout_error=None):
+        try:
+            import cv2
+        except Exception as exc:
+            raise ImportError(
+                "OpenCV is required for this feature. Install with 'pip install omnicam[opencv]'."
+            ) from exc
+        gstreamer_string = str(gstreamer_string)
+        self.gstreamer_string = gstreamer_string
+        super().__init__(
+            [gstreamer_string, cv2.CAP_GSTREAMER],
+            timeout=timeout, info=info,
+            open_error=open_error or RuntimeError(f"Could not open GStreamer stream with \"{gstreamer_string}\""),
+            timeout_error=timeout_error or TimeoutError(
+                f"Could not open GStreamer stream with \"{gstreamer_string}\" within {timeout} seconds")
+        )

omnicam-0.1.0/src/camerapy/internet_capture.py

@@ -0,0 +1,20 @@
+from .base_camera import CameraInfo
+from .cv_camera_base import CVCameraBase
+
+
+class InternetCapture(CVCameraBase):
+    def __init__(self, url: str, timeout=5, info: CameraInfo = None, args: list = None,
+                 open_error=None, timeout_error=None):
+        if not url.startswith("http://") and not url.startswith("https://") and not url.startswith("rtsp://"):
+            url = "http://" + url
+        domain = url.split("//")[1].split("/")[0]
+        if ":" not in domain:
+            url = url.replace(domain, domain + ":8080")
+        if "/" not in url.split("//")[1]:
+            url += "/video"
+        super().__init__(
+            [url, *(args or [])], timeout=timeout, info=info,
+            open_error=open_error or ValueError(f"Could not open video stream from URL {url}"),
+            timeout_error=timeout_error or TimeoutError(
+                f"Could not open video stream from URL {url} within {timeout} seconds")
+        )

omnicam-0.1.0/src/camerapy/pi_camera.py

@@ -0,0 +1,138 @@
+from typing import Union
+
+from .base_camera import BaseCamera, resolutions, CameraInfo
+
+
+class PiCamera(BaseCamera):
+    rpi_camera_definitions = [
+        CameraInfo(
+            name="Camera Module 1", short_name="OV5647",
+            focal_length_mm=(3.60, 3.60), pixel_size_um=1.40, max_resolution=(2592, 1944),
+            aperture_f=2.9, hfov_deg=53.5, focus_type="Fixed", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Camera Module 1 NoIR", short_name="OV5647 NoIR",
+            focal_length_mm=(3.60, 3.60), pixel_size_um=1.40, max_resolution=(2592, 1944),
+            aperture_f=2.9, hfov_deg=53.5, focus_type="Fixed", has_ir_filter=False
+        ),
+        CameraInfo(
+            name="Camera Module 2", short_name="IMX219",
+            focal_length_mm=(3.04, 3.04), pixel_size_um=1.12, max_resolution=(3280, 2464),
+            aperture_f=2.0, hfov_deg=62.2, focus_type="Fixed", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Camera Module 2 NoIR", short_name="IMX219 NoIR",
+            focal_length_mm=(3.04, 3.04), pixel_size_um=1.12, max_resolution=(3280, 2464),
+            aperture_f=2.0, hfov_deg=62.2, focus_type="Fixed", has_ir_filter=False
+        ),
+        CameraInfo(
+            name="Camera Module 3 - Standard", short_name="IMX708 Standard",
+            focal_length_mm=(4.74, 4.74), pixel_size_um=1.40, max_resolution=(4608, 2592),
+            aperture_f=1.8, hfov_deg=66.0, focus_type="Autofocus", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Camera Module 3 - Standard NoIR", short_name="IMX708 NoIR",
+            focal_length_mm=(4.74, 4.74), pixel_size_um=1.40, max_resolution=(4608, 2592),
+            aperture_f=1.8, hfov_deg=66.0, focus_type="Autofocus", has_ir_filter=False
+        ),
+        CameraInfo(
+            name="Camera Module 3 - Wide", short_name="IMX708 Wide",
+            focal_length_mm=(2.75, 2.75), pixel_size_um=1.40, max_resolution=(4608, 2592),
+            aperture_f=2.2, hfov_deg=102.0, focus_type="Autofocus", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Camera Module 3 - Wide NoIR", short_name="IMX708 Wide NoIR",
+            focal_length_mm=(2.75, 2.75), pixel_size_um=1.40, max_resolution=(4608, 2592),
+            aperture_f=2.2, hfov_deg=102.0, focus_type="Autofocus", has_ir_filter=False
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 6mm Lens", short_name="IMX477 6mm",
+            focal_length_mm=(6.00, 6.00), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=1.2, hfov_deg=55.0, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 16mm Lens", short_name="IMX477 16mm",
+            focal_length_mm=(16.00, 16.00), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=1.4, hfov_deg=22.2, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 35mm Lens", short_name="IMX477 35mm",
+            focal_length_mm=(35.00, 35.00), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=1.7, hfov_deg=10.1, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 8mm M12 Lens", short_name="IMX477 M12-8mm",
+            focal_length_mm=(8.00, 8.00), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=1.8, hfov_deg=49.0, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 25mm M12 Lens", short_name="IMX477 M12-25mm",
+            focal_length_mm=(25.00, 25.00), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=2.4, hfov_deg=14.4, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="High Quality Camera w/ 2.7mm M12 Fisheye", short_name="IMX477 M12-Fish",
+            focal_length_mm=(2.70, 2.70), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=2.5, hfov_deg=140.0, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Global Shutter Camera w/ 6mm Lens", short_name="IMX296 6mm",
+            focal_length_mm=(6.00, 6.00), pixel_size_um=3.45, max_resolution=(1456, 1088),
+            aperture_f=1.2, hfov_deg=45.0, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Global Shutter Camera w/ 16mm Lens", short_name="IMX296 16mm",
+            focal_length_mm=(16.00, 16.00), pixel_size_um=3.45, max_resolution=(1456, 1088),
+            aperture_f=1.4, hfov_deg=17.8, focus_type="Manual", has_ir_filter=True
+        ),
+        CameraInfo(
+            name="Raspberry Pi AI Camera", short_name="IMX500",
+            focal_length_mm=(4.74, 4.74), pixel_size_um=1.55, max_resolution=(4056, 3040),
+            aperture_f=1.79, hfov_deg=66.3, focus_type="Manual", has_ir_filter=True
+        )
+    ]
+
+    rpi_cameras = {}
+    for cam_info in rpi_camera_definitions:
+        rpi_cameras[cam_info.name] = cam_info
+        rpi_cameras[cam_info.short_name] = cam_info
+
+    def __init__(self, model: Union[str, CameraInfo], resolution: "tuple[int, int] | str" = "720p"):
+        super().__init__()
+        if not isinstance(model, CameraInfo):
+            if model not in PiCamera.rpi_cameras:
+                raise ValueError(f"Unsupported: {model}. Supported models: {', '.join(PiCamera.rpi_cameras.keys())}")
+            if isinstance(resolution, str) and resolution not in resolutions and resolution not in resolutions.values():
+                raise ValueError(
+                    f"Unsupported resolution: {resolution}. Supported resolutions: {', '.join(str(r) for r in resolutions.values())}")
+            model = PiCamera.rpi_cameras[model]
+        if isinstance(resolution, str):
+            resolution = resolutions[resolution]
+        self.resolution = resolution
+        self.model = model
+
+    def _open(self):
+        try:
+            from picamera2 import Picamera2
+        except Exception as e:
+            raise ImportError("PiCamera could not be initialized. Is picamera2 installed?") from e
+        self.cam = Picamera2()
+        self.cam.preview_configuration.main.format = "RGB888"
+        self.cam.preview_configuration.main.size = self.resolution
+        self.cam.configure("preview")
+        self.cam.start()
+
+    def _read(self):
+        return self.cam.capture_array()
+
+    def _release(self):
+        if not self.closed:
+            self.closed = True
+            self.cam.stop()
+            self.cam.close()
+
+    def _size(self):
+        return self.resolution
+
+    def focal_length(self):
+        return self.model.focal_length(self.size())

omnicam-0.1.0/src/camerapy/readonly_camera.py

@@ -0,0 +1,25 @@
+from .base_camera import BaseCamera
+
+
+class ReadonlyCamera(BaseCamera):
+    def __init__(self, cam: BaseCamera):
+        super().__init__()
+        self.cam = cam
+
+    def _open(self):
+        self.cam._open()
+
+    def _read(self):
+        return self.cam._read()
+
+    def _release(self):
+        pass
+
+    def _size(self):
+        return self.cam._size()
+
+    def _focus(self, rectangle: tuple[int, int, int, int]):
+        self.cam._focus(rectangle)
+
+    def focal_length(self):
+        return self.cam.focal_length()

omnicam-0.1.0/src/camerapy/screen_capture.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+from .base_camera import BaseCamera
+
+
+class ScreenCapture(BaseCamera):
+    # region: {"top": int, "left": int, "width": int, "height": int}
+    def __init__(self, index=1, region: "dict[str, int] | None" = None,
+                 focal_length: "tuple[float, float] | None" = None):
+        try:
+            import mss
+            self.mss = mss
+        except Exception as e:
+            raise ImportError("mss is required for this feature. Install with 'pip install omnicam[screen]'.") from e
+        super().__init__()
+        self.index = index
+        self.region = region
+        self._focal_length = focal_length
+
+    def _open(self):
+        self.cap = self.mss.mss()
+        self.monitor = self.cap.monitors[self.index]
+        self.region = self.region if self.region is not None else self.monitor
+
+    def _read(self):
+        return np.array(self.cap.grab(
+            {
+                "top": self.monitor["top"] + self.region["top"],
+                "left": self.monitor["left"] + self.region["left"],
+                "width": self.region["width"],
+                "height": self.region["height"]
+            } if self.region is not None else self.monitor))
+
+    def _release(self):
+        self.cap.close()
+
+    def _size(self):
+        if self.region is not None:
+            return self.region["width"], self.region["height"]
+        return self.monitor["width"], self.monitor["height"]
+
+    def focal_length(self):
+        if self._focal_length is None:
+            raise ValueError("Focal length not set for ScreenCapture")
+        return self._focal_length

omnicam-0.1.0/src/camerapy/simple_camera.py

@@ -0,0 +1,20 @@
+import platform
+
+from .base_camera import CameraInfo
+from .cv_camera_base import CVCameraBase
+
+
+class SimpleCamera(CVCameraBase):
+    def __init__(self, index=0, info: CameraInfo = None):
+        try:
+            import cv2
+        except Exception as exc:
+            raise ImportError(
+                "OpenCV is required for this feature. Install with 'pip install omnicam[opencv]'."
+            ) from exc
+        args = [index, cv2.CAP_DSHOW] if platform.system() == "Windows" else [index, cv2.CAP_V4L2]
+        try:
+            super().__init__(args, info=info)
+        except Exception as e:
+            raise RuntimeError(f"Camera with index {index} could not be opened: {e}") from e
+        self.index = index

omnicam-0.1.0/src/omnicam.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: omnicam
+Version: 0.1.0
+Summary: A Python package for camera utilities
+Author-email: OguzhanUmutlu <contact@oguzhanumutlu.com>
+License: MIT License
+        
+        Copyright (c) 2025 Oğuzhan
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/OguzhanUmutlu/omnicam
+Project-URL: Issues, https://github.com/OguzhanUmutlu/omnicam/issues
+Project-URL: Documentation, https://github.com/OguzhanUmutlu/omnicam#readme
+Keywords: camera,opencv,vision,stream,capture
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Provides-Extra: opencv
+Requires-Dist: opencv-python>=4.7; extra == "opencv"
+Provides-Extra: screen
+Requires-Dist: mss>=9.0; extra == "screen"
+Provides-Extra: pi
+Requires-Dist: picamera2>=0.3; extra == "pi"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# omnicam
+
+A small, unified API for reading frames from USB cameras, IP streams, video files, screen capture, and Raspberry Pi
+cameras.
+
+## Features
+
+- Unified `BaseCamera` interface across backends
+- OpenCV-based capture for USB webcams, video files, RTSP/HTTP streams, and GStreamer pipelines
+- Optional Raspberry Pi Camera support (Picamera2)
+- Optional screen capture via `mss`
+
+## Installation
+
+```bash
+pip install omnicam
+```
+
+Optional extras:
+
+```bash
+pip install omnicam[opencv]
+pip install omnicam[screen]
+pip install omnicam[pi]
+```
+
+## Quickstart
+
+```python
+from omnicam import SimpleCamera
+
+with SimpleCamera(index=0) as cam:
+    cam.open()
+    frame = cam.read()
+    if frame is not None:
+        print(frame.shape)
+```
+
+## Camera types
+
+```python
+from omnicam import FileCapture, InternetCapture, ScreenCapture
+
+# Video file
+cam = FileCapture("/path/to/video.mp4")
+
+# IP camera or MJPEG stream
+cam = InternetCapture("http://192.168.1.10:8080/video")
+
+# Screen capture (requires omnicam[screen])
+cam = ScreenCapture(index=1)
+```
+
+## Raspberry Pi camera
+
+```python
+from omnicam import PiCamera
+
+cam = PiCamera(model="IMX219", resolution="720p")
+```
+
+## GStreamer and Gazebo
+
+```python
+from omnicam import GStreamerCapture, GazeboCamera
+
+pipeline = (
+    GStreamerCapture.GstPipeline()
+    .add("v4l2src", device="/dev/video0")
+    .add("videoconvert")
+    .add("appsink")
+)
+cam = GStreamerCapture(pipeline)
+
+# Gazebo (requires gz tools available on PATH)
+cam = GazeboCamera(topic_name="my_camera")
+```
+
+## Notes
+
+- `numpy` is required. OpenCV-based backends need `omnicam[opencv]`.
+- GStreamer and Gazebo features rely on system-level tooling.
+
+## License
+
+MIT. See `LICENSE`.

omnicam-0.1.0/src/omnicam.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/camerapy/__init__.py
+src/camerapy/base_camera.py
+src/camerapy/cv_camera_base.py
+src/camerapy/file_capture.py
+src/camerapy/gazebo_camera.py
+src/camerapy/gstreamer_capture.py
+src/camerapy/internet_capture.py
+src/camerapy/pi_camera.py
+src/camerapy/readonly_camera.py
+src/camerapy/screen_capture.py
+src/camerapy/simple_camera.py
+src/omnicam.egg-info/PKG-INFO
+src/omnicam.egg-info/SOURCES.txt
+src/omnicam.egg-info/dependency_links.txt
+src/omnicam.egg-info/requires.txt
+src/omnicam.egg-info/top_level.txt

omnicam-0.1.0/src/omnicam.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

omnicam-0.1.0/src/omnicam.egg-info/requires.txt

@@ -0,0 +1,13 @@
+numpy>=1.21
+
+[dev]
+pytest>=7.0
+
+[opencv]
+opencv-python>=4.7
+
+[pi]
+picamera2>=0.3
+
+[screen]
+mss>=9.0

omnicam-0.1.0/src/omnicam.egg-info/top_level.txt

@@ -0,0 +1 @@
+camerapy