Merge pull request #11 from Attolab/add-pixel-length

Several general improvements

Author: BenediktBurger

README.rst

@@ -14,12 +14,17 @@ pymodaq_plugins_basler
 .. image:: https://github.com/BenediktBurger/pymodaq_plugins_basler/actions/workflows/Test.yml/badge.svg
     :target: https://github.com/BenediktBurger/pymodaq_plugins_basler/actions/workflows/Test.yml
 
-Set of PyMoDAQ plugins for cameras by Basler.
+Set of PyMoDAQ plugins for cameras by Basler, using the pypylon library. It handles basic camera functionalities (gain, exposure, ROI).
+The data is emitted together with spatial axes corresponding either to pixels or to real-world units (um). The pixel size of different camera model is hardcoded in the hardware/basler.py file.
+If the camera model is not specified, the pixel size is set to 1 um and can be changed manually by the user in the interface.
+
+The plugin was tested using an acA640-120gm camera. It is compatible with PyMoDAQ 4.4.7.
 
 Authors
 =======
 
 * Benedikt Burger
+* Romain Geneaux
 
 
 Instruments
@@ -54,5 +59,4 @@ Installation instructions
 =========================
 
 * You need the manufacturer's driver `Pylon <https://www.baslerweb.com/pylon>`_ for the cameras.
-* This package uses the work of a `genergic pylablib camera driver <https://github.com/rgeneaux/pymodaq_plugins_test_pylablib>`_, which is not yet available.
-  Relevant code is included in this package, so no additional installation needed.
+

plugin_info.toml

@@ -11,7 +11,7 @@ license = 'MIT'
 [plugin-install]
 #packages required for your plugin:
 packages-required = [
-    'pymodaq>=4.1.0',
+    'pymodaq>=4.4.7',
     'numpy',  # for Basler camera
     'pypylon',
 ]

src/pymodaq_plugins_basler/daq_viewer_plugins/plugins_2D/daq_2Dviewer_Basler.py

@@ -4,13 +4,7 @@
 from pymodaq.utils.daq_utils import ThreadCommand
 from pymodaq.control_modules.viewer_utility_classes import main
 
-try:
-    from pymodaq_plugins_pylablib_camera.daq_viewer_plugins.plugins_2D.daq_2Dviewer_GenericPylablibCamera import DAQ_2DViewer_GenericPylablibCamera
-    # available here: https://github.com/rgeneaux/pymodaq_plugins_test_pylablib
-except ModuleNotFoundError:
-    # Fall back to the internal version
-    from pymodaq_plugins_basler.daq_viewer_plugins.plugins_2D.daq_2Dviewer_GenericPylablibCamera import DAQ_2DViewer_GenericPylablibCamera
-
+from pymodaq_plugins_basler.hardware.daq_2Dviewer_GenericPylablibCamera import DAQ_2DViewer_GenericPylablibCamera
 from pymodaq_plugins_basler.hardware.basler import DartCamera
 
 
@@ -20,19 +14,14 @@ class DAQ_2DViewer_Basler(DAQ_2DViewer_GenericPylablibCamera):
     controller: DartCamera
     live_mode_available = True
 
-    # Generate a  **list**  of available cameras.
-    # Two cases:
-    # 1) Some pylablib classes have a .list_cameras method, which returns a list of available cameras, so we can just use that
-    # 2) Other classes have a .get_cameras_number(), which returns the number of connected cameras
-    #    in this case we can define the list as self.camera_list = [*range(number_of_cameras)]
-
     # For Basler, this returns a list of friendly names
     camera_list = [cam.GetFriendlyName() for cam in DartCamera.list_cameras()]
 
-    # Update the params (nothing to change here)
+    # Update the params
     params = DAQ_2DViewer_GenericPylablibCamera.params + [
         {'title': 'Automatic exposure:', 'name': 'auto_exposure', 'type': 'bool', 'value': False},
-        {'title': 'Gain (dB)', 'name': 'gain', 'type': 'float', 'value': 0, 'limits': [0, 18]},
+        {'title': 'Gain (dB)', 'name': 'gain', 'type': 'float', 'value': 0},#, 'limits': [0, 18]},
+        {'title': 'Pixel size (um)', 'name': 'pixel_length', 'type': 'float', 'value': 1, 'default' : 1, 'visible': False},
     ]
     params[next((i for i, item in enumerate(params) if item["name"] == "camera_list"), None)]['limits'] = camera_list  # type: ignore
 
@@ -70,11 +59,23 @@ def ini_detector(self, controller=None):
         self.ini_detector_init(old_controller=controller,
                                new_controller=self.init_controller())
 
+        # Check if pixel length is known
+        if self.controller.pixel_length is None:
+            model = self.controller.camera.GetDeviceInfo().GetModelName()
+            self.emit_status(ThreadCommand('Update_Status', [(f"No pixel length known for camera model '{model}', defaulting to user-chosen one"), 'log']))
+            self.settings.child('pixel_length').show()
+
+        # Check gain mode
+        if self.controller.raw_gain:
+            self.settings.child('gain').setOpts(type="int")
+            self.settings.child('gain').setOpts(title="Gain (raw)")
+        self.settings.child('gain').setValue(self.controller.gain)
+
         # Get camera name
         self.settings.child('camera_info').setValue(self.controller.get_device_info()[1])
 
         # Set exposure time
-        self.controller.set_exposure(self.settings.child('timing_opts', 'exposure_time').value() / 1000)
+        self.controller.exposure = self.settings.child('timing_opts', 'exposure_time').value() / 1000
 
         # FPS visibility
         self.settings.child('timing_opts', 'fps').setOpts(visible=self.settings.child('timing_opts', 'fps_on').value())
@@ -106,8 +107,12 @@ def commit_settings(self, param: Parameter) -> None:
         if param.name() == "auto_exposure":
             self.controller.camera.ExposureAuto.SetValue(
                 "Continuous" if self.settings['auto_exposure'] else "Off")
+        elif param.name() == "exposure_time":
+            self.controller.exposure = param.value()/1000
         elif param.name() == "gain":
-            self.controller.camera.Gain.SetValue(param.value())
+            self.controller.gain = param.value()
+        elif param.name() == "pixel_length":
+            self.controller.pixel_length = param.value()
         else:
             super().commit_settings(param=param)
 
@@ -134,4 +139,4 @@ def callback(self, array) -> None:
 
 
 if __name__ == '__main__':
-    main(__file__)
+    main(__file__, init=False)

src/pymodaq_plugins_basler/hardware/basler.py

@@ -17,6 +17,8 @@
     "daA1280-54um": 3.75,
     "daA2500-14um": 2.2,
     "daA3840-45um": 2,
+    "acA640-120gm": 5.6,
+    "acA645-100gm": 5.6,
 }
 
 
@@ -37,6 +39,10 @@ def __init__(self, name: str, callback: Optional[Callable] = None, **kwargs):
         # create camera object
         self.tlFactory = pylon.TlFactory.GetInstance()
         self.camera = pylon.InstantCamera()
+        self._exposure = None
+        self._gain = None
+        self.raw_gain = False
+
         # register configuration event handler
         self.configurationEventHandler = ConfigurationHandler()
         self.camera.RegisterConfiguration(
@@ -61,6 +67,29 @@ def open(self, name: str) -> None:
         self.camera.Attach(device)
         self.camera.Open()
         self.attributes["PixelWidth"] = self.pixel_length
+        self.check_attribute_names()
+
+    def check_attribute_names(self):
+        possible_exposures = ["ExposureTime", "ExposureTimeAbs"]
+        for exp in possible_exposures:
+            try:
+                if hasattr(self.camera, exp):
+                    self._exposure = getattr(self.camera, exp)
+                    break
+            except pylon.LogicalErrorException:
+                pass
+
+        possible_gains = ["Gain", "GainRaw"]
+        for gain in possible_gains:
+            try:
+                if hasattr(self.camera, gain):
+                    self._gain = getattr(self.camera, gain)
+
+                    if gain == "GainRaw":
+                        self.raw_gain = True
+                    break
+            except pylon.LogicalErrorException:
+                pass
 
     def set_callback(
         self, callback: Callable[[NDArray], None], replace_all: bool = True
@@ -103,13 +132,25 @@ def get_device_info(self) -> List[Any]:
             None,
         ]
 
-    def get_exposure(self) -> float:
+    @property
+    def exposure(self) -> float:
         """Get the exposure time in s."""
-        return self.camera.ExposureTime.GetValue() / 1e6
+        return self._exposure.GetValue() / 1e6
 
-    def set_exposure(self, value: float) -> None:
+    @exposure.setter
+    def exposure(self, value: float) -> None:
         """Set the exposure time in s."""
-        self.camera.ExposureTime.SetValue(value * 1e6)
+        self._exposure.SetValue(value * 1e6)
+
+    @property
+    def gain(self) -> Union[float, int]:
+        """Get the gain"""
+        return self._gain.GetValue()
+
+    @gain.setter
+    def gain(self, value: Union[float, int]) -> None:
+        """Set the gain"""
+        self._gain.SetValue(value)
 
     def get_roi(self) -> Tuple[float, float, float, float, int, int]:
         """Return x0, width, y0, height, xbin, ybin."""
@@ -165,7 +206,7 @@ def wait_for_frame(
         raise NotImplementedError("Not implemented")
 
     def get_all_attributes(self):
-        self.attributes
+        return self.attributes
 
     def get_attribute_value(self, name, error_on_missing=True):
         """Get the camera attribute with the given name"""
@@ -216,7 +257,10 @@ def start_grabbing(self, max_frame_rate: int = 1000) -> None:
 
         Whenever a grab succeeded, the callback defined in :meth:`set_callback` is called.
         """
-        self.camera.AcquisitionFrameRate.SetValue(max_frame_rate)
+        try:
+            self.camera.AcquisitionFrameRate.SetValue(max_frame_rate)
+        except pylon.LogicalErrorException:
+            pass
         self.camera.StartGrabbing(
             pylon.GrabStrategy_LatestImageOnly, pylon.GrabLoop_ProvidedByInstantCamera
         )
@@ -227,17 +271,21 @@ def stop_grabbing(self) -> None:
     @property
     def pixel_length(self) -> float:
         """Get the pixel length of the camera in µm.
-        
-        :raises: KeyError if the pixel length of the specific model is not known
+
+        Returns None if the pixel length of the specific model is not known
         """
         if self._pixel_length is None:
             model = self.camera.GetDeviceInfo().GetModelName()
             try:
                 self._pixel_length = pixel_lengths[model]
             except KeyError:
-                raise KeyError(f"No pixel length known for camera model '{model}'.")
+                self._pixel_length = None
         return self._pixel_length
 
+    @pixel_length.setter
+    def pixel_length(self, value):
+        self._pixel_length = value
+
 
 class ConfigurationHandler(pylon.ConfigurationEventHandler):
     """Handle the configuration events."""

…2D/daq_2Dviewer_GenericPylablibCamera.py …re/daq_2Dviewer_GenericPylablibCamera.pysrc/pymodaq_plugins_basler/daq_viewer_plugins/plugins_2D/daq_2Dviewer_GenericPylablibCamera.py renamed to src/pymodaq_plugins_basler/hardware/daq_2Dviewer_GenericPylablibCamera.py src/pymodaq_plugins_basler/daq_viewer_plugins/plugins_2D/daq_2Dviewer_GenericPylablibCamera.py renamed to src/pymodaq_plugins_basler/hardware/daq_2Dviewer_GenericPylablibCamera.py

@@ -6,7 +6,6 @@
 from time import perf_counter
 import numpy as np
 
-
 class DAQ_2DViewer_GenericPylablibCamera(DAQ_Viewer_base):
     """
     IMPORTANT: THIS IS A GENERIC CLASS THAT DOES NOT WORK ON ITS OWN!
@@ -27,21 +26,20 @@ class DAQ_2DViewer_GenericPylablibCamera(DAQ_Viewer_base):
         {'title': 'Image width', 'name': 'hdet', 'type': 'int', 'value': 1, 'readonly': True, 'default': 1},
         {'title': 'Image height', 'name': 'vdet', 'type': 'int', 'value': 1, 'readonly': True, 'default': 1},
         {'title': 'Timing', 'name': 'timing_opts', 'type': 'group', 'children':
-            [{'title': 'Exposure Time (ms)', 'name': 'exposure_time', 'type': 'int', 'value': 1, 'default': 1},
+            [{'title': 'Exposure Time (ms)', 'name': 'exposure_time', 'type': 'int', 'value': 100, 'default': 100},
              {'title': 'Compute FPS', 'name': 'fps_on', 'type': 'bool', 'value': True, 'default': True},
              {'title': 'FPS', 'name': 'fps', 'type': 'float', 'value': 0.0, 'readonly': True, 'default': 0.0}]
          }
     ]
     callback_signal = QtCore.Signal()
-    roi_pos_size = QtCore.QRectF(0, 0, 10, 10)
+    roi_info = None
     axes = []
 
     def init_controller(self):
         raise NotImplementedError('This is a generic camera plugin for which .init_controller() has not been defined.')
 
     def ini_attributes(self):
         self.controller: None
-        self.pixel_width = None  # pixel size in microns
         self.x_axis = None
         self.y_axis = None
         self.last_tick = 0.0  # time counter used to compute FPS
@@ -70,10 +68,8 @@ def commit_settings(self, param: Parameter):
                 # We handle ROI and binning separately for clarity
                 (old_x, _, old_y, _, xbin, ybin) = self.controller.get_roi()  # Get current binning
 
-                x0 = self.roi_pos_size.x()
-                y0 = self.roi_pos_size.y()
-                width = self.roi_pos_size.width()
-                height = self.roi_pos_size.height()
+                y0, x0 = self.roi_info.origin.coordinates
+                height, width = self.roi_info.size.coordinates
 
                 # Values need to be rescaled by binning factor and shifted by current x0,y0 to be correct.
                 new_x = (old_x + x0) * xbin
@@ -107,8 +103,8 @@ def commit_settings(self, param: Parameter):
                 self.update_rois(new_roi)
                 param.setValue(False)
 
-    def ROISelect(self, roi_pos_size):
-        self.roi_pos_size = roi_pos_size
+    def roi_select(self, roi_info, ind_viewer):
+        self.roi_info = roi_info
 
     def ini_detector(self, controller=None):
         """Detector communication initialization
@@ -159,10 +155,6 @@ def ini_detector(self, controller=None):
         self.callback_thread.callback = callback
         self.callback_thread.start()
 
-        # Check if pixel width is available
-        if 'PixelWidth' in self.controller.get_all_attributes():
-            self.pixel_width = self.controller.get_attribute_value('PixelWidth')
-
         self._prepare_view()
 
         info = "Initialized camera"
@@ -184,12 +176,12 @@ def _prepare_view(self):
         self.settings.child('vdet').setValue(height)
         mock_data = np.zeros((width, height))
 
-        if self.pixel_width:  # if pixel_width is defined
-            scaling = self.pixel_width
+        if self.controller.pixel_length:  # if pixel_width is defined
+            scaling = self.controller.pixel_length
             unit = 'um'
         else:
             scaling = 1
-            unit = 'Pxls'
+            unit = 'pixels'
 
         self.x_axis = Axis(offset = vstart * scaling, scaling=scaling * xbin, size=width // xbin, label="X", units=unit, index=0)
 

src/pymodaq_plugins_basler/resources/VERSION

@@ -1 +1 @@
-0.1.1
+1.0.0