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

PYMEcs/Acquire/Hardware/NikonTiFlaskServerT.py

@@ -0,0 +1,59 @@
+from flask import Flask, request, jsonify, make_response
+from http import HTTPStatus
+import logging
+
+def create_app(mode='simulated'):
+    # create and configure the app
+    app = Flask(__name__)
+    
+    if mode == 'simulated':
+        from PYMEcs.Acquire.Hardware.LPthreadedSimpleSim import LPThread
+    else:
+        from PYMEcs.Acquire.Hardware.LPthreadedSimple import LPThread
+
+    # so that we can see which thread processes the various messages, commands
+    logging.basicConfig(level=logging.DEBUG,
+                        format='(%(threadName)-9s) %(message)s',)
+
+    lpt = LPThread(name='NikonTiThread')
+    lpt.start()
+
+    @app.get("/names")
+    def get_names():
+        status, names = lpt.run_command('GetNames')
+        return jsonify(names)
+
+    @app.get("/port")
+    def get_port():
+        status, port = lpt.run_command('GetPort')
+        response = make_response(port, status)
+        response.mimetype = "text/plain"
+        return response
+
+    @app.put("/port")
+    def set_port():
+        port = request.get_data().decode("utf-8")
+        status = lpt.run_command('SetPort',port)
+        return port, status
+
+    @app.get("/position")
+    def get_position():
+        status, pos = lpt.run_command('GetPosition')
+        response = make_response(str(pos), status)
+        response.mimetype = "text/plain"
+        return response
+
+    @app.put("/position")
+    def set_position():
+        pos = int(request.get_data().decode("utf-8"))
+        status = lpt.run_command('SetPosition',pos)
+        return str(pos), status
+
+    return app
+
+if __name__ == '__main__':
+    app.run(threaded=False, processes=1)
+
+# invoke from the command line as, for example:
+#
+# flask --app 'PYMEcs.Acquire.Hardware.NikonTiFlaskServerT:create_app(mode="production")' --debug run

PYMEcs/Acquire/Hardware/NikonTiRESTClient.py

@@ -0,0 +1,73 @@
+import requests
+from urllib.parse import urljoin
+import logging
+from http import HTTPStatus
+from PYMEcs.Acquire.Hardware.NikonTiSim import LightPath as TiLightPath
+
+logger = logging.getLogger(__name__)
+
+# by basing it on the simulator we inherit the "generic" methods, i.e.
+# ProvideMetadata, OnChange and Poll
+# which are required for the functional object when used with
+# PYMEAcquire
+class LPClient(TiLightPath):
+    def __init__(self, url="http://127.0.0.1:5000", timeout=15):
+        self.url = url
+        self.timeout = timeout
+        self.wantChangeNotification = []
+
+        self.names = self.GetNames() # execute the method once and then keep the values cached
+        self.lastPosition = self.GetPosition() # initialise here as later used in Poll method
+
+    def GetPosition(self):
+        response = requests.get(urljoin(self.url,'position'),timeout=self.timeout)
+        if response.status_code == HTTPStatus.OK:
+            position = int(response.content.decode())
+            return position
+        else:
+            logger.warn("HTTP response error: got status %d" % response.status_code)
+            return None
+
+    def SetPosition(self,position):
+        response = requests.put(urljoin(self.url,'position'),data=str(position),timeout=self.timeout)
+        if response.status_code == HTTPStatus.OK:
+            newpos = int(response.content.decode())
+            if newpos != position:
+                logger.warn("asked for position '%d' but got position '%s'" % (newpos,position))
+            self.lastPosition = newpos # update so that OnChange works ok
+            self.OnChange()
+        else:
+            logger.warn("HTTP response error: got status %d" % response.status_code)
+
+    def GetPort(self):
+        response = requests.get(urljoin(self.url,'port'),timeout=self.timeout)
+        if response.status_code == HTTPStatus.OK:
+            port = response.content.decode()
+            return port
+        else:
+            logger.warn("HTTP response error: got status %d" % response.status_code)
+            return None
+
+    def SetPort(self,port):
+        if port in self.names:
+            response = requests.put(urljoin(self.url,'port'),data=port,timeout=self.timeout)
+            if response.status_code == HTTPStatus.OK:
+                newport = response.content.decode()
+                if newport != port:
+                    logger.warn("asked for port '%s' but got port '%s'" % (newport,port))
+                self.lastPosition = self.GetPosition() # update so that OnChange works ok
+                self.OnChange()
+            else:
+                logger.warn("HTTP response error: got status %d" % response.status_code)
+        else:
+            logger.warn("Asking for unknown port '%s', ignoring" % port)
+
+    def GetNames(self):
+        response = requests.get(urljoin(self.url,"names"),timeout=self.timeout)
+        if response.status_code == HTTPStatus.OK:
+            names = response.json()
+            return names
+        else:
+            logger.warn("HTTP response error: got status %d" % response.status_code)
+            return None
+

PYMEcs/Acquire/Hardware/NikonTiSim.py

@@ -0,0 +1,35 @@
+class LightPath:
+    def __init__(self, names = ['EYE', 'L100', 'R100', 'L80']):
+        self.simulatedPosition = 1
+        self.names = names
+        self.wantChangeNotification = []
+        
+        self.lastPosition = self.GetPosition()
+        
+    def SetPosition(self, pos):
+        self.simulatedPosition = (pos + 1)
+        self.lastPosition = pos
+        self.OnChange()
+        
+    def GetPosition(self):
+        return int(self.simulatedPosition) - 1
+        
+    def SetPort(self, port):
+        self.SetPosition(self.names.index(port))
+        self.OnChange()
+        
+    def GetPort(self):
+        return self.names[self.GetPosition()]
+    
+    def ProvideMetadata(self,mdh):
+        mdh.setEntry('NikonTi.LightPath', self.GetPort())
+        
+    def OnChange(self):
+        for a in self.wantChangeNotification:
+            a()
+            
+    def Poll(self):
+        pos = self.GetPosition()
+        if not self.lastPosition == pos:
+            self.lastPosition = pos
+            self.OnChange()

PYMEcs/Acquire/Hardware/driftTrackGUI.py

@@ -0,0 +1,329 @@
+#!/usr/bin/python
+
+##################
+# <filename>.py
+#
+# Copyright David Baddeley, 2012
+# d.baddeley@auckland.ac.nz
+#
+# This file may NOT be distributed without express permision from David Baddeley
+#
+##################
+import wx
+
+import numpy as np
+from PYME.contrib.wxPlotPanel import PlotPanel
+from PYME.IO import MetaDataHandler
+from PYME.DSView import dsviewer as dsviewer
+import PYME.IO.image as im
+
+from PYMEcs.misc.guiMsgBoxes import Info, Warn
+
+import os
+
+import logging
+logger = logging.getLogger(__name__)
+
+class TrackerPlotPanel(PlotPanel):
+    # import matplotlib.pyplot as plt # not needed if we use object based method for tight_layout
+    def __init__(self, parent, driftTracker, *args, **kwargs):
+        self.dt = driftTracker
+        PlotPanel.__init__(self, parent, *args, **kwargs)    
+
+    # add 5th suplot
+    # replace 4th plot with offset and
+    # new 5th subplot for z-pos (how calculated, z-nominal + dz?, remove offset)
+    def draw(self):
+        if self.IsShownOnScreen():
+            if not hasattr( self, 'subplotxy' ):
+                    self.subplotxy = self.figure.add_subplot( 411 )
+                    self.subplotz = self.figure.add_subplot( 412 )
+                    self.subploto = self.figure.add_subplot( 413 )
+                    self.subplotc = self.figure.add_subplot(414)
+                    # hopefully this sets it always for this fig, see https://matplotlib.org/stable/tutorials/intermediate/tight_layout_guide.html
+                    self.figure.set_tight_layout(True)
+                    # plt.tight_layout() # can we call as object oriented? do we need to call each time plotted?
+    
+            try:
+                t, dx, dy, dz, corr, corrmax, poffset, pos  = np.array(self.dt.get_history(1000)).T
+            except ValueError:
+                do_plot = False
+            else:
+                do_plot = True
+
+            if do_plot:
+                # note: we now assume that all history values that are distances are provided in nm
+                # this SHOULD match the conventions in driftTracking.py
+                
+                # a few reused variables
+                tolnm = 1e3*self.dt.get_focus_tolerance()
+                tdelta = t - self.dt.historyStartTime
+                trange = [tdelta.min(), tdelta.max()]
+                
+                self.subplotxy.cla()
+                self.subplotxy.plot(tdelta, dx, 'r')
+                self.subplotxy.plot(tdelta, dy, 'g')
+                self.subplotxy.set_ylabel('dx/dy (r/g) [nm]')
+                self.subplotxy.set_xlim(*trange)
+                
+                self.subplotz.cla()
+                self.subplotz.plot(tdelta, dz, 'b')
+                self.subplotz.plot([tdelta[0],tdelta[-1]],[tolnm,tolnm], 'g--')
+                self.subplotz.plot([tdelta[0],tdelta[-1]],[-tolnm,-tolnm], 'g--')
+                self.subplotz.set_ylabel('dz [nm]')
+                self.subplotz.set_xlim(*trange)
+                
+                self.subploto.cla()
+                self.subploto.plot(tdelta, poffset, 'm')
+                self.subploto.set_ylabel('offs [nm]')
+                self.subploto.set_xlim(*trange)
+                
+                self.subplotc.cla()
+                self.subplotc.plot(tdelta, corr/corrmax, 'r')
+                self.subplotc.set_ylabel('C/C_m')
+                self.subplotc.set_xlim(*trange)
+                self.subplotc.set_xlabel('Time (s)')
+
+
+    
+            #except:
+            #    pass
+    
+            #self.subplot.set_xlim(0, 512)
+            #self.subplot.set_ylim(0, 256)
+    
+            self.canvas.draw()
+
+
+
+# add controls for lastAdjustment
+class DriftTrackingControl(wx.Panel):
+    def __init__(self, parent, driftTracker, winid=-1, showPlots=True):
+        # begin wxGlade: MyFrame1.__init__
+        #kwds["style"] = wx.DEFAULT_FRAME_STYLE
+        wx.Panel.__init__(self, parent, winid)
+        self.dt = driftTracker
+        self.plotInterval = 10
+        self.showPlots = showPlots
+
+        sizer_1 = wx.BoxSizer(wx.VERTICAL)
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        
+        self.cbTrack = wx.CheckBox(self, -1, 'Track')
+        hsizer.Add(self.cbTrack, 0, wx.ALL, 2) 
+        self.cbTrack.Bind(wx.EVT_CHECKBOX, self.OnCBTrack)
+        self.cbLock = wx.CheckBox(self, -1, 'Lock')
+        self.cbLock.Bind(wx.EVT_CHECKBOX, self.OnCBLock)
+        hsizer.Add(self.cbLock, 0, wx.ALL, 2)
+        self.bSaveHist = wx.Button(self, -1, 'Save History')
+        hsizer.Add(self.bSaveHist, 0, wx.ALL, 2)
+        self.bSaveHist.Bind(wx.EVT_BUTTON, self.OnBSaveHist)
+        self.cbLockActive = wx.CheckBox(self, -1, 'Lock Active')
+        self.cbLockActive.Enable(False)
+        hsizer.Add(self.cbLockActive, 0, wx.ALL, 2)        
+        sizer_1.Add(hsizer, 0, wx.EXPAND, 0)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.bSetPostion = wx.Button(self, -1, 'Set focus to current')
+        hsizer.Add(self.bSetPostion, 0, wx.ALL, 2) 
+        self.bSetPostion.Bind(wx.EVT_BUTTON, self.OnBSetPostion)
+        self.bSaveCalib = wx.Button(self, -1, 'Save Cal')
+        hsizer.Add(self.bSaveCalib, 0, wx.ALL, 2)
+        self.bSaveCalib.Bind(wx.EVT_BUTTON, self.OnBSaveCalib)
+        sizer_1.Add(hsizer, 0, wx.EXPAND, 0)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "Calibration:"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.gCalib = wx.Gauge(self, -1, 11)
+        hsizer.Add(self.gCalib, 1, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2) 
+        sizer_1.Add(hsizer, 0, wx.EXPAND, 0)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "Tolerance [nm]:"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.tTolerance = wx.TextCtrl(self, -1, '%3.0f'% (1e3*self.dt.get_focus_tolerance()), size=[30,-1])
+        hsizer.Add(self.tTolerance, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetTolerance = wx.Button(self, -1, 'Set', style=wx.BU_EXACTFIT)
+        hsizer.Add(self.bSetTolerance, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2) 
+        self.bSetTolerance.Bind(wx.EVT_BUTTON, self.OnBSetTolerance)
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "Z-factor:"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.tZfactor = wx.TextCtrl(self, -1, '%3.1f'% self.dt.Zfactor, size=[30,-1])
+        hsizer.Add(self.tZfactor, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetZfactor = wx.Button(self, -1, 'Set', style=wx.BU_EXACTFIT)
+        hsizer.Add(self.bSetZfactor, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetZfactor.Bind(wx.EVT_BUTTON, self.OnBSetZfactor)
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "Correction fraction (0.1..1):"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.tFraction = wx.TextCtrl(self, -1, '%3.1f'% self.dt.correctionFraction, size=[30,-1])
+        hsizer.Add(self.tFraction, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetFraction = wx.Button(self, -1, 'Set', style=wx.BU_EXACTFIT)
+        hsizer.Add(self.bSetFraction, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetFraction.Bind(wx.EVT_BUTTON, self.OnBSetFraction)
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "feedback delay [frames]:"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.tMinDelay = wx.TextCtrl(self, -1, '%d' % (self.dt.minDelay), size=[30,-1])
+        hsizer.Add(self.tMinDelay, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetMinDelay = wx.Button(self, -1, 'Set', style=wx.BU_EXACTFIT)
+        hsizer.Add(self.bSetMinDelay, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetMinDelay.Bind(wx.EVT_BUTTON, self.OnBSetMinDelay)
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+        
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(wx.StaticText(self, -1, "Plot Interval [frames]:"), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.tPlotInterval = wx.TextCtrl(self, -1, '%d' % (self.plotInterval), size=[30,-1])
+        hsizer.Add(self.tPlotInterval, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetPlotInterval = wx.Button(self, -1, 'Set', style=wx.BU_EXACTFIT)
+        hsizer.Add(self.bSetPlotInterval, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 2)
+        self.bSetPlotInterval.Bind(wx.EVT_BUTTON, self.OnBSetPlotInterval)
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+                
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.stError = wx.StaticText(self, -1, 'Error:\n\n', size=[200,-1])
+        cfont = self.stError.GetFont()
+        font = wx.Font(cfont.GetPointSize(), wx.TELETYPE, wx.NORMAL, wx.NORMAL)
+        self.stError.SetFont(font)
+        hsizer.Add(self.stError, 0, wx.ALL, 2)        
+        sizer_1.Add(hsizer,0, wx.EXPAND, 0)
+        
+        if self.showPlots:
+            self.trackPlot = TrackerPlotPanel(self, self.dt, size=[300, 500])
+            
+            #hsizer.Add(self.stError, 0, wx.ALL, 2)        
+            sizer_1.Add(self.trackPlot,0, wx.EXPAND, 0)
+        
+        self.SetAutoLayout(1)
+        self.SetSizer(sizer_1)
+        sizer_1.Fit(self)
+        sizer_1.SetSizeHints(self)
+        self.Layout()
+        # end wxGlade
+
+        self.getMdh() # we should be able to use the metadata to look up pixel sizes?
+        # we pass this down to the drifttracker but could also do this only in driftTrackGUI when plotting?
+        # but seems preferable to keep this at the lower level as we then have the nm info in the events that are stored with data
+        self.dt.vsznm_x = self.mdh.voxelsize_nm.x
+        self.dt.vsznm_y = self.mdh.voxelsize_nm.y
+        
+    def OnCBTrack(self, event):
+        #print self.cbTrack.GetValue()
+        if self.cbTrack.GetValue():
+            self.dt.register()
+        else:
+            self.dt.deregister()
+            
+    def OnBSetPostion(self, event):
+        self.dt.reCalibrate()
+        
+    def OnBSaveCalib(self, event):
+        if not hasattr(self.dt, 'calibState') or (self.dt.calibState < self.dt.NCalibStates):
+            Warn(self,"not calibrated")
+        else:
+            self.showCalImages()
+
+    def getMdh(self):
+        # this methods gets us the cam metadata to check pixel sizes etc
+        # metadata handling
+        mdh = MetaDataHandler.NestedClassMDHandler()
+        # loop over all providers of metadata
+        for mdgen in MetaDataHandler.provideStartMetadata:
+            mdgen(mdh)
+
+        self.mdh = mdh
+            
+    def showCalImages(self):
+        import numpy as np
+        import time
+
+        #metadata handling
+        mdh = MetaDataHandler.NestedClassMDHandler()
+        mdh.setEntry('StartTime', time.time())
+        mdh.setEntry('AcquisitionType', 'Stack')
+
+        #loop over all providers of metadata
+        for mdgen in MetaDataHandler.provideStartMetadata:
+            mdgen(mdh)
+        mdh.setEntry('CalibrationPositions',self.dt.calPositions)
+
+        im = dsviewer.ImageStack(data = self.dt.refImages, mdh = mdh, titleStub='Unsaved Image')
+        if not im.mode == 'graph':
+            im.mode = 'lite'
+
+        #print im.mode
+        dvf = dsviewer.DSViewFrame(im, mode= im.mode, size=(500, 500))
+        dvf.SetSize((500,500))
+        dvf.Show()
+        
+    def OnBSaveHist(self, event):
+        if not hasattr(self.dt, 'history') or (len(self.dt.history) <= 0):
+            Warn(self,"no history")
+        else:
+            dlg = wx.FileDialog(self, message="Save file as...",  
+                                defaultFile='history.txt',
+                                wildcard='txt File (*.txt)|*.txt',
+                                style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+
+            if dlg.ShowModal() == wx.ID_OK:
+                historyfn = dlg.GetPath()
+                np.savetxt(historyfn, self.dt.history, header=' '.join(self.dt.historyColNames))
+                # Info(self,"history saved")
+
+
+    def OnBSetTolerance(self, event):
+        self.dt.set_focus_tolerance(float(self.tTolerance.GetValue())/1e3)
+
+    def OnBSetZfactor(self, event):
+        self.dt.Zfactor = float(self.tZfactor.GetValue())
+
+    def OnBSetFraction(self, event):
+        fraction = float(self.tZfactor.GetValue())
+        if fraction < 0.1:
+            fraction = 0.1
+        if fraction > 1.0:
+            fraction = 1.0
+        self.dt.correctionFraction = fraction
+
+    def OnBSetMinDelay(self, event):
+        self.dt.minDelay = int(self.tMinDelay.GetValue())
+
+    def OnBSetPlotInterval(self, event):
+        self.plotInterval = int(self.tPlotInterval.GetValue())
+    
+    def OnCBLock(self, event):
+        self.dt.set_focus_lock(self.cbLock.GetValue())
+
+    def refresh(self):
+        try:
+            calibState, NStates = self.dt.get_calibration_state()
+            self.gCalib.SetRange(int(NStates + 1))
+            self.gCalib.SetValue(int(calibState))
+
+            try:
+                t, dx, dy, dz, corr, corrmax,poffset,pos = self.dt.get_history(1)[-1]
+                posInd = self.dt.latestPosData[0]
+                self.stError.SetLabel(("Error: x = %s nm y = %s nm " +
+                                      "z = %s nm\nnoffs = %s nm c/cm = %4.2f posInd = %d") %
+                                      ("{:>+3.2f}".format(dx), "{:>+3.2f}".format(dy),
+                                       "{:>+3.1f}".format(dz), "{:>+6.1f}".format(poffset),
+                                       corr/corrmax, posInd))
+
+            except IndexError:
+                pass
+
+            self.cbLock.SetValue(self.dt.get_focus_lock())
+            self.cbTrack.SetValue(self.dt.is_tracking())
+            self.cbLockActive.SetValue(self.dt.lockActive)
+            
+            if (len(self.dt.get_history(0)) > 0) and (len(self.dt.get_history(0)) % self.plotInterval == 0) and self.showPlots:
+                self.trackPlot.draw()
+        except AttributeError:
+            logger.exception('error in refresh')
+            pass
+        except IndexError:
+            logger.exception('error in refresh')
+            pass