PYME-extra 1.0.4.post0__py3-none-any.whl

PYMEcs/Acquire/Actions/custom.py

@@ -0,0 +1,167 @@
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float, Bool
+from traitsui.api import View, Item, Group
+from traitsui.menu import OKButton, CancelButton, OKCancelButtons
+
+from PYMEcs.misc.guiMsgBoxes import YesNo
+from PYME.IO.FileUtils.nameUtils import numToAlpha
+
+
+# could be called in init file as:
+
+# @init_gui('ROI Calibration')
+# def roi_calibration(MainFrame, scope):
+#
+#     def roi_action_callback(event=None):
+#         from PYMEcs.Acquire.Actions.custom import queue_calibration_series
+#         queue_calibration_series(scope)
+    
+#     MainFrame.AddMenuItem('Calibration', 'Camera Maps>Sub ROIs', roi_action_callback)
+
+class ChipROI(HasTraits):
+    roiSize = Int(256)
+    overlap = Int(20)
+    numberOfFrames = Int(500)
+    checkBeforeQueuingActions = Bool(True)
+
+
+# commenting out the below which was just a quick trial how to do this
+# keeping in for reference right now
+
+# def queue_roi_series(scope):
+#     cam = scope.cam
+
+#     args = {'state': {'Camera.ROI' : [50, 50, 200, 200]}}
+#     scope.actions.QueueAction('state.update', args)
+#     args = {'maxFrames': 500, 'stack': False}
+#     scope.actions.QueueAction('spoolController.StartSpooling', args)
+#     args = {'state': {'Camera.ROI' : [100, 100, 250, 250]}}
+#     scope.actions.QueueAction('state.update', args)
+#     args = {'maxFrames': 500, 'stack': False}
+#     scope.actions.QueueAction('spoolController.StartSpooling', args)    
+#     args = {'state': {'Camera.ROI' : [0, 0, 256, 256]}}
+#     scope.actions.QueueAction('state.update', args)
+    
+#     # in future we might code this as:
+#     #
+#     # calib = [actions.SpoolSeries(maxFrames=500, stack=False, 
+#     #                              state={'Camera.ROI' : [50, 50, 200, 200]}),
+#     #          actions.SpoolSeries(maxFrames=500, stack=False,
+#     #                              state={'Camera.ROI' : [100, 100, 250, 250]}),
+#     # ]
+
+#     # scope.actions.queue_actions(calib)
+
+
+def check_roi(x0,y0,x1,y1,width=None, height=None):
+    if x0<0:
+        x0=0
+    if y0<0:
+        y0=0
+    if x1>(width):
+        x1 = width
+    if y1>(height):
+        y1 = height
+    return [x0,y0,x1,y1]
+
+
+def spoolSeries(scope, maxFrames=500, stack=False, state=None,
+                method=None, subdirectory=None):
+    if state is not None:
+        args = {'state': state}
+        scope.actions.QueueAction('state.update', args)
+
+    args = {'settings': {'max_frames': maxFrames,
+                         'stack': stack,
+                         'subdirectory': subdirectory,
+                         'method': method}}
+    scope.actions.QueueAction('spoolController.start_spooling', args)
+
+
+def setState(scope,state):
+    args = {'state': state}
+    scope.actions.QueueAction('state.update', args)
+
+
+
+def get_mapdir(scope):
+    import os
+    seriesCounter = 0
+    subdirectory =  'map_' + numToAlpha(seriesCounter)
+    while os.path.exists(scope.spoolController.get_dirname(subdirectory)):
+        seriesCounter += 1
+        subdirectory = 'map_' + numToAlpha(seriesCounter)
+    return subdirectory
+        
+        
+# ToDo - refine implementation as action interface improves
+#      - add online help, using traits help infrastructure (i.e. in class ChipROI)
+def camera_chip_calibration_series(scope):
+    import os
+
+    chipROI = ChipROI()
+    if not chipROI.configure_traits(kind='modal'):
+            return
+
+    cam = scope.cam
+    chipWidth  = cam.GetCCDWidth()
+    chipHeight = cam.GetCCDHeight()
+    curROI = cam.GetROI()
+    
+    stepsize = chipROI.roiSize - chipROI.overlap
+    rsz = chipROI.roiSize
+    
+    xsteps = int(chipWidth / stepsize)
+    ysteps = int(chipHeight / stepsize)
+
+    rois = []
+
+    # note PYME cam ROI conventions: 1) chip origin starts at 0,0
+    #                                2) ROI with coordinates [x0,y0,x1,y1] starts and includes point x0,y0
+    #                                   but extends to and *excludes* point x1, y1
+    #                                This implies that the ROI width is x1-x0 and height is y1-y0 (used further below)
+    x0 = 0
+    y0 = 0
+    x1 = rsz # note *not* rsz-1, since it excludes x1, y1, see above
+    y1 = rsz
+    
+    for iy in range(0,ysteps):
+        for ix in range(0,xsteps):
+            rois.append(check_roi(x0+ix*stepsize,y0+iy*stepsize,
+                                  x1+ix*stepsize,y1+iy*stepsize,
+                                  width = chipWidth, height=chipHeight))
+
+    # show tiling on chip
+            
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as patches
+    import numpy as np
+
+    cols = ['r','g']
+ 
+    fig,ax = plt.subplots(1)
+    ax.imshow(np.ones((chipWidth,chipHeight)))
+    for i, roi in enumerate(rois):
+        rect = patches.Rectangle((roi[0],roi[1]),
+                                 roi[2]-roi[0], # remember we get ROI width by difference of corner points
+                                 roi[3]-roi[1], # same for height
+                                 linewidth=1,edgecolor=cols[i %2],facecolor='none')
+        ax.add_patch(rect)
+        cx = 0.5*(roi[0]+roi[2])
+        cy = 0.5*(roi[1]+roi[3])
+        plt.text(cx,cy,'%d' % i,c='w') # plot in white to ensure we see on top of darkish chip plot
+
+
+    if chipROI.checkBeforeQueuingActions:
+        if not YesNo(None, "Will use %d ROIS.\nProceed with running ROI actions?" % len(rois), caption='Proceed'):
+            return
+
+    mapdir = get_mapdir(scope)
+    # actually queue series
+    for roi in rois:
+        spoolSeries(scope, maxFrames=chipROI.numberOfFrames, stack=False,
+                    state={'Camera.ROI' : roi}, subdirectory=mapdir,
+                    method='FILE')
+
+    # set back to original ROI
+    setState(scope,state={'Camera.ROI' : curROI})
+    

PYMEcs/Acquire/Hardware/LPthreadedSimple.py

@@ -0,0 +1,248 @@
+from threading import Thread, Lock
+from queue import Queue
+import logging
+from PYME.Acquire.Hardware.NikonTi import LightPath
+from http import HTTPStatus
+
+# derived class of NikonTi.LightPath that provides "safe" methods that catch certain exceptions
+# and return a status if the method invocation was successful
+#
+# in actual hardware version we would check for a com_error only, all other exceptions will not be
+# caught, i.e.
+#
+from pywintypes import com_error
+# ...
+# except com_error:
+# ...
+
+# note that we use HTTP status codes as we use a REST server anyway and
+# thus having status values we can directly pass back via HTTP responses are useful
+class LPSafe(LightPath):
+    def __init__(self):
+        super().__init__()
+
+    def GetNamesS(self):
+        try:
+            names = self.names
+            status = HTTPStatus.OK
+        except com_error:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            names = None
+        return status, names
+
+    def GetPortS(self):
+        try:
+            port = self.GetPort()
+            status = HTTPStatus.OK
+        except com_error:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            port = None
+        return status, port
+
+    # we check the input argument range and return a suitable status
+    # if an invalid argument was provided
+    def SetPortS(self,port):
+        if port not in self.names:
+            return HTTPStatus.BAD_REQUEST
+        try:
+            self.SetPort(port)
+        except com_error:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+        else:
+            status = HTTPStatus.OK
+        return status
+
+    def GetPositionS(self):
+        try:
+            pos = self.GetPosition()
+            status = HTTPStatus.OK
+        except com_error:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            pos = None
+        return status, pos
+
+    def SetPositionS(self,pos):
+        if pos not in range(len(self.names)):
+            return HTTPStatus.BAD_REQUEST
+        try:
+            self.SetPosition(pos)
+        except com_error:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+        else:
+            status = HTTPStatus.OK
+        return status
+    
+# objects that are used to pass info to and from the
+# threaded version of the LightPath object 
+class commandObject(object):
+    def __init__(self,cmd,*args):
+        self.cmd = cmd
+        self.args = args
+
+    def __repr__(self):
+        return 'CMDMSG : %s!' % (self.cmd) +  \
+            '[' + ','.join(str(x) for x in self.args) + ']'
+
+class returnObject(object):
+    def __init__(self,cmd,status,*args):
+        self.cmd = cmd
+        self.status = status
+        self.return_args = args
+        
+    def __repr__(self):
+        return 'RETMSG : %s!%s!' % (self.cmd,self.status) + \
+            '[' + ','.join(str(x) for x in self.return_args) + ']'
+
+
+class LPThread(Thread):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.command_queue = Queue()
+        self.results_queue = Queue()
+        self.lp = LPSafe()
+        
+        self.daemon = True
+
+    def run(self):
+        while True:
+            cmd = self.command_queue.get()
+            logging.debug('received command %s' % cmd)
+            result = self._parse_command_and_execute(cmd)
+            self.results_queue.put(result)
+
+    def _parse_command_and_execute(self,cmd):
+        if (not cmd.cmd) or (cmd.cmd is None):
+            return returnObject(None, HTTPStatus.NO_CONTENT, 'no command received')
+            logging.warn('no command received')
+        elif cmd.cmd == 'GetPort':
+            status, port = self.lp.GetPortS()
+            return returnObject(cmd.cmd, status, port)
+        elif cmd.cmd == 'SetPort':
+            status = self.lp.SetPortS(cmd.args[0])
+            return returnObject(cmd.cmd, status)       
+        elif cmd.cmd == 'GetPosition':
+            status, pos = self.lp.GetPositionS()
+            return returnObject(cmd.cmd, status,pos)
+        elif cmd.cmd == 'SetPosition':
+            status = self.lp.SetPositionS(cmd.args[0])
+            return returnObject(cmd.cmd, status)
+        elif cmd.cmd == 'GetNames':
+            status, names = self.lp.GetNamesS()
+            return returnObject(cmd.cmd, status, names)
+        else:
+            return returnObject(cmd.cmd, HTTPStatus.NOT_IMPLEMENTED)
+            logging.warn('received unknown command %s' % cmd)
+
+    # primary external facing method to execute a command in the NikonTi LP thread
+    # and return in a form suitable for the excecute command (e.g. getter, setter, array getter)
+    def run_command(self,cmd,*args):
+        self.command_queue.put(commandObject(cmd,*args))
+        logging.debug('running command %s' % cmd)
+        ret = self.results_queue.get()
+        # setter command
+        if len(ret.return_args) == 0:
+            return ret.status
+        # getter command
+        elif len(ret.return_args) == 1:
+            return ret.status, ret.return_args[0]
+        # getter command that expects an array back
+        else:
+            return ret.status, ret.return_args
+
+    # below we replicate the normal LightPath interface and allow using the threaded
+    # version as a stand-in for the "plain" LightPath
+    def GetPort(self):
+        status, port = self.run_command('GetPort')
+        if status == HTTPStatus.OK:
+            return port
+        else:
+            raise RuntimeError('GetPort: received HTTP status %s' % status)
+
+    def SetPort(self,port):
+        status = self.run_command('SetPort',port)
+        if status != HTTPStatus.OK:
+            raise RuntimeError('SetPort: received HTTP status %s' % status)
+        self.lastPosition = self.GetPosition()
+        self.OnChange()
+
+    def GetNames(self):
+        status, names = self.run_command('GetNames')
+        if status == HTTPStatus.OK:
+            return names
+        else:
+            raise RuntimeError('GetPort: received HTTP status %s' % status)
+
+    def GetPosition(self):
+        status, pos = self.run_command('GetPosition')
+        if status == HTTPStatus.OK:
+            return pos
+        else:
+            raise RuntimeError('GetPosition: received HTTP status %s' % status)
+
+    def SetPosition(self,pos):
+        status = self.run_command('SetPosition',pos)
+        if status != HTTPStatus.OK:
+            raise RuntimeError('SetPosition: received HTTP status %s' % status)
+        self.lastPosition = pos
+        self.OnChange()
+
+    def ProvideMetadata(self,mdh):
+        mdh.setEntry('NikonTi.LightPath', self.GetPort())
+        
+    def OnChange(self):
+        for a in self.wantChangeNotification:
+            a()
+
+    def Poll_initialize(self):
+        if self.is_alive(): # make sure we are already running
+            self.lastPosition = self.GetPosition()
+            self.names = self.GetNames()
+            self.wantChangeNotification = []
+        else:
+            logging.warning('Thread not running - Poll initialisation failed')
+        
+    def Poll(self):
+        pos = self.GetPosition()
+        if not self.lastPosition == pos:
+            self.lastPosition = pos
+            self.OnChange()
+
+# test some aspects of the code here
+def main():
+    import time
+    
+    lpt = LPThread(name='LPThread')
+    lpt.Poll_initialize() # this one should give a warning, thread not yet started
+    lpt.start()
+    lpt.Poll_initialize() # this one is done at the proper time
+
+    status,port = lpt.run_command('GetPort')
+    if status == HTTPStatus.OK:
+        print('Port is %s' % port)
+
+    status = lpt.run_command('SetPort','L100')
+    time.sleep(2.0) # wait two seconds for the command to complete
+
+    status, port = lpt.run_command('GetPort')
+    if status == HTTPStatus.OK:
+        print('Port is %s' % port)
+
+    status, pos = lpt.run_command('GetPosition')
+    if status == HTTPStatus.OK:
+        print('Position is %d' % pos)
+
+    status, names = lpt.run_command('GetNames')
+    if status == HTTPStatus.OK:
+        print('Names:',names)
+
+    print('Testing high level interface: Port is %s' % lpt.GetPort())
+    
+    status = lpt.run_command(None)   
+
+    print(commandObject('GetIt',1,'L100'))
+    print(returnObject('Received',HTTPStatus.OK,1,'L100'))
+    
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.DEBUG,
+                        format='(%(threadName)-9s) %(message)s',)
+    main()

PYMEcs/Acquire/Hardware/LPthreadedSimpleSim.py

@@ -0,0 +1,246 @@
+from threading import Thread, Lock
+from queue import Queue
+import logging
+from PYMEcs.Acquire.Hardware.NikonTiSim import LightPath
+from http import HTTPStatus
+
+# derived class of NikonTi.LightPath that provides "safe" methods that catch certain exceptions
+# and return a status if the method invocation was successful
+#
+# in actual hardware version we would check for a com_error only, all other exceptions will not be
+# caught, i.e.
+#
+# from pywintypes import com_error
+# ...
+# except com_error:
+# ...
+
+# note that we use HTTP status codes as we use a REST server anyway and
+# thus having status values we can directly pass back via HTTP responses are useful
+class LPSafe(LightPath):
+    def __init__(self):
+        super().__init__()
+
+    def GetNamesS(self):
+        try:
+            names = self.names
+            status = HTTPStatus.OK
+        except:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            names = None
+        return status, names
+
+    def GetPortS(self):
+        try:
+            port = self.GetPort()
+            status = HTTPStatus.OK
+        except:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            port = None
+        return status, port
+
+    # we check the input argument range and return a suitable status
+    # if an invalid argument was provided
+    def SetPortS(self,port):
+        if port not in self.names:
+            return HTTPStatus.BAD_REQUEST
+        try:
+            self.SetPort(port)
+        except:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+        else:
+            status = HTTPStatus.OK
+        return status
+
+    def GetPositionS(self):
+        try:
+            pos = self.GetPosition()
+            status = HTTPStatus.OK
+        except:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+            pos = None
+        return status, pos
+
+    def SetPositionS(self,pos):
+        if pos not in range(len(self.names)):
+            return HTTPStatus.BAD_REQUEST
+        try:
+            self.SetPosition(pos)
+        except:
+            status = HTTPStatus.SERVICE_UNAVAILABLE
+        else:
+            status = HTTPStatus.OK
+
+        return status
+    
+# objects that are used to pass info to and from the
+# threaded version of the LightPath object 
+class commandObject(object):
+    def __init__(self,cmd,*args):
+        self.cmd = cmd
+        self.args = args
+
+    def __repr__(self):
+        return 'CMDMSG : %s!' % (self.cmd) +  \
+            '[' + ','.join(str(x) for x in self.args) + ']'
+
+class returnObject(object):
+    def __init__(self,cmd,status,*args):
+        self.cmd = cmd
+        self.status = status
+        self.return_args = args
+        
+    def __repr__(self):
+        return 'RETMSG : %s!%s!' % (self.cmd,self.status) + \
+            '[' + ','.join(str(x) for x in self.return_args) + ']'
+
+
+class LPThread(Thread):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.command_queue = Queue()
+        self.results_queue = Queue()
+        self.lp = LPSafe()
+        
+        self.daemon = True
+
+    def run(self):
+        while True:
+            cmd = self.command_queue.get()
+            logging.debug('received command %s' % cmd)
+            result = self._parse_command_and_execute(cmd)
+            self.results_queue.put(result)
+
+    def _parse_command_and_execute(self,cmd):
+        if (not cmd.cmd) or (cmd.cmd is None):
+            return returnObject(None, HTTPStatus.NO_CONTENT, 'no command received')
+            logging.warn('no command received')
+        elif cmd.cmd == 'GetPort':
+            status, port = self.lp.GetPortS()
+            return returnObject(cmd.cmd, status, port)
+        elif cmd.cmd == 'SetPort':
+            status = self.lp.SetPortS(cmd.args[0])
+            return returnObject(cmd.cmd, status)       
+        elif cmd.cmd == 'GetPosition':
+            status, pos = self.lp.GetPositionS()
+            return returnObject(cmd.cmd, status,pos)
+        elif cmd.cmd == 'SetPosition':
+            status = self.lp.SetPositionS(cmd.args[0])
+            return returnObject(cmd.cmd, status)
+        elif cmd.cmd == 'GetNames':
+            status, names = self.lp.GetNamesS()
+            return returnObject(cmd.cmd, status, names)
+        else:
+            return returnObject(cmd.cmd, HTTPStatus.NOT_IMPLEMENTED)
+            logging.warn('received unknown command %s' % cmd)
+
+    # primary external facing method to execute a command in the NikonTi LP thread
+    # and return in a form suitable for the excecute command (e.g. getter, setter, array getter)
+    def run_command(self,cmd,*args):
+        self.command_queue.put(commandObject(cmd,*args))
+        logging.debug('running command %s' % cmd)
+        ret = self.results_queue.get()
+        # setter command
+        if len(ret.return_args) == 0:
+            return ret.status
+        # getter command
+        elif len(ret.return_args) == 1:
+            return ret.status, ret.return_args[0]
+        # getter command that expects an array back
+        else:
+            return ret.status, ret.return_args
+
+    # below we replicate the normal LightPath interface and allow using the threaded
+    # version as a stand-in for the "plain" LightPath
+    def GetPort(self):
+        status, port = self.run_command('GetPort')
+        if status == HTTPStatus.OK:
+            return port
+        else:
+            raise RuntimeError('GetPort: received HTTP status %s' % status)
+
+    def SetPort(self,port):
+        status = self.run_command('SetPort',port)
+        if status != HTTPStatus.OK:
+            raise RuntimeError('SetPort: received HTTP status %s' % status)
+        self.lastPosition = self.GetPosition()
+        self.OnChange()
+
+    def GetNames(self):
+        status, names = self.run_command('GetNames')
+        if status == HTTPStatus.OK:
+            return names
+        else:
+            raise RuntimeError('GetPort: received HTTP status %s' % status)
+
+    def GetPosition(self):
+        status, pos = self.run_command('GetPosition')
+        if status == HTTPStatus.OK:
+            return pos
+        else:
+            raise RuntimeError('GetPosition: received HTTP status %s' % status)
+
+    def SetPosition(self,pos):
+        status = self.run_command('SetPosition',pos)
+        if status != HTTPStatus.OK:
+            raise RuntimeError('SetPosition: received HTTP status %s' % status)
+        self.lastPosition = pos
+        self.OnChange()
+
+    def ProvideMetadata(self,mdh):
+        mdh.setEntry('NikonTi.LightPath', self.GetPort())
+        
+    def OnChange(self):
+        for a in self.wantChangeNotification:
+            a()
+
+    def Poll_initialize(self):
+        if self.is_alive(): # make sure we are already running
+            self.lastPosition = self.GetPosition()
+            self.names = self.GetNames()
+            self.wantChangeNotification = []
+        else:
+            logging.warning('Thread not running - Poll initialisation failed')
+        
+    def Poll(self):
+        pos = self.GetPosition()
+        if not self.lastPosition == pos:
+            self.lastPosition = pos
+            self.OnChange()
+
+# test some aspects of the code here
+def main():
+    lpt = LPThread(name='LPThread')
+    lpt.Poll_initialize() # this one should give a warning, thread not yet started
+    lpt.start()
+    lpt.Poll_initialize() # this one is done at the proper time
+
+    status,port = lpt.run_command('GetPort')
+    if status == HTTPStatus.OK:
+        print('Port is %s' % port)
+
+    status = lpt.run_command('SetPort','L100')
+
+    status, port = lpt.run_command('GetPort')
+    if status == HTTPStatus.OK:
+        print('Port is %s' % port)
+
+    status, pos = lpt.run_command('GetPosition')
+    if status == HTTPStatus.OK:
+        print('Position is %d' % pos)
+
+    status, names = lpt.run_command('GetNames')
+    if status == HTTPStatus.OK:
+        print('Names:',names)
+
+    print('Testing high level interface: Port is %s' % lpt.GetPort())
+    
+    status = lpt.run_command(None)   
+
+    print(commandObject('GetIt',1,'L100'))
+    print(returnObject('Received',HTTPStatus.OK,1,'L100'))
+    
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.DEBUG,
+                        format='(%(threadName)-9s) %(message)s',)
+    main()

PYMEcs/Acquire/Hardware/NikonTiFlaskServer.py

@@ -0,0 +1,45 @@
+from flask import Flask, request, jsonify, make_response
+from http import HTTPStatus
+
+def create_app(mode='simulated'):
+    # create and configure the app
+    app = Flask(__name__)
+    
+    if mode == 'simulated':
+        from PYMEcs.Acquire.Hardware import NikonTiSim
+        lp = NikonTiSim.LightPath()
+    else:
+        from PYME.Acquire.Hardware import NikonTi
+        lp = NikonTi.LightPath()
+        # lp.SetPosition(2)
+
+    @app.get("/names")
+    def get_names():
+        return jsonify(lp.names)
+
+    @app.get("/port")
+    def get_port():
+        response = make_response(lp.GetPort(), HTTPStatus.OK)
+        response.mimetype = "text/plain"
+        return response
+
+    @app.put("/port")
+    def set_port():
+        lp.SetPort(request.get_data().decode("utf-8"))
+        return lp.GetPort(), HTTPStatus.OK
+
+    @app.get("/position")
+    def get_position():
+        response = make_response(str(lp.GetPosition()), HTTPStatus.OK)
+        response.mimetype = "text/plain"
+        return response
+
+    @app.put("/position")
+    def set_position():
+        lp.SetPosition(int(request.get_data().decode("utf-8")))
+        return str(lp.GetPosition()), HTTPStatus.OK
+
+    return app
+
+if __name__ == '__main__':
+    app.run(threaded=False, processes=1)