def create_image_and_mask(imagefilename, maskfilename):
# import a clean input to be corrupted with the mask
input = mpimg.imread(imagefilename)
if input.ndim == 3:
M, N, C = input.shape
else:
M, N = input.shape
C = 1
# import the mask of the inpainting domain
# mask = 1 intact part
# mask = 0 missing domain
mask = scipy.float64((mpimg.imread(maskfilename) == 1))
if (input.ndim == 3) & (mask.ndim < 3):
mask = np.repeat(mask[:, :, np.newaxis], C, axis=2)
if C == 1:
input = scipy.expand_dims(input, axis=2)
mask = scipy.expand_dims(mask, axis=2)
# create the image with the missin domain:
noise = scipy.rand(M, N, C)
u = mask * input + (1 - mask) * noise
return (u, mask)
def fit(self, X):
n_samples, n_features = X.shape
n_classes = self.n_classes
max_iter = self.max_iter
tol = self.tol
rand_center_idx = sprand.permutation(n_samples)[0:n_classes]
center = X[rand_center_idx].T
responsilibity = sp.zeros((n_samples, n_classes))
for iter in range(max_iter):
# E step
dist = sp.expand_dims(X, axis=2) - sp.expand_dims(center, axis=0)
dist = spla.norm(dist, axis=1)**2
min_idx = sp.argmin(dist, axis=1)
responsilibity.fill(0)
responsilibity[sp.arange(n_samples), min_idx] = 1
# M step
center_new = sp.dot(X.T, responsilibity) / sp.sum(responsilibity, axis=0)
diff = center_new - center
print('K-Means: {0:5d} {1:4e}'.format(iter, spla.norm(diff) / spla.norm(center)))
if (spla.norm(diff) < tol * spla.norm(center)):
break
center = center_new
self.center = center.T
self.responsibility = responsilibity
return self
def update():
global i
if i == tvec.shape[0]-1:
i = 0
else:
i = i + 1
if show_left:
poi_left_scatter.setData(pos=sp.expand_dims(poi_left_pos[i],0))
hand_left_scatter.setData(pos=sp.expand_dims(hand_left_pos[i],0))
string_left_line.setData(pos=sp.vstack((hand_left_pos[i],poi_left_pos[i])))
# arm_left.setData(pos=sp.vstack((hand_left_pos[i],[0,-1*shoulder_width/2,0])))
arm_left.setData(pos=sp.vstack((hand_left_pos[i],[0,0,offset])))
else:
poi_left_scatter.hide()
poi_left_line.hide()
hand_left_scatter.hide()
hand_left_line.hide()
string_left_line.hide()
arm_left.hide()
if show_right:
poi_right_scatter.setData(pos=sp.expand_dims(poi_right_pos[i],0))
hand_right_scatter.setData(pos=sp.expand_dims(hand_right_pos[i],0))
string_right_line.setData(pos=sp.vstack((hand_right_pos[i],poi_right_pos[i])))
# arm_right.setData(pos=sp.vstack((hand_right_pos[i],[0,shoulder_width/2,0])))
arm_right.setData(pos=sp.vstack((hand_right_pos[i],[0,0,offset])))
else:
poi_right_scatter.hide()
poi_right_line.hide()
hand_right_scatter.hide()
hand_right_line.hide()
string_right_line.hide()
arm_right.hide()
def ZYFF(Te, EIJ):
"""Computes `ZY` and `FF`, used in other functions.
If `EIJ` is a scalar, the output has the same shape as `Te`. If `EIJ` is an
array, the output has shape `EIJ.shape` + `Te.shape`. This should keep the
output broadcastable with `Te`.
Parameters
----------
Te : array of float
Electron temperature. Shape is arbitrary.
EIJ : scalar float or array of float
Energy difference.
"""
# Expand the dimensions of EIJ to produce the desired output shape:
Te = scipy.asarray(Te, dtype=float)
EIJ = scipy.asarray(EIJ, dtype=float)
for n in xrange(Te.ndim):
EIJ = scipy.expand_dims(EIJ, axis=-1)
ZY = EIJ / (1e3 * Te)
FF = scipy.zeros_like(ZY)
mask = (ZY >= 1.5)
FF[mask] = scipy.log((ZY[mask] + 1) / ZY[mask]) - (0.36 + 0.03 * scipy.sqrt(ZY[mask] + 0.01)) / (ZY[mask] + 1)**2
mask = ~mask
FF[mask] = scipy.log((ZY[mask] + 1) / ZY[mask]) - (0.36 + 0.03 / scipy.sqrt(ZY[mask] + 0.01)) / (ZY[mask] + 1)**2
return ZY, FF
def plot_dist_grid(length=20,start=[(0,0)],n=1,metric='euclidean',interp=None,cmap=None,cbar=False,title='Distance to Closest Point',xlabel="X Coord",ylabel="Y Coord"):
# Create array of x and y coordinates
x_array = sp.zeros((length,length)) + sp.arange(length)
y_array = sp.zeros((length,length)) + sp.expand_dims(sp.arange(length),length)
coords = zip(x_array.ravel(),y_array.ravel())
# Iterate over coords to calculate distance from 'start'
minima = []
for i in range(len(start)):
val = distance.cdist([start[i]], coords, metric).reshape(length,length)
if i == 0:
minima = sp.copy(val) # Assume all are minimums
else:
minima = sp.minimum(minima,val) # Take smaller
# Create plot from 'minima' array
fig, ax = plt.subplots()
cax = ax.imshow(minima,interpolation=interp,cmap=cmap)
if cbar:
cbar = fig.colorbar(cax, ticks=[range(int(sp.amax(minima)))])
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
fig.savefig('figure' + str(n) + '.pdf')
def wrapper(self, *args, **kwargs):
kernel = self.kernelcorrmu if kwargs.get('corrmu',
False) else self.kernel
integrand = scipy.expand_dims(func(self, self.kk, self.mumu, *args,
**kwargs),
axis=-3)
return integrate.trapz(integrand * kernel, x=self.mu, axis=-1)
def harmonic_inpainting(
damaged_file, mask_file, output_file, fidelity, tol, maxiter,
dt): #damaged_file,mask_file,output_file,lambda,tol,maxiter,dt
input = mpimg.imread(damaged_file)
if input.ndim == 3:
M, N, C = input.shape
else:
M, N = input.shape
C = 1
mask = scipy.float64((mpimg.imread(mask_file) == 1))
if (input.ndim == 3) & (mask.ndim < 3):
mask = np.repeat(mask[:, :, np.newaxis], C, axis=2)
if C == 1:
input = scipy.expand_dims(input, axis=2)
mask = scipy.expand_dims(mask, axis=2)
u = mask * input
# u = input.copy()
for c in range(0, C):
for iter in range(0, maxiter):
# COMPUTE NEW SOLUTION
laplacian = cv.Laplacian(u[:, :, c], cv.CV_64F)
unew = u[:, :, c] + dt * (laplacian + fidelity * mask[:, :, c] *
(input[:, :, c] - u[:, :, c]))
# exit condition
diff_u = np.linalg.norm(
unew.reshape(M * N, 1) - u[:, :, c].reshape(M * N, 1),
2) / np.linalg.norm(unew.reshape(M * N, 1), 2)
# update
u[:, :, c] = unew
# test exit condition
if diff_u < tol:
break
mpimg.imsave(output_file, u)
return u
def predict(self, hyperparams, Xstar_r, compute_cov = False, debugging = False):
"""
predict on Xstar
"""
self._update_inputs(hyperparams)
KV = self.get_covariances(hyperparams,debugging=debugging)
self.covar_r.Xcross = Xstar_r
Kstar_r = self.covar_r.Kcross(hyperparams['covar_r'])
Kstar_c = self.covar_c.K(hyperparams['covar_c'])
KinvY = SP.dot(KV['U_r'],SP.dot(KV['Ytilde'],KV['U_c'].T))
Ystar = SP.dot(Kstar_r.T,SP.dot(KinvY,Kstar_c))
Ystar = unravel(Ystar,self.covar_r.n_cross,self.t)
if debugging:
Kstar = SP.kron(Kstar_c,Kstar_r)
Ynaive = SP.dot(Kstar.T,KV['alpha'])
Ynaive = unravel(Ynaive,self.covar_r.n_cross,self.t)
assert SP.allclose(Ystar,Ynaive), 'ouch, prediction does not work out'
Ystar_covar = []
if compute_cov:
CU = fast_dot(Kstar_c, KV['U_c'])
s_rev = 1./KV['S']
Ystar_covar = SP.zeros([Xstar_r.shape[0], self.Y.shape[1]])
printProgressBar(0, Xstar_r.shape[0], prefix = 'Computing perdiction varaince:', suffix = 'Complete', length = 20)
for i in range(Xstar_r.shape[0]):
R_star_star = self.covar_r.K(hyperparams['covar_r'], SP.expand_dims(Xstar_r[i,:],axis=0))
self.covar_r.Xcross = SP.expand_dims(Xstar_r[i,:],axis=0)
R_tr_star = self.covar_r.Kcross(hyperparams['covar_r'])
RU = SP.dot(R_tr_star.T, KV['U_r'])
q = SP.kron(SP.diag(Kstar_c), R_star_star)
t = SP.zeros([self.t])
for j in range(self.t):
temp = SP.kron(CU[j,:], RU)
t[j,] = SP.sum((s_rev * temp).T * temp.T, axis = 0)
Ystar_covar[i,:] = q - t
if (i + 1) % (Xstar_r.shape[0]/10) == 0:
printProgressBar(i+1, Xstar_r.shape[0], prefix = 'Computing perdiction varaince:', suffix = 'Complete', length = 20)
self.covar_r.Xcross = Xstar_r
return Ystar, Ystar_covar
def concatenate(misalignmentsAndScales, biases):
if sp.ndim(biases) > 1:
biases = sp.reshape(biases, 3)
modelParametersMatrix = sp.concatenate(
(misalignmentsAndScales, sp.expand_dims(biases, axis=1)), axis=1)
return sp.reshape(modelParametersMatrix, 12)
def sgrad(self, x, ndata=None):
"""Returns a stochastic gradient at x.
Projects the gradient in a uniformly random direction."""
### Pick a random direction, then calculate (U.T-dot-gradfx)*u
### to project grad vector in random direction.
# if ndata == None: ndata = 1
if x.ndim == 1:
x = x.reshape(1, x.size)
grad = self.grad(x)
u = scipy.randn(*x.shape)
# u = u / scipy.sqrt( (u*u).sum(axis=1) )
# u = u / scipy.linalg.norm(u,2,axis=1)
u = u / scipy.expand_dims(scipy.linalg.norm(u, 2, axis=1), 1)
gradfx = u * scipy.sum((self.grad(x) * u).sum(axis=1))
return bound(gradfx)
def spectrum_multipoles(self, *args, **kwargs):
qpar, qper = kwargs.get('qpar', 1.), kwargs.get('qper', 1.)
kwargs['kobs'] = self.kk
jacob, kap, muap = self.__class__.k_mu_ap(self.kk, self.mumu, qpar,
qper)
kernel = self.kernelcorrmu if kwargs.get('corrmu',
False) else self.kernel
integral = scipy.expand_dims(
jacob * self.input_model_ref(kap, muap, *args, **kwargs), axis=-3)
multi = integrate.trapz(integral * kernel, x=self.mu, axis=-1)
if self.input_model_lin is not None:
integral = jacob * self.input_model_lin(kap, *args, **kwargs)
modellin = integrate.trapz(integral * kernel[0],
x=self.mu,
axis=-1)
return multi, modellin
return multi, None
def readmattsdata(filename,datadir,outdir,keepspec=[0,1,2,6],angle=20.5):
d2r=sp.pi/180.
angr=d2r*angle
lsp=7
# Read in Data
inst = sio.loadmat(os.path.join(datadir,filename))
xg=inst['xg'][0,0]
x1v = xg['xp']# added to avoid gratting lobes.
x3v = xg['zp']
[x1mat,x3mat] = sp.meshgrid(x1v,x3v);
E = x1mat*sp.sin(angr)#x
N = x1mat*sp.cos(angr)#y
U = x3mat
lxs=x3mat.size
Time_Vector = sp.column_stack([inst['t'],inst['t']+15])
ns =inst['ns']
print('Loaded densities...');
ns= sp.reshape(ns,[lxs,lsp])
Ts =inst['Ts']
print('Loaded temperatures...')
Ts=sp.reshape(Ts,[lxs,lsp])
vs = inst['vsx1']
print('Loaded parallel velocities...\n');
# derive velocity from ExB
Ez,Ex=sp.gradient(-1*inst['Phi'])
dx=sp.diff(xg['x'].flatten())[0]
dEdx=Ex/dx
vx1=-1*dEdx/xg['Bmag']
# from looking at the data it seems that the velocity is off by a factor of
# 10.
vx1=vx1.flatten()/10.
vs=sp.reshape(vs,[lxs,lsp])
vs=sp.sum(ns[:,:(lsp-1)]*vs[:,:(lsp-1)],1)/ns[:,lsp-1]
v_e= vx1*sp.sin(angr)
v_n = vx1*sp.cos(angr)
v_u = vs
#change units of velocity to km/s
Velocity = sp.reshape(sp.column_stack([v_e,v_n,v_u]),[lxs,1,3])
# reduce the number of spcecies
# if islogical(keepspec)
# keepspec(end)=true;
# keepspecnum = sum(keepspec);
# elseif ~any(keepspec==numspec)
# keepspec = [keepspec(:),numspec];
# keepspecnum = length(keepspec);
# else
# keepspecnum = length(keepspec);
# end
nsout = sp.reshape(ns[:,keepspec],[lxs,1,len(keepspec)])
Tsout = sp.reshape(Ts[:,keepspec],[lxs,1,len(keepspec)])
# Put everything in to ionocontainer structure
Cart_Coords = sp.column_stack([E.flatten(),N.flatten(),U.flatten()])*1e-3
Param_List = sp.concatenate((sp.expand_dims(nsout,nsout.ndim),sp.expand_dims(Tsout,Tsout.ndim)),-1);
Species = sp.array(['O+','NO+','N2+','O2+','N+', 'H+','e-'])
Species = Species[keepspec]
fpart=os.path.splitext(filename)[0]
fout=os.path.join(outdir,fpart+'.h5')
ionoout=IonoContainer(Cart_Coords,Param_List,Time_Vector,ver=0,species=Species,velocity=Velocity)
ionoout.saveh5(fout)
def add_exon(self, exon, idx):
if idx > (len(self.exons) - 1):
self.exons.append(sp.zeros((0, 2), dtype='int'))
self.exons[idx] = sp.r_[self.exons[idx], sp.expand_dims(exon, axis=0)]
def predict(self, hyperparams, Xstar_r, compute_cov=False):
"""
predicting
"""
KV = self.get_covariances(hyperparams)
self.covar_r[0].Xcross = Xstar_r
Kstar_r = self.covar_r[0].Kcross(hyperparams['covar_r'][0])
USUr = SP.dot(
SP.sqrt(1. / KV['S_o'][0]) * KV['U_o'][0], KV['Utilde_r'][0])
S = KV['Stilde_rc']
RUSUrYhat = SP.dot(
Kstar_r.T,
SP.dot(
USUr,
unravel(
ravel(KV['UYtildeU_rc']) * 1. / S, self.n,
SP.prod(self.nbn))))
usuc = list()
for i in range(self.out_dims):
usuc.append(
SP.dot(
self.basis[i],
SP.dot(
KV['K_c'][i],
SP.dot(
self.basis[i].T,
SP.dot(self.nbasis[i],
SP.dot(KV['USi_s'][i].T,
KV['Utilde_c'][i]))))).T)
if SP.prod(self.t) <= 10000:
USUC = reduce(SP.kron, usuc[::-1])
Ystar = SP.dot(RUSUrYhat, USUC)
else:
Ystar = SP.zeros([Xstar_r.shape[0], SP.prod(self.t)])
if self.out_dims == 1:
for j in range(self.t[0]):
USUC = usuc[0][:, j]
Ystar[:, j] = SP.dot(RUSUrYhat, USUC)
elif self.out_dims == 2:
for j in range(self.t[0]):
for k in range(self.t[1]):
USUC = reduce(SP.kron, [usuc[1][:, k], usuc[0][:, j]])
Ystar[:, k + j * self.t[1]] = SP.dot(RUSUrYhat, USUC)
elif self.out_dims == 3:
for j in range(self.t[0]):
for k in range(self.t[1]):
for l in range(self.t[2]):
USUC = reduce(
SP.kron,
[usuc[2][:, l], usuc[1][:, k], usuc[0][:, j]])
Ystar[:, l + k * self.t[2] + j *
(self.t[1] * self.t[2])] = SP.dot(
RUSUrYhat, USUC)
Ystar_covar = []
if compute_cov:
if self.nt < 10000:
B = reduce(SP.kron, self.basis[::-1])
C = SP.dot(B, SP.dot(reduce(SP.kron, KV['K_c'][::-1]), B.T))
USUC = reduce(SP.kron, usuc[::-1])
R_star_star = self.covar_r[0].K(hyperparams['covar_r'][0],
Xstar_r)
temp = SP.kron(USUC.T, SP.dot(Kstar_r.T, USUr))
Ystar_covar = SP.kron(SP.diag(C),
SP.diag(R_star_star)) - SP.sum(
(1. / S * temp).T * temp.T, axis=0)
Ystar_covar = unravel(Ystar_covar, Xstar_r.shape[0],
SP.prod(self.t))
elif SP.prod(self.t) < 10000:
Ystar_covar = SP.zeros([Xstar_r.shape[0], SP.prod(self.t)])
B = reduce(SP.kron, self.basis[::-1])
C = SP.dot(B, SP.dot(reduce(SP.kron, KV['K_c'][::-1]), B.T))
USUC = reduce(SP.kron, usuc[::-1])
printProgressBar(0,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
for i in range(Xstar_r.shape[0]):
R_star_star = self.covar_r[0].K(
hyperparams['covar_r'][0],
SP.expand_dims(Xstar_r[i, :], axis=0))
self.covar_r[0].Xcross = SP.expand_dims(Xstar_r[i, :],
axis=0)
R_tr_star = self.covar_r[0].Kcross(
hyperparams['covar_r'][0])
r = SP.dot(R_tr_star.T, USUr)
q = SP.diag(SP.kron(C, R_star_star))
t = SP.zeros([SP.prod(self.t)])
for j in range(SP.prod(self.t)):
temp = SP.kron(USUC[:, j], r)
t[j, ] = SP.sum((1. / S * temp).T * temp.T, axis=0)
Ystar_covar[i, :] = q - t
if (i + 1) % 50 == 0:
printProgressBar(
i + 1,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
self.covar_r[0].Xcross = Xstar_r
elif Xstar_r.shape[0] < 2000:
Ystar_covar = SP.zeros([Xstar_r.shape[0], SP.prod(self.t)])
c_diag = list()
for j in range(self.out_dims):
temp = SP.dot(self.basis[j],
SP.dot(KV['K_c'][j], self.basis[j].T))
c_diag.append(SP.diag(temp))
C = reduce(SP.kron, c_diag[::-1])
R_star_star = self.covar_r[0].K(hyperparams['covar_r'][0],
Xstar_r)
R_tr_star = self.covar_r[0].Kcross(hyperparams['covar_r'][0])
r = SP.dot(R_tr_star.T, USUr)
#q = SP.reshape(SP.kron(SP.diag(R_star_star),C),[Ystar_covar.shape[0],Ystar_covar.shape[1]])
q = unravel(SP.kron(C, SP.diag(R_star_star)),
Ystar_covar.shape[0], Ystar_covar.shape[1])
t = SP.zeros(Ystar_covar.shape)
printProgressBar(0,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
if self.out_dims == 1:
for j in range(self.t[0]):
USUC = usuc[0][:, j]
temp = SP.kron(USUC, r)
t[j, ] = SP.sum((1. / S * temp).T * temp.T, axis=0)
printProgressBar(
j + 1,
self.t[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
elif self.out_dims == 2:
for j in range(self.t[0]):
for k in range(self.t[1]):
USUC = reduce(SP.kron,
[usuc[1][:, k], usuc[0][:, j]])
temp = SP.kron(USUC, r)
t[k + (j * self.t[1]), ] = SP.sum(
(1. / S * temp).T * temp.T, axis=0)
printProgressBar(
j + 1,
self.t[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
elif self.out_dims == 3:
for j in range(self.t[0]):
for k in range(self.t[1]):
for l in range(self.t[2]):
USUC = reduce(SP.kron, [
usuc[2][:, l], usuc[1][:, k], usuc[0][:, j]
])
temp = SP.kron(USUC, r)
t[:, l + k * self.t[2] +
j * self.t[1] * self.t[2], ] = SP.sum(
(1. / S * temp).T * temp.T, axis=0)
if (j + 1) % 5 == 0:
printProgressBar(
j + 1,
self.t[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
Ystar_covar = q - t
else:
Ystar_covar = SP.zeros([Xstar_r.shape[0], SP.prod(self.t)])
c_diag = list()
for j in range(self.out_dims):
temp = SP.dot(self.basis[j],
SP.dot(KV['K_c'][j], self.basis[j].T))
c_diag.append(SP.diag(temp))
C = reduce(SP.kron, c_diag[::-1])
printProgressBar(0,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
for i in range(Xstar_r.shape[0]):
R_star_star = self.covar_r[0].K(
hyperparams['covar_r'][0],
SP.expand_dims(Xstar_r[i, :], axis=0))
self.covar_r[0].Xcross = SP.expand_dims(Xstar_r[i, :],
axis=0)
R_tr_star = self.covar_r[0].Kcross(
hyperparams['covar_r'][0])
r = SP.dot(R_tr_star.T, USUr)
q = C * R_star_star
t = SP.zeros([SP.prod(self.t)])
if self.out_dims == 1:
for j in range(self.t[0]):
USUC = usuc[0][:, j]
temp = SP.kron(USUC, r)
t[j, ] = SP.sum((1. / S * temp).T * temp.T, axis=0)
elif self.out_dims == 2:
for j in range(self.t[0]):
for k in range(self.t[1]):
USUC = reduce(SP.kron,
[usuc[1][:, k], usuc[0][:, j]])
temp = SP.kron(USUC, r)
t[k + (j * self.t[1]), ] = SP.sum(
(1. / S * temp).T * temp.T, axis=0)
elif self.out_dims == 3:
for j in range(self.t[0]):
for k in range(self.t[1]):
for l in range(self.t[2]):
USUC = reduce(SP.kron, [
usuc[2][:, l], usuc[1][:, k],
usuc[0][:, j]
])
temp = SP.kron(USUC, r)
t[l + k * self.t[2] +
j * self.t[1] * self.t[2], ] = SP.sum(
(1. / S * temp).T * temp.T, axis=0)
Ystar_covar[i, :] = q - t
if (i + 1) % 10 == 0:
printProgressBar(
i + 1,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
self.covar_r[0].Xcross = Xstar_r
return Ystar, Ystar_covar
def add_exon(self, exon, idx):
if idx > (len(self.exons) - 1):
self.exons.append(sp.zeros((0, 2), dtype='int'))
self.exons[idx] = sp.r_[self.exons[idx], sp.expand_dims(exon, axis=0)]
def snow_partitioning(im,
dt=None,
r_max=4,
sigma=0.4,
return_all=False,
mask=True,
randomize=True):
r"""
Partitions the void space into pore regions using a marker-based watershed
algorithm, with specially filtered peaks as markers.
The SNOW network extraction algorithm (Sub-Network of an Over-segmented
Watershed) was designed to handle to perculiarities of high porosity
materials, but it applies well to other materials as well.
Parameters
----------
im : array_like
A boolean image of the domain, with ``True`` indicating the pore space
and ``False`` elsewhere.
dt : array_like, optional
The distance transform of the pore space. This is done automatically
if not provided, but if the distance transform has already been
computed then supplying it can save some time.
r_max : int
The radius of the spherical structuring element to use in the Maximum
filter stage that is used to find peaks. The default is 4
sigma : float
The standard deviation of the Gaussian filter used in step 1. The
default is 0.4. If 0 is given then the filter is not applied, which is
useful if a distance transform is supplied as the ``im`` argument that
has already been processed.
return_all : boolean
If set to ``True`` a named tuple is returned containing the original
image, the distance transform, the filtered peaks, and the final
pore regions. The default is ``False``
mask : boolean
Apply a mask to the regions where the solid phase is. Default is
``True``
randomize : boolean
If ``True`` (default), then the region colors will be randomized before
returning. This is helpful for visualizing otherwise neighboring
regions have simlar coloring are are hard to distinguish.
Returns
-------
image : ND-array
An image the same shape as ``im`` with the void space partitioned into
pores using a marker based watershed with the peaks found by the
SNOW algorithm [1].
Notes
-----
If ``return_all`` is ``True`` then a **named tuple** is returned containing
all of the images used during the process. They can be access as
attriutes with the following names:
* ``im``: The binary image of the void space
* ``dt``: The distance transform of the image
* ``peaks``: The peaks of the distance transform after applying the
steps of the SNOW algorithm
* ``regions``: The void space partitioned into pores using a marker
based watershed with the peaks found by the SNOW algorithm
References
----------
[1] Gostick, J. "A versatile and efficient network extraction algorithm
using marker-based watershed segmenation". Physical Review E. (2017)
"""
tup = namedtuple('results', field_names=['im', 'dt', 'peaks', 'regions'])
print('_' * 60)
print("Beginning SNOW Algorithm")
im_shape = sp.array(im.shape)
if im.dtype is not bool:
print('Converting supplied image (im) to boolean')
im = im > 0
if dt is None:
print('Peforming Distance Transform')
if sp.any(im_shape == 1):
ax = sp.where(im_shape == 1)[0][0]
dt = spim.distance_transform_edt(input=im.squeeze())
dt = sp.expand_dims(dt, ax)
else:
dt = spim.distance_transform_edt(input=im)
tup.im = im
tup.dt = dt
if sigma > 0:
print('Applying Gaussian blur with sigma =', str(sigma))
dt = spim.gaussian_filter(input=dt, sigma=sigma)
peaks = find_peaks(dt=dt, r_max=r_max)
print('Initial number of peaks: ', spim.label(peaks)[1])
peaks = trim_saddle_points(peaks=peaks, dt=dt, max_iters=500)
print('Peaks after trimming saddle points: ', spim.label(peaks)[1])
peaks = trim_nearby_peaks(peaks=peaks, dt=dt)
peaks, N = spim.label(peaks)
print('Peaks after trimming nearby peaks: ', N)
tup.peaks = peaks
if mask:
mask_solid = im > 0
else:
mask_solid = None
regions = watershed(image=-dt, markers=peaks, mask=mask_solid)
if randomize:
regions = randomize_colors(regions)
if return_all:
tup.regions = regions
return tup
else:
return regions
Q = Q[:, 0]
br_face_area = face_areas(brain)
Q = 1.0 + sp.zeros(brain.vertices.shape[0])
# Q=0.0*Q
# Q[1800]=1
# Q=smooth_surf_function(brain,Q,10,10)
area_v = (1.0 / 3.0) * Tri * br_face_area
v = sp.zeros(skull.vertices.shape[0]) # eq 8 from Sarvas
v_aaj = sp.zeros(skull.vertices.shape[0]) # joshi
view_patch(brain, attrib=Q, opacity=1)
for i in range(skull.vertices.shape[0]):
r0 = brain.vertices
r_r0 = skull.vertices[i, ] - r0
norm_r_r0 = norm2(r_r0, ord=2, axis=1)
den = norm_r_r0**3.0
num = r_r0
v1 = num / sp.expand_dims(den, axis=1)
Qvec = sp.expand_dims(Q, axis=1) * brain.normals
v1_aaj = (2.0 * m) / norm_r_r0
v1 = sp.sum(v1 * Qvec, axis=1)
# v1_aaj=v1_aaj*sp.sign(v1)
v[i] = sp.sum(v1 * area_v)
v_aaj[i] = sp.sum(Q * v1_aaj * area_v)
if sp.mod(i, 100) == 0:
print 'i=' + str(i)
# In[15]:
view_patch(skull, attrib=v, show=1)
#view_patch(skull, attrib=v_aaj,show=1)
def isInSpace(self, p):
"""Return true if the point p is in the affine space, false otherwise."""
p = scipy.array(p)
close = scipy.isclose(self.getProjection(p), p)
inSpace = scipy.all(close, axis=1)
return scipy.expand_dims(inSpace, 1)
def crsd(x, y, t, windowname = "hanning", ave = bool(True)):
"""
Calculate the cross spectrum (power spectrum) density between two signals.
:Example:
>>> from scipy import signal
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> import vibrationtesting as vt
>>> from numpy import linalg
Generate a 5 second test signal, a 10 V sine wave at 50 Hz, corrupted by
0.001 V**2/Hz of white noise sampled at 1 kHz.
>>> sample_freq = 1e3
>>> tfinal = 5
>>> sig_freq=50
>>> A=10
>>> noise_power = 0.0001 * sample_freq / 2
>>> noise_power = A/1e12
>>> time = np.arange(0,tfinal,1/sample_freq)
>>> time = np.reshape(time, (1, -1))
>>> x = A*np.sin(2*np.pi*sig_freq*time)
>>> x = x + np.random.normal(scale=np.sqrt(noise_power), size=(1, time.shape[1]))
>>> plt.subplot(2,1,1)
<matplotlib...>
>>> plt.plot(time[0,:],x[0,:])
[<matplotlib.lines.Line2D object at ...>]
>>> plt.title('Time history')
<matplotlib...>
>>> plt.xlabel('Time (sec)')
<matplotlib...>
>>> plt.ylabel('$x(t)$')
<matplotlib...>
Compute and plot the autospectrum density.
>>> freq_vec, Pxx = vt.asd(x, time, window="hanning", ave=bool(False))
>>> plt.subplot(2,1,2)
<matplotlib...>
>>> plt.plot(freq_vec[0,:], 20*np.log10(Pxx[0,:,:]))
[<matplotlib.lines.Line2D object at ...>]
>>> plt.ylim([-400, 100])
(-400, 100)
>>> plt.xlabel('frequency [Hz]')
<matplotlib.text.Text object at ...>
>>> plt.ylabel('PSD [V**2/Hz]')
<matplotlib.text.Text object at ...>
>>> plt.show()
If we average the last half of the spectral density, to exclude the
peak, we can recover the noise power on the signal.
Now compute and plot the power spectrum.
"""
#t=np.reshape(t,(1,-1))
if t.shape[0]>1:
dt=t[2]-t[1]
elif t.shape[1]>1:
dt=t[2]-t[1]
print('t must be a scalar or size (n,1)')
elif t.shape[1]==1 and t.shape[0]==1:
dt=t[0]
if dt <= 0:
print('You sent in bad data. Delta t is negative. Please check your inputs.')
if len(x.shape)==1:
x = sp.expand_dims(x, axis = 0)
x = sp.expand_dims(x, axis = 2)
y = sp.expand_dims(y, axis = 0)
y = sp.expand_dims(y, axis = 2)
n=x.shape[1];
# No clue what this does, and I wrote it. Comment your code, you fool!
# What this "should" do is assure that the data is longer in 0 axis than the others.
# if len(x.shape)==2:
# # The issue fixed here is that the user put time along the 1 axis (instead of zero)
# if (x.shape).index(max(x.shape))==0:
# #x=x.reshape(max(x.shape),-1,1)
# print('I think you put time along the 0 axis instead of the 1 axis. Not even attempting to fix this.')
# else:
# # Here we are appending a 3rd dimension to simplify averaging command later. We could bypass at that point, and should.
# x=x.reshape(max(x.shape),-1,1)
# if len(y.shape)==2:
# if (y.shape).indey(may(y.shape))==0:
# #y=y.reshape(may(y.shape),-1,1)
# print('I think you put time along the 0 axis instead of the 1 axis. Not attempting to fix this.')
# else:
# y=y.reshape(may(y.shape),-1,1)
# # Should use scipy.signal windows. I need to figure this out. Problem is: They don't scale the ASDs by the windowing "weakening".
if window=="none":
a=1
else:
#print('This doesn\'t work yet')
win=1
if window=="hanning":#BLACKWIN, BOXWIN, EXPWIN, HAMMWIN, FLATWIN and TRIWIN
#print('shape of x')
#print(x.shape)
win=window(x, windowname = 'hanning')
elif window=="blackwin":
win=window(x, windowname = 'blackwin')
elif window=="boxwin":
win=window(x, windowname = 'boxwin')
elif window=="expwin":
win=window(x, windowname = 'expwin')
elif window=="hammwin":
win=window(x, windowname = 'hamming')
elif window=="triwin":
win=window(x, windowname = 'triwin')
elif window=="flatwin":
win=window(x, windowname = 'flatwin')
y=y*win
x=x*win
del win
ffty=np.fft.rfft(y,axis = 1)*dt
fftx=np.fft.rfft(x,n,axis = 1)*dt
Pxy=np.conj(fftx)*ffty/(n*dt)*2
if len(Pxy.shape)==3 and Pxy.shape[2]>1 and ave:
Pxy=np.mean(Pxy,2)
nfreq=1/dt/2;
f=np.linspace(0, nfreq, Pxy.shape[1])#/2./sp.pi
return f, Pxy
def crsd(x, y, t, windowname="hanning", ave=bool(True)):
"""
Calculate the cross spectrum (power spectrum) density between two signals.
:Example:
>>> from scipy import signal
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> import vibrationtesting as vt
>>> from numpy import linalg
Generate a 5 second test signal, a 10 V sine wave at 50 Hz, corrupted by
0.001 V**2/Hz of white noise sampled at 1 kHz.
>>> sample_freq = 1e3
>>> tfinal = 5
>>> sig_freq=50
>>> A=10
>>> noise_power = 0.0001 * sample_freq / 2
>>> noise_power = A/1e12
>>> time = np.arange(0,tfinal,1/sample_freq)
>>> time = np.reshape(time, (1, -1))
>>> x = A*np.sin(2*np.pi*sig_freq*time)
>>> x = x + np.random.normal(scale=np.sqrt(noise_power), size=(1, time.shape[1]))
>>> plt.subplot(2,1,1)
<matplotlib...>
>>> plt.plot(time[0,:],x[0,:])
[<matplotlib.lines.Line2D object at ...>]
>>> plt.title('Time history')
<matplotlib...>
>>> plt.xlabel('Time (sec)')
<matplotlib...>
>>> plt.ylabel('$x(t)$')
<matplotlib...>
Compute and plot the autospectrum density.
>>> freq_vec, Pxx = vt.asd(x, time, window="hanning", ave=bool(False))
>>> plt.subplot(2,1,2)
<matplotlib...>
>>> plt.plot(freq_vec[0,:], 20*np.log10(Pxx[0,:,:]))
[<matplotlib.lines.Line2D object at ...>]
>>> plt.ylim([-400, 100])
(-400, 100)
>>> plt.xlabel('frequency [Hz]')
<matplotlib.text.Text object at ...>
>>> plt.ylabel('PSD [V**2/Hz]')
<matplotlib.text.Text object at ...>
>>> plt.show()
If we average the last half of the spectral density, to exclude the
peak, we can recover the noise power on the signal.
Now compute and plot the power spectrum.
"""
#t=np.reshape(t,(1,-1))
if t.shape[0] > 1:
dt = t[2] - t[1]
elif t.shape[1] > 1:
dt = t[2] - t[1]
print('t must be a scalar or size (n,1)')
elif t.shape[1] == 1 and t.shape[0] == 1:
dt = t[0]
if dt <= 0:
print(
'You sent in bad data. Delta t is negative. Please check your inputs.'
)
if len(x.shape) == 1:
x = sp.expand_dims(x, axis=0)
x = sp.expand_dims(x, axis=2)
y = sp.expand_dims(y, axis=0)
y = sp.expand_dims(y, axis=2)
n = x.shape[1]
# No clue what this does, and I wrote it. Comment your code, you fool!
# What this "should" do is assure that the data is longer in 0 axis than the others.
# if len(x.shape)==2:
# # The issue fixed here is that the user put time along the 1 axis (instead of zero)
# if (x.shape).index(max(x.shape))==0:
# #x=x.reshape(max(x.shape),-1,1)
# print('I think you put time along the 0 axis instead of the 1 axis. Not even attempting to fix this.')
# else:
# # Here we are appending a 3rd dimension to simplify averaging command later. We could bypass at that point, and should.
# x=x.reshape(max(x.shape),-1,1)
# if len(y.shape)==2:
# if (y.shape).indey(may(y.shape))==0:
# #y=y.reshape(may(y.shape),-1,1)
# print('I think you put time along the 0 axis instead of the 1 axis. Not attempting to fix this.')
# else:
# y=y.reshape(may(y.shape),-1,1)
# # Should use scipy.signal windows. I need to figure this out. Problem is: They don't scale the ASDs by the windowing "weakening".
if window == "none":
a = 1
else:
#print('This doesn\'t work yet')
win = 1
if window == "hanning": #BLACKWIN, BOXWIN, EXPWIN, HAMMWIN, FLATWIN and TRIWIN
#print('shape of x')
#print(x.shape)
win = window(x, windowname='hanning')
elif window == "blackwin":
win = window(x, windowname='blackwin')
elif window == "boxwin":
win = window(x, windowname='boxwin')
elif window == "expwin":
win = window(x, windowname='expwin')
elif window == "hammwin":
win = window(x, windowname='hamming')
elif window == "triwin":
win = window(x, windowname='triwin')
elif window == "flatwin":
win = window(x, windowname='flatwin')
y = y * win
x = x * win
del win
ffty = np.fft.rfft(y, axis=1) * dt
fftx = np.fft.rfft(x, n, axis=1) * dt
Pxy = np.conj(fftx) * ffty / (n * dt) * 2
if len(Pxy.shape) == 3 and Pxy.shape[2] > 1 and ave:
Pxy = np.mean(Pxy, 2)
nfreq = 1 / dt / 2
f = np.linspace(0, nfreq, Pxy.shape[1]) #/2./sp.pi
return f, Pxy
def predict(self, hyperparams, Xstar_r, compute_cov=False):
"""
predict on Xstar
"""
KV = self.get_covariances(hyperparams)
self.covar_r.Xcross = Xstar_r
Kstar_r = self.covar_r.Kcross(hyperparams['covar_r'])
Kstar_c = self.covar_c.K(hyperparams['covar_c'])
KinvY = SP.dot(KV['U_r'], SP.dot(KV['Ytilde'], KV['U_c'].T))
BD = SP.dot(self.basis, Kstar_c)
Ystar = reduce(SP.dot, [Kstar_r.T, KinvY, BD.T])
Ystar_covar = []
if compute_cov:
BDU = SP.dot(BD, KV['U_c'])
BDB = (BD * self.basis).sum(-1)
Ystar_covar = SP.zeros([Xstar_r.shape[0], self.Y.shape[1]])
s_rev = 1. / KV['S']
printProgressBar(0,
BDU.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
if Xstar_r.shape[0] < 500:
R_star_star = self.covar_r.K(hyperparams['covar_r'], Xstar_r)
self.covar_r.Xcross = Xstar_r
R_tr_star = self.covar_r.Kcross(hyperparams['covar_r'])
RU = SP.dot(R_tr_star.T, KV['U_r'])
q = unravel(SP.kron(BDB, SP.diag(R_star_star)),
Ystar_covar.shape[0], Ystar_covar.shape[1])
t = SP.zeros(Ystar_covar.shape)
for j in range(BDU.shape[0]):
temp = SP.kron(BDU[j, :], RU)
t[:, j] = SP.sum((s_rev * temp).T * temp.T, axis=0)
if (j + 1) % 10000 == 0:
printProgressBar(
j + 1,
BDU.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
Ystar_covar = q - t
else:
for i in range(Xstar_r.shape[0]):
R_star_star = self.covar_r.K(
hyperparams['covar_r'],
SP.expand_dims(Xstar_r[i, :], axis=0))
self.covar_r.Xcross = SP.expand_dims(Xstar_r[i, :], axis=0)
R_tr_star = self.covar_r.Kcross(hyperparams['covar_r'])
RU = SP.dot(R_tr_star.T, KV['U_r'])
q = SP.kron(BDB, R_star_star)
t = SP.zeros([self.basis.shape[0]])
for j in range(BDU.shape[0]):
temp = SP.kron(BDU[j, :], RU)
t[j, ] = SP.sum((s_rev * temp).T * temp.T, axis=0)
Ystar_covar[i, :] = q - t
if (i + 1) % (Xstar_r.shape[0] / 10) == 0:
printProgressBar(
i + 1,
Xstar_r.shape[0],
prefix='Computing perdiction varaince:',
suffix='Complete',
length=20)
self.covar_r.Xcross = Xstar_r
return Ystar, Ystar_covar
