def _gaussian2D(param, indy, indx, vals):
"""
param: (mean, max - mean, y, x, sigma)
"""
yyi = param[2] - indy
xxi = param[3] - indx
dist = -(yyi) * (yyi) - (xxi) * (xxi)
sigma = 2. * (param[4] * param[4])
return param[0] + param[1] * N.exp(dist / sigma) - vals
def _gaussian2D(param, indy, indx, vals):
"""
param: (mean, max - mean, y, x, sigma)
"""
yyi = param[2]-indy
xxi = param[3]-indx
dist = -(yyi)*(yyi) -(xxi)*(xxi)
sigma = 2. * (param[4]*param[4])
return param[0] + param[1] * N.exp(dist /sigma) - vals
def _gaussian2D_ellipse(param, indy, indx, vals):
"""
param: (mean, max - mean, y, x, sigmay, sigmax)
"""
sy = 2. * (param[4]*param[4])
sx = 2. * (param[5]*param[5])
yyi = param[2]-indy
xxi = param[3]-indx
dist = -(yyi)*(yyi)/sy -(xxi)*(xxi)/sx
return param[0] + param[1] * N.exp(dist) - vals
def _gaussian2D_ellipse(param, indy, indx, vals):
"""
param: (mean, max - mean, y, x, sigmay, sigmax)
"""
sy = 2. * (param[4] * param[4])
sx = 2. * (param[5] * param[5])
yyi = param[2] - indy
xxi = param[3] - indx
dist = -(yyi) * (yyi) / sy - (xxi) * (xxi) / sx
return param[0] + param[1] * N.exp(dist) - vals
def yExpDecay(rhamda=1, t=0, n0=100):
"""
rhamda: paramter
n0: the first value of the data
"""
tt = N.asarray(t)
try:
if tt[0]:
tt = tt.copy()
tt -= tt[0]
except TypeError:
pass
return n0 * N.exp(-rhamda * tt)
def yExpDecay(rhamda=1, t=0, n0=100):
"""
rhamda: paramter
n0: the first value of the data
"""
tt = N.asarray(t)
try:
if tt[0]:
tt = tt.copy()
tt -= tt[0]
except TypeError:
pass
return n0 * N.exp(-rhamda * tt)
def yGaussianND(param, inds, sidx):
"""
param: (mean, max - mean, z, y, x, sigmaz, sigmay, sigmax)
ind: coordinate as N.indices (float32)
sidx: idx of param where sigma starts (2 + ndim)
"""
s = 2. * param[sidx:] * param[sidx:] # sigma
zyx = param[2:sidx] #- 0.5 # use pixel center
DST = N.zeros(inds[0].shape, inds[0].dtype.type)
for i in range(sidx - 2):
IND = zyx[i] - inds[i]
DST -= (IND * IND) / s[i]
return param[0] + param[1] * N.exp(DST)
def ySkew(param, ts):
"""
param: (mean, max - mean, t, sigma, exp)
ind: coordinate as N.indices (float32)
sidx: idx of param where sigma starts (2 + ndim)
"""
s = 2. * (param[3]**2) # sigma
ss = ts**param[4] # exponential
ss *= s # sigma skewed by exp
t = param[2] - 0.5 # use pixel center
IND = t - ts
DST = -(IND * IND) / ss
return param[0] + param[1] * N.exp(DST)
def yGaussianND(param, inds, sidx):
"""
param: (mean, max - mean, z, y, x, sigmaz, sigmay, sigmax)
ind: coordinate as N.indices (float32)
sidx: idx of param where sigma starts (2 + ndim)
"""
s = 2. * param[sidx:] * param[sidx:] # sigma
zyx = param[2:sidx] #- 0.5 # use pixel center
DST = N.zeros(inds[0].shape, inds[0].dtype.type)
for i in range(sidx - 2):
IND = zyx[i] - inds[i]
DST -= (IND * IND) / s[i]
return param[0] + param[1] * N.exp(DST)
def ySkew(param, ts):
"""
param: (mean, max - mean, t, sigma, exp)
ind: coordinate as N.indices (float32)
sidx: idx of param where sigma starts (2 + ndim)
"""
s = 2. * (param[3]**2) # sigma
ss = ts ** param[4] # exponential
ss *= s # sigma skewed by exp
t = param[2] - 0.5 # use pixel center
IND = t - ts
DST = -(IND * IND) / ss
return param[0] + param[1] * N.exp(DST)
def yGaussian2D(param, indy, indx):
"""
param: (mean, max - mean, y, x, sigma[y], [sigmax])
indy, indx: coordinate of y and x as N.indices
"""
sy = 2. * (param[4] * param[4])
if len(param) == 6:
sx = 2. * (param[5] * param[5])
else:
sx = sy
yyi = param[2] - indy
xxi = param[3] - indx # int32 -> float64
# print yyi.dtype.type
dist = -(yyi) * (yyi) / sy - (xxi) * (xxi) / sx
return param[0] + param[1] * N.exp(dist)
def yGaussian2D(param, indy, indx):
"""
param: (mean, max - mean, y, x, sigma[y], [sigmax])
indy, indx: coordinate of y and x as N.indices
"""
sy = 2. * (param[4]*param[4])
if len(param) == 6:
sx = 2. * (param[5]*param[5])
else:
sx = sy
yyi = param[2]-indy
xxi = param[3]-indx # int32 -> float64
# print yyi.dtype.type
dist = -(yyi)*(yyi)/sy -(xxi)*(xxi)/sx
return param[0] + param[1] * N.exp(dist)
def yGaussian1D(param, t=0):
"""
param: (mean, max - mean, y, sigma)
or (mean, max - mean, y, sigma, sigmaSkew, sgimaSkew2)
latter may be sensitive to initial guess
"""
yyi = param[2]-t
dist = -(yyi)*(yyi)
if len(param) == 4:
c = 2.
elif len(param) == 6:
c = param[4]*t+param[5]
else:
raise ValueError('param must be tuple of length 4 or 6')
sigma = (param[3]*param[3]) * c
return param[0] + param[1] * N.exp(dist /sigma)
def yGaussian1D(param, t=0):
"""
param: (mean, max - mean, y, sigma)
or (mean, max - mean, y, sigma, sigmaSkew, sgimaSkew2)
latter may be sensitive to initial guess
"""
yyi = param[2] - t
dist = -(yyi) * (yyi)
if len(param) == 4:
c = 2.
elif len(param) == 6:
c = param[4] * t + param[5]
else:
raise ValueError('param must be tuple of length 4 or 6')
sigma = (param[3] * param[3]) * c
return param[0] + param[1] * N.exp(dist / sigma)
def yGaussian2DR(param, shape, LD, rot=0):
"""
param: (mean, max - mean, y, x, sigma[y], [sigmax], [rot])
shape: (y,x)
rot: scaler (counter clockwise) if len(param) < 7
LD: left down coordinate (offset)
"""
if len(param) == 7:
rot = parm[-1]
sy = 2. * (param[4] * param[4])
sx = 2. * (param[5] * param[5])
# import imgFilters
yx = N.subtract(param[2:4], LD)
# ll.append(yx)
yyi, xxi = rotateIndices2D(shape, rot, yx) # return float64
dist = -(yyi) * (yyi) / sy - (xxi) * (xxi) / sx
return param[0] + param[1] * N.exp(dist)
def yGaussian2DR(param, shape, LD, rot=0):
"""
param: (mean, max - mean, y, x, sigma[y], [sigmax], [rot])
shape: (y,x)
rot: scaler (counter clockwise) if len(param) < 7
LD: left down coordinate (offset)
"""
if len(param) == 7:
rot = parm[-1]
sy = 2. * (param[4]*param[4])
sx = 2. * (param[5]*param[5])
# import imgFilters
yx = N.subtract(param[2:4], LD)
# ll.append(yx)
yyi, xxi = rotateIndices2D(shape, rot, yx) # return float64
dist = -(yyi)*(yyi)/sy -(xxi)*(xxi)/sx
return param[0] + param[1] * N.exp(dist)
def gaussianArr2D(shape=(256,256), sigma=[2.,2.], peakVal=None, orig=None, rot=0):
"""
>1.5x faster implemetation than gaussianArrND
shape: (y,x)
sigma: scaler or [sigmay, sigmax]
orig: (y,x)
rot: scaler anti-clockwise
return N.float32
"""
shape = N.asarray(shape, N.uint)
try:
if len(sigma) == len(shape):
sy = 2*(sigma[0]*sigma[0])
sx = 2*(sigma[1]*sigma[1])
elif len(sigma) == 1:
sx = sy = 2*(sigma[0]*sigma[0])
else:
raise ValueError('sigma must be scaler or [sigmay, sigmax]')
except TypeError: # sigma scaler
sx = sy = 2*(sigma*sigma)
# print y, x
if rot:
yyi, xxi = imgFit.rotateIndices2D(shape, rot, orig, N.float32)
else:
if orig is None:
y, x = shape / 2. - 0.5 # pixel center remove
else:
y, x = N.subtract(orig, 0.5) # pixel center remove
yi, xi = N.indices(shape, dtype=N.float32)
yyi = y-yi
xxi = x-xi
k1 = -(yyi)*(yyi)/(sy) - (xxi)*(xxi)/(sx)
if peakVal:
k0 = peakVal
else:
k0 = 1. / ((sx+sy)/2. * ((2*N.pi)**0.5))
return k0 * N.exp(k1)
def gaussianArr2D(
shape=(256, 256), sigma=[2., 2.], peakVal=None, orig=None, rot=0):
"""
>1.5x faster implemetation than gaussianArrND
shape: (y,x)
sigma: scaler or [sigmay, sigmax]
orig: (y,x)
rot: scaler anti-clockwise
return N.float32
"""
shape = N.asarray(shape, N.uint)
try:
if len(sigma) == len(shape):
sy = 2 * (sigma[0] * sigma[0])
sx = 2 * (sigma[1] * sigma[1])
elif len(sigma) == 1:
sx = sy = 2 * (sigma[0] * sigma[0])
else:
raise ValueError('sigma must be scaler or [sigmay, sigmax]')
except TypeError: # sigma scaler
sx = sy = 2 * (sigma * sigma)
# print y, x
if rot:
yyi, xxi = imgFit.rotateIndices2D(shape, rot, orig, N.float32)
else:
if orig is None:
y, x = shape / 2. - 0.5 # pixel center remove
else:
y, x = N.subtract(orig, 0.5) # pixel center remove
yi, xi = N.indices(shape, dtype=N.float32)
yyi = y - yi
xxi = x - xi
k1 = -(yyi) * (yyi) / (sy) - (xxi) * (xxi) / (sx)
if peakVal:
k0 = peakVal
else:
k0 = 1. / ((sx + sy) / 2. * ((2 * N.pi)**0.5))
return k0 * N.exp(k1)
def yExpProb(rhamda=1, t=0):
t = N.asarray(t)
return rhamda * N.exp(-rhamda * t)
def yExpProb(rhamda=1, t=0):
t = N.asarray(t)
return rhamda * N.exp(-rhamda * t)
