def fast_odf(self, s):
odf = np.zeros(self.odfn)
Eq = np.zeros((self.sz, self.sz, self.sz))
#for i in range(self.dn):
# Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
Eq[self.q[:, 0], self.q[:, 1], self.q[:, 2]] = s[:] / np.float(s[0])
#self.Eqs.append(Eq)
if self.operator == 'laplacian':
LEq = laplace(Eq)
sign = -1
if self.operator == 'laplap':
LEq = laplace(laplace(Eq))
sign = 1
if self.operator == 'signal':
LEq = Eq
sign = 1
#LEs=map_coordinates(LEq,self.Ys.T,order=1)
#"""
LEs = np.zeros(self.Ysn)
strides = np.array(LEq.strides, 'i8')
map_coordinates_trilinear_iso(LEq, self.Ys, strides, self.Ysn, LEs)
#LEs=map_coordinates(LEq,self.zoom*self.Ys,order=1)
LEs = LEs.reshape(self.odfn, self.radiusn)
LEs = LEs * self.radius
#LEs=LEs*self.radius*self.zoom
LEsum = np.sum(LEs, axis=1)
#This is what the following code is doing
#for i in xrange(self.odfn):
# odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
#odf2=odf.copy()
LES = LEsum[self.eqinds_com]
sum_on_blocks_1d(LES, self.eqinds_len, odf, self.odfn)
odf = odf / self.eqinds_len
return self.angular_weighting(sign * odf)
def fast_odf(self,s):
odf = np.zeros(self.odfn)
Eq=np.zeros((self.sz,self.sz,self.sz))
#for i in range(self.dn):
# Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
Eq[self.q[:,0],self.q[:,1],self.q[:,2]]=s[:]/np.float(s[0])
#self.Eqs.append(Eq)
if self.operator=='laplacian':
LEq=laplace(Eq)
sign=-1
if self.operator=='laplap':
LEq=laplace(laplace(Eq))
sign=1
if self.operator=='signal':
LEq=Eq
sign=1
#LEs=map_coordinates(LEq,self.Ys.T,order=1)
#"""
LEs=np.zeros(self.Ysn)
strides=np.array(LEq.strides,'i8')
map_coordinates_trilinear_iso(LEq,self.Ys,
strides,self.Ysn, LEs)
#LEs=map_coordinates(LEq,self.zoom*self.Ys,order=1)
LEs=LEs.reshape(self.odfn,self.radiusn)
LEs=LEs*self.radius
#LEs=LEs*self.radius*self.zoom
LEsum=np.sum(LEs,axis=1)
#This is what the following code is doing
#for i in xrange(self.odfn):
# odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
#odf2=odf.copy()
LES=LEsum[self.eqinds_com]
sum_on_blocks_1d(LES,self.eqinds_len,odf,self.odfn)
odf=odf/self.eqinds_len
return self.angular_weighting(sign*odf)
def processing():
"""processing the digital images"""
# original image, cat
cat = folder + 'cat.jpg'
image = cv2.imread(cat, 0)
frequency(image, output + 'cat_frequency.jpg')
image_padded = padding(image, output + 'cat_padded.jpg')
filter_derivative(image_padded, output + 'cat_derivative.jpg')
# overwrite for the quality
image_derivative = ned.laplace(image)
imageio.imwrite(output + 'cat_derivative.jpg', image_derivative)
image_sharpened = image - image_derivative
imageio.imwrite(output + 'cat_sharpened.jpg', image_sharpened)
# original image, triangle
triangle = folder + 'triangle.jpg'
image = cv2.imread(triangle, 0)
frequency(image, output + 'triangle_frequency.jpg')
image_padded = padding(image, output + 'triangle_padded.jpg')
filter_derivative(image_padded, output + 'triangle_derivative.jpg')
# overwrite for the quality
image_derivative = ned.laplace(image)
imageio.imwrite(output + 'triangle_derivative.jpg', image_derivative)
image_sharpened = image - image_derivative
imageio.imwrite(output + 'triangle_sharpened.jpg', image_sharpened)
return
def fast_odf(self,s):
odf = np.zeros(self.odfn)
Eq=np.zeros((self.sz,self.sz,self.sz))
#for i in range(self.dn):
# Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
Eq[self.q[:,0],self.q[:,1],self.q[:,2]]=s[:]/s[0]
if self.operator=='2laplacian':
LEq=self.eit_operator(Eq,2)
sign=-1
if self.operator=='laplacian':
LEq=laplace(Eq)
sign=-1
if self.operator=='laplap':
LEq=laplace(laplace(Eq))
sign=1
if self.operator=='signal':
LEq=Eq
sign=1
LEs=map_coordinates(LEq,self.Ys,order=1)
LEs=LEs.reshape(self.odfn,self.radiusn)
LEs=LEs*self.radius
LEsum=np.sum(LEs,axis=1)
#This is what the following code is doing
#for i in xrange(self.odfn):
# odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
#odf2=odf.copy()
LES=LEsum[self.eqinds_com]
sum_on_blocks_1d(LES,self.eqinds_len,odf,self.odfn)
odf=odf/self.eqinds_len
return sign*odf
def Solve_diff_eq_RK4(stimulus,lamda,t0,h,D,t_N):
"""
Finds a solution to the linear and spatially discrete diffusion equation:
df/dt = D*K(f) - s*delta(t-t0)
using the 4th order Runge-Kutta method (ignoring leakage currents). The
stimulus is inject at t0 and then the defined lamda value permits certain
diffusion behaviour to occur iteratively over this initial stimuli. The
result is a diffusion of the maximum and minimum values across the stimuli
to obtain a global value of luminance extremities through local interactions.
Parameters
---------------
stimulus : array_like input stimuli [x,y] "photo receptor activity elicited by
some real-world luminance distribution"
lamda : int a value between +/- inf
t0 : int point of stimulus "injection"
h : int Runga-kutta step size
N : int stimulus array size
D : int diffusion coefficient weights rate of diffusion [0<D<1]
Returns
----------------
f : array_like computed diffused array
"""
f = np.zeros((t_N+1,stimulus.shape[0],stimulus.shape[1])) #[time, equal shape space dimension]
t = np.zeros(t_N+1)
if lamda ==0:
""" Linearity Global Activity Preserved """
for n in np.arange(0,t_N,h):
k1 = D*flt.laplace(f[t[n],:,:]) + stimulus*Dirac_delta_test(t[n]-t0)
k1 = k1.astype(np.float64)
k2 = D*flt.laplace(f[t[n]+(h/2.),:,:]+(0.5*h*k1)) + stimulus*Dirac_delta_test((t[n]+(0.5*h))- t0)
k2 = k2.astype(np.float64)
k3 = D*flt.laplace(f[t[n]+(h/2.),:,:]+(0.5*h*k2)) + stimulus*Dirac_delta_test((t[n]+(0.5*h))-t0)
k3 = k3.astype(np.float64)
k4 = D*flt.laplace(f[t[n]+h,:,:]+(h*k3)) + stimulus*Dirac_delta_test((t[n]+h)-t0)
k4 = k4.astype(np.float64)
f[n+1,:,:] = f[n,:,:] + (h/6.) * (k1 + 2.*k2 + 2.*k3 + k4)
t[n+1] = t[n] + h
return f
else:
""" Non-Linearity (max/min syncytium) Global Activity Not Preserved """
for n in np.arange(0,t_N):
k1 = D*Diffusion_operator(lamda,f[t[n],:,:],t[n]) + stimulus*Dirac_delta_test(t[n]-t0)
k1 = k1.astype(np.float64)
k2 = D*Diffusion_operator(lamda,(f[t[n]+(h/2.),:,:]+(0.5*h*k1)),t[n]) + stimulus*Dirac_delta_test((t[n]+(0.5*h))- t0)
k2 = k2.astype(np.float64)
k3 = D*Diffusion_operator(lamda,(f[t[n]+(h/2.),:,:]+(0.5*h*k2)),t[n]) + stimulus*Dirac_delta_test((t[n]+(0.5*h))-t0)
k3 = k3.astype(np.float64)
k4 = D*Diffusion_operator(lamda,(f[t[n]+h,:,:]+(h*k3)),t[n]) + stimulus*Dirac_delta_test((t[n]+h)-t0)
k4 = k4.astype(np.float64)
f[n+1,:,:] = f[n,:,:] + (h/6.) * (k1 + 2.*k2 + 2.*k3 + k4)
t[n+1] = t[n] + h
return f
def fusion(im1,im2):
sigma_r = 5
average_filter_size=31
r_1=45
r_2=7
eps_1=0.3
eps_2=10e-6
if im1.max()>1:
im1=im1/255
if im2.max()>1:
im2=im2/255
im1_blue, im1_green, im1_red = cv2.split(im1)
im2_blue, im2_green, im2_red = cv2.split(im2)
base_layer1 = uniform_filter(im1, mode='reflect',size=average_filter_size)
b1_blue, b1_green, b1_red = cv2.split(base_layer1)
base_layer2 = uniform_filter(im2, mode='reflect',size=average_filter_size)
b2_blue, b2_green, b2_red = cv2.split(base_layer2)
detail_layer1 = im1 - base_layer1
d1_blue, d1_green, d1_red = cv2.split(detail_layer1)
detail_layer2 = im2 - base_layer2
d2_blue, d2_green, d2_red = cv2.split(detail_layer2)
saliency1 = gaussian_filter(abs(laplace(im1_blue+im1_green+im1_red,mode='reflect')),sigma_r,mode='reflect')
saliency2 = gaussian_filter(abs(laplace(im2_blue+im2_green+im2_red,mode='reflect')),sigma_r,mode='reflect')
mask = np.float32(np.argmax([saliency1, saliency2], axis=0))
im1=np.float32(im1)
im2=np.float32(im2)
g1r1 = guided_filter(1 - mask, im1[:,:,0], r_1, eps_1)+guided_filter(1 - mask, im1[:,:,1], r_1, eps_1)+guided_filter(1 - mask, im1[:,:,2], r_1, eps_1)
g2r1 = guided_filter(mask, im2[:,:,0], r_1, eps_1)+guided_filter(mask, im2[:,:,1], r_1, eps_1)+guided_filter(mask, im2[:,:,2], r_1, eps_1)
g1r2 = guided_filter(1 - mask, im1[:,:,0], r_2, eps_2)+ guided_filter(1 - mask, im1[:,:,1], r_2, eps_2)+ guided_filter(1 - mask, im1[:,:,2], r_2, eps_2)
g2r2 = guided_filter(mask, im2[:,:,0], r_2, eps_2)+ guided_filter(1 - mask, im2[:,:,1], r_2, eps_2)+ guided_filter(1 - mask, im2[:,:,2], r_2, eps_2)
fused_base1 = np.float32((b1_blue * (g1r1) + b2_blue * (g2r1))/((g1r1+g2r1)))
fused_detail1 = np.float32((d1_blue * (g1r2) + d2_blue * (g2r2))/((g1r2+g2r2)))
fused_base2 = np.float32((b1_green * g1r1 + b2_green * g2r1)/((g1r1+g2r1)))
fused_detail2 = np.float32((d1_green * (g1r2) + d2_green * (g2r2))/((g1r2+g2r2)))
fused_base3 = np.float32((b1_red * (g1r1) + b2_red * (g2r1))/((g1r1+g2r1)))
fused_detail3 = np.float32((d1_red * (g1r2) + d2_red * (g2r2))/((g1r2+g2r2)))
B1=np.float32(fused_base1+fused_detail1)
B2=np.float32(fused_base2+fused_detail2)
B3=np.float32(fused_base3+fused_detail3)
fusion1=np.float32(cv2.merge((B1, B2, B3)))
fusion1=fusion1/fusion1.max()
return fusion1
def _inpaint_biharmonic_single_channel(mask, out, limits):
# Initialize sparse matrices
matrix_unknown = sparse.lil_matrix((np.sum(mask), out.size))
matrix_known = sparse.lil_matrix((np.sum(mask), out.size))
# Find indexes of masked points in flatten array
mask_i = np.ravel_multi_index(np.where(mask), mask.shape)
# Find masked points and prepare them to be easily enumerate over
mask_pts = np.array(np.where(mask)).T
# Iterate over masked points
for mask_pt_n, mask_pt_idx in enumerate(mask_pts):
# Get bounded neighborhood of selected radius
b_lo, b_hi = _get_neighborhood(mask_pt_idx, 2, out.shape)
# Create biharmonic coefficients ndarray
neigh_coef = np.zeros(b_hi - b_lo)
neigh_coef[tuple(mask_pt_idx - b_lo)] = 1
neigh_coef = laplace(laplace(neigh_coef))
# Iterate over masked point's neighborhood
it_inner = np.nditer(neigh_coef, flags=['multi_index'])
for coef in it_inner:
if coef == 0:
continue
tmp_pt_idx = np.add(b_lo, it_inner.multi_index)
tmp_pt_i = np.ravel_multi_index(tmp_pt_idx, mask.shape)
if mask[tuple(tmp_pt_idx)]:
matrix_unknown[mask_pt_n, tmp_pt_i] = coef
else:
matrix_known[mask_pt_n, tmp_pt_i] = coef
# Prepare diagonal matrix
flat_diag_image = sparse.dia_matrix((out.flatten(), np.array([0])),
shape=(out.size, out.size))
# Calculate right hand side as a sum of known matrix's columns
matrix_known = matrix_known.tocsr()
rhs = -(matrix_known * flat_diag_image).sum(axis=1)
# Solve linear system for masked points
matrix_unknown = matrix_unknown[:, mask_i]
matrix_unknown = sparse.csr_matrix(matrix_unknown)
result = spsolve(matrix_unknown, rhs)
# Handle enormous values
result = np.clip(result, *limits)
result = result.ravel()
# Substitute masked points with inpainted versions
for mask_pt_n, mask_pt_idx in enumerate(mask_pts):
out[tuple(mask_pt_idx)] = result[mask_pt_n]
return out
def _inpaint_biharmonic_single_channel(mask, out, limits):
# Initialize sparse matrices
matrix_unknown = sparse.lil_matrix((np.sum(mask), out.size))
matrix_known = sparse.lil_matrix((np.sum(mask), out.size))
# Find indexes of masked points in flatten array
mask_i = np.ravel_multi_index(np.where(mask), mask.shape)
# Find masked points and prepare them to be easily enumerate over
mask_pts = np.array(np.where(mask)).T
# Iterate over masked points
for mask_pt_n, mask_pt_idx in enumerate(mask_pts):
# Get bounded neighborhood of selected radius
b_lo, b_hi = _get_neighborhood(mask_pt_idx, 2, out.shape)
# Create biharmonic coefficients ndarray
neigh_coef = np.zeros(b_hi - b_lo)
neigh_coef[tuple(mask_pt_idx - b_lo)] = 1
neigh_coef = laplace(laplace(neigh_coef))
# Iterate over masked point's neighborhood
it_inner = np.nditer(neigh_coef, flags=['multi_index'])
for coef in it_inner:
if coef == 0:
continue
tmp_pt_idx = np.add(b_lo, it_inner.multi_index)
tmp_pt_i = np.ravel_multi_index(tmp_pt_idx, mask.shape)
if mask[tuple(tmp_pt_idx)]:
matrix_unknown[mask_pt_n, tmp_pt_i] = coef
else:
matrix_known[mask_pt_n, tmp_pt_i] = coef
# Prepare diagonal matrix
flat_diag_image = sparse.dia_matrix((out.flatten(), np.array([0])),
shape=(out.size, out.size))
# Calculate right hand side as a sum of known matrix's columns
matrix_known = matrix_known.tocsr()
rhs = -(matrix_known * flat_diag_image).sum(axis=1)
# Solve linear system for masked points
matrix_unknown = matrix_unknown[:, mask_i]
matrix_unknown = sparse.csr_matrix(matrix_unknown)
result = spsolve(matrix_unknown, rhs)
# Handle enormous values
result = np.clip(result, *limits)
result = result.ravel()
# Substitute masked points with inpainted versions
for mask_pt_n, mask_pt_idx in enumerate(mask_pts):
out[tuple(mask_pt_idx)] = result[mask_pt_n]
return out
def cplxlaplacian_filter(real_input, imag_input, mode_='reflect', cval_=0.0):
"""CPLXFILTER apply scipy's laplace filter to complex 3D image
filtered_image = cplxlaplacian_filter(realimg, imagimg)
:param mode: {'reflect', 'constant', 'nearest', 'mirror', 'wrap'},
optional. The mode parameter determines how the array borders are handled,
where cval is the value when mode is equal to 'constant'. Default is
'reflect'
:param cval: [optional] Value to fill past edges of input if mode is
'constant'. Default is 0.0
:return filtered_image: complex 3D array of gaussian laplace filtered
image,
scipy.ndimage.filters.laplace
scipy.ndimage.filters.laplace(input, output=None, mode='reflect',
cval=0.0)[source] N-dimensional Laplace filter based on approximate second
derivatives.
Parameters:
input : array_like
Input array to filter.
output : array, optional
The output parameter passes an array in which to store the filter output.
mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
The mode parameter determines how the array borders are handled, where cval
is the value when mode is equal to 'constant'. Default is 'reflect' cval :
scalar, optional Value to fill past edges of input if mode is
'constant'. Default is 0.0
"""
print "Complex Gaussian_laplace filter ", " mode ", mode_
if real_input.ndim == 3:
real_img = laplace(real_input, mode=mode_, cval=cval_)
imag_img = laplace(imag_input, mode=mode_, cval=cval_)
else:
real_img = np.empty_like(real_input, dtype=np.float32)
imag_img = np.empty_like(real_input, dtype=np.float32)
for echo in xrange(0, real_input.shape[4]):
for acq in xrange(0, real_input.shape[3]):
real_img[:, :, :, acq, echo] = laplace(real_input[:, :, :, acq,
echo],
mode=mode_,
cval=cval_)
imag_img[:, :, :, acq, echo] = laplace(imag_input[:, :, :, acq,
echo],
mode=mode_,
cval=cval_)
filtered_image = np.empty_like(real_input, dtype=np.complex64)
filtered_image.real = real_img
filtered_image.imag = imag_img
return filtered_image
def gvf(f,
mu=0.05,
iterations=30,
anisotropic=False,
ignore_second_term=False):
# Gradient vector flow
# Translated from https://github.com/smistad/3D-Gradient-Vector-Flow-for-Matlab
f = (f - f.min()) / (f.max() - f.min())
f = enforce_mirror_boundary(
f) # Enforce the mirror conditions on the boundary
dx, dy, dz = np.gradient(f) # Initialse with normal gradients
'''
Initialise the GVF vectors following S3 in
Yu, Zeyun, and Chandrajit Bajaj.
"A segmentation-free approach for skeletonization of gray-scale images via anisotropic vector diffusion."
CVPR, 2004. CVPR 2004.
It only uses one of the surronding neighbours with the lowest intensity
'''
# dx, dy, dz = distgradient(f)
magsq = dx**2 + dy**2 + dz**2
# Set up the initial vector field
u = dx.copy()
v = dy.copy()
w = dz.copy()
bar = progressbar.ProgressBar(max_value=iterations)
for i in range(iterations):
bar.update(i + 1)
# The boundary might not matter here
# u = enforce_mirror_boundary(u)
# v = enforce_mirror_boundary(v)
# w = enforce_mirror_boundary(w)
# Update the vector field
if anisotropic:
G = g_all(u, v, w)
u += mu / 6. * div(np.sum(G * d(u), axis=0))
v += mu / 6. * div(np.sum(G * d(v), axis=0))
w += mu / 6. * div(np.sum(G * d(w), axis=0))
else:
u += mu * 6 * laplace(u)
v += mu * 6 * laplace(v)
w += mu * 6 * laplace(w)
if not ignore_second_term:
u -= (u - dx) * magsq
v -= (v - dy) * magsq
w -= (w - dz) * magsq
return np.stack((u, v, w), axis=0)
def _get_neigh_coef(shape, center, dtype=float):
# Create biharmonic coefficients ndarray
neigh_coef = np.zeros(shape, dtype=dtype)
neigh_coef[center] = 1
neigh_coef = laplace(laplace(neigh_coef))
# extract non-zero locations and values
coef_idx = np.where(neigh_coef)
coef_vals = neigh_coef[coef_idx]
coef_idx = np.stack(coef_idx, axis=0)
return neigh_coef, coef_idx, coef_vals
def harris(im):
'''
gauss1d_k = numpy.array(gen_gauss1d_k([-1, 0, 1], 1))
res1 = numpy.zeros(im.shape, dtype=numpy.uint8)
for i in range(im.shape[0]):
for j in range(im.shape[1]):
if j >= (len(gauss1d_k)//2) and j <= (im.shape[1] - len(gauss1d_k)//2 - 1):#Skipping the border pixels
res1[i][j] = int(sum(im[i][j-len(gauss1d_k)//2:j+1+len(gauss1d_k)//2]*gauss1d_k))
else: # copying the border pixels of the original image as it is
res1[i][j] = im[i][j]
'''
Gim = gaussian_filter(im, 1.5)
print Gim
derx = numpy.array([[-1, 0, 1], [-1, 0, 1],
[-1, 0, 1]]) #derivative filter in X direction
dery = derx.transpose() # derivative filter on y component
Ix = cv2.filter2D(im, -1, derx) # Derivative of X component of Image
Iy = cv2.filter2D(im, -1, dery)
Ixy = cv2.filter2D(im, -1, dery)
Lx = laplace(Ix)
Ly = laplace(Iy)
Lxy = laplace(Ixy)
alpha = 0.04
R = numpy.empty(im.shape)
res = cv2.cvtColor(im, cv2.COLOR_GRAY2RGB)
for i in range(im.shape[0]):
for j in range(im.shape[1]):
h2 = numpy.matrix([[Lx[i, j] * Lx[i, j], Lxy[i, j]],
[Lxy[i, j], Ly[i, j] * Ly[i, j]]])
R[i, j] = numpy.linalg.det(h2) - (alpha * numpy.trace(h2))
th = numpy.max(R * 0.99)
for i in range(im.shape[0]):
for j in range(im.shape[1]):
if R[i, j] > th:
res[i, j] = [0, 0, 255]
cv2.imshow("Gim", Gim)
cv2.waitKey(0)
cv2.imshow("Ix", Ix)
cv2.waitKey(0)
cv2.imshow("Iy", Iy)
cv2.waitKey(0)
cv2.imshow("Lx", Lx)
cv2.waitKey(0)
cv2.imshow("Ly", Ly)
cv2.waitKey(0)
cv2.imshow("Lxy", Lxy)
cv2.waitKey(0)
cv2.imshow("res", res)
cv2.waitKey(0)
def create_GVF(f, mu, count, dt):
u = np.zeros_like(f)
v = np.zeros_like(f)
fy, fx = np.gradient(f)
b = fx**2 + fy**2
c1 = b * fx
c2 = b * fy
for i in range(count):
Delta_u = laplace(u, mode="constant")
Delta_v = laplace(v, mode="constant")
u = (1 - b * dt) * u + (mu * Delta_u + c1) * dt
v = (1 - b * dt) * v + (mu * Delta_v + c2) * dt
return u, v
def generate_stencials():
stencils = []
for i in range(5):
for j in range(5):
A = np.zeros((5, 5))
A[i, j] = 1
S = laplace(laplace(A))
x_range = np.array([i - 2, i + 3]).clip(0, 5)
y_range = np.array([j - 2, j + 3]).clip(0, 5)
S = S[x_range[0]:x_range[1], y_range[0]:y_range[1]]
stencils.append(S)
return stencils
def _calculate_media(self, check_start=40, check_interval_growth=5):
check_interval = check_interval_growth
limiting = max(self.spec.uptake_rate, self.spec.diffusion_constant)
dt = 1.0/(4*limiting)
cells = self._narrow_cells()
boundary = self._make_boundary_layer(cells)
media = np.ones_like(cells, np.float32)*self.spec.media_concentration
# guess a linear solution for faster convergence
heights = utils.compute_heights(np.logical_not(boundary))
for col, height in enumerate(heights):
if height == 0: continue
media[:height, col] = np.linspace(0, self.spec.media_concentration,
height)
media_next = np.empty_like(media)
# def error_handler(type, flag):
# if type == "underflow": return
# np.seterr(all='warn')
# print "Floating point error (%s), with flag %s" % (type, flag)
# print dt, self.spec.diffusion_constant, self.spec.uptake_rate
# print self.spec.media_concentration
# from matplotlib import pyplot as plt
# plt.figure(); plt.imshow(media); plt.colorbar()
# plt.figure(); plt.imshow(media_next); plt.colorbar()
# plt.figure(); plt.imshow(boundary); plt.colorbar()
# plt.figure(); plt.imshow(cells); plt.colorbar()
# plt.show()
# print step
# raise Exception()
# np.seterrcall(error_handler)
# np.seterr(all='call')
for step in range(self.spec.max_diffusion_iterations):
laplace(media, output=media_next)
media_next *= self.spec.diffusion_constant*dt
media_next += media
media_next[cells] *= 1 - self.spec.uptake_rate*dt
media_next[boundary] = self.spec.media_concentration
media, media_next = media_next, media
if step >= check_start and step%check_interval == 0:
media_next -= media
np.abs(media_next, out=media_next)
error = media_next.sum()/(dt*media_next.size)
if error <= self.spec.diffusion_tol: break
check_interval += check_interval_growth
self.media = media
def diffuse(cells=None, boundary=None, d=1.0, uptake=0.1, num_steps=1000):
dt = 1.0/(4*d)
u = 1.0*boundary
# dx = dy = 1
u_next = np.empty_like(u)
storage = np.empty_like(u)
for _ in range(num_steps):
laplace(u, output=storage)
u_next = u + d*dt*storage
u_next[cells] *= 1 - uptake*dt
u_next[boundary] = 1.0
u, u_next = u_next, u
return u
def errfun(coords, src, target, reg): coords = np.array(coords) coords = coords.reshape((2,) + src.shape) mask = gen_mask(src.shape) offset = coords + np.meshgrid(range(src.shape[0]), range(src.shape[1]), indexing='ij') warped = map_coordinates(src, offset) laplace_sum = np.sum(filters.laplace(coords[0])**2 + filters.laplace(coords[1])**2) match_sum = np.sum((warped - target)[mask]**2) return match_sum + reg*laplace_sum
def level_set_evolution(self):
self.public_data()
for i in range(self.iter_num):
# Neumann Boundary Condition
self.neum_bound_cond()
# dirac
dirac_phi = self.dirac()
# local binary fit
f1, f2 = self.local_bin_fit()
# data force
lbf = self.data_force(f1, f2)
# curvature central
curv = self.curvature_central()
# each item
area_term = -dirac_phi * lbf
len_term = self.nu * dirac_phi * curv
laplace_operator_phi = filters.laplace(
self.phi) # self.phi laplace operator
penalty = self.mu * (laplace_operator_phi - curv)
self.phi = self.phi + self.time_step * (area_term + penalty +
len_term)
# binary phi and then return
rtn_phi = np.uint8(self.phi > 0)
return rtn_phi * 255
def get_sharpness(img, sigma=10):
blurred = gaussian_filter(img, sigma)
#sharp = np.absolute(img - blurred)
#TAKE THE LOG (laplacian of a guassian) INSTEAD
sharp = np.absolute(laplace(blurred))
return sharp
def scale_space_transform(image, sigmas):
from scipy.ndimage.filters import gaussian_filter, gaussian_laplace, laplace
size = np.array(image.shape)
spacing = np.array(image.voxelsize)
scale_space = np.zeros((len(sigmas), size[0], size[1], size[2]),
dtype=float)
for i in xrange(len(sigmas)):
print "Sigma : ", np.exp(spacing * sigmas[i])
if i == 0:
previous_gaussian_img = gaussian_filter(image,
sigma=np.exp(spacing *
sigmas[i]),
order=0)
else:
gaussian_img = gaussian_filter(np.array(image, np.float64),
sigma=np.exp(spacing * sigmas[i]),
order=0)
laplace_img = laplace(gaussian_img)
scale_space[i, :, :, :] = laplace_img
# scale_space[i, : , : , : ] = gaussian_img
previous_gaussian_img = gaussian_img
return scale_space
def main(argv):
try:
file = argv[0]
except:
usage()
sys.exit(1)
g_name = 'unwrapPhase'
g_name_out = 'unwrapPhase_laplace'
print('calculate Laplace filter of {} based on approximate second derivatives.'.format(g_name))
f = h5py.File(file, 'a')
ds = f[g_name]
if g_name_out in f.keys():
ds_out = f[g_name_out]
else:
ds_out = f.create_dataset(g_name_out, shape=ds.shape, dtype=np.float32, chunks=True, compression=None)
print('write to dataset /{}'.format(g_name_out))
num_ifgram = ds.shape[0]
prog_bar = ptime.progressBar(maxValue=num_ifgram)
for i in range(num_ifgram):
unw = ds[i, :, :]
ds_out[i, :, :] = laplace(unw)
prog_bar.update(i+1, suffix='{}/{}'.format(i+1, num_ifgram))
prog_bar.close()
f.close()
print('finished writing to {}'.format(file))
return
def load_and_getDelSq(path_base):
i = 1
max_DelSq = 0
ind = 0
arr = []
while True:
from_path = os.path.join(path_base, path_base + "-" + get_str_from_number(i) + ".jpg")
# from_path = path_base + "/" + str(i) + ".png"
try:
img = plt.imread(from_path)
arr.append(img)
ds = np.sum(laplace(img[:, :, 0]) ** 2)
if ds > max_DelSq:
max_DelSq = ds
ind = i
i += 1
except (FileNotFoundError, OSError):
break
if ind > 25:
ind = 25
arr = np.array(arr)
##
if arr.shape == (0,):
print("IT'S GOING WRONG UP HERE THIS IS IT: ")
print(path_base)
##
return arr, ind
def _apply_laplacian(nx, ny, alpha, image):
""" Apply isotropic Laplacian to an image.
Parameters
----------
nx, ny: int
Dimensions of 2D image
alpha: float
Diffusion parameter
image: ndarray, ndim=1
Image as a 1D vector
Returns
-------
output: ndarray, ndim=2
Image after application of Laplacian
"""
# reshape
n = len(image)
image = image.reshape((ny, nx))
output = image - alpha * laplace(image)
output = output.reshape(n)
return output
def drlse_edge(self, phi):
[vy, vx] = np.gradient(self.F)
for k in range(self.iter):
phi = self.applyNeumann(phi)
[phi_y, phi_x] = np.gradient(phi)
s = np.sqrt(np.square(phi_x) + np.square(phi_y))
smallNumber = 1e-10
Nx = phi_x / (s + smallNumber)
Ny = phi_y / (s + smallNumber)
curvature = self.div(Nx, Ny)
if self.potential_function == 'single-well':
distRegTerm = filters.laplace(phi, mode='wrap') - curvature
elif self.potential_function == 'double-well':
distRegTerm = self.distReg_p2(phi)
else:
print(
'Error: Wrong choice of potential function. Please input the string "single-well" or "double-well" in the drlse_edge function.'
)
diracPhi = self.Dirac(phi)
areaTerm = diracPhi * self.F
edgeTerm = diracPhi * (vx * Nx +
vy * Ny) + diracPhi * self.F * curvature
x = (self.F1 - self.M2) / (self.M1 - self.M2)
leakproofterm = self.F * areaTerm * self.sigmoid(x)
y = self.dt * (self.mu * distRegTerm + self.lamda * edgeTerm +
self.alpha * areaTerm - leakproofterm * self.alpha)
#print(np.unique(y))
phi = phi + self.dt * (
self.mu * distRegTerm + self.lamda * edgeTerm +
self.alpha * areaTerm - leakproofterm * self.alpha)
return phi
def medial(image):
"""Creates a medial axis transform image
Args
----
image: ndarray
The image of which the medial axis is to be calculated.
This should be a binary image.
visualise: bool
Option to visualise the medial axis transform.
Returns
-------
out: ndarray
A boolean image with the medial axis pixels
"""
# Remove noise and make sure it's thresholded
im = thresholds(image)
# Calculate distance to all border pixels for each non-border pixel
dist = distance_transform_edt(im)
# Calculate laplacian
lap = laplace(dist, mode="constant")
# Select items that are maximums and therefore less than 0
out = lap < 0
# Mask all items that are outside the boundaries
# using the original image
resultImage = np.logical_and(np.logical_not(out), im )
return dist, lap, resultImage
def main(argv):
try:
file = argv[0]
except:
usage()
sys.exit(1)
g_name = 'unwrapPhase'
g_name_out = 'unwrapPhase_laplace'
print('calculate Laplace filter of {} based on approximate second derivatives.'.format(g_name))
f = h5py.File(file, 'a')
ds = f[g_name]
if g_name_out in f.keys():
ds_out = f[g_name_out]
else:
ds_out = f.create_dataset(g_name_out, shape=ds.shape, dtype=np.float32, chunks=True, compression=None)
print('write to dataset /{}'.format(g_name_out))
num_ifgram = ds.shape[0]
prog_bar = ptime.progressBar(maxValue=num_ifgram)
for i in range(num_ifgram):
unw = ds[i, :, :]
ds_out[i, :, :] = laplace(unw)
prog_bar.update(i+1, suffix='{}/{}'.format(i+1, num_ifgram))
prog_bar.close()
f.close()
print('finished writing to {}'.format(file))
return
def test_laplacian(self):
laplacian_ref = laplace(self.image)
# Laplacian = div(grad)
self.la.gradient(self.image)
laplacian_ocl = self.la.divergence(self.la.d_gradient,
return_to_host=True)
self.compare(laplacian_ocl, laplacian_ref, 1e-6, "laplacian")
def sciPyLaplacian(self, print_out=True):
"""tests the laplacian function against expected values"""
passed = True
a = self.a1 # shortcut
test = [
[(1, 1), np.asarray([0., 0.]).sum()], # 11
[(3, 3), np.asarray([-40., -4.]).sum()], # 44
[(4, 4), np.asarray([40., 4.]).sum()], # 11
[(3, 4), np.asarray([-40., 4.]).sum()], # 41
[(4, 3), np.asarray([40., -4.]).sum()], # 14
[(2, 3), np.asarray([0., -4.]).sum()]
] # 34
store = []
for pos, act in test: # iterate test values
res = laplace(a, mode='wrap').view(Periodic_Lattice)[pos]
passed *= (res == act).all()
if print_out: store.append([pos, res, act])
if print_out:
utils.display('SciPy Laplacian',
outcome=passed,
details={
'checked vs. known values (Mathematica)': [
'pos: {}, res: {}, act: {}'.format(*vals)
for vals in store
]
})
return passed
def downsample_f(pop_size,mu,s,m,num_intervals,dims,out):
output = np.zeros(tuple([num_intervals])+dims)
if s > 0:
interval = int(1/s)
else:
interval = 100
num_gens = interval * num_intervals
f = np.zeros(dims)
f[tuple(np.array(f.shape)-1)] = 1/pop_size
## pre-allocate list of when reset happens
reset_gens = []
for i in range(num_gens):
## update frequencies:
## Wright-Fisher diffusion w/Stepping Stone migration
df = mu*(1-2*f)-s*f*(1-f) \
+m*laplace(f,mode='wrap')
## bounds allele frequencies
p = np.clip(a= f + df ,a_min=0,a_max=1)
## genetic drift sampling
new_f = np.random.binomial(pop_size,p)/pop_size
## Check for implicit mu simulation and extinct allele
if mu==0 and np.all(new_f==0):
## if extinct, store previous freqs and reset
reset_gens.append(i)
## Add 1 allele to single element of
## an artbitrarily sized array
new_f[tuple(np.array(new_f.shape)-1)] = 1/pop_size
## Assign next frequencies
f = new_f
## choose freqs every 1/s and before reset happens
if (i + 1) % interval == 0:
output[i//interval] = f
# Write freqmat as .npy
np.save(out,output)
def drlse_region_interaction(phi_0, I, P, lmda, mu, alfa, beta, epsilon,
timestep, iters,
potentialFunction): # Updated Level Set Function
"""
:param phi_0: level set function to be updated by level set evolution
:param I: the input image to be segmented
:param P: the probability of being foreground, based on user interaction
:param lmda: weight of the weighted length term
:param mu: weight of distance regularization term
:param alfa: weight of the weighted area term
:param beta: weight of user interaction term
:param epsilon: width of Dirac Delta function
:param timestep: time step
:param iters: number of iterations
:param potentialFunction: choice of potential function in distance regularization term.
% As mentioned in the above paper, two choices are provided: potentialFunction='single-well' or
% potentialFunction='double-well', which correspond to the potential functions p1 (single-well)
% and p2 (double-well), respectively.
"""
phi = phi_0.copy()
# lu = (P - 0.5)*(P - 0.5)*(P - )
lu = np.log(P) - np.log(1.0 - P)
# [vy, vx] = np.gradient(g)
for k in range(iters):
phi = NeumannBoundCond(phi)
[phi_y, phi_x] = np.gradient(phi)
s = np.sqrt(np.square(phi_x) + np.square(phi_y))
smallNumber = 1e-10
Nx = phi_x / (
s + smallNumber
) # add a small positive number to avoid division by zero
Ny = phi_y / (s + smallNumber)
curvature = div(Nx, Ny)
if potentialFunction == 'single-well':
distRegTerm = filters.laplace(
phi, mode='wrap'
) - curvature # compute distance regularization term in equation (13) with the single-well potential p1.
elif potentialFunction == 'double-well':
distRegTerm = distReg_p2(
phi
) # compute the distance regularization term in eqaution (13) with the double-well potential p2.
else:
print(
'Error: Wrong choice of potential function. Please input the string "single-well" or "double-well" in the drlse_edge function.'
)
diracPhi = Dirac(phi, epsilon)
# areaTerm = diracPhi * g # balloon/pressure force
# edgeTerm = diracPhi * (vx * Nx + vy * Ny) + diracPhi * g * curvature
mean_in = I[phi > 0].mean()
mean_out = I[phi < 0].mean()
areaTerm = np.square(I - mean_in) - np.square(I - mean_out)
areaTerm = diracPhi * (areaTerm / abs(areaTerm.max()))
edgeTerm = diracPhi * curvature
phi = phi + timestep * (mu * distRegTerm + lmda * edgeTerm -
alfa * areaTerm + beta * lu)
return phi
def compute_accelerations(current_acceleration, current_velocities,
current_positions, simulation_parameters, forcers,
time, edge_conditions, edge_value):
# First Laplace * E
filters.laplace(current_positions, current_acceleration, edge_conditions,
edge_value)
current_acceleration *= simulation_parameters[0, :, :]
# Then -B * V
current_acceleration -= current_velocities * simulation_parameters[2, :, :]
# Then forcers forces
for forcer in forcers:
current_acceleration[forcer.position_y,
forcer.position_x] += forcer(time)
current_acceleration *= simulation_parameters[1, :, :]
def _remove_dup_laplace(self, data, mask, size=5):
laplacian = np.multiply(laplace(data, mode='wrap'), mask)
return generic_filter(laplacian,
self._local_max_laplace,
size=size,
mode='wrap',
extra_keywords={'size': size})
def fast_odf(self,s):
odf = np.zeros(self.odfn)
Eq=np.zeros((self.sz,self.sz,self.sz))
#for i in range(self.dn):
# Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
Eq[self.q[:,0],self.q[:,1],self.q[:,2]]=s[:]/s[0]
#self.Eqs.append(Eq)
if self.operator=='2laplacian':
LEq=self.eit_operator(Eq,2)
sign=-1
if self.operator=='laplacian':
#ZEq=zoom(Eq,zoom=5,order=self.order,mode=self.mode,cval=0.0,prefilter=True)
#self.ZEqs.append(ZEq)
#ZLEq=laplace(ZEq)
#self.ZLEqs.append(ZLEq)
#LEq=zoom(ZLEq,zoom=.2,order=self.order,mode=self.mode,cval=0.0,prefilter=True)
#LEq=laplace(Eq)
#if self.zoom>1:
# ZEq=zoom(Eq,zoom=self.zoom,order=self.order,mode=self.mode)
# LEq=laplace(ZEq)
#else:
LEq=laplace(Eq)
sign=-1
if self.operator=='laplap':
LEq=laplace(laplace(Eq))
sign=1
if self.operator=='signal':
LEq=Eq
sign=1
LEs=map_coordinates(LEq,self.Ys,order=1)
#LEs=map_coordinates(LEq,self.zoom*self.Ys,order=1)
LEs=LEs.reshape(self.odfn,self.radiusn)
LEs=LEs*self.radius
#LEs=LEs*self.radius*self.zoom
LEsum=np.sum(LEs,axis=1)
#This is what the following code is doing
#for i in xrange(self.odfn):
# odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
#odf2=odf.copy()
LES=LEsum[self.eqinds_com]
sum_on_blocks_1d(LES,self.eqinds_len,odf,self.odfn)
odf=odf/self.eqinds_len
return sign*odf
def fast_odf(self, s):
odf = np.zeros(self.odfn)
Eq = np.zeros((self.sz, self.sz, self.sz))
#for i in range(self.dn):
# Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
Eq[self.q[:, 0], self.q[:, 1], self.q[:, 2]] = s[:] / s[0]
#self.Eqs.append(Eq)
if self.operator == '2laplacian':
LEq = self.eit_operator(Eq, 2)
sign = -1
if self.operator == 'laplacian':
#ZEq=zoom(Eq,zoom=5,order=self.order,mode=self.mode,cval=0.0,prefilter=True)
#self.ZEqs.append(ZEq)
#ZLEq=laplace(ZEq)
#self.ZLEqs.append(ZLEq)
#LEq=zoom(ZLEq,zoom=.2,order=self.order,mode=self.mode,cval=0.0,prefilter=True)
#LEq=laplace(Eq)
#if self.zoom>1:
# ZEq=zoom(Eq,zoom=self.zoom,order=self.order,mode=self.mode)
# LEq=laplace(ZEq)
#else:
LEq = laplace(Eq)
sign = -1
if self.operator == 'laplap':
LEq = laplace(laplace(Eq))
sign = 1
if self.operator == 'signal':
LEq = Eq
sign = 1
LEs = map_coordinates(LEq, self.Ys, order=1)
#LEs=map_coordinates(LEq,self.zoom*self.Ys,order=1)
LEs = LEs.reshape(self.odfn, self.radiusn)
LEs = LEs * self.radius
#LEs=LEs*self.radius*self.zoom
LEsum = np.sum(LEs, axis=1)
#This is what the following code is doing
#for i in xrange(self.odfn):
# odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
#odf2=odf.copy()
LES = LEsum[self.eqinds_com]
sum_on_blocks_1d(LES, self.eqinds_len, odf, self.odfn)
odf = odf / self.eqinds_len
return sign * odf
def get_focus_measure(src, kind):
if not isinstance(src, ndarray):
src = asarray(src)
dst = laplace(src.astype(float))
d = dst.flatten()
d = percentile(d, 99)
return d.mean()
def update(self):
self.t += self.dt
self.current, self.previous = 2 * self.current - self.previous + laplace(
self.current) * (self.c * self.dt / self.ds)**2, self.current
# b = 1.
# self.current, self.previous = (2 * self.current - (1 - b / 2 * self.dt) * self.previous + laplace(
# self.current) * (self.c * self.dt / self.ds) ** 2) / (1 + b / 2 * self.dt), self.current
self.boundary_conditions(self.current)
def errfun(coords, src, target, reg):
coords = np.array(coords)
coords = coords.reshape((2, ) + src.shape)
mask = gen_mask(src.shape)
offset = coords + np.meshgrid(
range(src.shape[0]), range(src.shape[1]), indexing='ij')
warped = map_coordinates(src, offset)
laplace_sum = np.sum(
filters.laplace(coords[0])**2 + filters.laplace(coords[1])**2)
match_sum = np.sum((warped - target)[mask]**2)
return match_sum + reg * laplace_sum
def update(self):
self.t += self.dt
self.current, self.previous = 2 * self.current - self.previous + laplace(self.current) * (
self.c * self.dt / self.ds) ** 2, self.current
# b = 1.
# self.current, self.previous = (2 * self.current - (1 - b / 2 * self.dt) * self.previous + laplace(
# self.current) * (self.c * self.dt / self.ds) ** 2) / (1 + b / 2 * self.dt), self.current
self.boundary_conditions(self.current)
def get_laplacian_img(img,pool_size,padding='SAME'):
#Convert image to greyscale.
img = tf.image.rgb_to_grayscale(img)
pool = tf.nn.max_pool(img, ksize=[1,pool_size,pool_size,1], strides=[1,pool_size,pool_size,1], padding=padding)
return np.squeeze(laplace(pool))
def get_focus_measure(src, kind):
if not isinstance(src, ndarray):
src = asarray(src)
dst = laplace(src.astype(float))
d = dst.flatten()
d = percentile(d, 99)
return d.mean()
def Laplacian2d(d, boxsize=None):
l = sft.laplace(d)
if boxsize == None:
dl = 1.
else:
dl = boxsize / d.shape[0]
return l / dl**2.
def distReg_p2(self, phi):
[phi_y, phi_x] = np.gradient(phi)
s = np.sqrt(np.square(phi_x) + np.square(phi_y))
a = (s >= 0) & (s <= 1)
b = (s > 1)
ps = a * np.sin(2 * np.pi * s) / (2 * np.pi) + b * (s - 1)
dps = ((ps != 0) * ps + (ps == 0)) / ((s != 0) * s + (s == 0))
return self.div(dps * phi_x - phi_x, dps * phi_y -
phi_y) + filters.laplace(phi, mode='wrap')
def errfun_derivs(coords, src, target, reg): coords = coords.reshape((2,) + src.shape) offset = coords + np.meshgrid(range(src.shape[0]), range(src.shape[1]), indexing='ij') warped = map_coordinates(src, offset) diff_im = warped - target grad_im = np.gradient(src) grad_warped = np.zeros((2,) + src.shape) laplacian = np.empty(coords.shape) laplacian[0] = filters.laplace(coords[0]) laplacian[1] = filters.laplace(coords[1]) laplacian_deriv = -11.3*laplacian mask = gen_mask(src.shape) for i in range(2): grad_warped[i] = map_coordinates(grad_im[i], offset) match_deriv = 0.1*4*grad_warped*diff_im*mask return (match_deriv + laplacian_deriv*reg).flatten()
def main(argv):
try:
file=argv[0]
except:
Usage();sys.exit(1)
h5file=h5py.File(file,'r')
kh5=h5file.keys()
# if 'interferograms' in kh5:
ifgramList=h5file['interferograms'].keys()
# Igram_with_minBase=ifgramList[0]
# for ifgram in ifgramList:
# Baseline = float(h5file['interferograms'][ifgram].attrs['P_BASELINE_BOTTOM_HDR'])
#
# if abs(Baseline) <float(h5file['interferograms'][Igram_with_minBase].attrs['P_BASELINE_BOTTOM_HDR']):
# Igram_with_minBase=ifgram
#
# print Igram_with_minBase
try:
OutName=argv[1]
except:
OutName='Laplacian.h5'
h5laplace=h5py.File(OutName,'w')
group=h5laplace.create_group('interferograms')
print 'Calculating the Discrete Laplacian Transform'
for ifgram in ifgramList:
print ifgram
dset=h5file['interferograms'][ifgram].get(ifgram)
unw=dset[0:dset.shape[0],0:dset.shape[1]]
Lunw=laplace(unw)
g=group.create_group(ifgram)
g.create_dataset(ifgram,data=Lunw,compression='gzip')
for key, value in h5file['interferograms'][ifgram].attrs.iteritems():
g.attrs[key] = value
gm = h5laplace.create_group('mask')
mask = h5file['mask'].get('mask')
dset = gm.create_dataset('mask', data=mask, compression='gzip')
try:
meanCoherence = h5file['meanCoherence'].get('meanCoherence')
gc = h5laplace.create_group('meanCoherence')
dset = gc.create_dataset('meanCoherence', data=meanCoherence, compression='gzip')
except:
print ''
print 'DONE!'
def diffuse_check(cells=None, boundary=None, d=1.0, uptake=0.1, tol=1e-4, max_steps=5000,
check_start=40):
check_interval = 10
dt = 1.0/(4*d)
u = 1.0*boundary
# dx = dy = 1
u_next = np.empty_like(u)
storage = np.empty_like(u)
for step in range(max_steps):
laplace(u, output=storage)
u_next = u + d*dt*storage
u_next[cells] *= 1 - uptake*dt
u_next[boundary] = 1.0
u, u_next = u_next, u
if step >= check_start and step%check_interval == 0:
error = np.abs(u_next-u).sum()/(dt*u.size)
if error <= tol: break
check_interval += 5
return u, step
def fast_odf(self,s):
odf = np.zeros(self.odfn)
Eq=np.zeros((self.sz,self.sz,self.sz))
for i in xrange(self.dn):
Eq[self.q[i][0],self.q[i][1],self.q[i][2]]+=s[i]/s[0]
LEq=laplace(Eq)
LEs=map_coordinates(LEq,self.Ys.T,order=1)
LEs=LEs.reshape(self.odfn,self.radiusn)
LEs=LEs*self.radius
LEsum=np.sum(LEs,axis=1)
for i in xrange(self.odfn):
odf[i]=np.sum(LEsum[self.eqinds[i]])/self.eqinds_len[i]
return -odf
def slow_odf(self,s):
""" Calculate the orientation distribution function
"""
odf = np.zeros(self.odfn)
Eq=np.zeros((self.sz,self.sz,self.sz))
for i in range(self.dn):
Eq[self.q[i][0],self.q[i][1],self.q[i][2]]=s[i]/np.float(s[0])
LEq=laplace(Eq)
self.Eq=Eq
self.LEq=LEq
LEs=map_coordinates(LEq,self.Xs,order=1)
le_to_odf(odf,LEs,self.radius,self.odfn,self.radiusn,self.equatorn)
return odf
def get_focus_measure(src, kind):
if not isinstance(src, ndarray):
src = asarray(src)
# w, h = GetSize(pychron)
# dst = CreateMat(w, h, CV_16SC1)
# Laplace(pychron, dst)
# d = asarray(dst).flatten()
dst = laplace(src.astype(float))
d = dst.flatten()
d = percentile(d, 99)
return d.mean()
def GVF(f, mu, ITER):
f = f.astype('float')
# height, width = f.shape[0], f.shape[1]
# fmin = f.min()
# fmax = f.max()
# f = (f - fmin)/ (fmax - fmin)
f = BoundMirrorExpand(f)
fy, fx = np.gradient(f)
u = fx
v = fy
sqrMagf = fx*fx + fy*fy
for i in range(ITER):
print i
u = BoundMirrorEnsure(u)
v = BoundMirrorEnsure(v)
u = u + mu*laplace(u) - sqrMagf*(u-fx)
v = v + mu*laplace(v) - sqrMagf*(v-fy)
u = BoundMirrorShrink(u)
v = BoundMirrorShrink(v)
return u, v
def Diffusion_operator(lamda,f,t):
"""
Diffusion Operator - 2D Spatially Discrete Non-Linear Diffusion
---------------------------------------------------------------------------
This describes the synaptic states of diffusion processes and correspond to
It "models different types of electrical synapses (gap junctions).
The linear version, Kλ=0 , describes the exchange of both polarizing and
de-polarizing". Thus the rectification found in the T operator serves to
dictate whether polizing (half-wave rectification) or de-polizing (inverse
half-wave rectification) flow states are allowed to occur.
Parameters
----------
D : int diffusion coefficient
h : int step size
t0 : int stimulus injection point
stimulus : array-like luminance distribution
Returns
----------
f : array-like output of diffusion equation
---------------------------------------------------------------------
|lamba | state | result on input x |
|------|-------------------------|----------------------------------|
|==0 | linearity (T[0]) | Operator becomes Laplacian |
|<0 | positive K(lamda) | Half-wave rectification |
|>0 | negative K(lamda) | Inverse half-wave rectification |
---------------------------------------------------------------------
"""
if lamda == 0: # linearity
return flt.laplace(f)
else: # non-linearity (neighbour interactions up/down/left/right)
f_new = T(lamda,np.roll(f,1, axis=0)-f) \
+T(lamda,np.roll(f,-1, axis=0)-f) \
+T(lamda,np.roll(f, 1, axis=1)-f) \
+T(lamda,np.roll(f,-1, axis=1)-f)
return f_new
def cost(image):
return laplace(image)**2
def outline(self):
from scipy.ndimage.filters import laplace
pbox = self.boxed(pad=1)
return boolmask(laplace(pbox))
def gradient_diffusion(im_dx, im_dy, im_fgnd_mask,
mu=5, lamda=5, iterations=10, dt=0.05):
"""
Diffusion of gradient field using Navier-Stokes equation. Used for
smoothing/denoising a gradient field.
Takes as input a gradient field image (dX, dY), and a mask of the
foreground region, and then iteratively solves the Navier-Stokes equation
to diffuse the vector field and align noisy gradient vectors with their
surrounding signals.
Parameters
----------
im_dx : array_like
Horizontal component of gradient image.
im_dy : array_like
Vertical component of gradient image.
im_fgnd_mask : array_like
Binary mask where foreground objects have value 1, and background
objects have value 0. Used to restrict influence of background vectors
on diffusion process.
mu : float
Weight parmeter from Navier-Stokes equation - weights divergence and
Laplacian terms. Default value = 5.
lamda : float
Weight parameter from Navier-Stokes equation - used to weight
divergence. Default value = 5.
iterations : float
Number of time-steps to use in solving Navier-Stokes. Default value =
10.
dt : float
Timestep to be used in solving Navier-Stokes. Default value = 0.05.
Returns
-------
im_vx : array_like
Horizontal component of diffused gradient.
im_vy : array_like
Vertical component of diffused gradient.
See Also
--------
histomicstk.segmentation.nuclear.GradientFlow
References
----------
.. [1] G. Li et al "3D cell nuclei segmentation based on gradient flow
tracking" in BMC Cell Biology,vol.40,no.8, 2007.
"""
# initialize solution
im_vx = im_dx.copy()
im_vy = im_dy.copy()
# iterate for prescribed number of iterations
for it in range(iterations):
# calculate divergence of current solution
vXY, vXX = np.gradient(im_vx)
vYY, vYX = np.gradient(im_vy)
Div = vXX + vYY
DivY, DivX = np.gradient(Div)
# calculate laplacians of current solution
im_vx += dt * (mu * spf.laplace(im_vx) +
(lamda + mu) * DivX +
im_fgnd_mask * (im_dx - im_vx))
im_vy += dt * (mu * spf.laplace(im_vy) +
(lamda + mu) * DivY +
im_fgnd_mask * (im_dy - im_vy))
# return solution
return im_vx, im_vy
def _remove_dup_laplace(self, data, mask, size=5):
laplacian = np.multiply(laplace(data, mode='wrap'), mask)
return generic_filter(laplacian, self._local_max_laplace, size=size, mode='wrap',
extra_keywords={'size': size})
# How often to add a raindrop (rate is a bad name, larger actually means less often)
rate = 40
# Set up a figure window with an array color plot 'im', using a logarithmic color scale
fig = pp.figure()
ax = fig.gca()
ax.set_xticks([])
ax.set_yticks([])
im = ax.imshow([[1]], norm=cl.LogNorm())
# Set up a 3xMxM array to hold the state of the system at the current, last and last-but-one timesteps
a = np.ones([3] + d * [M])
for i in range(t):
# Iterate the system according the finite-difference algorithm
a[0] = 2.0 * a[1] - a[2] + l * ft.laplace(a[1])
# Every 'rate' iterations, add 1.0 to a random array index
if i % rate == 0:
a[0][tuple(np.random.randint(0, M, size=d))] += 1.0
# Subtract a bit from all of the array to keep the overall sum constant
a[0] -= 1.0 / a[0].size
# Every 'every' iterations, update the plot and save an image
if i % every == 0:
im.set_data(a[0])
fig.savefig('%08i.png' % i)
print('%.2f%%' % (100.0 * float(i) / t))
# Hack to make the colormap scaling work correctly
if i == 0:
im.autoscale()
params.append((0.16, 0.08, 0.060, 0.062)) # Coral
params.append((0.19, 0.05, 0.060, 0.062)) # Fingerprint
params.append((0.10, 0.10, 0.018, 0.050)) # Spirals
params.append((0.12, 0.08, 0.020, 0.050)) # Spirals Dense
params.append((0.10, 0.16, 0.020, 0.050)) # Spirals Fast
params.append((0.16, 0.08, 0.020, 0.055)) # Unstable
params.append((0.16, 0.08, 0.050, 0.065)) # Worms 1
params.append((0.16, 0.08, 0.054, 0.063)) # Worms 2
params.append((0.16, 0.08, 0.035, 0.060)) # Zebrafish
(du, dv, f, k) = params[2]
dt = 1.
ims = []
fig = figure()
axis('off')
N = 20000
for ind in range(N):
u, v = u + (du * laplace(u, mode='wrap') - u * v ** 2 + f * (1. - u)) * dt, v + (
dv * laplace(v, mode='wrap') + u * v ** 2 - (k + f) * v) * dt
if ind % 10 == 0:
print(str(ind) + "/" + str(N))
ims.append([imshow(v)])
ani = ArtistAnimation(fig, ims, interval=10, blit=True, repeat_delay=1000)
Writer = writers['ffmpeg']
writer = Writer(fps=100, metadata=dict(artist='Laurent Garcin'), bitrate=18000)
ani.save('morpho.mp4', writer=writer)
show()
def run(fileName,sequence=None,plot=False,verbose=False,referenceName='2OMZ'):
from scipy.ndimage.filters import laplace
import numpy
upperValues = 5
diagonalLength = 10
filterBand = 25
if verbose:
print '<!--',fileName,'-->'
try:
m = parseFFASMatrix(fileName)
except IOError:
print 'Error reading file', fileName
raise Exception
if plot:
pyplot.imshow(m,interpolation='nearest',cmap = cm.BrBG)
pyplot.show()
# pyplot.imshow(m,interpolation='nearest',cmap = cm.BrBG)
# pyplot.show()
m = filterDiagonal(m,diagonalLength)
if plot:
pyplot.imshow(m,interpolation='nearest',cmap = cm.BrBG)
pyplot.show()
m = compressMatrix(m,referenceName)
if plot:
pyplot.imshow(m,interpolation='nearest',cmap = cm.BrBG)
pyplot.show()
m = laplace(m)
if plot:
pyplot.imshow(m,interpolation='nearest',cmap = cm.BrBG)
pyplot.show()
signal = diagonalSum(m[:upperValues,:])
signal = (signal - numpy.mean(signal)) / numpy.std(signal)
irregularities = {}
try:
if verbose:
print '<!--','Before parseFFASAlignment','-->'
referenceOffset,queryOffset,referenceAlignment,queryAlignment = parseFFASAlignment(fileName.replace('.mat','.txt'))
if verbose:
print '<!--','After parseFFASAlignment','-->'
except :
queryOffset = 0
# print signal
# queryOffset = 0
print '<!--','Query Offset', queryOffset,'-->'
meanLength,sigmaScale = meanLengthFromSignal(signal[queryOffset:],verbose)
print '<!--',sigmaScale,'-->'
indexes = peaksFromSignal(signal,sigmaScale)
units = getUnitsFromSignal(signal,queryOffset,12)
unitStarts = [u[0] for u in units]
unitEnds = [u[1] for u in units]
irregularities = [unit[1] - unit[0] for unit in units]
if sequence:
subsequences = [sequence.seq[unit[0]:unit[1]] for unit in units]
else:
subsequences = []
return unitStarts, unitEnds, units,irregularities , subsequences,meanLength,signal
frame_number = ini_f + tt,
worm_index = w_ind,
roi_size=-1
)
#%%
w_roi = worm_roi.astype(np.float32)
valid_pix = w_roi[w_roi!=0]
bot = valid_pix.min()
top = valid_pix.max()
w_roi[w_roi==0] = top
w_roi = (w_roi-bot)/(top-bot+1) + 1e-3
dm = gaussian_filter(w_roi, 1, mode='reflect')
#dm = median_filter(w_roi, 5, mode='reflect')
dl = laplace(dm, mode='reflect')
dl = np.abs(dl)
w_roi_border = gaussian_filter(dl, 1, mode='reflect')
dd = dm #+ w_roi_border
dd = dd - dd.min()
dd = dd/dd.max()
#plt.imshow(dd)
#%%
w_roi = dd
#%%
#plt.imshow(w_roi_border, interpolation='none', cmap='gray')
#%%
w_roi = Variable(torch.from_numpy(w_roi))
#w_roi_border = Variable(torch.from_numpy(w_roi_border))
def test():
# img=nib.load('/home/eg309/Data/project01_dsi/connectome_0001/tp1/RAWDATA/OUT/mr000001.nii.gz')
btable = np.loadtxt(get_data("dsi515btable"))
# volume size
sz = 16
# shifting
origin = 8
# hanning width
filter_width = 32.0
# number of signal sampling points
n = 515
# odf radius
radius = np.arange(2.1, 6, 0.2)
# create q-table
bv = btable[:, 0]
bmin = np.sort(bv)[1]
bv = np.sqrt(bv / bmin)
qtable = np.vstack((bv, bv, bv)).T * btable[:, 1:]
qtable = np.floor(qtable + 0.5)
# copy bvals and bvecs
bvals = btable[:, 0]
bvecs = btable[:, 1:]
# S=img.get_data()[38,50,20]#[96/2,96/2,20]
S, stics = SticksAndBall(
bvals, bvecs, d=0.0015, S0=100, angles=[(0, 0), (60, 0), (90, 90)], fractions=[0, 0, 0], snr=None
)
S2 = S.copy()
S2 = S2.reshape(1, len(S))
dn = DiffusionNabla(S2, bvals, bvecs, auto=False)
pR = dn.equators
odf = dn.odf(S)
# Xs=dn.precompute_interp_coords()
peaks, inds = peak_finding(odf.astype("f8"), dn.odf_faces.astype("uint16"))
print peaks
print peaks / peaks.min()
# print dn.PK
dn.fit()
print dn.PK
# """
ren = fvtk.ren()
colors = fvtk.colors(odf, "jet")
fvtk.add(ren, fvtk.point(dn.odf_vertices, colors, point_radius=0.05, theta=8, phi=8))
fvtk.show(ren)
# """
stop
# ds=DiffusionSpectrum(S2,bvals,bvecs)
# tpr=ds.pdf(S)
# todf=ds.odf(tpr)
"""
#show projected signal
Bvecs=np.concatenate([bvecs[1:],-bvecs[1:]])
X0=np.dot(np.diag(np.concatenate([S[1:],S[1:]])),Bvecs)
ren=fvtk.ren()
fvtk.add(ren,fvtk.point(X0,fvtk.yellow,1,2,16,16))
fvtk.show(ren)
"""
# qtable=5*matrix[:,1:]
# calculate radius for the hanning filter
r = np.sqrt(qtable[:, 0] ** 2 + qtable[:, 1] ** 2 + qtable[:, 2] ** 2)
# setting hanning filter width and hanning
hanning = 0.5 * np.cos(2 * np.pi * r / filter_width)
# center and index in q space volume
q = qtable + origin
q = q.astype("i8")
# apply the hanning filter
values = S * hanning
"""
#plot q-table
ren=fvtk.ren()
colors=fvtk.colors(values,'jet')
fvtk.add(ren,fvtk.point(q,colors,1,0.1,6,6))
fvtk.show(ren)
"""
# create the signal volume
Sq = np.zeros((sz, sz, sz))
for i in range(n):
Sq[q[i][0], q[i][1], q[i][2]] += values[i]
# apply fourier transform
Pr = fftshift(np.abs(np.real(fftn(fftshift(Sq), (sz, sz, sz)))))
# """
ren = fvtk.ren()
vol = fvtk.volume(Pr)
fvtk.add(ren, vol)
fvtk.show(ren)
# """
"""
from enthought.mayavi import mlab
mlab.pipeline.volume(mlab.pipeline.scalar_field(Sq))
mlab.show()
"""
# vertices, edges, faces = create_unit_sphere(5)
vertices, faces = sphere_vf_from("symmetric362")
odf = np.zeros(len(vertices))
for m in range(len(vertices)):
xi = origin + radius * vertices[m, 0]
yi = origin + radius * vertices[m, 1]
zi = origin + radius * vertices[m, 2]
PrI = map_coordinates(Pr, np.vstack((xi, yi, zi)), order=1)
for i in range(len(radius)):
odf[m] = odf[m] + PrI[i] * radius[i] ** 2
"""
ren=fvtk.ren()
colors=fvtk.colors(odf,'jet')
fvtk.add(ren,fvtk.point(vertices,colors,point_radius=.05,theta=8,phi=8))
fvtk.show(ren)
"""
"""
#Pr[Pr<500]=0
ren=fvtk.ren()
#ren.SetBackground(1,1,1)
fvtk.add(ren,fvtk.volume(Pr))
fvtk.show(ren)
"""
peaks, inds = peak_finding(odf.astype("f8"), faces.astype("uint16"))
Eq = np.zeros((sz, sz, sz))
for i in range(n):
Eq[q[i][0], q[i][1], q[i][2]] += S[i] / S[0]
LEq = laplace(Eq)
# Pr[Pr<500]=0
ren = fvtk.ren()
# ren.SetBackground(1,1,1)
fvtk.add(ren, fvtk.volume(Eq))
fvtk.show(ren)
phis = np.linspace(0, 2 * np.pi, 100)
planars = []
for phi in phis:
planars.append(sphere2cart(1, np.pi / 2, phi))
planars = np.array(planars)
planarsR = []
for v in vertices:
R = vec2vec_rotmat(np.array([0, 0, 1]), v)
planarsR.append(np.dot(R, planars.T).T)
"""
ren=fvtk.ren()
fvtk.add(ren,fvtk.point(planarsR[0],fvtk.green,1,0.1,8,8))
fvtk.add(ren,fvtk.point(2*planarsR[1],fvtk.red,1,0.1,8,8))
fvtk.show(ren)
"""
azimsums = []
for disk in planarsR:
diskshift = 4 * disk + origin
# Sq0=map_coordinates(Sq,diskshift.T,order=1)
# azimsums.append(np.sum(Sq0))
# Eq0=map_coordinates(Eq,diskshift.T,order=1)
# azimsums.append(np.sum(Eq0))
LEq0 = map_coordinates(LEq, diskshift.T, order=1)
azimsums.append(np.sum(LEq0))
azimsums = np.array(azimsums)
# """
ren = fvtk.ren()
colors = fvtk.colors(azimsums, "jet")
fvtk.add(ren, fvtk.point(vertices, colors, point_radius=0.05, theta=8, phi=8))
fvtk.show(ren)
# """
# for p in planarsR[0]:
"""
def _solvePoissonEq(self, I1, I2, iOutItr=0):
"""Solve the Poisson's equation by Fourier transform (differential) or
serial expansion (integration).
There is no convergence for fft actually. Need to add the difference
comparison and X-alpha method. Need to discuss further for this.
Parameters
----------
I1 : Image
Intra- or extra-focal image.
I2 : Image
Intra- or extra-focal image.
iOutItr : int, optional
ith number of outer loop iteration which is important in "fft"
algorithm. (the default is 0.)
Returns
-------
numpy.ndarray
Coefficients of normal/ annular Zernike polynomials.
numpy.ndarray
Estimated wavefront.
"""
# Calculate the aperature pixel size
apertureDiameter = self._inst.getApertureDiameter()
sensorFactor = self._inst.getSensorFactor()
dimOfDonut = self._inst.getDimOfDonutOnSensor()
aperturePixelSize = apertureDiameter*sensorFactor/dimOfDonut
# Calculate the differential Omega
dOmega = aperturePixelSize**2
# Solve the Poisson's equation based on the type of algorithm
numTerms = self.getNumOfZernikes()
zobsR = self.getObsOfZernikes()
PoissonSolver = self.getPoissonSolverName()
if (PoissonSolver == "fft"):
# Use the differential method by fft to solve the Poisson's
# equation
# Parameter to determine the threshold of calculating I0.
sumclipSequence = self.getSignalClipSequence()
cliplevel = sumclipSequence[iOutItr]
# Generate the v, u-coordinates on pupil plane
padDim = self.getFftDimension()
v, u = np.mgrid[
-0.5/aperturePixelSize: 0.5/aperturePixelSize: 1./padDim/aperturePixelSize,
-0.5/aperturePixelSize: 0.5/aperturePixelSize: 1./padDim/aperturePixelSize]
# Show the threshold and pupil coordinate information
if (self.debugLevel >= 3):
print("iOuter=%d, cliplevel=%4.2f" % (iOutItr, cliplevel))
print(v.shape)
# Calculate the const of fft:
# FT{Delta W} = -4*pi^2*(u^2+v^2) * FT{W}
u2v2 = -4 * (np.pi**2) * (u*u + v*v)
# Set origin to Inf to result in 0 at origin after filtering
ctrIdx = int(np.floor(padDim/2.0))
u2v2[ctrIdx, ctrIdx] = np.inf
# Calculate the wavefront signal
Sini = self._createSignal(I1, I2, cliplevel)
# Find the just-outside and just-inside indices of a ring in pixels
# This is for the use in setting dWdn = 0
boundaryT = self.getBoundaryThickness()
struct = generate_binary_structure(2, 1)
struct = iterate_structure(struct, boundaryT)
ApringOut = np.logical_xor(binary_dilation(self.pMask, structure=struct),
self.pMask).astype(int)
ApringIn = np.logical_xor(binary_erosion(self.pMask, structure=struct),
self.pMask).astype(int)
bordery, borderx = np.nonzero(ApringOut)
# Put the signal in boundary (since there's no existing Sestimate,
# S just equals self.S as the initial condition of SCF
S = Sini.copy()
for jj in range(self.getNumOfInnerItr()):
# Calculate FT{S}
SFFT = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(S)))
# Calculate W by W=IFT{ FT{S}/(-4*pi^2*(u^2+v^2)) }
W = np.fft.fftshift(np.fft.irfft2(np.fft.fftshift(SFFT/u2v2), s=S.shape))
# Estimate the wavefront (includes zeroing offset & masking to
# the aperture size)
# Take the estimated wavefront
West = extractArray(W, dimOfDonut)
# Calculate the offset
offset = West[self.pMask == 1].mean()
West = West - offset
West[self.pMask == 0] = 0
# Set dWestimate/dn = 0 around boundary
WestdWdn0 = West.copy()
# Do a 3x3 average around each border pixel, including only
# those pixels inside the aperture
for ii in range(len(borderx)):
reg = West[borderx[ii] - boundaryT:
borderx[ii] + boundaryT + 1,
bordery[ii] - boundaryT:
bordery[ii] + boundaryT + 1]
intersectIdx = ApringIn[borderx[ii] - boundaryT:
borderx[ii] + boundaryT + 1,
bordery[ii] - boundaryT:
bordery[ii] + boundaryT + 1]
WestdWdn0[borderx[ii], bordery[ii]] = \
reg[np.nonzero(intersectIdx)].mean()
# Take Laplacian to find sensor signal estimate (Delta W = S)
del2W = laplace(WestdWdn0)/dOmega
# Extend the dimension of signal to the order of 2 for "fft" to
# use
Sest = padArray(del2W, padDim)
# Put signal back inside boundary, leaving the rest of
# Sestimate
Sest[self.pMaskPad == 1] = Sini[self.pMaskPad == 1]
# Need to recheck this condition
S = Sest
# Define the estimated wavefront
# self.West = West.copy()
# Calculate the coefficient of normal/ annular Zernike polynomials
if (self.getCompensatorMode() == "zer"):
xSensor, ySensor = self._inst.getSensorCoor()
zc = ZernikeMaskedFit(West, xSensor, ySensor, numTerms,
self.pMask, zobsR)
else:
zc = np.zeros(numTerms)
elif (PoissonSolver == "exp"):
# Use the integration method by serial expansion to solve the
# Poisson's equation
# Calculate I0 and dI
I0, dI = self._getdIandI(I1, I2)
# Get the x, y coordinate in mask. The element outside mask is 0.
xSensor, ySensor = self._inst.getSensorCoor()
xSensor = xSensor * self.cMask
ySensor = ySensor * self.cMask
# Create the F matrix and Zernike-related matrixes
F = np.zeros(numTerms)
dZidx = np.zeros((numTerms, dimOfDonut, dimOfDonut))
dZidy = dZidx.copy()
zcCol = np.zeros(numTerms)
for ii in range(int(numTerms)):
# Calculate the matrix for each Zk related component
# Set the specific Zk cofficient to be 1 for the calculation
zcCol[ii] = 1
F[ii] = np.sum(dI*ZernikeAnnularEval(zcCol, xSensor, ySensor, zobsR))*dOmega
dZidx[ii, :, :] = ZernikeAnnularGrad(zcCol, xSensor, ySensor, zobsR, "dx")
dZidy[ii, :, :] = ZernikeAnnularGrad(zcCol, xSensor, ySensor, zobsR, "dy")
# Set the specific Zk cofficient back to 0 to avoid interfering
# other Zk's calculation
zcCol[ii] = 0
# Calculate Mij matrix, need to check the stability of integration
# and symmetry later
Mij = np.zeros([numTerms, numTerms])
for ii in range(numTerms):
for jj in range(numTerms):
Mij[ii, jj] = np.sum(I0*(dZidx[ii, :, :].squeeze()*dZidx[jj, :, :].squeeze() +
dZidy[ii, :, :].squeeze()*dZidy[jj, :, :].squeeze()))
Mij = dOmega/(apertureDiameter/2.)**2 * Mij
# Calculate dz
focalLength = self._inst.getFocalLength()
offset = self._inst.getDefocalDisOffset()
dz = 2*focalLength*(focalLength-offset)/offset
# Define zc
zc = np.zeros(numTerms)
# Consider specific Zk terms only
idx = (self.getZernikeTerms() - 1).tolist()
# Solve the equation: M*W = F => W = M^(-1)*F
zc_tmp = np.linalg.lstsq(Mij[:, idx][idx], F[idx], rcond=None)[0]/dz
zc[idx] = zc_tmp
# Estimate the wavefront surface based on z4 - z22
# z0 - z3 are set to be 0 instead
West = ZernikeAnnularEval(np.concatenate(([0, 0, 0], zc[3:])),
xSensor, ySensor, zobsR)
return zc, West
