maint: isort and black recently added example file and picam module.

Author: carandraug

doc/examples/time-lapse-example-code.py

@@ -15,45 +15,48 @@
 
 import time
 from queue import Queue
+
+from tifffile import TiffWriter
+
 from microscope import TriggerMode, TriggerType
 from microscope.cameras.pvcam import PVCamera
 from microscope.lights.toptica import TopticaiBeam
-from tifffile import TiffWriter
 
-#set parameters
+
+# set parameters
 n_repeats = 10
 interval_seconds = 15
-exposure_seconds = .5
-power_level = .5
+exposure_seconds = 0.5
+power_level = 0.5
 
-#create devices
+# create devices
 camera = PVCamera()
 laser = TopticaiBeam(port="COM1")
 
-#initialise buffer as a queue
+# initialise buffer as a queue
 image_buffer = Queue()
 
-#configure camera, pass the buffer queue and enable.
+# configure camera, pass the buffer queue and enable.
 camera.set_client(image_buffer)
 camera.exposure_time = exposure_seconds
 camera.set_trigger(TriggerType.SOFTWARE, TriggerMode.ONCE)
 camera.enable()
 
-#configure laser
+# configure laser
 laser.power = power_level
 laser.set_trigger(TriggerType.HIGH, TriggerMode.BULB)
 laser.enable()
 
-#main loop to collect images.
+# main loop to collect images.
 for i in range(n_repeats):
     camera.trigger()
     time.sleep(interval_seconds)
 
-#shutdown hardware devices
+# shutdown hardware devices
 laser.shutdown()
 camera.shutdown()
 
-#write out image data to a file.
+# write out image data to a file.
 writer = TiffWriter("data.tif")
 for i in range(n_repeats):
     writer.save(image_buffer.get())

microscope/cameras/picam.py

@@ -1,5 +1,4 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+#!/usr/bin/env python3
 
 ## Copyright (C) 2016-2017 Mick Phillips <mick.phillips@gmail.com>
 ## Copyright (C) 2019 Ian Dobbie <ian.dobbie@bioch.ox.ac.uk>
@@ -20,99 +19,102 @@
 ## along with Microscope.  If not, see <http://www.gnu.org/licenses/>.
 
 import time
+from io import BytesIO
 
-import Pyro4
 import numpy as np
+import Pyro4
 
-from microscope import devices
-from microscope.devices import keep_acquiring, Binning, Roi
-
-#import raspberry pi specific modules
+# import raspberry pi specific modules
 import picamera
 import picamera.array
-from io import BytesIO
-#to allow hardware trigger.
+# to allow hardware trigger.
 import RPi.GPIO as GPIO
-GPIO_Trigger=21
+
+from microscope import devices
+from microscope.devices import Binning, Roi, keep_acquiring
+
+
+GPIO_Trigger = 21
 
 
 # Trigger mode to type.
 TRIGGER_MODES = {
-    'internal': None,
-    'external': devices.TRIGGER_BEFORE,
-    'external start': None,
-    'external exposure': devices.TRIGGER_DURATION,
-    'software': devices.TRIGGER_SOFT,
+    "internal": None,
+    "external": devices.TRIGGER_BEFORE,
+    "external start": None,
+    "external exposure": devices.TRIGGER_DURATION,
+    "software": devices.TRIGGER_SOFT,
 }
 
 
 @Pyro4.expose
-@Pyro4.behavior('single')
+@Pyro4.behavior("single")
 class PiCamera(devices.CameraDevice):
     def __init__(self, *args, **kwargs):
         super(PiCamera, self).__init__(**kwargs)
-#example parameter to allow setting.
-#        self.add_setting('_error_percent', 'int',
-#                         lambda: self._error_percent,
-#                         self._set_error_percent,
-#                         lambda: (0, 100))
+        # example parameter to allow setting.
+        #        self.add_setting('_error_percent', 'int',
+        #                         lambda: self._error_percent,
+        #                         self._set_error_percent,
+        #                         lambda: (0, 100))
         self._acquiring = False
         self._exposure_time = 0.1
         self._triggered = False
         self.camera = None
         # Region of interest.
         self.roi = Roi(None, None, None, None)
         # Cycle time
-        self.exposure_time = 0.001 # in seconds
+        self.exposure_time = 0.001  # in seconds
         self.cycle_time = self.exposure_time
-        #initialise in soft trigger mode
-        self.trigger=devices.TRIGGER_SOFT
-        #setup hardware triggerline
+        # initialise in soft trigger mode
+        self.trigger = devices.TRIGGER_SOFT
+        # setup hardware triggerline
         GPIO.setmode(GPIO.BCM)
         GPIO.setup(GPIO_Trigger.GPIO.IN)
 
-        #when a rasing edge is detected on port GPIO_Trigger,
-        #regardless of whatever else is happening in the program, the
-        #function self._HW_trigger will be run
-        GPIO.add_event_detect(GPIO_Trigger, GPIO.RAISING,
-                              callback=self._HW_trigger, bouncetime=10)  
-
-
+        # when a rasing edge is detected on port GPIO_Trigger,
+        # regardless of whatever else is happening in the program, the
+        # function self._HW_trigger will be run
+        GPIO.add_event_detect(
+            GPIO_Trigger,
+            GPIO.RAISING,
+            callback=self._HW_trigger,
+            bouncetime=10,
+        )
 
     def _HW_trigger(self):
-        '''Function called by GPIO interupt, needs to trigger image capture'''
-        print ('PiCam HW trigger')
-
+        """Function called by GPIO interupt, needs to trigger image capture"""
+        print("PiCam HW trigger")
 
     def _fetch_data(self):
         if self._acquiring and self._triggered:
             with picamera.array.PiYUVArray(self.camera) as output:
-                self.camera.capture(output, format='yuv', use_video_port = False)
-                #just return intensity values
-                self._logger.info('Sending image')
+                self.camera.capture(output, format="yuv", use_video_port=False)
+                # just return intensity values
+                self._logger.info("Sending image")
                 self._triggered = False
-                return(output.array[:,:,0])
+                return output.array[:, :, 0]
 
     def initialize(self):
         """Initialise the Pi Camera camera.
         Open the connection, connect properties and populate settings dict.
         """
         if not self.camera:
             try:
-                #initialise camera in still image mode.
-                self.camera  = picamera.PiCamera(sensor_mode=2)
+                # initialise camera in still image mode.
+                self.camera = picamera.PiCamera(sensor_mode=2)
             except:
                 raise Exception("Problem opening camera.")
-        self._logger.info('Initializing camera.')
-        #create img buffer to hold images.
-        #disable camera LED by default
+        self._logger.info("Initializing camera.")
+        # create img buffer to hold images.
+        # disable camera LED by default
         self.setLED(False)
         self._get_sensor_shape()
-        
+
     def make_safe(self):
         if self._acquiring:
             self.abort()
-            
+
     def _on_disable(self):
         self.abort()
 
@@ -121,24 +123,24 @@ def _on_enable(self):
         if self._acquiring:
             self.abort()
         self._acquiring = True
-        #actually start camera
+        # actually start camera
         self._logger.info("Acquisition enabled.")
         return True
 
     def abort(self):
-        self._logger.info('Disabling acquisition.')
+        self._logger.info("Disabling acquisition.")
         if self._acquiring:
             self._acquiring = False
-                                                
 
-    def set_trigger_type(self,trigger):
-        if (trigger == devices.TRIGGER_SOFT):
+    def set_trigger_type(self, trigger):
+        if trigger == devices.TRIGGER_SOFT:
             GPIO.remove_event_detect(GPIO_Trigger)
-            self.trigger=devices.TRIGGER_SOFT
-        elif (trigger == devices.TRIGGER_BEFORE):
-            GPIO.add_event_detect(GPIO_Trigger,RISING,
-                                  self.HWtrigger,self.exposure_time)
-            self.trigger=devices.TRIGGER_BEFORE
+            self.trigger = devices.TRIGGER_SOFT
+        elif trigger == devices.TRIGGER_BEFORE:
+            GPIO.add_event_detect(
+                GPIO_Trigger, RISING, self.HWtrigger, self.exposure_time
+            )
+            self.trigger = devices.TRIGGER_BEFORE
 
     def get_trigger_type(self):
         return self.trigger
@@ -151,59 +153,52 @@ def _set_binning(self, h_bin, v_bin):
         return True
 
     def _get_binning(self):
-        return(Binning(1,1))
+        return Binning(1, 1)
 
     @keep_acquiring
     def _set_roi(self, left, top, width, height):
         """Set the ROI to (left, tip, width, height)."""
         self.roi = Roi(left, top, width, height)
-                                        
-        
-    #set camera LED status, off is best for microscopy.
-    def setLED(self, state=False):
-        print ('self.camera.led(state)')
 
+    # set camera LED status, off is best for microscopy.
+    def setLED(self, state=False):
+        print("self.camera.led(state)")
 
     def set_exposure_time(self, value):
-        #exposure times are set in us.
-        self.camera.shutter_speed=(int(value*1.0E6))
-
+        # exposure times are set in us.
+        self.camera.shutter_speed = int(value * 1.0e6)
 
     def get_exposure_time(self):
-        #exposure times are in us, so multiple by 1E-6 to get seconds.
-        return (self.camera.exposure_speed*1.0E-6) 
-
+        # exposure times are in us, so multiple by 1E-6 to get seconds.
+        return self.camera.exposure_speed * 1.0e-6
 
     def get_cycle_time(self):
-        #fudge to make it work initially
-        #exposure times are in us, so multiple by 1E-6 to get seconds.
-        return (self.camera.exposure_speed*1.0E-6+.1) 
+        # fudge to make it work initially
+        # exposure times are in us, so multiple by 1E-6 to get seconds.
+        return self.camera.exposure_speed * 1.0e-6 + 0.1
 
-    
     def _get_sensor_shape(self):
-        res=self.camera.resolution
-        self._set_roi(0,0,res[0],res[1])
-        return (res)
+        res = self.camera.resolution
+        self._set_roi(0, 0, res[0], res[1])
+        return res
 
     def soft_trigger(self):
-        self._logger.info('Trigger received; self._acquiring is %s.'
-                          % self._acquiring)
+        self._logger.info(
+            "Trigger received; self._acquiring is %s." % self._acquiring
+        )
         if self._acquiring:
             self._triggered = True
 
-
     def HWtrigger(self, pin):
-        self._logger.info('HWTrigger received')
+        self._logger.info("HWTrigger received")
 
-        
-#ongoing implemetation notes
 
-#should be able to use rotation and hflip to set specific output image
-# rotations
+# ongoing implemetation notes
 
-#roi's can be set with the zoom function, default is (0,0,1,1) meaning all the data.
-
-#Need to setup a buffer for harware triggered data aquisition so we can
-#call the acquisition and then download the data at our leasure
+# should be able to use rotation and hflip to set specific output image
+# rotations
 
+# roi's can be set with the zoom function, default is (0,0,1,1) meaning all the data.
 
+# Need to setup a buffer for harware triggered data aquisition so we can
+# call the acquisition and then download the data at our leasure