python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/Acquire/Hardware/multiview.py

@@ -0,0 +1,287 @@
+import imp
+from PYME.Acquire.Hardware import Camera
+from PYME.Acquire.Hardware.Simulator import fakeCam
+import numpy as np
+import logging
+logger = logging.getLogger(__name__)
+
+class MultiviewWrapper(object):
+    def __init__(self, base_camera, multiview_info, default_roi=None):
+        """
+        Used principally for cutting horizontally spaced ROIs out of a vertical band of the sCMOS chip, where there
+        is dark space between the images and we want to avoid saving and transmitting this dark data.
+
+        This class supports the standard full chip and cropped ROI modes, as well as a new multiview mode. The
+        multiview mode makes the frames appear to the outside world as though they are just active multiview views
+        concatenated horizontally.
+
+        The class wraps around an existing camera class, redefining the methods associated
+        with getting and setting ROIs and image data, other camera methods are passed through to the
+        base camera class.
+
+        Usage is as follows:
+
+        ```
+        #initialise base camera as normal
+        base_camera = SomeCameraClass(...)
+        # wrap it
+        mvcam = MultiviewWrapper(base_camera, multiview_info, default_roi)
+        ```
+
+        Parameters
+        ----------
+        base_camera: Camera.Camera (or subclass) instance
+            the object representing the actual physical camera. 
+        multiview_info : dict
+            Information about how to crop the image. Can either be a dictionary, or something which behaves like a
+            dictionary (e.g. a MetaDataHandler).
+        default_roi: dict, optional
+            contains the default ROI of the camera. This will usually be automatically read from the base camera
+        
+
+        Notes
+        -----
+        For now, the 0th multiview ROI should be the upper-left most multiview ROI, in order to properly spoof the
+        position to match up with the stage. See PYME.IO.MetaDataHandler.get_camera_roi_origin.
+        """
+        self._camera = base_camera # type: Camera.Camera
+
+        if default_roi is None:
+            
+            #full field of base camera
+            default_roi = {
+                'xi' : 0,
+                'yi' : 0,
+                'xf' : self._camera.GetCCDWidth(),
+                'yf' : self._camera.GetCCDHeight()
+            }
+
+        self.multiview_info = multiview_info
+        self._channel_color = multiview_info['Multiview.ChannelColor']
+
+        self.n_views = multiview_info['Multiview.NumROIs']
+        self.view_origins = [multiview_info['Multiview.ROI%dOrigin' % i] for i in range(self.n_views)]
+        self.size_x, self.size_y = multiview_info['Multiview.DefaultROISize']
+        self.multiview_roi_size_options =  multiview_info['Multiview.ROISizeOptions']
+
+        self.view_centers = [(ox + int(0.5*self.size_x), oy + int(0.5*self.size_y)) for ox, oy in self.view_origins]
+
+        self.multiview_enabled = False
+        self.active_views = []
+
+        # set default width and height to return to when multiview is disabled
+        self._default_chip_width = default_roi['xf'] - default_roi['xi']
+        self._default_chip_height = default_roi['yf'] - default_roi['yi']
+        self.default_chip_roi = default_roi
+        self._current_pic_width = self._default_chip_width
+        self._current_pic_height = self._default_chip_height
+
+        #hack for simulator TODO - move this somewhere more sensible
+        if isinstance(self._camera, fakeCam.FakeCamera):
+            vx = self._camera.XVals[1] - self._camera.XVals[0]
+            self._camera._chan_x_offsets = [vx*x0 for x0, y0 in self.view_origins]
+
+    def ChangeMultiviewROISize(self, x_size, y_size):
+        """
+        Changes the ROI size of the views. Currently they are all the same size
+        Parameters
+        ----------
+        x_size: int
+            first dimension size
+        y_size: int
+            second dimension size
+
+        Returns
+        -------
+        None
+        """
+        # shift the origins
+        self.view_origins = [(xc - int(0.5*x_size), yc - int(0.5*y_size)) for xc, yc in self.view_centers]
+        # store the new sizes
+        self.size_x, self.size_y = x_size, y_size
+
+        if self.multiview_enabled:
+            # re-set the slices for frame cropping
+            self.enable_multiview(self.active_views)
+
+
+    def GetPicWidth(self):
+        """
+        This clobbers the inherited self.camera_class GetPicWidth method so that the outside world (FrameWrangler)
+        only allocates memory/thinks our camera frames are the final concatenated multiview width.
+        Returns
+        -------
+        pic_width: int
+            width of the concatenated multiview frame
+        """
+        if self.multiview_enabled:
+            return self._current_pic_width
+        else:
+            return self._camera.GetPicWidth()
+
+    def GetPicHeight(self):
+        """
+        This clobbers the inherited self.camera_class GetPicHeight method so that the outside world (FrameWrangler)
+        only allocates memory/thinks our camera frames are the final multiview frame height.
+        Returns
+        -------
+        pic_height: int
+            height of the multiview frame
+        """
+        if self.multiview_enabled:
+            return self._current_pic_height
+        else:
+            return self._camera.GetPicHeight()
+    
+    def set_active_views(self, views):
+        if len(views) == 0:
+            self.disable_multiview()
+        elif sorted(views) == self.active_views:
+            pass
+        else:
+            self.enable_multiview(views)
+        
+
+    def enable_multiview(self, views):
+        """
+
+        Parameters
+        ----------
+        views: list
+            views to activate. Should be integers which can be used to index self.multiview_info
+
+        Returns
+        -------
+
+        Notes
+        -----
+        FrameWrangler must be stopped before this function is called, and "prepared" afterwards before being started
+        again. This is not special to this function, but rather anytime SetROI gets called.
+
+        """
+        views = sorted(list(views))  # tuple(int) isn't iterable, make sure we avoid it
+        # set the camera FOV to be just large enough so we do most of the cropping where it is already optimized
+        self.x_origins, self.y_origins = zip(*[self.view_origins[view] for view in views])
+        chip_x_min, chip_x_max = min(self.x_origins), max(self.x_origins)
+        chip_y_min, chip_y_max = min(self.y_origins), max(self.y_origins)
+
+        chip_width = chip_x_max + self.size_x - chip_x_min
+        chip_height = chip_y_max + self.size_y - chip_y_min
+
+        self.chip_roi = [chip_x_min, chip_y_min, chip_x_min + chip_width, chip_y_min + chip_height]
+        logger.debug('setting chip ROI')
+        self._camera.SetROI(*self.chip_roi)
+        actual = self._camera.GetROI()
+        try:
+            assert actual == tuple(self.chip_roi)
+        except AssertionError:
+            raise(AssertionError('Error setting camera ROI. Check that ROI is feasible for camera, target: %s, actual: %s'
+                            % (tuple(self.chip_roi), actual)))
+
+        # hold an array for temporarily writing the roughly cropped chip
+        self.chip_data = np.empty((chip_width, chip_height), dtype='uint16', order='F')
+
+        # precalculate slices for each view
+        self.view_slices, self.output_slices = [], []
+        for x_ind, view in enumerate(views):
+            ox, oy = self.view_origins[view]
+            # calculate the offset from the chip origin
+            oxp, oyp = ox - chip_x_min, oy - chip_y_min
+            # calculate the slices to pull out of roi on chip
+            self.view_slices.append(np.s_[oxp:oxp + self.size_x, oyp: oyp + self.size_y])
+            # calculate slices to write into out array
+            self.output_slices.append(np.s_[self.size_x * x_ind:self.size_x * (x_ind + 1), 0:self.size_y])
+
+        # update our apparent height and widths, concatenating along 'x' or the 0th dim
+        self._current_pic_width = len(views) * self.size_x
+        self._current_pic_height = self.size_y
+        # tell the world what we've accomplished here today
+        self.multiview_enabled = True
+        self.active_views = views
+
+    def disable_multiview(self):
+        """
+        Disables multiview mode and returns camera to the default ROI (e.g. full chip)
+        Returns
+        -------
+
+        """
+        self.multiview_enabled = False
+        self.active_views = []
+        self._camera.SetROI(self.default_chip_roi['xi'], self.default_chip_roi['yi'],
+                    self.default_chip_roi['xf'], self.default_chip_roi['yf'],)
+
+
+    def ExtractColor(self, output_frame, mode):
+        """
+        Override camera get-frame function, but with multiview cropping.
+
+        Parameters
+        ----------
+        output_frame: np.array
+            array sized for the final multiview frame
+        mode: int
+            camera acquisition mode.
+
+        Returns
+        -------
+
+        """
+        if self.multiview_enabled:
+            # logger.debug('pulling frame')
+            # pull data off the roughly cropped frame
+            self._camera.ExtractColor(self.chip_data, mode)
+            # extract the multiview frames from the cropped chip into our output
+            for out_slice, view_slice in zip(self.output_slices, self.view_slices):
+                output_frame[out_slice] = self.chip_data[view_slice]
+
+        else:
+            # skip extra cropping, extract the full chip directly into the output frame
+            self._camera.ExtractColor(output_frame, mode)
+
+    def GenStartMetadata(self, mdh):
+        """
+        Light shim to record multiview metadata, when appropriate
+
+        Parameters
+        ----------
+        mdh : MetaDataHandler
+            MetaDataHandler object for Camera.
+
+        Returns
+        -------
+        None
+        """
+        self._camera.GenStartMetadata(mdh)
+        # add in multiview info
+        if self.multiview_enabled:
+            mdh.setEntry('Multiview.NumROIs', self.n_views)
+            mdh.setEntry('Multiview.ROISize', [self.size_x, self.size_y])
+            mdh.setEntry('Multiview.ChannelColor', self._channel_color)
+            mdh.setEntry('Multiview.ActiveViews', self.active_views)
+            for ind in range(self.n_views):
+                mdh.setEntry('Multiview.ROI%dOrigin' % ind, self.view_origins[ind])
+
+    def register_state_handlers(self, state_manager):
+        """ Allow key multiview settings to be updated easily through
+        the microscope state handler
+
+        Parameters
+        ----------
+        state_manager : PYME.Acquire.microscope.State
+        """
+        logger.debug('registering multiview camera state handlers')
+        
+        state_manager.registerHandler('Multiview.ActiveViews', 
+                                        lambda : self.active_views, 
+                                        self.set_active_views, True)
+        state_manager.registerHandler('Multiview.ROISize', 
+                                        lambda : [self.size_x, self.size_y],
+                                        lambda p : self.ChangeMultiviewROISize(p[0], p[1]),
+                                        True)
+
+    def __getattr__(self, key):
+        """
+        Proxy any methods we don't implement here by passing through to the base camera class
+        """
+        return getattr(self._camera, key)

PYME/Acquire/Hardware/olympusix81.py

@@ -0,0 +1,59 @@
+"""
+Control the halogen lamp (transmitted light) on an Olympus IX81 stand.
+
+Uses the serial command set described at https://madhadron.com/science/olympus_ix81_commands.html
+
+TODO - move logic to an IX81 class which also allows control of other stand features and support more of the command set.
+TODO - some form of error handling
+TODO - consider re-writing the query function to try and match responses to commands (these are not guaranteed to be synchronous) 
+
+"""
+import serial
+import time
+import threading
+from PYME.Acquire.Hardware.lasers import Laser
+
+class OlympusIX81HalogenLamp(Laser):
+    def __init__(self, name, portname='COM17', turn_on=False, **kwargs):
+        self.ser_port = serial.Serial(portname, 19200, parity='E',
+                                      timeout=2, writeTimeout=2)
+        self.lock = threading.Lock()
+        self.name = name
+        self.powerControlable = False
+        self.isOn = False
+        #self.TurnOn()
+        Laser.__init__(self, name, turn_on, **kwargs)
+
+    def _query(self, command, lines_expected=1):
+        with self.lock:
+            self.ser_port.reset_input_buffer()
+            self.ser_port.write(command)
+            reply = [self.ser_port.readline() for line in range(lines_expected)]
+            self.ser_port.reset_input_buffer()
+        return reply
+
+    def IsOn(self):
+        return self.isOn
+        
+    def TurnOn(self):
+        # make sure serial is open
+        try:
+            self.ser_port.open()
+        except serial.SerialException:
+            pass
+
+        self.isOn = True
+
+        # turn on the laser
+        self._query(b'1LOG IN\r\n', lines_expected=1)
+        self._query(b'1LMPSW ON\r\n', lines_expected=1)
+        self._query(b'1LOG OUT\r\n', lines_expected=1)
+        #self.ser_port.flush()
+
+    def TurnOff(self):
+        self._query(b'1LOG IN\r\n', lines_expected=1)
+        self._query(b'1LMPSW OFF\r\n', lines_expected=1)
+        self._query(b'1LOG OUT\r\n', lines_expected=1)
+        #self.ser_port.flush()
+        self.isOn = False
+

PYME/Acquire/Hardware/pco/pco_cam.py

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*-
+
+"""
+Created on Mon August 10 2020
+
+@author: zacsimile
+"""
+
+from PYME.Acquire.Hardware.Camera import Camera
+from PYME.Acquire import eventLog
+
+import numpy as np
+import logging
+logger = logging.getLogger(__name__)
+
+import ctypes
+import platform
+import time
+
+sys = platform.system()
+if sys != 'Windows':
+    raise Exception("Operating system is not supported.")
+
+# We use https://pypi.org/project/pco/
+# For API docs, see https://www.pco.de/fileadmin/user_upload/pco-manuals/pco.sdk_manual.pdf and
+# https://www.pco.de/fileadmin/user_upload/pco-manuals/pco.recorder_manual.pdf
+try:
+    import pco
+except ModuleNotFoundError:
+    raise ModuleNotFoundError('Please install the pco package from https://pypi.org/project/pco/.')
+
+timebase = {'ns': 1e-9, 'us': 1e-6, 'ms': 1e-3}  # Conversions from a pco dictionary
+
+class PcoCam(Camera):
+    numpy_frames = 1
+    
+    def __init__(self, camNum, debuglevel='off'):
+        Camera.__init__(self)
+        self.camNum = camNum
+        self.initalized = False
+        self.noiseProps = None
+        self._debuglevel = debuglevel  # ['off', 'error', 'verbose', 'extra verbose']
+
+    def Init(self):
+        self.cam = pco.Camera(debuglevel=self._debuglevel)
+        self.SetDescription()
+        self._mode = self.MODE_CONTINUOUS
+        self.SetHotPixelCorrectionMode('off')
+        self.buffer_size = 0
+        self.n_read = 0
+        self.initalized = True
+        self._roi = None
+        self.SetROI(1, 1, self.GetCCDWidth(), self.GetCCDHeight())
+        self._ccd_temp = 0 
+        self._ccd_temp_set_point = 0
+        self._electr_temp = 0
+        self._cycle_time = 0
+        self._integ_time = 0
+        self._binning_x = 0
+        self._binning_y = 0
+        self.recording = False
+
+    @property
+    def noise_properties(self):
+        return self.noiseProps
+
+    def SetDescription(self):
+        self.desc = self.cam.sdk.get_camera_description()
+
+    def ExpReady(self):
+        return self.recording and (self.GetNumImsBuffered() >= 1)
+
+    def GetName(self):
+        return self.cam.sdk.get_camera_name()['camera name']
+
+    def CamReady(self):
+        # return self.cam.sdk.get_camera_busy_status()['busy status'] == 0
+        return self.initalized
+
+    def ExtractColor(self, chSlice, mode):
+        # Somehow this check matters... shouldn't this be taken care of by ExpReady???
+        if (not self.recording) or (self.GetNumImsBuffered() < 1):
+            raise RuntimeError('Trying to grab a frame when there is no frame to grab.')
+
+        if self.n_read < self.buffer_size:
+            curr_frame = self.n_read
+        else:
+            curr_frame = self.buffer_size-self.GetNumImsBuffered()
+
+        # Grab the image (unused metadata _)
+        image, _ = self.cam.image(curr_frame)
+
+        ctypes.cdll.msvcrt.memcpy(chSlice.ctypes.data_as(ctypes.POINTER(ctypes.c_uint16)),
+                   image.ctypes.data_as(ctypes.POINTER(ctypes.c_uint16)), 
+                   chSlice.nbytes)
+
+        self.n_read += 1
+
+    def GetHeadModel(self):
+        return self.cam.sdk.get_camera_type()['camera type']
+
+    def GetSerialNumber(self):
+        return str(self.cam.sdk.get_camera_type()['serial number'])
+
+    def SetIntegTime(self, time):
+        lb = self.desc['Min Expos DESC']*1e-9  # ns
+        ub = self.desc['Max Expos DESC']*1e-3  # ms
+        step = self.desc['Min Expos Step DESC']*1e-9  # ns
+        
+        # Round to a multiple of time step
+        time = np.floor(time/step)*step
+
+        # Don't let this go out of bounds
+        time = np.clip(time, lb, ub)
+            
+        self.cam.set_exposure_time(time)
+        d = self.cam.sdk.get_delay_exposure_time()
+        self._integ_time = d['exposure']*timebase[d['exposure timebase']] 
+
+    def GetIntegTime(self):
+        return self._integ_time
+
+    def GetCycleTime(self):
+        return self._cycle_time
+
+    def GetCCDWidth(self):
+        return int(self.desc['max. horizontal resolution standard'])
+
+    def GetCCDHeight(self):
+        return int(self.desc['max. vertical resolution standard'])
+
+    def GetPicWidth(self):
+        return self.GetROI()[2] - self.GetROI()[0] + 1
+
+    def GetPicHeight(self):
+        return self.GetROI()[3] - self.GetROI()[1] + 1
+
+    def SetHorizontalBin(self, value):
+        b_max, step_type = self.desc['max. binning horizontal'], self.desc['binning horizontal stepping']
+
+        if step_type == 0:
+            # binary binning, round to powers of two
+            value = 1<<(value-1).bit_length()
+        else:
+            value = int(np.round(value)) # integer
+
+        value = np.clip(value, 1, b_max)
+
+        self.cam.sdk.set_binning(value, self.GetVerticalBin())
+        self._binning_x = self.cam.sdk.get_binning()['binning x']
+
+    def GetHorizontalBin(self):
+        return self._binning_x
+
+    def SetVerticalBin(self, value):
+        b_max, step_type = self.desc['max. binning vert'], self.desc['binning vert stepping']
+
+        if step_type == 0:
+            # binary binning, round to powers of two
+            value = 1<<(value-1).bit_length()
+        else:
+            value = int(np.round(value)) 
+
+        value = np.clip(value, 1, b_max)
+
+        self.cam.sdk.set_binning(self.GetHorizontalBin(), value)
+        self._binning_y = self.cam.sdk.get_binning()['binning y']
+
+    def GetVerticalBin(self):
+        return self._binning_y
+
+    def GetSupportedBinning(self):
+        import itertools
+
+        bx_max, bx_step_type = self.desc['max. binning horizontal'], self.desc['binning horizontal stepping']
+        by_max, by_step_type = self.desc['max. binning vert'], self.desc['binning vert stepping']
+
+        if bx_step_type == 0:
+            # binary step type
+            x = [2**j for j in np.arange((bx_max).bit_length())]
+        else:
+            x = [j for j in np.arange(bx_max)]
+
+        if by_step_type == 0:
+            y = [2**j for j in np.arange((by_max).bit_length())]
+        else:
+            y = [j for j in np.arange(by_max)]
+
+        return list(itertools.product(x,y))
+
+    def SetROI(self, x0, y0, x1, y1):
+        # Stepping (n pixels)
+        dx = self.desc['roi hor steps']
+        dy = self.desc['roi vert steps']
+
+        # Chip size
+        lx_max = self.GetCCDWidth()
+        ly_max = self.GetCCDHeight()
+
+        # Minimum ROI size
+        lx_min = self.desc['min size horz']
+        ly_min = self.desc['min size vert']
+
+        # Make sure bounds are ordered
+        if x1 < x0:
+            x0, x1 = x1, x0
+        if y1 < y0:
+            y0, y1 = y1, y0
+
+        # Don't let the ROI go out of bounds
+        # See pco.sdk manual chapter 3: IMAGE AREA SELECTION (ROI)
+        x0 = np.clip(x0, 1, lx_max-dx+1)
+        y0 = np.clip(y0, 1, ly_max-dy+1)
+        x1 = np.clip(x1, 1+dx, lx_max)
+        y1 = np.clip(y1, 1+dy, ly_max)
+
+        # Don't let us choose too small an ROI
+        if (x1-x0+1) < lx_min:
+            logger.debug('Selected ROI width is too small, automatically adjusting to {}.'.format(lx_min))
+            guess_pos = x0+lx_min
+            # Deal with boundaries
+            if guess_pos <= lx_max:
+                x1 = guess_pos
+            else:
+                x0 = x1-lx_min-1
+        if (y1-y0+1) < ly_min:
+            logger.debug('Selected ROI height is too small, automatically adjusting to {}.'.format(ly_min))
+            guess_pos = y0+ly_min
+            if guess_pos <= ly_max:
+                y1 = guess_pos
+            else:
+                y0 = y1-ly_min-1
+
+        # Round to a multiple of dx, dy
+        # TODO: Why do I need the 1 correction only on x0, y0???
+        x0 = 1+int(np.floor((x0-1)/dx)*dx)
+        y0 = 1+int(np.floor((y0-1)/dy)*dy)
+        x1 = int(np.floor(x1/dx)*dx)
+        y1 = int(np.floor(y1/dy)*dy)
+
+        self.cam.sdk.set_roi(x0, y0, x1, y1)
+        self._roi = [x0, y0, x1, y1]
+
+        logger.debug('ROI set: x0 %3.1f, y0 %3.1f, w %3.1f, h %3.1f' % (x0, y0, x1-x0+1, y1-y0+1))
+
+    def GetROI(self):
+        return self._roi
+    
+    def GetElectrTemp(self):
+        return self._electr_temp
+
+    def GetCCDTemp(self):
+        return self._ccd_temp
+
+    def GetCCDTempSetPoint(self):
+        return self._ccd_temp_set_point
+
+    def SetCCDTemp(self, temp):
+        lb = self.desc['Min Cool Set DESC']
+        ub = self.desc['Max Cool Set DESC']
+        temp = np.clip(temp, lb, ub)
+
+        self.cam.sdk.set_cooling_setpoint_temperature(temp)
+        self._ccd_temp_set_point = temp
+        self._get_temps()
+
+    def _get_temps(self):
+        # NOTE: temperature only gets probed when acquisition starts/stops (which can be fairly
+        # irregularly - to the point of not being useful).
+        # TODO - find a way to safely call this while the camera is running
+        d = self.cam.sdk.get_temperature()
+        self._ccd_temp = d['sensor temperature']
+        self._electr_temp = d['camera temperature']  # FIXME: should this be 'power temperature'?
+
+    def GetAcquisitionMode(self):
+        return self._mode
+
+    def SetAcquisitionMode(self, mode):
+        if mode in [self.MODE_CONTINUOUS, self.MODE_SINGLE_SHOT]:
+            self._mode = mode
+        else:
+            raise RuntimeError('Mode %d not supported' % mode)
+
+    def StartExposure(self):
+        self.StopAq()
+        self._get_temps()
+
+        d = self.cam.sdk.get_delay_exposure_time()
+        self._integ_time = d['exposure']*timebase[d['exposure timebase']] 
+        self._cycle_time = self._integ_time \
+                           + d['delay']*timebase[d['delay timebase']]
+        if self._mode == self.MODE_SINGLE_SHOT:
+            self.cam.record(number_of_images=1, mode='sequence')
+        elif self._mode == self.MODE_CONTINUOUS:
+            # Allocate buffer (2 seconds of buffer)
+            self.buffer_size = int(max(int(2.0*self.GetFPS()), 1))
+            self.cam.record(number_of_images=self.buffer_size, mode='ring buffer')
+        self.recording = True
+
+        self._log_exposure_start()
+
+        return 0
+
+    def StopAq(self):
+        self.recording = False
+        if self.cam.rec.recorder_handle.value is not None:
+            # NOTE: probably don't need this if statement thanks to the self.recording flag,
+            # but better to be safe
+            self.cam.rec.stop_record()
+            self.cam.rec.delete()
+
+        self._integ_time = 0
+        self._cycle_time = 0
+        self.buffer_size = 0
+        self.n_read = 0
+        
+        # read the temp in StopAq too, as this has the side effect of making sure we have
+        # a reasonably correct temperature in acquisition metadata (as we
+        # stop acquisition, record metadata, and then restart)
+        self._get_temps()
+
+    def GetNumImsBuffered(self):
+        if self.recording:
+            # FIXME: dwProcImgCount is an unsigned 32-bit integer, so this will 
+            # fail after 2**32 images
+            n_buf = self.cam.rec.get_status()['dwProcImgCount'] - self.n_read
+        else:
+            n_buf = 0
+        # print(n_buf+self.n_read, self.n_read)
+        return n_buf
+
+    def GetBufferSize(self):
+        # return self.cam.rec.get_settings()['maximum number of images']
+        return self.buffer_size
+
+    def GetFPS(self):
+        if self.GetCycleTime() == 0:
+            return 0
+        return 1.0/self.GetCycleTime()
+
+    def SetHotPixelCorrectionMode(self, mode):
+        if mode in ['on', 'off']:
+            self.cam.sdk.set_hot_pixel_correction_mode(mode)
+        else:
+            logger.debug('Hot Pixel Correction not set. Invalid mode {}. Choose "on" or "off".'.format(mode))
+
+    def Shutdown(self):
+        self.cam.close()