python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/Acquire/Hardware/Simulator/fakePiezo.py

@@ -0,0 +1,95 @@
+#!/usr/bin/python
+
+##################
+# fakePiezo.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.Acquire.Hardware.Piezos.base_piezo import PiezoBase
+import threading
+import numpy as np
+import time
+
+class FakePiezo(PiezoBase):
+    gui_description = 'Fake %s-piezo'
+    units_um = 1.0
+    
+    def __init__(self, maxtravel = 100.00):
+        self.max_travel = maxtravel
+        self.curpos = maxtravel/2.0
+        
+    def MoveTo(self, iChannel, fPos, bTimeOut=True, vel=1.0):
+        if (fPos >= 0):
+            if (fPos <= self.max_travel):
+                self.curpos=fPos
+            else:
+                self.curpos=self.max_travel
+        else:
+            self.curpos=0
+
+    def MoveRel(self, iChannel, incr, bTimeOut=True):
+        self.MoveTo(iChannel, self.curpos+incr)
+
+    def GetPos(self, iChannel=1):
+        return self.curpos
+
+    def GetControlReady(self):
+        return True
+
+    def GetChannelObject(self):
+        return 1
+
+    def GetChannelPhase(self):
+        return 1
+
+    def GetMin(self,iChan=1):
+        return 0
+
+    def GetMax(self, iChan=1):
+        return self.max_travel
+
+    def __getattr__(self, name):
+        if name == 'lastPos':
+            return self.curpos
+        else: 
+            raise AttributeError(name)  # <<< DON'T FORGET THIS LINE !!
+        
+class DriftyFakePiezo(FakePiezo):
+    """Fake piezo that drifts over time using a random-walk model. Drift rate is specified in um/s^2.
+    
+    We use a 100ms time step.
+    """
+    def __init__(self, maxtravel = 100.00, drift_rate = 0.01):
+        FakePiezo.__init__(self, maxtravel)
+        self._100ms_drift_rate = drift_rate*np.sqrt(0.1)
+
+        self.drift = 0.0 # initial drift
+
+        self._drift_thread = threading.Thread(target=self._drift)
+        self._drift_thread.setDaemon(True)
+        self._drift_thread.start()
+
+    def _drift(self):
+        while True:
+            self.drift += self._100ms_drift_rate*np.random.randn()
+            time.sleep(0.1)
+
+    @property
+    def effective_pos(self):
+        return self.curpos + self.drift

PYME/Acquire/Hardware/Simulator/fluor.py

@@ -0,0 +1,336 @@
+#!/usr/bin/python
+
+##################
+# fluor.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 threading
+import time
+
+try:
+    import Queue
+except ImportError:
+    import queue as Queue
+
+try:
+    from . import illuminate
+    HAVE_ILLUMINATE_MOD = True
+except ImportError:
+    HAVE_ILLUMINATE_MOD = False
+    
+
+class states:
+    caged, active, blinked, bleached = range(4)
+    n=4
+
+ALL_TRANS, FROM_ONLY, TO_ONLY = range(3)
+
+
+illuminationFunctions = {}
+
+def registerIllumFcn(fcn):
+    illuminationFunctions[fcn.__name__] = fcn
+    return fcn
+
+@registerIllumFcn
+def ConstIllum(fluors, position):
+    return 1.0
+
+def createSimpleTransitionMatrix(pPA=[1e6,.1,0] , pOnDark=[0,0,.1], pDarkOn=[0,.001,0], pOnBleach=[0,0,0], pCagedBlinked = [0,0,0]):
+    M = np.zeros((states.n,states.n,len(pPA)), 'f')
+    M[states.caged, states.active, :] = pPA
+    M[states.active, states.blinked, :] = pOnDark
+    M[states.blinked, states.active, :] = pDarkOn
+    M[states.active, states.bleached,:] = pOnBleach
+    M[states.caged, states.blinked, :] = pCagedBlinked
+    return M
+
+# class fluorophore:
+#     def __init__(self, x, y, z, transitionProbablilities, excitationCrossections, thetas = [0,0], initialState=states.active, activeState=states.active):
+#         """Create a new 'fluorophore' having one dark state where:
+#         transitionProbablilities is a 4x4x[number of laser wavelengths + 1] tensor of transition probablilites (units = 1/mJ)
+#         the diagonal elements (transition from one state to itself) should be zero as they'll be calculated later to make sum(P) =1
+#         excitationCrossections is an array of length [number of laser wavelengths] giving the number of photons per mJ emmited when in the on state
+#         thetas is an array of length [number of laser wavelengths] giving the angle (in rad.) between dipole moment of the fluoropore and the laser polarisations
+#         initialState is the initial state of the fluorophore"""
+
+#         self.x = x
+#         self.y = y
+#         self.z = z
+
+#         self.state = initialState
+#         self.activeState = activeState
+#         self.thetas = thetas
+#         self.transitionProbabilities = transitionProbablilities * np.concatenate(([1], abs(np.cos(thetas))),0)
+#         self.excitationCrossections = excitationCrossections *abs(np.cos(thetas))
+
+#     def illuminate(self, laserPowers, expTime):
+#         dose = np.concatenate(([1],laserPowers),0)*expTime
+#         #grab transition matrix
+#         transVec = (self.transitionProbabilities[self.state,:,:]*dose).sum(1)
+#         transVec[self.state]= 1 - transVec.sum()
+#         transCs = transVec.cumsum()
+        
+#         r = np.random.RandomState().rand()  # replace with np.random.default_rng() on later numpy versions
+        
+#         for i in range(len(transVec)):
+#             if (r < transCs[i]):
+#                 self.state = i
+#                 if (i == self.activeState):
+#                     return (laserPowers*self.excitationCrossections).sum()*expTime
+#                 else:
+#                     return 0
+        
+class Fluorophores(object):
+    '''
+    Base class representing a collection of fluorophores
+
+    key method is `illuminate()` which conducts the necessary state transisitions and returns the fluoresence intensity of each
+    fluorophore for a given illumination intensity.
+    '''
+    def __init__(self,x, y, z,  transitionProbablilities, excitationCrossections, thetas = [0,0], initialState=states.active, activeState=states.active):
+        self.fl = np.zeros(len(x), [('x', 'f'),('y', 'f'),('z', 'f'),('exc', '2f'), ('abcosthetas', '2f'),('state', 'i')])
+        self.fl['x'] = x
+        self.fl['y'] = y
+        self.fl['z'] = z
+        #fl['exc'][:] = abs(cos(thetas))
+        self.fl['exc'][:] = excitationCrossections 
+        self.fl['abcosthetas'][:] = abs(np.cos(thetas))
+        self.fl['state'][:] = initialState 
+
+        self.transitionTensor = transitionProbablilities.astype('f')
+        self.activeState = activeState
+
+        self._bounds = (x.min()-100, y.min()-100,x.max()+100, y.max()+100)
+        #self.TM = self.transitionTensor[self.fl['state'],:,:].copy()
+        #self.illuminationFunction = illuminationFunction
+
+    def hit_test(self, box):
+        '''
+        return true if any of our points are within the given bounding box 
+
+        Parameters
+        ----------
+        box : 4-tuple of float
+            (x0, y0, x1, y1)
+        '''
+
+        x0, y0, x1, y1 = box
+        xb0, yb0, xb1, yb1 = self._bounds
+
+        return ((xb0 < x1)*(yb0 < y1)*(xb1 > x0)*(yb1>y0)) > 0
+    
+    #return fl
+    if HAVE_ILLUMINATE_MOD:
+        #use faster cythoned version of function if available
+        def illuminate(self,laserPowers, expTime, position=[0,0,0], illuminationFunction = 'ConstIllum'):
+            dose = (np.concatenate(([1.0],laserPowers),0)*expTime).astype('f')
+            ilFrac = illuminationFunctions[illuminationFunction](self.fl, position)
+            return illuminate.illuminate(self.transitionTensor, self.fl, self.fl['state'], self.fl['abcosthetas'], dose, ilFrac, self.activeState)
+    else:
+        def illuminate(self, laserPowers, expTime, position=[0,0,0], illuminationFunction = 'ConstIllum'):
+            dose = np.concatenate(([1.0],laserPowers),0)*expTime
+            #grab transition matrix
+            transMat = self.transitionTensor[self.fl['state'],:,:].copy()
+            
+    
+            ilFrac = illuminationFunctions[illuminationFunction](self.fl, position)
+    
+            c0 = self.fl['abcosthetas'][:,0]*dose[1]*ilFrac
+            c1 = self.fl['abcosthetas'][:,1]*dose[2]*ilFrac
+            #print c0.shape
+            #print transMat.shape,transMat.dtype
+            #print vstack((c0,c0, c0,c0)).shape
+    
+            transMat[:,:,0] *= dose[0]
+            transMat[:,:,1] *= c0[:,None] #vstack((c0,c0, c0,c0)).T 
+            transMat[:,:,2] *= c1[:,None] #vstack((c1, c1, c1, c1)).T
+            
+            transVec = transMat.sum(2)
+            tvs = transVec.sum(1)
+            for i in range(transVec.shape[1]):
+                m = self.fl['state'] == i
+                transVec[m, i]= 1 - tvs[m]
+            transCs = transVec.cumsum(1)
+            
+            r = np.random.RandomState().rand(len(self.fl))  # replace with np.random.default_rng() on later numpy versions
+            
+            self.fl['state'] = (transCs < r[:, None]).sum(1)
+            
+            return (self.fl['state'] == self.activeState)*(self.fl['exc'][:,0]*c0 + self.fl['exc'][:,1]*c1)
+
+
+class SpectralFluorophores(Fluorophores):
+    '''
+    Extension of the base fluorophore class which also records a spectral signature for ratiometric imaging.
+    '''
+    def __init__(self,x, y, z,  transitionProbablilities, excitationCrossections, thetas = [0,0], spectralSig = [1,0], initialState=states.active, activeState=states.active):
+        self.fl = np.zeros(len(x), [('x', 'f'),('y', 'f'),('z', 'f'),('exc', '2f'), ('abcosthetas', '2f'),('state', 'i'), ('spec', '2f')])
+        self.fl['x'] = x
+        self.fl['y'] = y
+        self.fl['z'] = z
+        #fl['exc'][:] = abs(cos(thetas))
+        self.fl['exc'][:] = excitationCrossections 
+        self.fl['abcosthetas'][:] = abs(np.cos(thetas))
+        self.fl['state'][:] = initialState
+        self.fl['spec'][:] = spectralSig
+
+        self.transitionTensor = transitionProbablilities.astype('f')
+        self.activeState = activeState
+
+        self._bounds = (x.min()-100, y.min()-100,x.max()+100, y.max()+100)
+
+    def status(self):
+        cts = np.zeros(4)
+        for i in range(len(cts)):
+            cts[i] = int((self.fl['state'] == i).sum())
+
+        return cts
+    
+    def __repr__(self):
+        return 'SpectralFluorophores object: %s' % self.status()
+    
+
+class EmpiricalHistFluors(Fluorophores):
+    """
+    Fluorophores with on/off times generated by empirical data.
+
+    Notes
+    -----
+    This class relies on empirical data. For fluorophore simulation based on
+    first principles see Fluorophores.
+    
+    """
+
+    def __init__(self, x, y, z, histogram, spectralSig = [1,0],
+                 initialState=states.active, activeState=states.active):
+
+        self.histogram = histogram
+        self.fl = np.zeros(len(x), [('x', 'f'), ('y', 'f'), ('z', 'f'),
+                                 ('state', 'i'), ('spec', '2f')])
+        self.fl['x'] = x
+        self.fl['y'] = y
+        self.fl['z'] = z
+        self.fl['state'][:] = initialState
+        self.fl['spec'][:] = spectralSig
+
+        self._bounds = (x.min()-100, y.min()-100,x.max()+100, y.max()+100)
+
+        self.laserPowers = [1.0,1.0]
+        self.expTime = 0.01
+
+        self.activeState = activeState
+
+        self.stateQueue = Queue.Queue()
+
+        self.doPoll = True
+
+        # initialize the state vector
+        self.state_curr = self.fl['state'].copy() #np.ones(self.fl['state'].shape)
+        self.times = np.zeros_like(self.state_curr, dtype='f4')
+        self.active_time = np.zeros_like(self.state_curr, dtype=float)
+        
+        self.count_on = []
+        self.count_off = []
+
+        self.threadPoll = threading.Thread(target=self._calculate_times)
+        self.threadPoll.start()
+        time.sleep(.5)
+
+    def _calculate_times(self):
+        while self.doPoll:
+            # make sure we're not overfilling the queue
+            if self.stateQueue.qsize() >= 1.0e6/self.expTime:
+                time.sleep(.1)
+
+            #print(self.times[0:19])
+
+            # Add the new state to the queue
+            self.stateQueue.put(self.times*(self.state_curr == self.activeState))
+
+            # calculate on time, off time
+            # compute state vector, toss it in the queue
+
+            # update the states
+            self.times = np.subtract(self.times, self.expTime)
+            new_locs = self.times < 0
+            
+            #trans_locs = (self.times > 0) & (self.times < self.expTime)
+            
+            #self.state_curr[new_locs] = 1 - np.round(self.state_curr[new_locs])
+            
+            #casting to bool and then back might not be necessary
+            self.state_curr[new_locs] = ~self.state_curr[new_locs].astype(bool)
+            
+            #self.state_curr[trans_locs] = self.times[trans_locs]/self.expTime
+            #print(self.state_curr[trans_locs].dtype)
+
+            # find the current active states
+            idxs_on = (self.state_curr == self.activeState) & new_locs
+            idxs_off = (self.state_curr != self.activeState) & new_locs
+
+            # Calculate how long these suckers will be on
+            #if any(idxs_on):
+            r_on = np.random.rand(sum(idxs_on.astype(int)))
+            self.times[idxs_on] = self.histogram.get_time_splined(self.laserPowers[1], r_on, 'on')
+            
+            self.count_on.extend(self.times[idxs_on].toList()) #FIXME - What is this used for??? this will be really slow!
+            
+           
+            #if any(idxs_off) > 0:
+            r_off = np.random.rand(sum(idxs_off.astype(int)))
+            self.times[idxs_off] = self.histogram.get_time_splined(self.laserPowers[1], r_off, 'off')
+            
+            self.count_off.extend(self.times[idxs_off].tolist()) #FIXME - this will be really slow
+
+
+    def illuminate(self, laserPowers, expTime, position=[0, 0, 0],
+                   illuminationFunction = 'ConstIllum'):
+
+        # Restart simulation on parameter changes
+        if not np.isclose(laserPowers[1], self.laserPowers[1]*1e3/self.histogram.prange('on')[-1], atol=1) or (expTime != self.expTime):
+            #TODO - tolerance copied from Rollins/Marin branch - does a tolerance of 1 make sense??
+            self.laserPowers = [p/(1e3*self.histogram.prange('on')[-1]) for p in laserPowers]
+            self.expTime = expTime
+            self.count_on = []
+            self.count_off = []
+            #print('exptime', self.expTime)
+            with self.stateQueue.mutex:
+                self.stateQueue.queue.clear()
+            time.sleep(.5)
+
+        #print(self.laserPowers)
+        
+        dose = 1e5*self.expTime #TODO - I assume this is the photon count. Break out as a parameter???
+
+        # Grab a state off the queue and display
+        #curr_state = self.stateQueue.get()
+        active_time = self.stateQueue.get().copy()
+        
+        self.fl['state'] = active_time > 0
+
+        ilFrac = illuminationFunctions[illuminationFunction](self.fl,position) #*expTime*\laserPowers[1]*90
+        
+        return np.minimum(active_time, self.expTime)*ilFrac*dose
+
+    def __del__(self):
+        self.doPoll = False
+        self.threadPoll.join()

PYME/Acquire/Hardware/Simulator/illuminate.pyx

@@ -0,0 +1,93 @@
+#!/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 numpy as np
+cimport numpy as np
+#from libc.stdlib cimport random, RAND_MAX
+cdef extern from "stdlib.h":
+    long int rand()
+    long int RAND_MAX
+
+#ctypedef np.int_t INT_t
+#ctypedef np.float_t FLOAT_t
+
+cdef float IRMAX = 1.0/RAND_MAX
+
+def illuminate(np.ndarray[float, ndim=3] transTensor,
+               fl, 
+               np.ndarray[int, ndim=1] state, 
+               np.ndarray[float, ndim=2] abscosthetas, 
+               np.ndarray[float, ndim=1] dose, 
+               ilFrac, 
+               int activeState):
+    
+    cdef np.ndarray[float, ndim=1] c0 = abscosthetas[:,0]*dose[1]*ilFrac
+    cdef np.ndarray[float, ndim=1] c1 = abscosthetas[:,1]*dose[2]*ilFrac
+    #grab transition matrix
+    #for i in range(fl.shape[0]):
+    #    fli = fl[i]
+    
+    cdef np.ndarray[float, ndim=2] exc = fl['exc']
+    
+    cdef int nStates = transTensor.shape[0]
+    
+    cdef np.ndarray[float, ndim=1] transVec = np.zeros([nStates], 'f')
+
+    cdef np.ndarray[float, ndim=1] Iout = np.zeros([c0.shape[0]], 'f')
+    
+    cdef float tvs
+    cdef float transCs
+    cdef int i
+    cdef int j
+    cdef int st_i
+    cdef float r
+    cdef float dose0 = dose[0]
+    cdef float c0i, c1i, tvj
+    
+    
+    #print transTensor.shape[0], transTensor.shape[1], transTensor.shape[2]
+
+    for i in range(fl.shape[0]):
+        st_i = state[i]
+        c0i = c0[i]
+        c1i = c1[i]
+        
+        tvs = 0
+        
+        for j in range(nStates):
+            tvj = dose0*transTensor[st_i, j,0]
+            tvj += c0i*transTensor[st_i, j,1] #vstack((c0,c0, c0,c0)).T 
+            tvj += c1i*transTensor[st_i, j,2]
+            
+            tvs += tvj
+            transVec[j] = tvj
+                    
+        transVec[st_i] = 1 - tvs
+        
+        #r = float(np.random.rand())
+        r = IRMAX*float(rand())
+        
+        transCs = 0
+        j = 0
+        transCs += transVec[j]
+        while transCs < r and j < (nStates - 1):
+            j += 1
+            transCs += transVec[j]
+            
+            
+        
+        state[i] = j
+        
+        if (j == activeState):
+            Iout[i] = (exc[i, 0]*c0i + exc[i,1]*c1i)
+    
+    #return (fl['state'] == activeState)*(fl['exc'][:,0]*c0 + fl['exc'][:,1]*c1)
+    return Iout

PYME/Acquire/Hardware/Simulator/lasersliders.py

@@ -0,0 +1,90 @@
+#!/usr/bin/python
+
+##################
+# lasersliders.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/>.
+#
+##################
+
+#!/usr/bin/env python
+# generated by wxGlade 0.3.3 on Thu Sep 23 08:22:22 2004
+
+
+import wx
+import sys
+
+#redefine wxFrame with a version that hides when someone tries to close it
+#dirty trick, but lets the Boa gui builder still work with frames we do this to
+#from noclosefr import * 
+
+class LaserSliders(wx.Panel):
+    def __init__(self, parent, lasers, winid=-1):
+        # begin wxGlade: MyFrame1.__init__
+        #kwds["style"] = wx.DEFAULT_FRAME_STYLE
+        wx.Panel.__init__(self, parent, winid)
+
+        #self.cam = cam
+        self.lasers = [l for l in lasers if l.IsPowerControlable()]
+        self.laserNames=[l.GetName() for l in lasers]
+        
+        self.sliders = []
+        #self.SetTitle("Piezo Control")
+        
+        sizer_2 = wx.BoxSizer(wx.VERTICAL)
+
+        for c in range(len(self.lasers)):
+            #if sys.platform == 'darwin': #sliders are subtly broken on MacOS, requiring workaround
+            sl = wx.Slider(self, -1, self.lasers[c].GetPower(), 0, 1000, size=wx.Size(150,-1),style=wx.SL_HORIZONTAL)#|wx.SL_AUTOTICKS|wx.SL_LABELS)
+            #else: #sane OS's
+            #    sl = wx.Slider(self, -1, self.cam.laserPowers[c], 0, 1000, size=wx.Size(300,-1),style=wx.SL_HORIZONTAL|wx.SL_AUTOTICKS|wx.SL_LABELS)
+
+            #sl.SetSize((800,20))
+            sl.SetTickFreq(100,1)
+            sz = wx.StaticBoxSizer(wx.StaticBox(self, -1, self.laserNames[c] + " [mW]"), wx.HORIZONTAL)
+            sz.Add(sl, 1, wx.ALL|wx.EXPAND, 2)
+            sizer_2.Add(sz,1,wx.EXPAND,0)
+
+            self.sliders.append(sl)
+
+        #sizer_2.AddSpacer(5)
+
+        wx.EVT_SCROLL(self,self.onSlide)
+                
+       
+        #self.SetAutoLayout(1)
+        self.SetSizer(sizer_2)
+        sizer_2.Fit(self)
+        #sizer_2.SetSizeHints(self)
+        
+        #self.Layout()
+        # end wxGlade
+
+    def onSlide(self, event):
+        sl = event.GetEventObject()
+        ind = self.sliders.index(sl)
+        self.sl = sl
+        self.ind = ind
+        self.lasers[ind].SetPower(self.lasers[ind].MAX_POWER*sl.GetValue()/1.0e3)
+
+    def update(self):
+        for ind, L in enumerate(self.lasers):
+            self.sliders[ind].SetValue(L.GetPower()*1e3/L.MAX_POWER)
+
+            
+
+