python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/localization/FitFactories/zEstimators/genericEstimator.py

@@ -0,0 +1,224 @@
+#!/usr/bin/python
+
+##################
+# astigEstimator.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/>.
+#
+##################
+"""Uses machine learning to estimate starting parameters in a way that is (hopefully) both PSF agnostic and reasonable
+quick.
+"""
+
+from scipy.interpolate import splprep, splev
+import numpy
+import numpy as np
+from sklearn import svm
+#from pylab import *
+
+splines = {}
+rawMeas = {}
+
+_svr = None
+
+sintheta = 0
+costheta = 1
+
+TWOCHANNEL = False
+
+DEBUG_PLOTS = False
+
+def calibrate(interpolator, md, roiSize=5):
+    global sintheta, costheta, calibrated, _svr
+    #global zvals, dWidth
+    #generate grid to evaluate function on
+    X, Y, Z, safeRegion = interpolator.getCoords(md, slice(-roiSize,roiSize), slice(-roiSize,roiSize), slice(0, 2))
+    #print Z, safeRegion
+    axialShift = md.getOrDefault('Analysis.AxialShift', 0)
+    if axialShift is None:
+        axialShift = 0
+    
+    ratio = 0.5#md.Analysis.ColourRatio
+
+    if len(X.shape) > 1: #X is a matrix
+        X_ = X[:, 0, 0]
+        Y_ = Y[0, :, 0]
+    else:
+        X_ = X
+        Y_ = Y
+
+    zmin, zmax  = safeRegion[2]
+    
+    #print zmin, zmax
+    zmin = max(zmin, zmin - axialShift)
+    zmax = min(zmax, zmax - axialShift)
+    
+    #print zmin, zmax
+    
+    z = numpy.arange(max(-800, zmin), min(810, zmax), 10)
+    ps = []
+    
+    #print axialShift
+    dx = 0*70*np.random.normal(size=len(z))
+    dy = 0*70 * np.random.normal(size=len(z))
+
+    for x0, y0, z0 in zip(dx, dy, z):
+        d1 = interpolator.interp(X + x0, Y+ y0, Z + z0)
+        
+        ps.append(_calcParams(np.random.poisson(2+ (1000 + np.random.exponential(1000))*d1), X_, Y_))
+        #ps.append(_calcParams(numpy.concatenate([numpy.atleast_3d(d1), numpy.atleast_3d(d2)], 2), X_, Y_))
+
+    ps = numpy.array(ps).T
+    xp, yp =  ps[:2, :]
+    
+    A = ps[2]
+    feat = ps[3:]
+    
+    #print ps, feat
+    
+    rawMeas['feat'] = feat
+    rawMeas['z'] = z
+
+    rawMeas['xp'] = xp + dx
+    rawMeas['yp'] = yp + dy
+    
+    _svr = svm.SVR(C=1000)
+    _svr.fit(feat.T, z)
+
+    sp, u = splprep([xp], u=z, s=1)
+    splines['xp'] = sp
+
+    sp, u = splprep([yp], u=z, s=1)
+    splines['yp'] = sp
+    
+    splines['z'] = True
+    
+    if DEBUG_PLOTS:
+        #print feat.shape
+        
+        import matplotlib.pyplot as plt
+        
+        plt.figure(figsize=(5, 10))
+        n_feats = feat.shape[0]
+        for i in range(n_feats):
+            plt.subplot(n_feats, 1, i+1)
+            plt.plot(z, feat[i, :])
+    
+
+    
+    
+
+
+
+
+def _calcParams(data, X, Y):
+    """calculates the \sigma_x - \sigma_y term used for z position estimation"""
+    data = np.atleast_3d(data)
+    A = np.atleast_1d((data - data.min(1).min(0)[None,None,:]).sum(1).sum(0)) #amplitude
+    A_ = np.atleast_1d(data.max(1).max(0) - data.min(1).min(0))
+    
+    #print data.shape, A, X
+    
+    #threshold at half maximum and subtract threshold
+    dr = numpy.maximum(data - data.min(1).min(0) - 0.2*A_[None,None, :], 0)#.squeeze()
+
+    dr = numpy.maximum(data - data.mean(1).mean(0), 0)#.squeeze()
+    #dr = (data - data.mean()).squeeze()
+    
+    #print A
+    
+    if len(A) == 2:
+        sr = dr.sum(1).sum(0)
+        sr = (sr[0]/sr.sum(), )
+    else:
+        sr = ()
+        
+    
+    dr = dr/dr.sum(1).sum(0)[None,None,:]
+
+    if False:#DEBUG_PLOTS:
+        #print feat.shape
+        import matplotlib.pyplot as plt
+    
+        plt.figure(figsize=(5, 3))
+        plt.subplot(1,2,1)
+        plt.imshow(dr[:,:,0])
+        plt.subplot(1, 2, 2)
+        plt.imshow(dr[:, :, 1])
+    #print dr.sum(1).sum(0)[None,None,:] 
+
+    x0 = (X[:,None, None]*dr).sum(1).sum(0)
+    y0 = (Y[None, :, None]*dr).sum(1).sum(0)
+    
+    x0_ = (x0*A).sum()/A.sum()
+    y0_ = (y0 * A).sum() / A.sum()
+    
+    
+    #print x0
+
+    xn = X[:,None, None] - x0_
+    yn = Y[None, :, None] - y0_
+    
+    #r = numpy.sqrt(xn*xn + yn*yn)
+
+    #sig = numpy.sqrt((xn*xn*dr + yn*yn*dr).sum(1).sum(0)) #+ (xn*xn*dr).sum(1).sum(0)
+
+    rn2 = xn*xn + yn*yn
+
+    #print data.shape,
+    sig_x = (numpy.abs(xn) * dr).sum(1).sum(0)/80.
+    sig_y = (numpy.abs(yn) * dr).sum(1).sum(0)/80.
+    
+    d_sig = (sig_x - sig_y)
+    
+    #d2_sig = (sig_x[1] - sig_x[0], sig_y[1] - sig_y[0])
+    
+    d1 = (rn2 < (2*70.)**2).astype('f')*data
+    #print d1.shape
+
+    sig = d1.sum(1).sum(0)/data.sum(1).sum(0)
+
+    
+    #print A.mean(), x0[0], y0[0], sig[1] - sig[0]
+    return (x0_, y0_) + tuple(A/1e3) + tuple(d_sig) + tuple(0.5*(sig_x + sig_y) - 1)  #+ sr
+
+
+def getStartParameters(data, X, Y, Z=None):
+    p = _calcParams(data, X, Y)
+    x0, y0 = p[:2]
+    
+    A = 1e3*np.array(p[2])
+    
+    feat = p[3:]
+    #print 'p:', p
+    #print 'feat:', feat
+    
+    z0 = _svr.predict(np.array(feat).reshape(1, -1))
+    z0 = -max(min(z0, 800), -800)
+    #print z0
+
+    #correct position & intensity estimates for z position
+    #A = A/splev(z0, splines['A'])[0]
+    x0 = x0 #- splev(z0, splines['xp'])[0]
+    y0 = y0 #- splev(z0, splines['yp'])[0]
+
+    b = data.min()
+    
+    #print 'sp', x0, y0, z0
+
+    return [np.mean(A), x0, y0, z0, b]
+

PYME/localization/FitFactories/zEstimators/priEstimator.py

@@ -0,0 +1,255 @@
+#!/usr/bin/python
+
+##################
+# priEstimator.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/>.
+#
+##################
+"""Calculates starting parameters for fitting to a phase ramp PSF. As it uses the
+angle between the lobes it should also be able to be used for double helix PSFs
+with little/no modification"""
+
+from scipy.interpolate import splprep, splev
+from scipy import ndimage
+import numpy
+from PYME.Analysis.binAvg import binAvg
+#from pylab import *
+
+splines = {}
+
+rawMeas = {}
+
+lobeSeparation = None
+axis_x = None
+
+#note that the bulk of this code is copied from astigEstimator, just replacing the
+#difference in widths with a measure of rotation
+
+def calibrate(interpolator, md, roiSize=5):
+    #global zvals, dWidth
+    global lobeSeparation, axis_x
+
+        
+    
+    #generate grid to evaluate function on
+    X, Y, Z, safeRegion = interpolator.getCoords(md, slice(-roiSize,roiSize), slice(-roiSize,roiSize), slice(0, 2))
+    #print Z, safeRegion
+
+    if len(X.shape) > 1: #X is a matrix
+        X_ = X[:, 0, 0]
+        Y_ = Y[0, :, 0]
+    else:
+        X_ = X
+        Y_ = Y
+
+    z = numpy.arange(-500, 500, 10)
+    
+    p = interpolator.interpModel.max(2)
+
+    if md['PRI.Axis'] == 'x':
+        I = p.max(1)
+    else:
+        I = p.max(0)
+            
+    sepr = I[int(I.size/2):].argmax()
+    sepl = I[int(I.size/2)::-1].argmax()
+    
+    #print sepr, sepl
+    
+    lobeSeparation = sepr + sepl
+    axis_x = md['PRI.Axis'] == 'x'    
+    
+    ps = []
+
+    for z0 in z:    
+        d = interpolator.interp(X, Y, Z + z0)
+#        if z0 % 100 == 0:
+#            figure()
+#            imshow(d)
+        ps.append(_calcParams(d, X_, Y_))
+
+    ps = numpy.array(ps)
+    A, xp, yp, dw = ps.T
+    
+    xp = xp - xp[int(z.size/2)]
+    yp = yp - yp[int(z.size/2)]
+
+    rawMeas['A'] = A
+    rawMeas['xp'] = xp
+    rawMeas['yp'] = yp
+    rawMeas['dw'] = dw
+
+    sp, u = splprep([A], u=z, s=1)
+    splines['A'] = sp
+
+    sp, u = splprep([xp], u=z, s=1)
+    splines['xp'] = sp
+
+    sp, u = splprep([yp], u=z, s=1)
+    splines['yp'] = sp
+
+    #now for z - want this as function of dw (the difference in x & y std. deviations)
+    #first look at dw as a function of z & smooth
+    sp, u = splprep([dw], u=z, s=.01)
+    splines['dw'] = sp
+    dw2 = splev(z, sp)[0] #evaluate to give smoothed dw values
+
+    #unfortunately dw is not always monotonic - pull out the central section that is
+    d_dw = numpy.diff(splev(numpy.arange(-500, 501, 10), sp)[0])
+
+    #find whether gradient is +ve or negative
+    sgn = numpy.sign(d_dw)
+
+    #take all bits having the same gradient sign as the central bit
+    mask = sgn == sgn[int(len(sgn)/2)]
+
+    zm = z[mask]
+    dwm = dw2[mask]
+    
+    #now sort the values by dw, so we can use dw as the dependant variable
+    I = dwm.argsort()
+    zm = zm[I]
+    dwm = dwm[I]
+
+    sp, u = splprep([zm], u=dwm, s=1)
+    splines['z'] = sp
+    
+    
+
+
+def _calcParams(data, X, Y):
+    """calculates the mean angle in the image, used for z position estimation"""
+    A = (data.max()- data.min()) #amplitude
+
+    #threshold at half maximum and subtract threshold
+    dr = numpy.maximum(data - data.min() - 0.2*A, 0).squeeze()
+    drs = dr.sum()
+#    
+#    labs, nlabs = ndimage.label(dr)
+#    nr = 0
+#    x0 = 0
+#    y0 = 0
+#    
+#    for i in xrange(1, nlabs + 1):
+#        dri = dr*(labs == i)
+#        dris = dri.sum()
+#        
+#        if dris > A:
+#            x0 += (X[:,None]*dri).sum()/dris
+#            y0 += (Y[None, :]*dri).sum()/dris
+#            nr += 1
+    
+    if len(data.shape) == 3:
+        xi, yi, zi = numpy.unravel_index(data.argmax(), data.shape)
+    else:
+        xi, yi = numpy.unravel_index(data.argmax(), data.shape)
+    
+    
+    if axis_x:
+        if xi < data.shape[0]/2:
+            x2 = min(xi + lobeSeparation, data.shape[0] - 1)
+        else:
+            x2 = max(0, xi - lobeSeparation)
+            
+        y2 = data[int(x2),:].argmax()
+            
+        
+    else:
+        x0 = X[xi]
+        
+        if yi < data.shape[1]/2:
+            y2 = min(yi + lobeSeparation, data.shape[1] - 1)
+        else:
+            y2 = max(yi - lobeSeparation, 0)
+            
+        #print y2, lobeSeparation
+            
+        x2 = data[:,int(y2)].argmax()
+    
+#    dr = data.squeeze()[(xi - 1):(xi+2), (yi - 1):(yi +2)]
+#    dr /= dr.sum()        
+#    x_0 = (X[(xi - 1):(xi+2), None]*dr).sum()
+#    y_0 = (Y[None, (yi - 1):(yi+2)]*dr).sum()
+#    
+#    dr = data.squeeze()[(x2 - 1):(x2+2), (y2 - 1):(y2 +2)]
+#    dr /= dr.sum()        
+#    x_2 = (X[(x2 - 1):(x2+2), None]*dr).sum()
+#    y_2 = (Y[None,(y2 - 1):(y2+2)]*dr).sum()
+#    
+    
+#    x0 = 0.5*(x_0 + x_2)
+#    y0 = 0.5*(y_0 + y_2)
+    
+    print((xi, yi, x2, y2))
+#    
+    
+    x0 = 0.5*(X[xi] + X[x2])
+    y0 = 0.5*(Y[yi] + Y[y2])
+    
+    
+
+#    print nr, x0, y0, X[xi], Y[yi]            
+    
+#    x0 /= nr
+#    y0 /= nr
+    #x0 = (X[:,None]*dr).sum()/drs
+    #y0 = (Y[None, :]*dr).sum()/drs
+
+    #sig_xl = (numpy.maximum(0, x0 - X)[:,None]*dr).sum()/(drs)
+    #sig_xr = (numpy.maximum(0, X - x0)[:,None]*dr).sum()/(drs)
+
+    #sig_yu = (numpy.maximum(0, y0 - Y)[None, :]*dr).sum()/(drs)
+    #sig_yd = (numpy.maximum(0, Y - y0)[None, :]*dr).sum()/(drs)
+
+    #mask of thresholded region
+    #m = dr > 0
+    
+    #angle of each pixel
+    theta = numpy.mod(numpy.angle((x0 -X[:,None]) +1j*(y0 - Y[None, :])), numpy.pi)
+
+    #print theta.shape
+
+    #import pylab
+    #pylab.imshow(theta)
+
+    thm = (theta*dr).sum()/drs
+    #thm = float(numpy.mod(numpy.angle((x0 -X[xi]) +1j*(y0 - Y[yi])), numpy.pi))
+    
+    #A = (data - data.min()).sum()
+
+    return A, x0, y0, thm
+
+
+def getStartParameters(data, X, Y, Z=None):
+    ds = ndimage.gaussian_filter(data, 1)
+    A, x0, y0, dw = _calcParams(ds, X, Y)
+
+    #clamp dw to valid region
+    dw_ = min(max(dw, splines['z'][0][0]), splines['z'][0][-1])
+    #lookup z
+    z0 = max(min(splev(dw_, splines['z'])[0], 500), -500)
+
+    #correct position & intensity estimates for z position
+    A = A/splev(z0, splines['A'])[0]
+    x0 = x0 - splev(z0, splines['xp'])[0]
+    y0 = y0 - splev(z0, splines['yp'])[0]
+
+    b = data.min()
+
+    return [A, x0, y0, -z0, b]
+