python-microscopy 26.7.9__cp313-cp313-macosx_26_0_arm64.whl

PYME/Acquire/Hardware/ccdAdjPanel.py

@@ -0,0 +1,188 @@
+#!/usr/bin/python
+
+##################
+# ccdAdjPanel.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+from PYME.contrib import wxPlotPanel
+import wx
+import numpy as np
+import matplotlib
+from PYME.Acquire.Hardware import EMCCDTheory
+from PYME.Acquire.Hardware import ccdCalibrator
+import scipy.special
+
+class sizedCCDPanel(wx.Panel):
+    def __init__(self, parent, scope, empan):
+        wx.Panel.__init__(self, parent)
+
+        vsizer = wx.BoxSizer(wx.VERTICAL)
+
+        self.ccdPan = ccdPlotPanel(self, scope, empan)
+
+        vsizer.Add(self.ccdPan, 1, wx.EXPAND, 0)
+
+        self.SetSizerAndFit(vsizer)
+
+
+class ccdPlotPanel(wxPlotPanel.PlotPanel):
+    def __init__(self, parent, scope, empan, **kwargs ):
+        self.scope = scope
+        #self.dp = dispPan
+        self.empan = empan
+        self.eventDuration = 0.05
+
+        wxPlotPanel.PlotPanel.__init__( self, parent, **kwargs )
+
+    def draw( self ):
+            """Draw data."""
+            #matplotlib.interactive(False)
+
+            if not 'vsp' in dir(self.scope): # can't do anything
+                #self.figure.show()
+                #matplotlib.interactive(True)
+                return
+
+            emGainSettings = np.arange(0, 220, 5)
+
+            emGains = ccdCalibrator.getCalibratedCCDGain(emGainSettings, self.scope.cam.GetCCDTempSetPoint())
+
+            if emGains is None: # can't do anything
+                #self.figure.show()
+                #matplotlib.interactive(True)
+                return
+
+            matplotlib.interactive(False)
+
+            if not hasattr( self, 'spEMGain' ):
+                self.spEMSNR = self.figure.add_axes([.15,.55,.7,.3])
+                self.spEMHeadroom = self.figure.add_axes([.15,.55,.7,.3], axisbg=None, frameon=False, label='headroom')
+                self.spIntSNR = self.figure.add_axes([.15,.1,.7,.3])
+                self.spIntFrameRate = self.spIntSNR.twinx()#self.figure.add_axes([.15,.1,.7,.3], axisbg=None, frameon=False, label='framerate')
+
+            #a, ed = numpy.histogram(self.fitResults['tIndex'], self.Size[0]/2)
+            self.spEMSNR.cla()
+            self.spEMHeadroom.cla()
+            self.spIntSNR.cla()
+            self.spIntFrameRate.cla()
+
+            
+
+            currEMGain = ccdCalibrator.getCalibratedCCDGain(self.scope.cam.GetEMGain(), self.scope.cam.GetCCDTempSetPoint())
+
+            Imin = self.scope.vsp.dmin
+            Imax = self.scope.vsp.dmax
+            Imean = self.scope.vsp.dmean
+
+            off = self.scope.cam.ADOffset
+
+            #snrMin = EMCCDTheory.SNR((np.minimum(Imin - off, 1)/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, emGains, self.scope.cam.NGainElements)
+            snrMean = EMCCDTheory.SNR(((Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, emGains, self.scope.cam.NGainElements)
+            snrMax = EMCCDTheory.SNR(((Imax - off)/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, emGains, self.scope.cam.NGainElements)
+
+            
+            #self.spEMSNR.plot(np.log10(emGains), 10*np.log10(snrMin), color='b')
+            self.spEMSNR.plot(np.log10(emGains), 10*np.log10(snrMean), color='b', lw=2)
+            self.spEMSNR.plot(np.log10(emGains), 10*np.log10(snrMax), color='b', lw=2)
+            xticks = [1, 10, 100, 1000]
+            self.spEMSNR.set_xticks(np.log10(xticks))
+            self.spEMSNR.set_xticklabels([str(t) for t in xticks])
+            self.spEMSNR.set_xlim(np.log10(emGains).min(), np.log10(emGains).max())
+            self.spEMSNR.set_xlabel('True EM Gain')
+            self.spEMSNR.set_ylabel('SNR [dB]', color = 'b')
+            for t in self.spEMSNR.get_yticklabels():
+                t.set_color('b')
+
+            self.spEMHeadroom.yaxis.tick_right()
+            self.spEMHeadroom.yaxis.set_label_position('right')
+            self.spEMHeadroom.xaxis.tick_top()
+            self.spEMHeadroom.xaxis.set_label_position('top')
+
+            self.spEMHeadroom.semilogy(np.log10(emGains), np.maximum((self.scope.cam.SaturationThreshold - off)/((Imax - off)*emGains/currEMGain), 1), color='r', lw=2)
+            #self.spEMHeadroom.xaxis.tick_top()
+            xticks = [0, 50, 100, 150, 200]
+            self.spEMHeadroom.set_xticks(np.log10(ccdCalibrator.getCalibratedCCDGain(xticks, self.scope.cam.GetCCDTempSetPoint())))
+            self.spEMHeadroom.set_xticklabels([str(t) for t in xticks])
+            self.spEMHeadroom.set_xlim(np.log10(emGains).min(), np.log10(emGains).max())
+            self.spEMHeadroom.set_xlabel('EM Gain Setting')
+            self.spEMHeadroom.set_ylabel('Headroom - Isat/Imax', color = 'r')
+            self.spEMHeadroom.set_ylim(ymin=1)
+            for t in self.spEMHeadroom.get_yticklabels():
+                t.set_color('r')
+
+
+            iTimes = np.logspace(-3, 0, 50)
+            iScale = iTimes/self.scope.cam.GetIntegTime()
+
+            #snrMeanI = EMCCDTheory.SNR((iScale*(Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, currEMGain, self.scope.cam.NGainElements)
+            snrMaxI = EMCCDTheory.SNR((iScale*(Imax - off)/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, currEMGain, self.scope.cam.NGainElements,(iScale*(Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount)
+
+            evtI = (Imax - Imean)/scipy.special.gammainc(1, self.scope.cam.GetIntegTime()/self.eventDuration)
+            snrFlash = EMCCDTheory.SNR(((scipy.special.gammainc(1, iTimes/self.eventDuration)*evtI + iScale*(Imean - off))/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, currEMGain, self.scope.cam.NGainElements,(iScale*(Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount)
+
+            evtI = (Imax - Imean)/scipy.special.gammainc(1, self.scope.cam.GetIntegTime()*5/self.eventDuration)
+            snrFlash02 = EMCCDTheory.SNR(((scipy.special.gammainc(1, iTimes*5/self.eventDuration)*evtI + iScale*(Imean - off))/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, currEMGain, self.scope.cam.NGainElements,(iScale*(Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount)
+
+            evtI = (Imax - Imean)/scipy.special.gammainc(1, self.scope.cam.GetIntegTime()/(self.eventDuration*5))
+            snrFlash5 = EMCCDTheory.SNR(((scipy.special.gammainc(1, iTimes/(self.eventDuration*5))*evtI + iScale*(Imean - off))/currEMGain)*self.scope.cam.ElectronsPerCount, self.scope.cam.ReadoutNoise, currEMGain, self.scope.cam.NGainElements,(iScale*(Imean - off)/currEMGain)*self.scope.cam.ElectronsPerCount)
+
+
+            #self.spIntSNR.plot(np.log10(iTimes), 10*np.log10(snrMeanI), color='b', lw=2)
+            #self.spIntSNR.plot(np.log10(iTimes), 10*np.log10(snrMaxI), color='b', lw=2)
+            self.spIntSNR.plot(np.log10(iTimes), 10*np.log10(snrFlash), color='b', lw=2)
+            self.spIntSNR.plot(np.log10(iTimes), 10*np.log10(snrFlash02), color='b', lw=2, ls=';')
+            self.spIntSNR.plot(np.log10(iTimes), 10*np.log10(snrFlash5), color='b', lw=2, ls='--')
+
+            xticks = [1, 10, 100, 1000]
+            self.spIntSNR.set_xticks(np.log10(np.array(xticks)*1e-3))
+            self.spIntSNR.set_xticklabels([str(t) for t in xticks])
+            self.spIntSNR.set_xlim(np.log10(iTimes).min(), np.log10(iTimes).max())
+            self.spIntSNR.set_xlabel('Integration Time [ms]')
+            self.spIntSNR.set_ylabel('SNR [dB]', color = 'b')
+            for t in self.spIntSNR.get_yticklabels():
+                t.set_color('b')
+
+
+            self.spIntFrameRate.yaxis.tick_right()
+            self.spIntFrameRate.yaxis.set_label_position('right')
+
+            tFrame = np.maximum(iTimes, (1e-6/self.scope.cam.HorizShiftSpeeds[0][0][self.scope.cam.HSSpeed]*self.scope.cam.GetPicWidth()*self.scope.cam.GetPicHeight()))
+            tFrame += self.scope.cam.GetCCDHeight()*self.scope.cam.vertShiftSpeeds[self.scope.cam.VSSpeed]*1e-6
+
+            self.spIntFrameRate.plot(np.log10(iTimes), 1./tFrame, color='g', lw=2)
+
+            xticks = [1, 10, 100, 1000]
+            #self.spIntSNR.set_xticks(np.log10(np.array(xticks)*1e-3))
+            #self.spIntSNR.set_xticklabels([str(t) for t in xticks])
+            #self.spIntSNR.set_xlim(np.log10(iTimes).min(), np.log10(iTimes).max())
+            #self.spIntSNR.set_xlabel('Integration Time [ms]')
+            self.spIntFrameRate.set_ylabel('FPS', color = 'g')
+            for t in self.spIntFrameRate.get_yticklabels():
+                t.set_color('g')
+
+            #self.subplot1.set_yticks([0, a.max()])
+            #self.subplot2.plot(ed[:-1], numpy.cumsum(a), color='g' )
+            #self.subplot2.set_xticks([0, ed.max()])
+            #self.subplot2.set_yticks([0, a.sum()])
+
+            #self.figure.show()
+
+            matplotlib.interactive(True)
+

PYME/Acquire/Hardware/ccdCalibrator.py

@@ -0,0 +1,161 @@
+#!/usr/bin/python
+
+##################
+# ccdCalibrator.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import numpy as np
+import datetime
+import time
+
+global scope
+scope = None
+
+import logging
+logger = logging.getLogger(__name__)
+
+def setScope(sc):
+    global scope
+    scope = sc
+
+def getCalibratedCCDGain(nomGain, temperature):
+    with scope.settingsDB as conn:
+        ret = conn.execute("SELECT nominalGains, trueGains FROM CCDCalibration2 WHERE temperature=? AND serial=? ORDER BY time DESC", (temperature,scope.cam.GetSerialNumber())).fetchone()
+    if ret is None or np.max(nomGain) > ret[0].max():
+        return None
+    else:
+        return np.interp(nomGain, ret[0], ret[1])
+
+class ccdCalibrator:
+    """ class for calibrating the ccd
+
+    usage:
+    - use transmitted light to produce a roughly uniform field
+    - make sure CCD temperature has settled to the the specified set point
+    - adjust intensity and integration time so that camera is not saturated at
+      the maximum em gain which is going to be calibrated for (220 when using
+      default options). To give good results the image at max em-gain should
+      however be bright - ~50% of saturation seems like a good point. Note that
+      this WILL saturate the display (12 bits as opposed to 16) - use the
+      histogram display.
+    - instantiate the class on the console - ie:
+      from PYME.Hardware import ccdCalibrator
+      ccdCal = ccdCalibrator.ccdCalibrator(scope.frameWrangler, scope.cam)
+    """
+    def __init__(self, gains = np.arange(0, 220, 5)):
+        global scope
+        self.pa = scope.frameWrangler
+        self.cam = scope.cam
+
+        self.gains = gains
+        self.pos = -1
+
+        self.frameN = 0
+
+        self.contMode = self.cam.contMode
+        self.emgain = self.cam.GetEMGain()
+
+        if abs(self.cam.GetCCDTemp() - self.cam.GetCCDTempSetPoint()) >=4:
+            import wx
+            wx.MessageBox('Error ...', 'CCD Temperature has not settled', wx.OK|wx.ICON_HAND)
+            return 
+
+        self.realGains = np.zeros(len(gains))
+
+        self.dsa = self.pa.dsa
+
+        self.pa.stop()
+        #self.cam.SetAcquisitionMode(self.cam.MODE_SINGLE_SHOT)
+
+        #self.pa.WantFrameNotification.append(self.tick)
+        self.pa.onFrame.connect(self.tick)
+        self.cam.SetShutter(0)
+
+        self.cam.SetBaselineClamp(True) #otherwise baseline changes with em gain
+
+        self.pd = wx.ProgressDialog('CCD Gain Calibration', 'Calibrating CCD Gain', len(self.gains))
+        #self.pd.Show()
+        self.pa.start()
+
+
+    def finish(self):
+        import wx
+        logger.debug('Disconnecting')
+        self.pa.onFrame.disconnect(self.tick)
+        self.cam.SetEMGain(self.emgain)
+        time.sleep(0.5)
+        logger.debug('Disconnected')
+        wx.CallAfter(self.plot)
+        
+    def plot(self):
+        import matplotlib.pyplot as plt
+        #self.pa.stop()
+        #self.pa.onFrame.disconnect(self.tick)
+        
+        #if self.contMode:
+        #    self.cam.SetAcquisitionMode(self.cam.MODE_CONTINUOUS)
+
+        self.pd.Destroy()
+
+        self.realGains = self.realGains/self.realGains[0]
+
+        plt.figure()
+        plt.semilogy(self.gains, self.realGains)
+        plt.xlabel('EMGain Setting')
+        plt.ylabel('EMGain')
+
+        self._saveCalibration()
+
+        #self.pa.start()
+
+    def tick(self, sender, frameData, **kwargs):
+        import wx
+        if self.frameN < 3:
+            self.frameN +=1
+            return
+
+        self.pa.stop()
+        self.frameN = 0
+        imMean = frameData.mean()
+        if self.pos == -1: #calculate background
+            self.offset = imMean
+            self.cam.SetShutter(1)
+        else:
+            self.realGains[self.pos] = imMean - self.offset
+
+        self.pos += 1
+        wx.CallAfter(self.pd.Update,self.pos)
+        if self.pos < len(self.gains):
+            logger.debug('Setting EM Gain to %d' % self.gains[self.pos])
+            self.cam.SetEMGain(self.gains[self.pos])
+        else:
+            self.finish()
+
+        self.pa.start()
+
+
+    def _saveCalibration(self):
+        with scope.settingsDB as conn:
+            conn.execute("INSERT INTO CCDCalibration2 VALUES (?, ?, ?, ?, ?)", (datetime.datetime.now(), self.cam.GetCCDTempSetPoint(), self.cam.GetSerialNumber(), self.gains,self.realGains))
+        
+
+
+            
+            

PYME/Acquire/Hardware/cobaltLaser.py

@@ -0,0 +1,108 @@
+#!/usr/bin/python
+
+##################
+# piezo_e816.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import serial
+#import time
+
+from PYME.Acquire.Hardware.lasers import Laser
+
+class CobaltLaser(Laser):
+    def __init__(self, name,turnOn=False, portname='COM1', maxpower=0.1, **kwargs):
+        self.ser_args = dict(port=portname, baudrate=115200, timeout=2, writeTimeout=2)
+        self.powerControlable = True
+        self.isOn=True
+        self.maxpower = maxpower
+
+        self.power =  0.01#self._getOutputPower()
+        
+        self._TurnOn()
+
+        Laser.__init__(self, name, turnOn, **kwargs)
+
+    def IsOn(self):
+        return self.isOn
+        
+    def _TurnOn(self):
+        with serial.Serial(**self.ser_args) as ser:
+            ser.write(b'@cobas 0\r\n')
+            ser.write(b'l1\r\n')
+            ser.flush()
+            self.isOn = True
+
+    def TurnOn(self):
+        with serial.Serial(**self.ser_args) as ser:
+            ser.write(b'p %3.2f\r\n' % (self.power*self.maxpower))
+            ser.flush()
+            self.isOn = True
+
+    def TurnOff(self):
+        with serial.Serial(**self.ser_args) as ser:
+            ser.write(b'l0\r\n')
+            ser.write(b'p 0\r\n')
+            ser.flush()
+            self.isOn = False
+
+    def SetPower(self, power):
+        if power < 0 or power > 1:
+            raise RuntimeError('Error setting laser power: Power (%3.2f) must be between 0 and 1' % power)
+        self.power = power
+
+        if self.isOn:
+            self.TurnOn() #turning on actually sets power
+
+    def _getOutputPower(self):
+        with serial.Serial(**self.ser_args) as ser:
+            ser.write(b'p?\r')
+            ser.flush()
+    
+            res = float(ser.readline())
+        
+        return res
+
+    def GetPower(self):
+        return self.power
+
+    def checkfault(self):
+        with serial.Serial(**self.ser_args) as ser:
+           ser.write(b'f?\r\n')
+           ser.flush()
+           #print('fault code: 0-no errors; 1-temperature error; 3-interlock error; 4-constant power time out')
+           ret = ser.read(50)
+        return
+
+class CobaltLaserE(CobaltLaser):
+    def __init__(self, name,turnOn=False, portname='COM1', minpower=0.001, maxpower=0.1, **kwargs):
+        CobaltLaser.__init__(self, name, turnOn, portname, maxpower=maxpower, **kwargs)
+
+        self.minpower = minpower
+        self.power = minpower/self.maxpower
+
+    def TurnOn(self):
+        with serial.Serial(**self.ser_args) as ser:
+            ser.write(b'@cobas 0\r\n')
+            ser.write(b'cf\r\n')
+            ser.write(b'l1\r\n') # the Cobolt 405nm laser needs to be restarted if it is powered on before the interlock is closed.
+            ser.write(b'p %3.2f\r\n' % (self.power*self.maxpower))
+            ser.flush()
+            self.isOn = True
+

PYME/Acquire/Hardware/cobaltLaser561.py

@@ -0,0 +1,94 @@
+#!/usr/bin/python
+
+##################
+# piezo_e816.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import serial
+#import time
+
+from lasers import Laser
+
+class CobaltLaser561(Laser):
+    def __init__(self, name,turnOn=False, portname='COM1', maxpower=0.2):
+        self.ser_port = serial.Serial(portname, 115200, 
+                                      timeout=2, writeTimeout=2)
+        self.powerControlable = True
+        self.isOn=True
+        self.maxpower = maxpower
+
+        self.power =  0.5#self._getOutputPower()
+        
+    #    self._TurnOn()
+
+        Laser.__init__(self, name, turnOn)
+
+    def IsOn(self):
+        return self.isOn
+        
+    #def _TurnOn(self):
+    #    self.ser_port.write('@cobas 0\r\n')
+    #    self.ser_port.write('l1\r\n')
+    #    self.ser_port.flush()
+    #    self.isOn = True
+
+    def TurnOn(self):
+        self.ser_port.write('@cobas 0\r\n')
+        self.ser_port.write('cf\r\n')
+        self.ser_port.write('l1\r\n')
+        self.ser_port.flush()
+        self.isOn = True
+
+    #    self.ser_port.write('p %3.2f\r\n' % (self.power*self.maxpower))
+    #    self.ser_port.flush()
+    #    self.isOn = True
+
+    def TurnOff(self):
+        self.ser_port.write('l0\r\n')
+        self.ser_port.flush()
+        self.isOn = False
+
+    def SetPower(self, power):
+        if power < 0.5 or power > 1:
+            power = 0.5
+            raise RuntimeError('Error setting laser power: Power must be between 0.5 and 1!')
+        self.power = power
+
+        self.ser_port.write('p %3.2f\r\n' % (self.power*self.maxpower))
+        self.ser_port.flush()
+
+    #    if self.isOn:
+    #        self.TurnOn() #turning on actually sets power
+
+    def _getOutputPower(self):
+        self.ser_port.write('p?\r\n')
+        self.ser_port.flush()
+
+        return float(self.ser_port.readline())
+
+    def checkfault(self):
+        self.ser_port.write('f?\r\n')
+        self.ser_port.flush()
+
+        return self.ser_port.read(50)
+        #print('fault code: 0-no errors; 1-temperature error; 3-interlock error; 4-constant power time out')
+
+    def GetPower(self):
+        return self.power

PYME/Acquire/Hardware/comports.py

@@ -0,0 +1,26 @@
+class ComPort:
+    def __init__(self, port, doc=None):
+        import re
+        try:
+            m = re.match('^COM(\d+)',port)
+        except TypeError:
+            m = None
+        if m:
+            self.pnum = int(m.group(1))
+        else:
+            try:
+                self.pnum = int(port)
+            except TypeError:
+                print("could not parse port name: %s" % port)
+
+        self.pname = 'COM%d' % self.pnum
+        self.doc = doc
+
+    def portname(self):
+        return self.pname
+
+    def portnumber(self):
+        return self.pnum
+
+    def getdoc(self):
+        return self.doc