QVideo 3.0.0__py3-none-any.whl

QVideo/QCamcorder.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+'''Composite camcorder widget combining a video screen, camera controls, and DVR.
+
+Run directly to launch a full camcorder application with camera selection::
+
+    python -m QVideo.QCamcorder [-c|-f|-s|-v] [cameraID]
+
+Camera flags (mutually exclusive):
+
+.. code-block:: text
+
+    -b [cameraID]   Basler camera (requires pylon SDK)
+    -c [cameraID]   OpenCV camera
+    -f [cameraID]   FLIR camera (requires Spinnaker SDK)
+    -i [cameraID]   IDS Imaging camera (requires IDS peak SDK)
+    -m [cameraID]   MATRIX VISION mvGenTLProducer (universal GenICam, not FLIR)
+    -p [cameraID]   Raspberry Pi camera module (requires picamera2)
+    -v [cameraID]   Allied Vision VimbaX camera
+
+If no flag is given, a noise camera is used as a fallback.
+'''
+
+from pyqtgraph.Qt.QtWidgets import QWidget
+from pyqtgraph.Qt.QtCore import pyqtSlot
+from pyqtgraph.Qt import QtGui, uic
+from QVideo.lib import QCameraTree, QVideoSource
+from pathlib import Path
+
+
+__all__ = ['QCamcorder']
+
+
+class QCamcorder(QWidget):
+    '''A widget combining a video screen, camera controls, and DVR.
+
+    Lays out a :class:`~QVideo.lib.QVideoScreen.QVideoScreen` alongside
+    a :class:`~QVideo.dvr.QDVRWidget.QDVRWidget` and an arbitrary
+    :class:`~QVideo.lib.QCameraTree.QCameraTree` control panel.  Live
+    frames from the camera source are routed to the screen; when the DVR
+    starts playback the screen is switched to the playback stream and the
+    camera controls are disabled until playback ends.
+
+    Parameters
+    ----------
+    cameraWidget : QCameraTree
+        Camera control tree to embed in the controls panel.
+    *args :
+        Additional positional arguments forwarded to
+        :class:`~pyqtgraph.Qt.QtWidgets.QWidget`.
+    **kwargs :
+        Additional keyword arguments forwarded to
+        :class:`~pyqtgraph.Qt.QtWidgets.QWidget`.
+    '''
+
+    UIFILE = Path(__file__).parent / 'QCamcorder.ui'
+
+    def __init__(self,
+                 cameraWidget: QCameraTree,
+                 *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.cameraWidget = cameraWidget
+        self._setupUi()
+        self._connectSignals()
+        self.screen.source = self.source
+        self.dvr.source = self.source
+
+    def _setupUi(self) -> None:
+        uic.loadUi(str(self.UIFILE), self)
+        self.controls.layout().addWidget(self.cameraWidget)
+
+    def _connectSignals(self) -> None:
+        self.dvr.playing.connect(self.dvrPlayback)
+
+    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
+        '''Stop the camera source when the widget is closed.'''
+        self.cameraWidget.stop()
+        super().closeEvent(event)
+
+    @pyqtSlot(bool)
+    def dvrPlayback(self, playback: bool) -> None:
+        '''Switch the screen source between live camera and DVR playback.
+
+        Connected to :attr:`~QVideo.dvr.QDVRWidget.QDVRWidget.playing`.
+        When playback starts the camera source is disconnected from the
+        screen and the DVR's :attr:`~QVideo.dvr.QDVRWidget.QDVRWidget.newFrame`
+        signal is connected instead; the camera controls are disabled.
+        When playback ends the connections are reversed and the controls
+        are re-enabled.
+
+        Parameters
+        ----------
+        playback : bool
+            ``True`` when DVR playback begins, ``False`` when it ends.
+        '''
+        try:
+            if playback:
+                self.source.newFrame.disconnect(self.screen.setImage)
+                self.dvr.newFrame.connect(self.screen.setImage)
+            else:
+                self.dvr.newFrame.disconnect(self.screen.setImage)
+                self.source.newFrame.connect(self.screen.setImage)
+        except (RuntimeError, TypeError):
+            pass
+        self.cameraWidget.setDisabled(playback)
+
+    @property
+    def source(self) -> QVideoSource:
+        '''The :class:`~QVideo.lib.QVideoSource.QVideoSource` from the camera widget.'''
+        return self.cameraWidget.source
+
+
+def main() -> None:  # pragma: no cover
+    '''Launch the camcorder with an interactively chosen camera.'''
+    import pyqtgraph as pg
+    from QVideo.lib import choose_camera
+
+    pg.mkQApp()
+    camera = choose_camera()
+    widget = QCamcorder(camera.start())
+    widget.show()
+    pg.exec()
+
+
+if __name__ == '__main__':
+    main()

QVideo/__init__.py

@@ -0,0 +1,5 @@
+from QVideo.lib import QVideoScreen
+from QVideo.version import *
+
+
+__all__ = ['QVideoScreen']

QVideo/cameras/Basler/QBaslerCamera.py

@@ -0,0 +1,50 @@
+from QVideo.cameras.Genicam import QGenicamCamera, QGenicamSource
+
+
+__all__ = ['QBaslerCamera', 'QBaslerSource']
+
+
+class QBaslerCamera(QGenicamCamera):
+
+    '''Camera backed by a Basler device via the pylon GenTL producer.
+
+    `pylon <https://www.baslerweb.com/en/software/pylon/>`_ is Basler's
+    SDK for machine-vision cameras.  It installs separate GenTL producers
+    for USB3 Vision and GigE Vision cameras whose paths are discovered
+    automatically from the ``GENICAM_GENTL64_PATH`` environment variable
+    set by the pylon installer.
+
+    If pylon is not installed, instantiation raises :exc:`TypeError`.
+
+    Parameters
+    ----------
+    cameraID : int
+        Index of the Basler camera to open.  Default: ``0``.
+    '''
+
+    producer = QGenicamCamera._findProducer('ProducerU3V.cti',
+                                            'ProducerGEV.cti')
+
+
+class QBaslerSource(QGenicamSource):
+
+    '''Threaded video source backed by :class:`QBaslerCamera`.
+
+    Parameters
+    ----------
+    camera : QBaslerCamera or None
+        Camera instance to wrap.  If ``None``, a new
+        :class:`QBaslerCamera` is created from ``cameraID``.
+    cameraID : int
+        Index of the camera to open.  Used only when *camera* is ``None``.
+        Default: ``0``.
+    '''
+
+    def __init__(self, camera: QBaslerCamera | None = None,
+                 cameraID: int = 0) -> None:
+        camera = camera or QBaslerCamera(cameraID=cameraID)
+        super().__init__(camera)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    QBaslerCamera.example()

QVideo/cameras/Basler/QBaslerTree.py

@@ -0,0 +1,67 @@
+from QVideo.cameras.Genicam import QGenicamTree
+from QVideo.cameras.Basler.QBaslerCamera import QBaslerCamera
+from QVideo.lib.QCameraTree import Source
+
+
+__all__ = ['QBaslerTree']
+
+
+class QBaslerTree(QGenicamTree):
+
+    '''Camera property tree for :class:`~QVideo.cameras.Basler.QBaslerCamera`.
+
+    Builds a :class:`~QVideo.lib.QCameraTree.QCameraTree` with a curated
+    set of controls and sensible default settings for Basler cameras.
+
+    Parameters
+    ----------
+    camera : QBaslerCamera or None
+        Camera instance to use.  If ``None``, a new :class:`QBaslerCamera`
+        is created from ``cameraID``.
+    cameraID : int
+        Index of the Basler camera to open.  Used only when *camera* is
+        ``None``.  Default: ``0``.
+    controls : list of str or None
+        Names of GenICam nodes to show.  Default: :attr:`_DEFAULT_CONTROLS`.
+    '''
+
+    _DEFAULT_CONTROLS = [
+        'ReverseX',
+        'ReverseY',
+        'AcquisitionFrameRate',
+        'AcquisitionResultingFrameRate',
+        'ExposureTime',
+        'ExposureAuto',
+        'Gain',
+        'GainAuto',
+        'Gamma',
+        'BlackLevel',
+        'Width',
+        'Height',
+        'OffsetX',
+        'OffsetY',
+    ]
+
+    _DEFAULT_SETTINGS = dict(
+        AcquisitionFrameRateEnable=True,
+        BlackLevelSelector='All',
+        GammaEnable=True,
+        ExposureAuto='Off',
+        GainAuto='Off',
+    )
+
+    def __init__(self, *args,
+                 camera: Source | None = None,
+                 cameraID: int = 0,
+                 controls: list[str] | None = None,
+                 **kwargs) -> None:
+        camera = camera or QBaslerCamera(cameraID=cameraID)
+        camera.setSettings(self._DEFAULT_SETTINGS)
+        super().__init__(*args,
+                         camera=camera,
+                         controls=controls or self._DEFAULT_CONTROLS,
+                         **kwargs)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    QBaslerTree.example()

QVideo/cameras/Basler/__init__.py

@@ -0,0 +1,5 @@
+from .QBaslerCamera import QBaslerCamera, QBaslerSource
+from .QBaslerTree import QBaslerTree
+
+
+__all__ = ['QBaslerCamera', 'QBaslerSource', 'QBaslerTree']

QVideo/cameras/Flir/QFlirCamera.py

@@ -0,0 +1,48 @@
+from QVideo.cameras.Genicam import QGenicamCamera, QGenicamSource
+
+
+__all__ = ['QFlirCamera', 'QFlirSource']
+
+
+class QFlirCamera(QGenicamCamera):
+
+    '''Camera backed by a FLIR device via the Spinnaker GenTL producer.
+
+    `Spinnaker <https://www.flir.com/products/spinnaker-sdk/>`_ is FLIR's
+    SDK for machine-vision cameras.  It installs a GenTL producer whose
+    path is discovered automatically from the ``GENICAM_GENTL64_PATH``
+    environment variable set by the Spinnaker installer.
+
+    If Spinnaker is not installed, instantiation raises :exc:`TypeError`.
+
+    Parameters
+    ----------
+    cameraID : int
+        Index of the FLIR camera to open.  Default: ``0``.
+    '''
+
+    producer = QGenicamCamera._findProducer('Spinnaker_GenTL.cti')
+
+
+class QFlirSource(QGenicamSource):
+
+    '''Threaded video source backed by :class:`QFlirCamera`.
+
+    Parameters
+    ----------
+    camera : QFlirCamera or None
+        Camera instance to wrap.  If ``None``, a new
+        :class:`QFlirCamera` is created from ``cameraID``.
+    cameraID : int
+        Index of the camera to open.  Used only when *camera* is ``None``.
+        Default: ``0``.
+    '''
+
+    def __init__(self, camera: QFlirCamera | None = None,
+                 cameraID: int = 0) -> None:
+        camera = camera or QFlirCamera(cameraID=cameraID)
+        super().__init__(camera)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    QFlirCamera.example()

QVideo/cameras/Flir/QFlirTree.py

@@ -0,0 +1,70 @@
+from QVideo.cameras.Genicam import QGenicamTree
+from QVideo.cameras.Flir.QFlirCamera import QFlirCamera
+from QVideo.lib.QCameraTree import Source
+
+
+__all__ = ['QFlirTree']
+
+
+class QFlirTree(QGenicamTree):
+
+    '''Camera property tree for :class:`~QVideo.cameras.Flir.QFlirCamera`.
+
+    Builds a :class:`~QVideo.lib.QCameraTree.QCameraTree` with a curated
+    set of controls and sensible default settings for FLIR cameras.
+
+    Parameters
+    ----------
+    camera : QFlirCamera or None
+        Camera instance to use.  If ``None``, a new :class:`QFlirCamera`
+        is created from ``cameraID``.
+    cameraID : int
+        Index of the FLIR camera to open.  Used only when *camera* is
+        ``None``.  Default: ``0``.
+    controls : list of str or None
+        Names of GenICam nodes to show.  Default: :attr:`_DEFAULT_CONTROLS`.
+    '''
+
+    _DEFAULT_CONTROLS = [
+        'ReverseX',
+        'ReverseY',
+        'AcquisitionFrameRate',
+        'AcquisitionResultingFrameRate',
+        'ExposureTime',
+        'ExposureAuto',
+        'Gain',
+        'GainAuto',
+        'Gamma',
+        'BlackLevel',
+        'Width',
+        'Height',
+        'OffsetX',
+        'OffsetY',
+    ]
+
+    _DEFAULT_SETTINGS = dict(
+        AcquisitionFrameRateEnable=True,
+        BlackLevelSelector='All',
+        GammaEnable=True,
+        AutoExposureControlPriority='Gain',
+        ExposureAuto='Off',
+        ExposureMode='Timed',
+        ExposureTimeMode='Common',
+        GainAuto='Off',
+    )
+
+    def __init__(self, *args,
+                 camera: Source | None = None,
+                 cameraID: int = 0,
+                 controls: list[str] | None = None,
+                 **kwargs) -> None:
+        camera = camera or QFlirCamera(cameraID=cameraID)
+        camera.setSettings(self._DEFAULT_SETTINGS)
+        super().__init__(*args,
+                         camera=camera,
+                         controls=controls or self._DEFAULT_CONTROLS,
+                         **kwargs)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    QFlirTree.example()

QVideo/cameras/Flir/QListFlirCameras.py

@@ -0,0 +1,31 @@
+from QVideo.lib import QListCameras
+from harvesters.core import Harvester
+from QVideo.cameras.Flir.QFlirCamera import QFlirCamera
+
+
+__all__ = ['QListFlirCameras']
+
+
+class QListFlirCameras(QListCameras):
+    '''A QComboBox that lists available Flir cameras.
+
+    Inherits
+    --------
+    QVideo.lib.QListCameras
+    '''
+
+    def _model(self) -> type:
+        return QFlirCamera
+
+    def _listCameras(self) -> None:
+        h = Harvester()
+        h.add_file(QFlirCamera.producer())
+        h.update()
+        for n, c in enumerate(h.device_info_list):
+            p = c.property_dict
+            self.addItem(f'{p["model"]} (SN {p["serial_number"]})', n)
+        h.reset()
+
+
+if __name__ == '__main__':
+    QListFlirCameras.example()

QVideo/cameras/Flir/__init__.py

@@ -0,0 +1,5 @@
+from .QFlirCamera import (QFlirCamera, QFlirSource)
+from .QFlirTree import QFlirTree
+
+
+__all__ = 'QFlirCamera QFlirSource QFlirTree'.split()