def _doBilinear2D(a2d, tyx=(0,0), r=0, mag=1, anismag=1, dyx=(0,0), mr=0, b2d=None):
if b2d is None:
b2d = N.empty_like(a2d)
else:
b2d = N.ascontiguousarray(b2d)
a2d = a2d.copy() # otherwise, the following code will mess up the input
if N.any(dyx[-2:]) or mr:
temp = b2d
target = a2d
U.trans2d(target, temp, (dyx[-1], dyx[-2], mr, 1, 0, 1))
else:
temp = a2d
target = b2d
# rot mag first to make consistent with affine
magaxis = 1 # only this axis works
if r or mag != 1 or anismag != 1:
U.trans2d(temp, target, (0, 0, r, mag, magaxis, anismag))
else:
target[:] = temp[:]
# then translate
tyx2 = N.array(tyx) # copy
tyx2[-2:] -= dyx[-2:]
if N.any(tyx2[-2:]) or mr:
U.trans2d(target, temp, (tyx2[-1], tyx2[-2], -mr, 1, 0, 1))
else:
temp[:] = target[:]
#a[z] = temp[:]
return temp
def remap(img, mapy, mapx, interp=2):
"""
transform image using coordinate x,y
Interpolation method:
0 = CV_INTER_NN nearest-neigbor interpolation
1 = CV_INTER_LINEAR bilinear interpolation (used by default)
2 = CV_INTER_CUBIC bicubic interpolation
3 = CV_INTER_AREA resampling using pixel area relation. It is the preferred method for image decimation that gives moire-free results. In terms of zooming it is similar to the CV_INTER_NN method
return resulting array
"""
des = N.zeros_like(img)
# cv.fromarray: array can be 2D or 3D only
if cv2.__version__.startswith('2'):
cimg = cv.fromarray(img)
cdes = cv.fromarray(des)
cmapx = cv.fromarray(mapx.astype(N.float32))
cmapy = cv.fromarray(mapy.astype(N.float32))
cv.Remap(cimg, cdes, cmapx, cmapy, flags=interp+cv.CV_WARP_FILL_OUTLIERS)
else:
cimg = img
#cdes = des
cmapx = mapx.astype(N.float32)
cmapy = mapy.astype(N.float32)
cdes = cv2.remap(cimg, cmapx, cmapy, interp)
return N.asarray(cdes)
def gaussianArrND(shape=(256,256), sigma=2., peakVal=None, orig=None, rot=0):
try:
ndim = len(shape)
except TypeError:
shape = [shape]
ndim = 1
sidx = ndim + 2
slices = [Ellipsis] + [slice(0,m) for m in shape]
inds, LD = imgFit.rotateIndicesND(slices, N.float32, rot)
#inds = N.indices(shape, N.float32)
try:
if len(sigma) != ndim:
raise ValueError('len(sigma) must be the same as len(shape)')
except TypeError:
sigma = [sigma] * ndim
if orig is None:
c = N.asarray(shape, N.float32)/2.
else:
c = N.asarray(orig, N.float32)
if peakVal:
k0 = peakVal
else:
k0 = 1. / (N.average(sigma) * ((2*N.pi)**0.5))
param = [0, k0] + list(c) + list(sigma)
param = N.asarray(param, N.float32)
return imgFit.yGaussianND(param, inds, sidx)
def findMaxWithGFit(img, sigma=0.5, win=11):
'''
find sub-pixel peaks from input img using n-dimensional Guassian fitting
sigma: scaler or [simgaZ,sigmaY..]
window: a window where the Guassian fit is performed on
return [v, zyx, sigma]
'''
vzyx = N.array(U.findMax(img))
ndim = img.ndim
try:
ret, check = imgFit.fitGaussianND(img, vzyx[-ndim:], sigma, win)
except IndexError: # too close to the edge
imgFit.fitFailedAppend("at %s" % str(vzyx[-ndim:]))
sigma = imgFit._scalerToSeq(sigma, ndim)
return vzyx[0:1], vzyx[-ndim:], list(sigma)
if check == 5 or N.any(ret[2:2+ndim] > (vzyx[-ndim:] + win)) or N.any(ret[2:2+ndim] < (vzyx[-ndim:] - win)):
imgFit.fitFailedAppend("at %s, %s, check=%i" % (str(vzyx[-ndim:]), str(ret), check))
sigma = imgFit._scalerToSeq(sigma, ndim)
return [vzyx[0:1], vzyx[-ndim:], sigma]
#x= (vzyx[0:1] + [vzyx[-ndim:]] + [sigma])
# print x
# return x
else:
v = ret[1]
zyx = ret[2:2+ndim]
sigma = ret[2+ndim:2+ndim*2]
return [v,zyx,sigma]
def apodize(img, napodize=10, doZ=True):
"""
softens the edges of a singe xy section to reduce edge artifacts and improve the fits
return copy of the img
"""
img = img.copy()
img = img.astype(N.float32) # casting rule
# determine napodize
shape = N.array(img.shape) // 2
napodize = N.where(shape < napodize, shape, napodize)
if doZ and img.ndim >= 3 and img.shape[0] > 3:
rr = range(-3, 0)
else:
rr = range(-2, 0)
for idx in rr:
fact = N.arange(1. / napodize[idx],
napodize[idx],
1. / napodize[idx],
dtype=N.float32)[:napodize[idx]]
for napo in range(napodize[idx]):
slc0 = [Ellipsis, slice(napo, napo + 1)
] + [slice(None)] * abs(idx + 1)
if not napo:
slc1 = [Ellipsis, slice(-(napo + 1), None)
] + [slice(None)] * abs(idx + 1)
else:
slc1 = [Ellipsis, slice(-(napo + 1), -(napo))
] + [slice(None)] * abs(idx + 1)
img[slc0] *= fact[napo]
img[slc1] *= fact[napo]
#img[slc0] = img[slc0] * fact[napo] # casting rule
#img[slc1] = img[scl1] * fact[napo]
return img
def gaussianArrND(shape=(256, 256), sigma=2., peakVal=None, orig=None, rot=0):
try:
ndim = len(shape)
except TypeError:
shape = [shape]
ndim = 1
sidx = ndim + 2
slices = [Ellipsis] + [slice(0, m) for m in shape]
inds, LD = imgFit.rotateIndicesND(slices, N.float32, rot)
#inds = N.indices(shape, N.float32)
try:
if len(sigma) != ndim:
raise ValueError('len(sigma) must be the same as len(shape)')
except TypeError:
sigma = [sigma] * ndim
if orig is None:
c = N.asarray(shape, N.float32) / 2.
else:
c = N.asarray(orig, N.float32)
if peakVal:
k0 = peakVal
else:
k0 = 1. / (N.average(sigma) * ((2 * N.pi)**0.5))
param = [0, k0] + list(c) + list(sigma)
param = N.asarray(param, N.float32)
return imgFit.yGaussianND(param, inds, sidx)
def findMaxWithGFit(img, sigma=0.5, win=11):
'''
find sub-pixel peaks from input img using n-dimensional Guassian fitting
sigma: scaler or [simgaZ,sigmaY..]
window: a window where the Guassian fit is performed on
return [v, zyx, sigma]
'''
vzyx = N.array(U.findMax(img))
ndim = img.ndim
try:
ret, check = imgFit.fitGaussianND(img, vzyx[-ndim:], sigma, win)
except IndexError: # too close to the edge
imgFit.fitFailedAppend("at %s" % str(vzyx[-ndim:]))
sigma = imgFit._scalerToSeq(sigma, ndim)
return vzyx[0:1], vzyx[-ndim:], list(sigma)
if check == 5 or N.any(ret[2:2 + ndim] > (vzyx[-ndim:] + win)) or N.any(
ret[2:2 + ndim] < (vzyx[-ndim:] - win)):
imgFit.fitFailedAppend("at %s, %s, check=%i" %
(str(vzyx[-ndim:]), str(ret), check))
sigma = imgFit._scalerToSeq(sigma, ndim)
return [vzyx[0:1], vzyx[-ndim:], sigma]
#x= (vzyx[0:1] + [vzyx[-ndim:]] + [sigma])
# print x
# return x
else:
v = ret[1]
zyx = ret[2:2 + ndim]
sigma = ret[2 + ndim:2 + ndim * 2]
return [v, zyx, sigma]
def _doBilinear2D(a2d, tyx=(0,0), r=0, mag=1, anismag=1, dyx=(0,0), mr=0, b2d=None):
if b2d is None:
b2d = N.empty_like(a2d)
else:
b2d = N.ascontiguousarray(b2d)
a2d = a2d.copy() # otherwise, the following code will mess up the input
if N.any(dyx[-2:]) or mr:
temp = b2d
target = a2d
U.trans2d(target, temp, (dyx[-1], dyx[-2], mr, 1, 0, 1))
else:
temp = a2d
target = b2d
# rot mag first to make consistent with affine
magaxis = 1 # only this axis works
if r or mag != 1 or anismag != 1:
U.trans2d(temp, target, (0, 0, r, mag, magaxis, anismag))
else:
target[:] = temp[:]
# then translate
tyx2 = N.array(tyx) # copy
tyx2[-2:] -= dyx[-2:]
if N.any(tyx2[-2:]) or mr:
U.trans2d(target, temp, (tyx2[-1], tyx2[-2], -mr, 1, 0, 1))
else:
temp[:] = target[:]
#a[z] = temp[:]
return temp
def _cutoutForAlign2(fn, py, outFn=''):
"""
if not outFn, default with 'cut' extention
resulting array is imgSequence=0 (t,w,z,y,x)
return outFn
"""
h = imgManager.ImageManager(fn)
slc, shiftZYX, ZYX = makeSlice(h, py)
# input
arr = N.empty((h.nt, h.nw, h.nz, h.ny, h.nx), h.dtype)
for t in range(h.nt):
for w in range(h.nw):
arr[t, w] = h.get3DArr(w=w, t=t)
canvas = N.squeeze(arr[slc].astype(arr.dtype.type))
newNum = (canvas.shape[-1], canvas.shape[-2], N.prod(canvas.shape[:-3]))
if not outFn:
outFn = '_'.join((h.filePath, EXT_CUTOUT)) #arr.Mrc.path, EXT_CUTOUT))
hdr = Mrc.makeHdrArray()
Mrc.initHdrArrayFrom(hdr, h.hdr) #arr.Mrc.hdr)
hdr.ImgSequence = 2
hdr.Num[:] = newNum
mstart = [sl.start for sl in slc[::-1][:3] if isinstance(sl, slice)]
hdr.mst[:len(mstart)] += mstart
Mrc.save(canvas, outFn, ifExists='overwrite', hdr=hdr)
return outFn
def remap(img, mapy, mapx, interp=2):
"""
transform image using coordinate x,y
Interpolation method:
0 = CV_INTER_NN nearest-neigbor interpolation
1 = CV_INTER_LINEAR bilinear interpolation (used by default)
2 = CV_INTER_CUBIC bicubic interpolation
3 = CV_INTER_AREA resampling using pixel area relation. It is the preferred method for image decimation that gives moire-free results. In terms of zooming it is similar to the CV_INTER_NN method
return resulting array
"""
des = N.empty_like(img)
# cv.fromarray: array can be 2D or 3D only
if cv2.__version__.startswith('2'):
cimg = cv.fromarray(img)
cdes = cv.fromarray(des)
cmapx = cv.fromarray(mapx.astype(N.float32))
cmapy = cv.fromarray(mapy.astype(N.float32))
cv.Remap(cimg, cdes, cmapx, cmapy, flags=interp+cv.CV_WARP_FILL_OUTLIERS)
else:
cimg = img
cdes = des
cmapx = mapx.astype(N.float32)
cmapy = mapy.astype(N.float32)
cdes = cv2.remap(cimg, cmapx, cmapy, interp)
return N.asarray(cdes)
def selectZsecs(self, start=0, stop=None, pattern=[1], pickWhich=1):
"""
stores section indices to be picked up when doing copy region
pattern: smallest pattern of elements eg. [1,1,0,2]
pickWich: sections corresponding this number in the pattern is picked up
"""
if stop is None:
stop = self.cropbox_u[0]
if start is None:
start = self.cropbox_l[0]
unit = len(pattern)
idx = N.arange(self.nz)
repeat = N.ceil(self.nz / float(unit))
repPat = N.tile(pattern, repeat)[:self.nz]
ids = N.compress(repPat == pickWhich, idx)
self._zIdx = [i for i in ids if i >= start and i < stop]
if not self._zIdx:
self._zIdx = [0]
print self._zIdx
self.cropbox_l[0] = start
self.cropbox_u[0] = stop
if self.cropbox_l[0] == self.cropbox_u[0]:
self.cropbox_u[0] += 1
self._zPtrn = pattern
self._zPick = pickWhich
def apodize(img, napodize=10, doZ=True):
"""
softens the edges of a singe xy section to reduce edge artifacts and improve the fits
return copy of the img
"""
img = img.copy()
img = img.astype(N.float32) # casting rule
# determine napodize
shape = N.array(img.shape) // 2
napodize = N.where(shape < napodize, shape, napodize)
if doZ and img.ndim >= 3 and img.shape[0] > 3:
rr = list(range(-3,0))
else:
rr = list(range(-2,0))
for idx in rr:
fact = N.arange(1./napodize[idx],napodize[idx],1./napodize[idx], dtype=N.float32)[:napodize[idx]]
for napo in range(napodize[idx]):
slc0 = [Ellipsis,slice(napo, napo+1)] + [slice(None)] * abs(idx+1)
if not napo:
slc1 = [Ellipsis,slice(-(napo+1),None)] + [slice(None)] * abs(idx+1)
else:
slc1 = [Ellipsis,slice(-(napo+1),-(napo))] + [slice(None)] * abs(idx+1)
img[slc0] *= fact[napo]
img[slc1] *= fact[napo]
#img[slc0] = img[slc0] * fact[napo] # casting rule
#img[slc1] = img[scl1] * fact[napo]
return img
def normalizedXcorr(a, b):
std = N.std(a) * N.std(b)
a_ = (a - N.mean(a)) / std
b_ = (b - N.mean(b)) / std
c = F.convolve(a_, b_, conj=1) # / a.size
return c
def normalizedXcorr(a, b):
std = N.std(a) * N.std(b)
a_ = (a - N.mean(a)) / std
b_ = (b - N.mean(b)) / std
c = F.convolve(a_, b_, conj=1)# / a.size
return c
def _makeSlice(zyx):
slcs = []
for x in zyx:
if x >= 0:
slc = slice(int(N.ceil(x)), None, None)
else:
slc = slice(0, -int(N.ceil(abs(x))))
slcs.append(slc)
return slcs
def psf__wPSF(parm, t):
"""
parm: s0, c, d, A, B
example (72, 125, 246, 1, 1)
"""
s0, c, d, A, B = parm
com = (t - c) / d
sq = 1 + N.power(com, 2) + A * N.power(com, 3) + B * N.power(com, 4)
return s0 * N.sqrt(sq)
def psf__wPSF(parm, t):
"""
parm: s0, c, d, A, B
example (72, 125, 246, 1, 1)
"""
s0, c, d, A, B = parm
com = (t - c) / d
sq = 1 + N.power(com, 2) + A * N.power(com, 3) + B * N.power(com, 4)
return s0 * N.sqrt(sq)
def psf__wPSF_fromSigma(t, parm):
"""
t: now this is sigma that you got
parm: s0, c, d, A, B (use parm form psf__wPSF fit)
"""
s0, c, d, A, B = parm
com = (t - c) / d
sq = 1 + N.power(com, 2) + A * N.power(com, 3) + B * N.power(com, 4)
return s0 * N.sqrt( 1 + sq)
def psf__wPSF_fromSigma(t, parm):
"""
t: now this is sigma that you got
parm: s0, c, d, A, B (use parm form psf__wPSF fit)
"""
s0, c, d, A, B = parm
com = (t - c) / d
sq = 1 + N.power(com, 2) + A * N.power(com, 3) + B * N.power(com, 4)
return s0 * N.sqrt(1 + sq)
def __init__(self, fns):
"""
fns
"""
# input types
self.img = load(fns)
# copy attributes
self.nt = self.img.nt
self.nw = self.img.nw
self.nz = self.img.nz
self.ny = self.img.ny
self.nx = self.img.nx
self.dtype = self.img.dtype
self.hdr = self.img.hdr
self.dirname = os.path.dirname(self.img.filename) #path)
self.file = self.path = os.path.basename(self.img.filename) #path)
self.shape = N.asarray(
mrcIO.shapeFromNum(self.hdr.Num, self.nw, self.nt,
self.hdr.ImgSequence))
self.ndim = int(self.nz > 1) + int(self.nw > 1) + int(self.nt > 1) + 2
zwt = ['z', 'w', 't']
num = [self.nz, self.nw, self.nt]
maxdim = max(num)
self.maxaxs = zwt[num.index(maxdim)]
# slicing parameter
self.ignor_color_axis = False
self.sld_axs = 't'
# cropping region
self.cropbox_l = N.array([0, 0, 0], N.int32)
self.cropbox_u = N.array([self.nz, self.ny, self.nx], N.int32)
self.setMstUse(
False) # this has to be False since original shape cannot be known
self.tSlice = 0
self.setIndices(range(self.nw), range(self.nt), range(self.nz),
self.hdr.ImgSequence, self.dtype)
self.sliceIdx = [self.nz // 2, self.ny // 2, self.nx // 2]
self.selectZsecs()
# output
self.byteorder = '='
self.interporder = imgResample.ORDER
# viewer
self.vid = None
self._rub = None
self.vid_single = None
# aui
self.t = 0
self.w = 0
self.z = self.nz // 2
self.y = self.ny // 2
self.x = self.nx // 2
def rotateIndices2DNew(shape, rot, orig=None, dtype=N.float64):
"""
shape: 2D
rot: anti-clockwise
orig: (y, x)
return: yi, xi
"""
# FIX ME Rot is something wrong!! 081027
shape = N.asarray(shape, N.int)
if orig is None:
y, x = shape / 2.
else:
y, x = orig
print(y, x)
if not rot:
yi, xi = N.indices(shape, dtype=N.float64)
yi -= y - 0.5 # remove pix center
xi -= x - 0.5
return yi, xi
# twice as large window
# mo = N.abs(N.mod(shape, 2) + [-1,-1])
s2 = shape * 2 #+ mo # always odd for even shape, even for odd shape
yi, xi = N.indices(s2, dtype=N.float32)
mm = N.ceil(shape / 2.) #(s2 -1 - shape)//2 # offset always int
yi -= mm[0]
xi -= mm[1]
pxc = imgGeo.RotateXY((0.5, 0.5), rot) # remove pix center
yi += pxc[0]
xi += pxc[1]
y0, x0 = shape / 2. #N.ceil(shape / 2) # img center
yc = y0 - y # delta rotation center
xc = x0 - x
yi = U.trans2d(yi, None, (xc, yc, rot, 1, 0, 1))
xi = U.trans2d(xi, None, (xc, yc, rot, 1, 0, 1))
yi = U.trans2d(yi, None, (-xc, -yc, 0, 1, 0, 1))
xi = U.trans2d(xi, None, (-xc, -yc, 0, 1, 0, 1))
yi = yi.astype(dtype)
xi = xi.astype(dtype)
yi -= y
xi -= x
yi = imgFilters.cutOutCenter(yi, shape)
xi = imgFilters.cutOutCenter(xi, shape)
return yi, xi
def rotateIndices2DNew(shape, rot, orig=None, dtype=N.float64):
"""
shape: 2D
rot: anti-clockwise
orig: (y, x)
return: yi, xi
"""
# FIX ME Rot is something wrong!! 081027
shape = N.asarray(shape, N.int)
if orig is None:
y, x = shape / 2.
else:
y, x = orig
print(y,x)
if not rot:
yi,xi = N.indices(shape, dtype=N.float64)
yi -= y - 0.5 # remove pix center
xi -= x - 0.5
return yi,xi
# twice as large window
# mo = N.abs(N.mod(shape, 2) + [-1,-1])
s2 = shape * 2 #+ mo # always odd for even shape, even for odd shape
yi, xi = N.indices(s2, dtype=N.float32)
mm = N.ceil(shape / 2.)#(s2 -1 - shape)//2 # offset always int
yi -= mm[0]
xi -= mm[1]
pxc = imgGeo.RotateXY((0.5,0.5), rot) # remove pix center
yi += pxc[0]
xi += pxc[1]
y0, x0 = shape / 2. #N.ceil(shape / 2) # img center
yc = y0 - y # delta rotation center
xc = x0 - x
yi = U.trans2d(yi, None, (xc,yc,rot,1,0,1))
xi = U.trans2d(xi, None, (xc,yc,rot,1,0,1))
yi = U.trans2d(yi, None, (-xc,-yc,0,1,0,1))
xi = U.trans2d(xi, None, (-xc,-yc,0,1,0,1))
yi = yi.astype(dtype)
xi = xi.astype(dtype)
yi -= y
xi -= x
yi = imgFilters.cutOutCenter(yi, shape)
xi = imgFilters.cutOutCenter(xi, shape)
return yi, xi
def nanFilter(af, kernel=3):
"""
3D phase contrast filter often creates 'nan'
this filter removes nan by averaging surrounding pixels
return af
"""
af = af.copy()
shape = N.array(af.shape)
radius = N.subtract(kernel, 1) // 2
box = kernel * af.ndim
nan = N.isnan(af)
nids = N.array(N.nonzero(nan)).T
for nidx in nids:
slc = [slice(idx, idx + 1) for idx in nidx]
slices = []
for dim in range(af.ndim):
slc2 = slice(slc[dim].start - radius, slc[dim].stop + radius)
while slc2.start < 0:
slc2 = slice(slc2.start + 1, slc2.stop)
while slc2.stop > shape[dim]:
slc2 = slice(slc2.start, slc2.stop - 1)
slices.append(slc2)
val = af[slices]
nanlocal = N.isnan(val)
ss = N.sum(N.where(nanlocal, 0, val)) / float((box - N.sum(nanlocal)))
af[slc] = ss
return af
def nanFilter(af, kernel=3):
"""
3D phase contrast filter often creates 'nan'
this filter removes nan by averaging surrounding pixels
return af
"""
af = af.copy()
shape = N.array(af.shape)
radius = N.subtract(kernel, 1) // 2
box = kernel * af.ndim
nan = N.isnan(af)
nids = N.array(N.nonzero(nan)).T
for nidx in nids:
slc = [slice(idx,idx+1) for idx in nidx]
slices = []
for dim in range(af.ndim):
slc2 = slice(slc[dim].start - radius, slc[dim].stop + radius)
while slc2.start < 0:
slc2 = slice(slc2.start + 1, slc2.stop)
while slc2.stop > shape[dim]:
slc2 = slice(slc2.start, slc2.stop -1)
slices.append(slc2)
val = af[slices]
nanlocal = N.isnan(val)
ss = N.sum(N.where(nanlocal, 0, val)) / float((box - N.sum(nanlocal)))
af[slc] = ss
return af
def transformMatrix(rot=0.0, mag=1.0):
"""
retrn invmat
"""
rotRadian = N.pi / 180. * rot
cosTheta = N.cos(rotRadian)
sinTheta = N.sin(rotRadian)
affmatrix = N.array([[cosTheta, sinTheta], [-sinTheta, cosTheta]]) * mag
invmat = N.linalg.inv(affmatrix)
return invmat
def paddingFourier(arr, shape, value=0, interpolate=True):
"""
arr: assuming origin at 0, rfft product (half x size), up to 3D
shape: target shape
value: the value to fill in empty part
interpolate: shift by interpolation if necessary
return array with target shape
"""
# prepare buffer
dtype = arr.dtype.type
canvas = N.empty(shape, dtype)
canvas[:] = value
# calc and shift
shapeS = N.array(arr.shape)
shapeL = N.asarray(shape)
halfS = shapeS / 2.
subpx_shift = halfS % 1
if interpolate and N.sometrue(subpx_shift):
arr = U.nd.shift(arr, subpx_shift)
halfS = [int(s) for s in halfS]
# create empty list for slices
nds = arr.ndim - 1
choices = ['slice(halfS[%i])', 'slice(-halfS[%i], None)']
nchoices = len(choices)
nds2 = nds**2
slcs = []
for ns in range(nds2):
slcs.append([])
for n in range(nchoices * nds):
slcs[ns].append(
[Ellipsis]) # Ellipsis help to make arbitray number of list
# fill the empty list by slice (here I don't know how to use 4D..)
for i in range(nds2):
for d in range(nds):
for x in range(nds):
for c, choice in enumerate(choices):
if d == 0 and x == 0:
idx = x * (nchoices) + c
else: # how can I use 4D??
idx = x * (nchoices) + (nchoices - 1) - c
exec('content=' + choice % d)
slcs[i][idx] += [content]
# cutout and paste
for slc in slcs:
for s in slc:
s.append(slice(int(shapeS[-1])))
#print s
canvas[s] = arr[s]
return canvas
def transformMatrix(rot=0.0, mag=1.0):
"""
retrn invmat
"""
rotRadian = N.pi / 180. * rot
cosTheta = N.cos(rotRadian)
sinTheta = N.sin(rotRadian)
affmatrix = N.array([ [cosTheta, sinTheta], [-sinTheta, cosTheta] ]) * mag
invmat = N.linalg.inv(affmatrix)
return invmat
def arr_edgeFilter(img, sigma=1.5):
"""
average-deviation with a gaussian prefilter
img must be in an even shape
"""
if sigma:
g = gaussianArrND(img.shape, sigma)
g = F.shift(g)
img = F.convolve(img.astype(N.float32), g)
gr = N.gradient(img.astype(N.float32))
ff = N.sum(N.power(gr, 2), 0)
return ff
def logpolar_cv(img, center=None, mag=1):
des = N.zeros_like(img)
if center is None:
center = N.divide(img.shape, 2)
# cv.fromarray: array can be 2D or 3D only
cimg = cv.fromarray(img)
cdes = cv.fromarray(des)
cv.LogPolar(cimg, cdes, tuple(center), mag)#, cv.CV_WARP_FILL_OUTLIERS)
return N.array(cdes)
def logpolar_cv(img, center=None, mag=1):
des = N.zeros_like(img)
if center is None:
center = N.divide(img.shape, 2)
# cv.fromarray: array can be 2D or 3D only
cimg = cv.fromarray(img)
cdes = cv.fromarray(des)
cv.LogPolar(cimg, cdes, tuple(center), mag) #, cv.CV_WARP_FILL_OUTLIERS)
return N.array(cdes)
def paddingFourier(arr, shape, value=0, interpolate=True):
"""
arr: assuming origin at 0, rfft product (half x size), up to 3D
shape: target shape
value: the value to fill in empty part
interpolate: shift by interpolation if necessary
return array with target shape
"""
# prepare buffer
dtype = arr.dtype.type
canvas = N.empty(shape, dtype)
canvas[:] = value
# calc and shift
shapeS = N.array(arr.shape)
shapeL = N.asarray(shape)
halfS = shapeS / 2.
subpx_shift = halfS % 1
if interpolate and N.sometrue(subpx_shift):
arr = U.nd.shift(arr, subpx_shift)
halfS = [int(s) for s in halfS]
# create empty list for slices
nds = arr.ndim - 1
choices = ['slice(halfS[%i])', 'slice(-halfS[%i], None)']
nchoices = len(choices)
nds2 = nds**2
slcs = []
for ns in range(nds2):
slcs.append([])
for n in range(nchoices*nds):
slcs[ns].append([Ellipsis]) # Ellipsis help to make arbitray number of list
# fill the empty list by slice (here I don't know how to use 4D..)
for i in range(nds2):
for d in range(nds):
for x in range(nds):
for c, choice in enumerate(choices):
if d == 0 and x == 0:
idx = x*(nchoices) + c
else: # how can I use 4D??
idx = x*(nchoices) + (nchoices-1) - c
exec('content=' + choice % d)
slcs[i][idx] += [content]
# cutout and paste
for slc in slcs:
for s in slc:
s.append(slice(int(shapeS[-1])))
#print s
canvas[s] = arr[s]
return canvas
def arr_edgeFilter(img, sigma=1.5):
"""
average-deviation with a gaussian prefilter
img must be in an even shape
"""
if sigma:
g = gaussianArrND(img.shape, sigma)
g = F.shift(g)
img = F.convolve(img.astype(N.float32), g)
gr = N.gradient(img.astype(N.float32))
ff = N.sum(N.power(gr, 2), 0)
return ff
def zoomFourier(arr, factor, use_abs=False):
shape = N.array(arr.shape)
target = [int(s) for s in shape * factor]
#target[-1] //= 2
#target[-1] += 1
af = F.fft(arr)
ap = paddingFourier(af, target)
afp = F.ifft(ap)
factor = target / shape
if use_abs:
return N.abs(afp) * N.product(factor)
else:
return N.real(afp) * N.product(factor)
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 zoomFourier(arr, factor, use_abs=False):
shape = N.array(arr.shape)
target = [int(s) for s in shape * factor]
#target[-1] //= 2
#target[-1] += 1
af = F.fft(arr)
ap = paddingFourier(af, target)
afp = F.ifft(ap)
factor = target / shape
if use_abs:
return N.abs(afp) * N.product(factor)
else:
return N.real(afp) * N.product(factor)
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 _indLD(win, y, x):
"""
return yi, xi, LD
"""
try:
len(win)
yi, xi = N.indices(int(win))
except TypeError:
yi, xi = N.indices((int(win), int(win)))
yx = N.asarray((y, x))
LD = yx - win / 2. + 0.5 # use pixel center
yi += LD[0]
xi += LD[1]
return yi, xi, LD
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 mask_gaussianND(arr, zyx, v, sigma=2., ret=None, rot=0, clipZero=True):
'''
subtract elliptical gaussian at y,x with peakVal v
if ret, return arr, else, arr itself is edited
'''
from . import imgGeo
zyx = N.asarray(zyx)
ndim = arr.ndim
shape = N.array(arr.shape)
try:
if len(sigma) != ndim:
raise ValueError('len(sigma) must be the same as len(shape)')
else:
sigma = N.asarray(sigma)
except TypeError:#(TypeError, ValueError):
sigma = N.asarray([sigma]*ndim)
# prepare small window
slc = imgGeo.nearbyRegion(shape, N.floor(zyx), sigma * 10)
inds, LD = imgFit.rotateIndicesND(slc, dtype=N.float32, rot=rot)
param = (0, v,) + tuple(zyx) + tuple(sigma)
sidx = 2 + ndim
g = imgFit.yGaussianND(N.asarray(param), inds, sidx).astype(arr.dtype.type)
roi = arr[slc]
if clipZero:
g = N.where(g > roi, roi, g)
if ret:
e = N.zeros_like(arr)
e[slc] = g # this may be faster than copy()
return arr - e
else:
arr[slc] -= g
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 _indLD(win, y, x):
"""
return yi, xi, LD
"""
try:
len(win)
yi, xi = N.indices(int(win))
except TypeError:
yi, xi = N.indices((int(win), int(win)))
yx = N.asarray((y, x))
LD = yx - win/2. + 0.5 # use pixel center
yi += LD[0]
xi += LD[1]
return yi, xi, LD
def showSelection(self):
sentence = []
sep = ': '
d = 'default (%i)'
u = 'unknown'
s = 'start---%3d stop---%3d step---%s (%i)'
things = [('time', self.nt, self._tIdx), ('zsec', self.nz, self._zIdx),
('wave', self.nw, self._wIdx),
('y ', self.shape[-2], self._yxSlice[0]),
('x ', self.shape[-1], self._yxSlice[1])]
for title, n, idxNow in things:
if type(idxNow) == slice:
start = idxNow.start
if start is None:
start = 0
stop = idxNow.stop
step = idxNow.step
if step is None:
step = 1
idxNow = range(int(start), int(stop), int(step))
else:
start = idxNow[0]
stop = idxNow[-1] + 1
listed = list(idxNow)
nn = len(listed)
if listed == range(int(n)):
sentence.append(sep.join((title, d % nn)))
else:
stepGuess = N.ceil((stop - start) / float(len(idxNow)))
if N.alltrue(idxNow == range(start, stop, int(stepGuess))):
step = str(int(stepGuess))
sentence.append(
sep.join((title, s % (start, stop, step, nn))))
else:
step = u
sentence.append(
sep.join((title, s % (start, stop, step, nn))))
if nn > 20:
tail = '...'
else:
tail = ''
sentence.append(' ' * (len(title) + len(sep)) +
','.join([str(a)
for a in listed[:20]]) + tail)
return '\n'.join(sentence)
def __getitem__(self, idx):
try:
idx = int(idx)
if idx < 0:
idx = self.shape[0] + idx
ws = range(self.nw)
ts = range(self.nt)
zs = range(self.nz)
if self.maxaxs == 'w' and not self.ignor_color_axis:
ws = [idx]
self.sld_axs = 'w'
elif self.maxaxs == 't' or (self.ignor_color_axis
and self.ndim > 4):
ts = [idx]
self.sld_axs = 't'
elif self.maxaxs == 'z' or (self.ignor_color_axis
and self.ndim == 4):
zs = [idx]
self.sld_axs = 'z'
else:
raise ValueError, 'section axis not determined'
if self.hdr.ImgSequence == 0:
e = N.empty((len(ws), len(ts), len(zs), self.ny, self.nx),
self.dtype)
for wo, wi in enumerate(ws):
for to, ti in enumerate(ts):
for zo, zi in enumerate(zs):
e[wo, to, zo] = self.img.getArr(w=wi, t=ti, z=zi)
elif self.hdr.ImgSequence == 1:
e = N.empty((len(ts), len(zs), len(ws), self.ny, self.nx),
self.dtype)
for to, ti in enumerate(ts):
for zo, zi in enumerate(zs):
for wo, wi in enumerate(ws):
e[to, zo, wo] = self.img.getArr(w=wi, t=ti, z=zi)
elif self.hdr.ImgSequence == 2:
e = N.empty((len(ts), len(ws), len(zs), self.ny, self.nx),
self.dtype)
for to, ti in enumerate(ts):
for wo, wi in enumerate(ws):
for zo, zi in enumerate(zs):
e[to, wo, zo] = self.img.getArr(w=wi, t=ti, z=zi)
except TypeError:
pass
return N.squeeze(e)
def mexhatFilter(a, mexSize=1):#, trimRatio=0.9):
"""
returned array is trimmed to remove edge
"""
global mexhatC, mexhatC_size, mexhatCf
a = imgFilters.evenShapeArr(a)
from Priithon.all import F as fftw
try:
if mexhatC.shape != a.shape:
raise ValueError('go to except')
if mexhatC_size != mexSize:
raise ValueError('go to except')
except NameError as ValueError:
mexhatC_size = mexSize
shape = N.asarray(a.shape, N.int)#N.float32)
mexhatC = F.shift(F.mexhatArr(shape, scaleHalfMax=mexhatC_size, orig=None)) # orig 0.5 pixel does not work...
mexhatCf = fftw.rfft(mexhatC) / N.multiply.reduce( shape )
ar = fftw.irfft( fftw.rfft(a.astype(N.float32)) * mexhatCf )
#if trimRatio < 1:
# ar = trim3D(ar, trimRatio)
#ar = imgFilters.maskEdgeWithValue2D(ar) # 2 pixels at the edges
return ar
def phaseContrastFilter(a, inFourier=False, removeNan=True, nyquist=0.6):
global GAUSS
if inFourier:
af = a.copy()
else:
af = F.rfft(a)
# here is the phase contrast
amp = N.abs(af)
afa = af / amp
if removeNan:
afa = nanFilter(afa)
# lowpass gaussian filter of phase image
if nyquist: # since this takes long time, gaussian array is re-used if possible
if GAUSS is not None and GAUSS[0] == nyquist and GAUSS[
1].shape == afa.shape:
nq, gf = GAUSS
else:
sigma = af.shape[-1] * nyquist
gf = F.gaussianArr(afa.shape,
sigma,
peakVal=1,
orig=0,
wrap=(1, ) * (afa.ndim - 1) +
(0, )) #, dtype=afa.dtype.type)
GAUSS = (nyquist, gf)
afa *= gf
if inFourier:
ap = afa
else:
ap = F.irfft(afa)
return ap
def mask_value(arr, zyx, r=2.5, value=0):
''' Edit the pixels around zyx to be zero
r: radius (will be 2*r + 1)
'''
from . import imgGeo
sls = imgGeo.nearbyRegion(arr.shape, zyx, 2*N.asarray(r)+1)
arr[sls] = value
def _fitGaussian2D(img, indy, indx, y, x, sigma=[2.,2.], mean_max=None):
"""
img: already cut out with indy, indx
"""
if mean_max is None:
mi, ma, me, sd = U.mmms(img)
#ma = img[y,x]
else:
me, ma = mean_max
try:
sigma, sigma2 = sigma
param0 = (me, float(ma-me), y, x, float(sigma), float(sigma2))
# func = _gaussian2D_ellipse
except (ValueError, TypeError):
try:
len(sigma)
sigma = [0]
except TypeError:
pass
param0 = (me, float(ma-me), y, x, float(sigma))
#func = _gaussian2D
img = img.flatten()
def func(p, indy, indx):
return yGaussian2D(p, indy, indx) - img
from scipy import optimize
ret, check = optimize.leastsq(func, param0,
args=(indy.flatten(), indx.flatten()), warning=None)
ret[2:4] += 0.5 # use pixel center
ret[4:] = N.abs(ret[4:])
return ret, check
def getOffset(shape, invmat, ty, tx, start=0):
try:
if len(start) == len(shape):
yxCenter = [s / 2. + start[i] for i, s in enumerate(shape)]
except TypeError:
yxCenter = [s / 2. + start for s in shape]
return -N.dot(invmat, yxCenter) + yxCenter - [ty, tx]
def _fitGaussian2DR(img, LD, y, x, sigma=[2.,2.], mean_max=None, window=5, rot=0, searchRot=None):
"""
img: already cut out with indy, indx
"""
if mean_max is None:
mi, ma, me, sd = U.mmms(img)
#ma = img[y,x]
else:
me, ma = mean_max
if searchRot:
param0 = (me, float(ma-me), y, x, float(sigma[0]), float(sigma[1]), rot)
else:
param0 = (me, float(ma-me), y, x, float(sigma[0]), float(sigma[1]))
img = img.flatten()
def func(p, shape, LD, rot):
return yGaussian2DR(p, shape, LD, rot).flatten() - img
from scipy import optimize
ret, check = optimize.leastsq(func, param0,
args=((window,window), LD, rot), warning=None)
if searchRot and ret[-1] < 0:
ret[-1] += 90
ret[4:] = N.abs(ret[4:])
return ret, check
def getOffset(shape, invmat, ty, tx, start=0):
try:
if len(start) == len(shape):
yxCenter = [s/2. + start[i] for i, s in enumerate(shape)]
except TypeError:
yxCenter = [s/2. + start for s in shape]
return -N.dot(invmat, yxCenter) + yxCenter - [ty, tx]
def mexhatFilter(a, mexSize=1): #, trimRatio=0.9):
"""
returned array is trimmed to remove edge
"""
global mexhatC, mexhatC_size, mexhatCf
a = imgFilters.evenShapeArr(a)
from Priithon.all import F as fftw
try:
if mexhatC.shape != a.shape:
raise ValueError('go to except')
if mexhatC_size != mexSize:
raise ValueError('go to except')
except NameError as ValueError:
mexhatC_size = mexSize
shape = N.asarray(a.shape, N.int) #N.float32)
mexhatC = F.shift(
F.mexhatArr(shape, scaleHalfMax=mexhatC_size,
orig=None)) # orig 0.5 pixel does not work...
mexhatCf = fftw.rfft(mexhatC) / N.multiply.reduce(shape)
ar = fftw.irfft(fftw.rfft(a.astype(N.float32)) * mexhatCf)
#if trimRatio < 1:
# ar = trim3D(ar, trimRatio)
#ar = imgFilters.maskEdgeWithValue2D(ar) # 2 pixels at the edges
return ar
def arr_histStretch(img, imgMin=None, imgMax=None, scaleMax=None):
"""
scaleMax = None: use maximum possible for the dtype
"""
if imgMin is None:
imgMin = img.min()
if imgMax is None:
imgMax = img.max()
if scaleMax is None:
img = N.asarray(img)
scaleMax = 1 << (img.nbytes // img.size) * 8
scaleMax -= 1
img = img - imgMin#img.min()
ratio = float(scaleMax) / imgMax#img.max()
return N.asarray(ratio * img, img.dtype.type)
def psf__wPSF_yPolyInv(t, *parm):
"""
abs()
"""
if len(parm) == 1:
parm = parm[0]
r = psf__wPSF_yPolyInv_bare(t, parm)
return N.abs(r)
def findMaxWithGFitAll(img, thre=0, sigma_peak=0.5, win=11, mask_npxls=3):
"""
find peaks until either
1. any pxls becomes below thre
2. the same peak was found as the maximum
mask_npxls: number of pixels to mask when Gaussian fitting failed
return poslist
"""
img = img.copy()
imgFit.fitFailedClear()
ndim = img.ndim
sigma_peak = imgFit._scalerToSeq(sigma_peak, ndim)
poses = []
vzyx = U.findMax(img)
while vzyx[0] > thre:
prev = vzyx
try:
ret, check = imgFit.fitGaussianND(img, vzyx[-ndim:], sigma_peak, win)
except IndexError: # too close to the edge
imgFit.fitFailedAppend("at %s" % str(vzyx[-ndim:]))
mask_value(img, vzyx[-ndim:], r=mask_npxls, value=img.min())
poses.append(list(vzyx)[0:1] + [vzyx[-ndim:]] + [list(sigma_peak)])
if check == 5:
imgFit.fitFailedAppend("at %s, %s, check=%i" % (str(vzyx[-ndim:]), str(ret), check))
mask_value(img, vzyx[-ndim:], r=mask_npxls, value=img.min())
poses.append(list(vzyx)[0:1] + [vzyx[-ndim:]] + [sigma_peak])
else:
v = ret[1]
zyx = ret[2:2+ndim]
if N.any(N.abs(zyx - vzyx[1:]) > win/2.):#zyx < 0 or zyx > img.shape or ):
mask_value(img, vzyx[-ndim:], r=mask_npxls, value=img.min())
poses.append(list(vzyx)[0:1] + [vzyx[-ndim:]] + [sigma_peak])
else:
sigma = ret[2+ndim:2+ndim*2]
mask_gaussianND(img, zyx, v, sigma)
poses.append([v,zyx,sigma])
vzyx = U.findMax(img)
if N.all(vzyx == prev):
break
return poses#, img
def cutOutCenter(arr, windowSize, sectWise=None, interpolate=True):
"""
windowSize: scalar (in pixel or as percent < 1.) or ((z,)y,x)
sectWise: conern only XY of windowSize
"""
shape = N.array(arr.shape)
center = shape / 2.
return pointsCutOutND(arr, [center], windowSize, sectWise, interpolate)[0]
def arr_histStretch(img, imgMin=None, imgMax=None, scaleMax=None):
"""
scaleMax = None: use maximum possible for the dtype
"""
if imgMin is None:
imgMin = img.min()
if imgMax is None:
imgMax = img.max()
if scaleMax is None:
img = N.asarray(img)
scaleMax = 1 << (img.nbytes // img.size) * 8
scaleMax -= 1
img = img - imgMin #img.min()
ratio = float(scaleMax) / imgMax #img.max()
return N.asarray(ratio * img, img.dtype.type)
def cutOutCenter(arr, windowSize, sectWise=None, interpolate=True):
"""
windowSize: scalar (in pixel or as percent < 1.) or ((z,)y,x)
sectWise: conern only XY of windowSize
"""
shape = N.array(arr.shape)
center = shape / 2.
return pointsCutOutND(arr, [center], windowSize, sectWise, interpolate)[0]
def psf__wPSF_yPolyInv(t, *parm):
"""
abs()
"""
if len(parm) == 1:
parm = parm[0]
r = psf__wPSF_yPolyInv_bare(t, parm)
return N.abs(r)
def centerOfMass(img, yx, window=5):
"""
find peak by center of mass in a 2D image
img: a 2D image array
yx: (y,x) in the image
window: a window where CM calculation is performed on
return yx
"""
# prepare small image
s = N.array([window, window])
c = s / 2.
yx = N.round_(yx)
yx -= c
yi, xi = N.indices(s)
yi += yx[0]
xi += yx[1]
cc = img[yi, xi]
# calculate center of mass
yxi = N.indices(s)
yxi *= cc
yxi = yxi.T
vv = N.sum(yxi, axis=0)
vv = N.sum(vv, axis=0)
yxs = vv / float(N.sum(cc))
yxs += yx
return yxs
def centerOfMass(img, yx, window=5):
"""
find peak by center of mass in a 2D image
img: a 2D image array
yx: (y,x) in the image
window: a window where CM calculation is performed on
return yx
"""
# prepare small image
s = N.array([window,window])
c = s/2.
yx = N.round_(yx)
yx -= c
yi, xi = N.indices(s)
yi += yx[0]
xi += yx[1]
cc = img[yi,xi]
# calculate center of mass
yxi = N.indices(s)
yxi *= cc
yxi = yxi.T
vv = N.sum(yxi, axis=0)
vv = N.sum(vv, axis=0)
yxs = vv / float(N.sum(cc))
yxs += yx
return yxs
