Add base class for cameras

catkit2/services/allied_vision_camera_v2/allied_vision_camera_v2.py

@@ -0,0 +1,127 @@
+'''
+This module contains a service for Allied Vision cameras.
+
+This service is a wrapper around the Vimba X SDK.
+It provides a simple interface to control the camera and acquire images.
+'''
+
+from __future__ import annotations
+import contextlib
+
+from catkit2.base_services.camera import CameraService, StoppedAcquisition
+
+from vmbpy import (AllocationMode,
+                   Camera, Frame, Stream,
+                   FrameStatus,
+                   PixelFormat,
+                   VmbSystem,
+                   VmbCameraError)
+
+
+class AlliedVisionCamera(CameraService):
+    # Stopped acquisition flags for base class
+    width_requires_stopped_acquisition = True
+    height_requires_stopped_acquisition = True
+    offset_x_requires_stopped_acquisition = True
+    offset_y_requires_stopped_acquisition = True
+    exposure_time_requires_stopped_acquisition = False
+    gain_requires_stopped_acquisition = False
+
+    def __init__(self, exit_stack: contextlib.ExitStack):
+        '''
+        Create a new AlliedVisionCamera service.
+
+        Parameters
+        ----------
+        exit_stack : contextlib.ExitStack
+            The exit stack to which this service should be added.
+            This is used to ensure that resources are properly cleaned up when the service is closed.
+        '''
+        super().__init__('allied_vision_camera_v2')
+        self.exit_stack = exit_stack
+
+        # dictionary to store the pixel format and the corresponding numpy dtype and vimba pixel format
+        self.pixel_formats = {
+            "Mono8": PixelFormat.Mono8,
+            "Mono12": PixelFormat.Mono12,
+            "Mono12Packed": PixelFormat.Mono12Packed,
+            "Mono14": PixelFormat.Mono14,
+            "Mono16": PixelFormat.Mono16,
+        }
+        self.current_pixel_format = None
+
+    def open(self):
+        pass
+
+    def close(self):
+        pass
+
+    def start_acquisition(self):
+        pass
+
+    def end_acquisition(self):
+        pass
+
+    def capture_image(self):
+        pass
+
+    def get_roi_width(self):
+        pass
+
+    def set_roi_width(self, width):
+        pass
+
+    def get_roi_height(self):
+        pass
+
+    def set_roi_height(self, height):
+        pass
+
+    def get_roi_offset_x(self):
+        pass
+
+    def set_roi_offset_x(self, offset_x):
+        pass
+
+    def get_roi_offset_y(self):
+        pass
+
+    def set_roi_offset_y(self, offset_y):
+        pass
+
+    def get_sensor_width(self):
+        pass
+
+    def get_sensor_height(self):
+        pass
+
+    def get_exposure_time(self):
+        pass
+
+    def set_exposure_time(self, exposure_time):
+        pass
+
+    def get_gain(self):
+        pass
+
+    def set_gain(self, gain):
+        pass
+
+    def get_temperature(self):
+        '''
+        Get the temperature of the camera.
+
+        This function gets the temperature of the camera.
+
+        Returns
+        -------
+        float:
+            The temperature of the camera in degrees Celsius.
+        '''
+        return self.cam.DeviceTemperature.get()
+
+
+if __name__ == '__main__':
+    with contextlib.ExitStack() as main_exit_stack:
+        service = AlliedVisionCamera(main_exit_stack)
+        service.run()

catkit2/services/dummy_camera/dummy_camera.py

@@ -1,10 +1,11 @@
 from catkit2.testbed.service import Service
 
 import time
-from hcipy import *
+import hcipy
 import numpy as np
 import threading
 
+
 class DummyCamera(Service):
     def __init__(self):
         super().__init__('dummy_camera')
@@ -16,16 +17,16 @@ def __init__(self):
         self._offset_x = self.config['offset_x']
         self._offset_y = self.config['offset_y']
 
-        self.flux = self.config['flux']
+
         self.sensor_width = self.config['sensor_width']
         self.sensor_height = self.config['sensor_height']
 
         self.should_be_acquiring = threading.Event()
         self.should_be_acquiring.set()
 
-        self.pupil_grid = make_pupil_grid(128)
-        self.aperture = evaluate_supersampled(make_hicat_aperture(True), self.pupil_grid, 4)
-        self.wf = Wavefront(self.aperture)
+        self.pupil_grid = hcipy.make_pupil_grid(128)
+        self.aperture = hcipy.evaluate_supersampled(hcipy.make_hicat_aperture(True), self.pupil_grid, 4)
+        self.wf = hcipy.Wavefront(self.aperture)
         self.wf.total_power = 1
 
         self.images = self.make_data_stream('images', 'uint16', [self.sensor_height, self.sensor_width], 20)
@@ -64,17 +65,17 @@ def make_property_helper(name, read_only=False):
 
     def get_image(self):
         try:
-            focal_grid = make_focal_grid(8, np.array([self.sensor_width, self.sensor_height]) / 16)
+            focal_grid = hcipy.make_focal_grid(8, np.array([self.sensor_width, self.sensor_height]) / 16)
             # focal_grid = focal_grid.shifted([-self._offset_x / 8, -self._offset_y / 8])
 
-            prop = FraunhoferPropagator(self.pupil_grid, focal_grid)
+            prop = hcipy.FraunhoferPropagator(self.pupil_grid, focal_grid)
             img = prop(self.wf).power.shaped
 
             img = img[self._offset_y:self._offset_y + self._height, self._offset_x:self._offset_x + self._width]
 
             img = img * self.flux * self.exposure_time / 1e6
 
-            img = large_poisson(img)
+            img = hcipy.large_poisson(img)
             img = np.clip(img, 0, 2**16 - 1).astype('uint16')
         except Exception as e:
             print(e)

catkit2/services/dummy_camera_v2/dummy_camera_v2.py

@@ -0,0 +1,103 @@
+import time
+from hcipy import evaluate_supersampled, make_hicat_aperture, make_pupil_grid, Wavefront
+import numpy as np
+
+from catkit2.base_services.camera import CameraService
+
+
+class DummyCamera(CameraService):
+    def __init__(self):
+        super().__init__('dummy_camera_v2')
+        self.log.debug('Dummy camera service started')
+        self.flux = self.config['flux']
+
+        self.pupil_grid = make_pupil_grid(128)
+        self.aperture = evaluate_supersampled(make_hicat_aperture(True), self.pupil_grid, 4)
+        self.wf = Wavefront(self.aperture)
+        self.wf.total_power = 1
+
+        self.make_command('repeater', self.repeater)
+
+    def open(self):
+        # Set up general camera properties.
+        super().open()
+
+    def close(self):
+        super().close()
+        self.camera.close()
+
+    # TODO - write all functions in here
+    def start_acquisition(self):
+        # TODO - write a function to start the acquisition
+        self.should_be_acquiring.set()
+        pass
+
+    def end_acquisition(self):
+        # TODO - write a function to start the acquisition
+        self.should_be_acquiring.clear()
+        pass
+
+    def monitor_temperature(self):
+        while not self.should_shut_down:
+            self.log.debug('Monitoring temperature')
+            temperature = self.get_temperature()
+            self.temperature.submit_data(np.array([temperature]))
+            self.sleep(0.1)
+
+    def get_temperature(self):
+        return np.sin(2 * np.pi * time.time() / 10)
+
+    def get_roi_width(self):
+        return self.config['width']
+
+    def set_roi_width(self, width):
+        return width
+
+    def get_roi_height(self):
+        return self.config['height']
+
+    def set_roi_height(self, height):
+        return height
+
+    def get_roi_offset_x(self):
+        pass
+
+    def set_roi_offset_x(self, offset_x):
+        pass
+
+    def get_roi_offset_y(self):
+        pass
+
+    def set_roi_offset_y(self, offset_y):
+        pass
+
+    def get_sensor_width(self):
+        return self.config['sensor_width']
+
+    def get_sensor_height(self):
+        return self.config['sensor_height']
+
+    def get_exposure_time(self):
+        pass
+
+    def set_exposure_time(self, exposure_time):
+        pass
+
+    def get_gain(self):
+        pass
+
+    def set_gain(self, gain):
+        pass
+
+
+if __name__ == '__main__':
+    try:
+        service = DummyCamera()
+        service.run()
+
+    except Exception:
+        import traceback
+
+        print(traceback.format_exc())
+        input()
+

catkit2/services/flir_camera/flir_camera.py

@@ -7,6 +7,7 @@
 from catkit2.testbed.service import Service
 from catkit2.testbed.tracing import trace_interval
 
+
 def _create_property(flir_property_name, read_only=False, stopped_acquisition=True):
     def getter(self):
         with self.mutex:
@@ -32,6 +33,7 @@ def setter(self, value):
 
     return property(getter, setter)
 
+
 def _create_enum_property(flir_property_name, enum_name, stopped_acquisition=True):
     def getter(self):
         with self.mutex:
@@ -63,6 +65,7 @@ def setter(self, value):
 
     return property(getter, setter)
 
+
 class FlirCamera(Service):
     NUM_FRAMES_IN_BUFFER = 20