python-camera-manager-directshow 0.1.0__py3-none-any.whl

python_camera_manager_directshow-0.1.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: python-camera-manager-directshow
+Version: 0.1.0
+Summary: Python camera manager with DirectShow capability discovery and .NET bridge integration
+Author: Lior Blokshtein
+License: MIT
+Project-URL: Homepage, https://github.com/LBlokshtein/python-camera-manager-directshow.git
+Project-URL: Repository, https://github.com/LBlokshtein/python-camera-manager-directshow.git
+Keywords: camera,directshow,pythonnet,opencv,computer-vision
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Multimedia :: Video :: Capture
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pythonnet
+Requires-Dist: opencv-python
+Requires-Dist: Pillow
+Dynamic: license-file
+
+# Python Camera Manager (DirectShow Bridge)
+
+A Python-first camera control and preview application built on top of a .NET DirectShow wrapper.
+
+This project was created to solve a common limitation in OpenCV camera workflows: while OpenCV can open cameras quickly, it does not provide a reliable, discoverable, device-specific model of control capabilities (valid ranges, step sizes, defaults, and auto/manual support) across many webcams.
+
+This codebase provides that missing layer:
+
+- discover camera capabilities and supported formats using DirectShow
+- expose those capabilities as plain Python data structures
+- open and stream camera frames through the same API
+- optionally use this metadata with another capture backend (for example OpenCV)
+
+## Why This Project Exists
+
+In many practical camera applications, you need to know more than whether a property exists. You need to know:
+
+- minimum and maximum values
+- step increments
+- default values
+- current values
+- whether auto mode is supported
+- whether auto mode is currently enabled
+
+OpenCV alone does not consistently provide this level of introspection across devices and drivers. This project addresses that gap by using DirectShow (via a .NET wrapper) for capability discovery and control, then exposing a clean Python API for application code.
+
+## Core Design
+
+### .NET for camera graph and capability access
+
+The .NET layer (`DirectShowLibWrapper.dll`) handles DirectShow-specific operations such as:
+
+- camera enumeration
+- supported format discovery
+- capability/range discovery
+- frame acquisition
+- camera property set/get with auto/manual modes
+
+### Python bridge for usability
+
+The Python bridge files:
+
+- `camera/camera_inspector_bridge.py`
+- `camera/camera_device_bridge.py`
+
+load the .NET assemblies and call into the wrapper.
+
+### Python manager for developer experience
+
+`camera/camera_manager.py` is the high-level facade.
+
+It converts .NET objects into Python-native types (`NamedTuple`, `dict`, `list`) so downstream code does not need to work with .NET object syntax. The output is intentionally Pythonic and user-friendly.
+
+In other words, consumers can use the API without needing to understand .NET interop details.
+
+## What You Can Do With It
+
+1. Full managed workflow
+- discover devices, formats, ranges
+- open camera and stream frames
+- change auto/manual modes
+- set precise property values based on discovered constraints
+- format note: without OpenCV installed, streaming requires uncompressed formats (for example RGB24/BGR24/GRAY8). MJPG and YUY2 decoding paths require OpenCV.
+
+2. Hybrid workflow
+- use this project only for camera capability discovery (ranges, steps, auto support)
+- then open/stream with another backend (such as OpenCV) if preferred
+
+This gives you flexibility to mix tooling while still relying on robust capability metadata.
+
+## Repository Structure
+
+```text
+
+app/
+  main.py                      # Main runnable application entrypoint
+camera/
+  __init__.py
+  camera_manager.py            # High-level Python API and cache
+  camera_device_bridge.py      # Frame/camera control bridge into .NET
+  camera_inspector_bridge.py   # Camera discovery/capability bridge into .NET
+GUI/
+  main_GUI.py                  # Tkinter UI
+runtime/
+  dotnet/
+    DirectShowLib.dll
+    DirectShowLibWrapper.dll
+```
+
+## Requirements
+
+- Windows (DirectShow)
+- Python 3.10+ (recommended)
+- .NET runtime compatible with your `DirectShowLibWrapper.dll`
+- A DirectShow-capable camera device
+
+Python packages:
+
+- `pythonnet`
+- `opencv-python` (required for MJPG and YUY2 decode paths)
+- `Pillow`
+
+Streaming without OpenCV is supported only when the camera output is already an uncompressed format handled by the bridge (for example `RGB24`, `BGR24`, or `GRAY8`).
+
+## Setup
+
+Install from PyPI (after package publication):
+
+```bash
+pip install python-camera-manager-directshow
+```
+
+Install from source (current repository):
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+pip install pythonnet opencv-python Pillow
+```
+
+Ensure these assemblies exist:
+
+- `runtime/dotnet/DirectShowLib.dll`
+- `runtime/dotnet/DirectShowLibWrapper.dll`
+
+## Run
+
+```bash
+python -m app.main
+```
+
+Alternative:
+
+```bash
+python app/main.py
+```
+
+## API Example (Python-native usage)
+
+```python
+from camera.camera_manager import Camera
+
+# Discover all cameras with formats and control ranges
+devices = Camera.get_connected_cameras(get_formats=True, get_ranges=True)
+
+if not devices:
+    raise RuntimeError("No camera detected")
+
+selected = devices[0]
+fmt = selected.formats[0]
+
+cam = Camera(debug_logging=False)
+cam.open(selected.path, fmt, request_rgb24_conversion=False)
+
+# Ranges are plain Python structures
+ranges = cam.property_ranges
+exposure = ranges.get("Exposure")
+if exposure and exposure.property_supported:
+    # Respect discovered min/max/step
+    cam.set_property_auto_mode("Exposure", False)
+    cam.set_property_value("Exposure", int(exposure.default))
+
+ok, frame = cam.get_frame()
+cam.close()
+```
+
+## Hybrid Example (Use metadata here, capture elsewhere)
+
+```python
+import cv2
+from camera.camera_manager import Camera
+
+devices = Camera.get_connected_cameras(get_formats=False, get_ranges=True)
+if not devices:
+    raise RuntimeError("No camera")
+
+# Use discovered ranges for UI/validation logic
+ranges = devices[0].ranges
+print(ranges.get("Exposure"))
+
+# Open camera with another backend if desired
+cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+ret, frame = cap.read()
+cap.release()
+```
+
+## Notes for Recruiters / Reviewers
+
+This project demonstrates:
+
+- cross-language integration (.NET DirectShow + Python)
+- practical camera systems engineering
+- robust control-surface modeling (ranges, steps, auto/manual capabilities)
+- Python API design that hides interop complexity
+- real-time GUI integration and format negotiation
+
+## Limitations
+
+- Device behavior depends on camera driver and hardware implementation.
+- Some controls may be unsupported or partially supported on specific devices.
+- Only one process/backend should actively own a camera stream at a time.
+- MJPG and YUY2 decoding require OpenCV in the current implementation; without OpenCV, use uncompressed output formats.
+
+## Companion .NET Repository
+
+The .NET wrapper source code is maintained in a separate repository:
+
+- https://github.com/LBlokshtein/DirectShowLibWrapper
+
+This Python repository consumes the compiled artifacts and focuses on Python API ergonomics and application usage.
+
+## License
+
+MIT. See `LICENSE`.

python_camera_manager_directshow-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+GUI/__init__.py,sha256=5ORv_CAOI7g_FJyIXn5NkbybEKoa2-fOUda8fOiIm4E,64
+GUI/main_GUI.py,sha256=M5OEVPWKoBUnpKgcYjmq2mo3LysV_V2VOadvV_kPrcw,39705
+app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/main.py,sha256=4l97Wh6Kz4d9KfkitfwE7pB_uneTGHHmPYviaQSZt1c,3304
+camera/__init__.py,sha256=DNaYXuH4E8XTnTDVUR217Iw3Ijzs7WWF8iqWjFK0bqA,227
+camera/camera_device_bridge.py,sha256=nTMbwNTFi8DbEwy-q9g4gGc9KtWmTB8kyjE40Xf1YiI,54048
+camera/camera_inspector_bridge.py,sha256=Ugh5BfI5Fzryl48PBu3MzgjQrjyXb94bDO_YtU_SGkE,1781
+camera/camera_manager.py,sha256=SX9xogRQhi3K7ROT7NKCSa9rKahG7KzcP2zcNUUJSTg,40418
+python_camera_manager_directshow-0.1.0.dist-info/licenses/LICENSE,sha256=JwhXJ0q2mbWl5x8JFZ_t73TfZZi090M34vkkP6KsB2s,1093
+runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+runtime/dotnet/DirectShowLib.dll,sha256=a-Vjg86DmC9piMcAAVr6PVBkG6abSNDwKTKiJgIq_FY,294912
+runtime/dotnet/DirectShowLibWrapper.dll,sha256=fl5TDBoC_suceKznwpjjX9koVuyHtzkWl8tzAkBObaM,36352
+runtime/dotnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_camera_manager_directshow-0.1.0.dist-info/METADATA,sha256=Pe7XM-eidHQ3t5ezrPssTDNzTmCC03JpKR8-vR9jZ9c,7742
+python_camera_manager_directshow-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+python_camera_manager_directshow-0.1.0.dist-info/entry_points.txt,sha256=bSzCSCUgYi3ypOcJhk3LUvJbu3rU7j72ig7nijgGUcI,49
+python_camera_manager_directshow-0.1.0.dist-info/top_level.txt,sha256=gdFqPcJYq8TO7tRKRMXAEKgAvC1vwao8g_U8BHgK3AY,23
+python_camera_manager_directshow-0.1.0.dist-info/RECORD,,

python_camera_manager_directshow-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_camera_manager_directshow-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+camera-manager = app.main:main

python_camera_manager_directshow-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lior Blokshtein
+
+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.

python_camera_manager_directshow-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+GUI
+app
+camera
+runtime