def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the gradient of the input images to be used in the
computation of the forward and backward steps.
"""
self.gradient_moving = np.empty(
shape=(self.moving_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert static image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(
shape=(self.static_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert static image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the gradient of the input images to be used in the
computation of the forward and backward steps.
"""
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert static image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(shape=(self.static_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert static image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def initialize_iteration(self):
r'''
Precomputes the transfer functions (hidden random variables) and
variances of the estimators. Also precomputes the gradient of both
input images. Note that once the images are transformed to the opposite
modality, the gradient of the transformed images can be used with the
gradient of the corresponding modality in the same fasion as
diff-demons does for mono-modality images. If the flag
self.use_double_gradient is True these garadients are averaged.
'''
self.__connect_functions()
sampling_mask = self.fixed_image_mask * self.moving_image_mask
self.sampling_mask = sampling_mask
fixedq, self.fixedq_levels, hist = self.quantize(
self.fixed_image, self.q_levels)
fixedq = np.array(fixedq, dtype=np.int32)
self.fixedq_levels = np.array(self.fixedq_levels)
fixedq_means, fixedq_variances = self.compute_stats(
sampling_mask, self.moving_image, self.q_levels, fixedq)
fixedq_means[0] = 0
fixedq_means = np.array(fixedq_means)
fixedq_variances = np.array(fixedq_variances)
self.fixedq_sigma_field = fixedq_variances[fixedq]
self.fixedq_means_field = fixedq_means[fixedq]
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=np.float64)
i = 0
for grad in sp.gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
self.gradient_fixed = np.empty(shape=(self.fixed_image.shape) +
(self.dim, ),
dtype=np.float64)
i = 0
for grad in sp.gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
movingq, self.movingq_levels, hist = self.quantize(
self.moving_image, self.q_levels)
movingq = np.array(movingq, dtype=np.int32)
self.movingq_levels = np.array(self.movingq_levels)
movingq_means, movingq_variances = self.compute_stats(
sampling_mask, self.fixed_image, self.q_levels, movingq)
movingq_means[0] = 0
movingq_means = np.array(movingq_means)
movingq_variances = np.array(movingq_variances)
self.movingq_sigma_field = movingq_variances[movingq]
self.movingq_means_field = movingq_means[movingq]
if self.use_double_gradient:
i = 0
for grad in sp.gradient(self.fixedq_means_field):
self.gradient_moving[..., i] += grad
i += 1
i = 0
for grad in sp.gradient(self.movingq_means_field):
self.gradient_fixed[..., i] += grad
i += 1
def initialize_iteration(self):
r'''
Precomputes the transfer functions (hidden random variables) and
variances of the estimators. Also precomputes the gradient of both
input images. Note that once the images are transformed to the opposite
modality, the gradient of the transformed images can be used with the
gradient of the corresponding modality in the same fasion as
diff-demons does for mono-modality images. If the flag
self.use_double_gradient is True these garadients are averaged.
'''
self.__connect_functions()
sampling_mask = self.fixed_image_mask*self.moving_image_mask
self.sampling_mask = sampling_mask
fixedq, self.fixedq_levels, hist = self.quantize(self.fixed_image,
self.q_levels)
fixedq = np.array(fixedq, dtype = np.int32)
self.fixedq_levels = np.array(self.fixedq_levels)
fixedq_means, fixedq_variances = self.compute_stats(sampling_mask,
self.moving_image,
self.q_levels,
fixedq)
fixedq_means[0] = 0
fixedq_means = np.array(fixedq_means)
fixedq_variances = np.array(fixedq_variances)
self.fixedq_sigma_field = fixedq_variances[fixedq]
self.fixedq_means_field = fixedq_means[fixedq]
self.gradient_moving = np.empty(
shape = (self.moving_image.shape)+(self.dim,), dtype = np.float64)
i = 0
for grad in sp.gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
self.gradient_fixed = np.empty(
shape = (self.fixed_image.shape)+(self.dim,), dtype = np.float64)
i = 0
for grad in sp.gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
movingq, self.movingq_levels, hist = self.quantize(self.moving_image,
self.q_levels)
movingq = np.array(movingq, dtype = np.int32)
self.movingq_levels = np.array(self.movingq_levels)
movingq_means, movingq_variances = self.compute_stats(
sampling_mask, self.fixed_image, self.q_levels, movingq)
movingq_means[0] = 0
movingq_means = np.array(movingq_means)
movingq_variances = np.array(movingq_variances)
self.movingq_sigma_field = movingq_variances[movingq]
self.movingq_means_field = movingq_means[movingq]
if self.use_double_gradient:
i = 0
for grad in sp.gradient(self.fixedq_means_field):
self.gradient_moving[..., i] += grad
i += 1
i = 0
for grad in sp.gradient(self.movingq_means_field):
self.gradient_fixed[..., i] += grad
i += 1
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the cross-correlation factors for efficient computation
of the gradient of the Cross Correlation w.r.t. the displacement field.
It also pre-computes the image gradients in the physical space by
re-orienting the gradients in the voxel space using the corresponding
affine transformations.
"""
def invalid_image_size(image):
min_size = self.radius * 2 + 1
return any([size < min_size for size in image.shape])
msg = ("Each image dimension should be superior to 2 * radius + 1."
"Decrease CCMetric radius or increase your image size")
if invalid_image_size(self.static_image):
raise ValueError("Static image size is too small. " + msg)
if invalid_image_size(self.moving_image):
raise ValueError("Moving image size is too small. " + msg)
self.factors = self.precompute_factors(self.static_image,
self.moving_image,
self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(
shape=(self.moving_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(
shape=(self.static_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def gradient(self):
"""
Return a numpy array containing the gradient of the sample data
"""
# Check the number of axis
if self.data.shape[1] > 1: # More than 1 axis
# Calculate the gradient and extract only the first element
return sp.gradient(self.data)[0]
else: # The case with only one axis must be handled differently
# Reshape the data
reshaped = self.data.reshape(1, -1)[0]
# Calculate the gradient and reshape the result
return sp.gradient(reshaped).reshape(-1, 1)
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the cross-correlation factors for efficient computation
of the gradient of the Cross Correlation w.r.t. the displacement field.
It also pre-computes the image gradients in the physical space by
re-orienting the gradients in the voxel space using the corresponding
affine transformations.
"""
def invalid_image_size(image):
min_size = self.radius * 2 + 1
return any([size < min_size for size in image.shape])
msg = ("Each image dimension should be superior to 2 * radius + 1."
"Decrease CCMetric radius or increase your image size")
if invalid_image_size(self.static_image):
raise ValueError("Static image size is too small. " + msg)
if invalid_image_size(self.moving_image):
raise ValueError("Moving image size is too small. " + msg)
self.factors = self.precompute_factors(self.static_image,
self.moving_image, self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(shape=(self.static_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def estimateNewMultimodalRigidTransformation2D_ecqmmf(moving, fixed, probs, nclasses, previousBeta=None):
epsilon=1e-9
sh=moving.shape
center=(np.array(sh)-1)/2.0
X0,X1=np.mgrid[0:sh[0], 0:sh[1]]
X0=X0-center[0]
X1=X1-center[1]
mask=np.ones_like(X0, dtype=np.int32)
if((previousBeta!=None) and (np.max(np.abs(previousBeta))>epsilon)):
R=rcommon.getRotationMatrix2D(previousBeta[0])
X0new,X1new=(R[0,0]*X0 + R[0,1]*X1 + center[0] + 2.0*previousBeta[1],
R[1,0]*X0 + R[1,1]*X1 + center[1] + 2.0*previousBeta[2])
moving=ndimage.map_coordinates(moving, [X0new, X1new], prefilter=const_prefilter_map_coordinates)
mask[...]=(X0new<0) + (X0new>(sh[0]-1))
mask[...]=mask + (X1new<0) + (X1new>(sh[1]-1))
mask[...]=1-mask
means, variances=tf.computeMaskedVolumeClassStatsProbsCYTHON(mask, moving, probs)
means=np.array(means)
weights=np.array([1.0/x if(x>0) else 0 for x in variances], dtype=np.float64)
g0, g1=sp.gradient(moving)
q=np.empty(shape=(X0.shape)+(3,), dtype=np.float64)
q[...,0]=g1*X0-g0*X1
q[...,1]=g0
q[...,2]=g1
expected=probs.dot(means)
diff=expected-moving
Aw, bw=tf.integrateMaskedWeightedTensorFieldProductsCYTHON(mask, q, diff, numLevels, rightQ, weights)
beta=linalg.solve(Aw,bw)
return beta
def estimateNewMultimodalRigidTransformation3D(left, right, rightQ, numLevels, previousBeta=None):
epsilon=1e-9
sh=left.shape
center=(np.array(sh)-1)/2.0
X0,X1,X2=np.mgrid[0:sh[0], 0:sh[1], 0:sh[2]]
X0=X0-center[0]
X1=X1-center[1]
X2=X2-center[2]
mask=np.ones_like(X0, dtype=np.int32)
if((previousBeta!=None) and (np.max(np.abs(previousBeta))>epsilon)):
R=rcommon.getRotationMatrix(previousBeta[0:3])
X0new,X1new,X2new=(R[0,0]*X0 + R[0,1]*X1 + R[0,2]*X2 + center[0] + 2.0*previousBeta[3],
R[1,0]*X0 + R[1,1]*X1 + R[1,2]*X2 + center[1] + 2.0*previousBeta[4],
R[2,0]*X0 + R[2,1]*X1 + R[2,2]*X2 + center[2] + 2.0*previousBeta[5])
left=ndimage.map_coordinates(left, [X0new, X1new, X2new], prefilter=const_prefilter_map_coordinates)
mask[...]=(X0new<0) + (X0new>(sh[0]-1))
mask[...]=mask + (X1new<0) + (X1new>(sh[1]-1))
mask[...]=mask + (X2new<0) + (X2new>(sh[2]-1))
mask[...]=1-mask
means, variances=tf.computeMaskedVolumeClassStatsCYTHON(mask, left, numLevels, rightQ)
means=np.array(means)
weights=np.array([1.0/x if(x>0) else 0 for x in variances], dtype=np.float64)
g0, g1, g2=sp.gradient(left)
q=np.empty(shape=(X0.shape)+(6,), dtype=np.float64)
q[...,0]=g2*X1-g1*X2
q[...,1]=g0*X2-g2*X0
q[...,2]=g1*X0-g0*X1
q[...,3]=g0
q[...,4]=g1
q[...,5]=g2
diff=means[rightQ]-left
Aw, bw=tf.integrateMaskedWeightedTensorFieldProductsCYTHON(mask, q, diff, numLevels, rightQ, weights)
beta=linalg.solve(Aw,bw)
return beta
def compute_desired_velocity(self):
"""
To compute the geodesic distance to the doors in using \
a fast-marching method. The opposite of the gradient of this distance
corresponds to the desired velocity which permits to reach the closest
door
Returns
-------
door_distance : numpy array
distance to the closest door
desired_velocity_X : numpy array
opposite of the gradient of the door distance, x component
desired_velocity_Y : numpy array
opposite of the gradient of the door distance, y component
"""
mask_red = (self.image_red == 255) \
*(self.image_green == 0) \
*(self.image_blue == 0)
ind_red = sp.where(mask_red)
phi = sp.ones(self.image_red.shape)
phi[ind_red] = 0
phi = sp.ma.MaskedArray(phi, mask=self.mask)
self.door_distance = skfmm.distance(phi, dx=self.pixel_size)
tmp_dist = self.door_distance.filled(9999)
grad = sp.gradient(tmp_dist, edge_order=2)
grad_X = -grad[1] / self.pixel_size
grad_Y = -grad[0] / self.pixel_size
norm = sp.sqrt(grad_X**2 + grad_Y**2)
norm = (norm > 0) * norm + (norm == 0) * 0.001
self.desired_velocity_X = grad_X / norm
self.desired_velocity_Y = grad_Y / norm
return self.door_distance, self.desired_velocity_X, self.desired_velocity_Y
def estimateNewRigidTransformation3D(left, right, previousBeta=None):
epsilon=1e-9
sh=left.shape
center=(np.array(sh)-1)/2.0
X0,X1,X2=np.mgrid[0:sh[0], 0:sh[1], 0:sh[2]]
X0=X0-center[0]
X1=X1-center[1]
X2=X2-center[2]
if((previousBeta!=None) and (np.max(np.abs(previousBeta))>epsilon)):
R=rcommon.getRotationMatrix(previousBeta[0:3])
X0new,X1new,X2new=(R[0,0]*X0 + R[0,1]*X1 + R[0,2]*X2 + center[0] + 2.0*previousBeta[3],
R[1,0]*X0 + R[1,1]*X1 + R[1,2]*X2 + center[1] + 2.0*previousBeta[4],
R[2,0]*X0 + R[2,1]*X1 + R[2,2]*X2 + center[2] + 2.0*previousBeta[5])
left=ndimage.map_coordinates(left, [X0new, X1new, X2new], prefilter=const_prefilter_map_coordinates)
g0, g1, g2=sp.gradient(left)
q=np.empty(shape=(X0.shape)+(6,), dtype=np.float64)
q[...,0]=g2*X1-g1*X2
q[...,1]=g0*X2-g2*X0
q[...,2]=g1*X0-g0*X1
q[...,3]=g0
q[...,4]=g1
q[...,5]=g2
diff=right-left
A,b=tf.integrateTensorFieldProductsCYTHON(q,diff)
#A,b=tf.integrateTensorFieldProducts(q,diff)
beta=linalg.solve(A,b)
return beta
def estimateNewRotation(left,
right,
previousAngleRadians,
maxAngleRads=0,
thr=-1):
epsilon = 1e-9
center = (np.array(right.shape) - 1) / 2.0
C, R = sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64),
np.array(range(right.shape[0]), dtype=np.float64))
R = R - center[0]
C = C - center[1]
if (np.abs(previousAngleRadians) > epsilon):
a = np.cos(previousAngleRadians)
b = np.sin(previousAngleRadians)
Rnew, Cnew = (a * R - b * C + center[0], b * R + a * C + center[1])
right = ndimage.map_coordinates(
right, [Rnew, Cnew], prefilter=const_prefilter_map_coordinates)
[dr, dc] = sp.gradient(right)
prod = R * dc - C * dr
diff = left - right
num = prod * diff
den = prod**2
theta = 0
if (thr > 0):
N = np.sqrt((R * maxAngleRads)**2 + (C * maxAngleRads)**2)
M = (N < thr)
theta = np.sum(num * M) / np.sum(den * M)
else:
theta = np.sum(num) / np.sum(den)
return theta
def estimateNewRigidTransformation3D(left, right, previousBeta=None):
epsilon = 1e-9
sh = left.shape
center = (np.array(sh) - 1) / 2.0
X0, X1, X2 = np.mgrid[0:sh[0], 0:sh[1], 0:sh[2]]
X0 = X0 - center[0]
X1 = X1 - center[1]
X2 = X2 - center[2]
if ((previousBeta != None) and (np.max(np.abs(previousBeta)) > epsilon)):
R = rcommon.getRotationMatrix(previousBeta[0:3])
X0new, X1new, X2new = (R[0, 0] * X0 + R[0, 1] * X1 + R[0, 2] * X2 +
center[0] + 2.0 * previousBeta[3],
R[1, 0] * X0 + R[1, 1] * X1 + R[1, 2] * X2 +
center[1] + 2.0 * previousBeta[4],
R[2, 0] * X0 + R[2, 1] * X1 + R[2, 2] * X2 +
center[2] + 2.0 * previousBeta[5])
left = ndimage.map_coordinates(
left, [X0new, X1new, X2new],
prefilter=const_prefilter_map_coordinates)
g0, g1, g2 = sp.gradient(left)
q = np.empty(shape=(X0.shape) + (6, ), dtype=np.float64)
q[..., 0] = g2 * X1 - g1 * X2
q[..., 1] = g0 * X2 - g2 * X0
q[..., 2] = g1 * X0 - g0 * X1
q[..., 3] = g0
q[..., 4] = g1
q[..., 5] = g2
diff = right - left
A, b = tf.integrateTensorFieldProductsCYTHON(q, diff)
#A,b=tf.integrateTensorFieldProducts(q,diff)
beta = linalg.solve(A, b)
return beta
def augmentTrans(self, df, deg):
''' joins calculated and fitted transconductances to existing dataframe
'''
xs = sp.array(df.filter(like='Vgs'))
ys = df.filter(like='Ids')
grad_cols = [i.replace('Ids', 'tcd') for i in ys.columns]
fit_cols = [i.replace('Ids', 'tcfit') for i in ys.columns]
grads = []
fits = []
for x, y in zip(sp.array(xs).T, sp.array(ys).T):
g = sp.gradient(y, x)
grads.append(g)
p = sp.polyfit(x, g, deg)
fit = sp.poly1d(p)(x)
fits.append(fit)
graddf = pd.DataFrame(sp.array(grads).T, columns=grad_cols)
fitdf = pd.DataFrame(sp.array(fits).T, columns=fit_cols)
df = df.join(graddf)
df = df.join(fitdf)
return df
def harris(I):
""" Harris Corner Detector """
Ix,Iy = scipy.gradient(I)
H11 = Ix*Ix
H12 = Ix*Iy
H22 = Iy*Iy
return (H11*H22 - H12**2)
def skeletize_latecki(img,gaussian_filter):
# http://www.cis.temple.edu/~latecki/Papers/icip__SSM07.pdf
dt=numpy.float32
if (img.ndim==3):
img=img.mean(axis=2)
img=img.astype(dt)
img/=img.max()
gimg=scipy.ndimage.gaussian_filter(img,2)
ximg=img.max()-img
dimg=scipy.ndimage.distance_transform_edt(ximg)
#
# now let's compute f
fimg=1-scipy.abs(scipy.convolve(cgradient(gimg),dimg))
#
# and now compute its gradient
u0,v0=scipy.gradient(fimg)
#
# now we do diffusion
##
# now we apply SSM map
gvf=diffuse_gradient_vector
#
# then we do particular point detection
mimg1=scipy.ndimage.maximum_filter(dimg,size=(3,3))
img=(((dimg-mimg1)==0).astype(dt))
img*=ximg
return img
def initialize_iteration(self):
r'''
Precomputes the gradient of the input images to be used in the
computation of the forward and backward steps.
'''
self.gradient_moving = np.empty(
shape = (self.moving_image.shape)+(self.dim,), dtype = np.float64)
i = 0
for grad in gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
i = 0
self.gradient_fixed = np.empty(
shape = (self.fixed_image.shape)+(self.dim,), dtype = np.float64)
for grad in gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
def getJacobian(x, y, f, g, x0, y0):
"""J = getJacobian(x,y,f,g,x0,y0)
getJacobian takes a grid of derivative values and a point in phase
space, and returns the Jacobian around that point.
Parameters:
x : The x-values of f and g.
y : The y-values of f and g.
f : A matrix approximating the derivative wrt x.
g : A matrix approximating the derivative wrt y.
x0 : The x-value for the point.
y0 : The y-value for the point.
Returns Jacobian:
J(1,1): Derivative of f wrt x evaluated at x0, y0.
J(1,2): Derivative of f wrt y evaluated at x0, y0.
J(2,1): Derivative of g wrt x evaluated at x0, y0.
J(2,2): Derivative of g wrt y evaluated at x0, y0.
"""
dx = sp.gradient(x)[1] # the derivative in the X direction
dy = sp.gradient(y)[0] # the derivative in the Y direction
dfy, dfx = sp.gradient(f) # the derivatives of f in the X and Y directions
dgy, dgx = sp.gradient(g) # the derivatives of g in the X and Y directions
# Now we need to get the values at the fixed point. We have to interpolate
# the data from what we have.
points = (x.flatten(), y.flatten())
point = (x0, y0)
dx0 = griddata(points, dx.flatten(), point)
dy0 = griddata(points, dy.flatten(), point)
dfdx0 = griddata(points, dfx.flatten(), point)
dfdy0 = griddata(points, dfy.flatten(), point)
dgdx0 = griddata(points, dgx.flatten(), point)
dgdy0 = griddata(points, dgy.flatten(), point)
#X, Y = x.flatten(), y.flatten()
#xi,yi = plt.meshgrid([x0-1, x0, x0+1], [y0-1, y0, y0+1])
#dx0 = griddata(X, Y, dx.flatten(), xi,yi)[1][1]
#dy0 = griddata(X, Y, dy.flatten(), xi,yi)[1][1]
#dfdx0 = griddata(X, Y, dfx.flatten(),xi,yi)[1][1]
#dfdy0 = griddata(X, Y, dfy.flatten(),xi,yi)[1][1]
#dgdx0 = griddata(X, Y, dgx.flatten(),xi,yi)[1][1]
#dgdy0 = griddata(X, Y, dgy.flatten(),xi,yi)[1][1]
return sp.array([[dfdx0 / dx0, dfdy0 / dy0], [dgdx0 / dx0, dgdy0 / dy0]])
def getJacobian(x,y,f,g,x0,y0):
"""J = getJacobian(x,y,f,g,x0,y0)
getJacobian takes a grid of derivative values and a point in phase
space, and returns the Jacobian around that point.
Parameters:
x : The x-values of f and g.
y : The y-values of f and g.
f : A matrix approximating the derivative wrt x.
g : A matrix approximating the derivative wrt y.
x0 : The x-value for the point.
y0 : The y-value for the point.
Returns Jacobian:
J(1,1): Derivative of f wrt x evaluated at x0, y0.
J(1,2): Derivative of f wrt y evaluated at x0, y0.
J(2,1): Derivative of g wrt x evaluated at x0, y0.
J(2,2): Derivative of g wrt y evaluated at x0, y0.
"""
dx = sp.gradient(x)[1] # the derivative in the X direction
dy = sp.gradient(y)[0] # the derivative in the Y direction
dfy, dfx = sp.gradient(f) # the derivatives of f in the X and Y directions
dgy, dgx = sp.gradient(g) # the derivatives of g in the X and Y directions
# Now we need to get the values at the fixed point. We have to interpolate
# the data from what we have.
points = (x.flatten(), y.flatten())
point = (x0, y0)
dx0 = griddata(points, dx.flatten(), point)
dy0 = griddata(points, dy.flatten(), point)
dfdx0 = griddata(points, dfx.flatten(), point)
dfdy0 = griddata(points, dfy.flatten(), point)
dgdx0 = griddata(points, dgx.flatten(), point)
dgdy0 = griddata(points, dgy.flatten(), point)
#X, Y = x.flatten(), y.flatten()
#xi,yi = plt.meshgrid([x0-1, x0, x0+1], [y0-1, y0, y0+1])
#dx0 = griddata(X, Y, dx.flatten(), xi,yi)[1][1]
#dy0 = griddata(X, Y, dy.flatten(), xi,yi)[1][1]
#dfdx0 = griddata(X, Y, dfx.flatten(),xi,yi)[1][1]
#dfdy0 = griddata(X, Y, dfy.flatten(),xi,yi)[1][1]
#dgdx0 = griddata(X, Y, dgx.flatten(),xi,yi)[1][1]
#dgdy0 = griddata(X, Y, dgy.flatten(),xi,yi)[1][1]
return sp.array([[dfdx0/dx0, dfdy0/dy0], [dgdx0/dx0, dgdy0/dy0]])
def estimateNewMonomodalDiffeomorphicField2D(moving, fixed, lambdaParam,
maxOuterIter,
previousDisplacement,
previousDisplacementInverse):
'''
Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
as opposed as lambdaParam=150 used in the multimodal case
'''
innerTolerance = 1e-4
displacement = np.zeros(shape=(moving.shape) + (2, ), dtype=np.float64)
gradientField = np.empty(shape=(moving.shape) + (2, ), dtype=np.float64)
totalDisplacement = np.zeros(shape=(moving.shape) + (2, ),
dtype=np.float64)
totalDisplacementInverse = np.zeros(shape=(moving.shape) + (2, ),
dtype=np.float64)
if (previousDisplacement != None):
totalDisplacement[...] = previousDisplacement
totalDisplacementInverse[...] = previousDisplacementInverse
outerIter = 0
framesToCapture = 5
maxOuterIter = framesToCapture * (
(maxOuterIter + framesToCapture - 1) / framesToCapture)
itersPerCapture = maxOuterIter / framesToCapture
plt.figure()
while (outerIter < maxOuterIter):
outerIter += 1
print 'Outer iter:', outerIter
warped = np.array(tf.warp_image(moving, totalDisplacement, None))
if ((outerIter == 1) or (outerIter % itersPerCapture == 0)):
plt.subplot(1, framesToCapture + 1,
1 + outerIter / itersPerCapture)
rcommon.overlayImages(warped, fixed, False)
plt.title('Iter:' + str(outerIter - 1))
sigmaField = np.ones_like(warped, dtype=np.float64)
deltaField = fixed - warped
gradientField[:, :, 0], gradientField[:, :, 1] = sp.gradient(warped)
maxVariation = 1 + innerTolerance
innerIter = 0
displacement[...] = 0
maxInnerIter = 200
while ((maxVariation > innerTolerance) and (innerIter < maxInnerIter)):
innerIter += 1
maxVariation = tf.iterateDisplacementField2DCYTHON(
deltaField, sigmaField, gradientField, lambdaParam,
displacement, None)
#maxDisplacement=np.max(np.abs(displacement))
expd, invexpd = tf.vector_field_exponential(displacement, True)
totalDisplacement, stats = tf.compose_vector_fields(
displacement, totalDisplacement)
#totalDisplacement=np.array(totalDisplacement)
totalDisplacementInverse, stats = tf.compose_vector_fields(
totalDisplacementInverse, invexpd)
#totalDisplacementInverse=np.array(totalDisplacementInverse)
#if(maxDisplacement<outerTolerance):
#break
print "Iter: ", innerIter, "Max variation:", maxVariation
return totalDisplacement, totalDisplacementInverse
def harris_smooth(I,alpha=0.04,si=1):
""" Harris Corner Detector """
def imsmooth(I,si):
return scipy.ndimage.gaussian_filter(I,si)
Ix,Iy = scipy.gradient(I)
H11 = imsmooth(Ix*Ix, si)
H12 = imsmooth(Ix*Iy, si)
H22 = imsmooth(Iy*Iy, si)
return (H11*H22 - H12**2) - alpha*(H11+H22)**2
def harris_noble(I,si):
""" Noble's variation of Harris Corner Detector """
eps=1e-16
def imsmooth(I,si):
return scipy.ndimage.gaussian_filter(I,si)
Ix,Iy = scipy.gradient(I)
H11 = imsmooth(Ix*Ix, si)
H12 = imsmooth(Ix*Iy, si)
H22 = imsmooth(Iy*Iy, si)
return 2 * (H11*H22 - H12**2)/(H11+H22+eps)
def initialize_iteration(self):
r'''
Precomputes the gradient of the input images to be used in the
computation of the forward and backward steps.
'''
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=np.float64)
i = 0
for grad in gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
i = 0
self.gradient_fixed = np.empty(shape=(self.fixed_image.shape) +
(self.dim, ),
dtype=np.float64)
for grad in gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
def initialize_iteration(self):
r'''
Precomputes the cross-correlation factors
'''
self.factors = tf.precompute_cc_factors_3d(self.fixed_image,
self.moving_image,
self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(
shape = (self.moving_image.shape)+(self.dim,), dtype = np.float64)
i = 0
for grad in sp.gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
self.gradient_fixed = np.empty(
shape = (self.fixed_image.shape)+(self.dim,), dtype = np.float64)
i = 0
for grad in sp.gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
def estimateNewMonomodalDiffeomorphicField3D(moving,
fixed,
lambdaParam,
maxOuterIter,
previousDisplacement,
reportProgress=False):
'''
Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
as opposed as lambdaParam=150 used in the multimodal case
'''
innerTolerance = 1e-3
outerTolerance = 1e-3
displacement = np.zeros(shape=(moving.shape) + (3, ), dtype=np.float64)
residuals = np.zeros(shape=(moving.shape), dtype=np.float64)
gradientField = np.empty(shape=(moving.shape) + (3, ), dtype=np.float64)
totalDisplacement = np.zeros(shape=(moving.shape) + (3, ),
dtype=np.float64)
if (previousDisplacement != None):
totalDisplacement[...] = previousDisplacement
outerIter = 0
while (outerIter < maxOuterIter):
outerIter += 1
if (reportProgress):
print 'Iter:', outerIter, '/', maxOuterIter
warped = np.array(tf.warp_volume(moving, totalDisplacement))
sigmaField = np.ones_like(warped, dtype=np.float64)
deltaField = fixed - warped
g0, g1, g2 = sp.gradient(warped)
gradientField[:, :, :, 0] = g0
gradientField[:, :, :, 1] = g1
gradientField[:, :, :, 2] = g2
maxVariation = 1 + innerTolerance
innerIter = 0
maxResidual = 0
displacement[...] = 0
maxInnerIter = 50
while ((maxVariation > innerTolerance) and (innerIter < maxInnerIter)):
innerIter += 1
maxVariation = tf.iterateDisplacementField3DCYTHON(
deltaField, sigmaField, gradientField, lambdaParam,
totalDisplacement, displacement, residuals)
opt = np.max(residuals)
if (maxResidual < opt):
maxResidual = opt
maxDisplacement = np.max(np.abs(displacement))
totalDisplacement, stats = tf.compose_vector_fields3D(
displacement, totalDisplacement)
if (maxDisplacement < outerTolerance):
break
print "Iter: ", outerIter, "Max lateral displacement:", maxDisplacement, "Max variation:", maxVariation, "Max residual:", maxResidual
if (previousDisplacement != None):
return totalDisplacement - previousDisplacement
return totalDisplacement
def plotDiffeomorphism(GT, GTinv, GTres, titlePrefix, delta=10):
nrows=GT.shape[0]
ncols=GT.shape[1]
X1,X0=np.mgrid[0:GT.shape[0], 0:GT.shape[1]]
lattice=drawLattice2D((nrows+delta)/(delta+1), (ncols+delta)/(delta+1), delta)
lattice=lattice[0:nrows,0:ncols]
gtLattice=warpImage(lattice, np.array(GT))
gtInvLattice=warpImage(lattice, np.array(GTinv))
gtResidual=warpImage(lattice, np.array(GTres))
plt.figure()
plt.subplot(2, 3, 1)
plt.imshow(gtLattice, cmap=plt.cm.gray)
plt.title(titlePrefix+'[Deformation]')
plt.subplot(2, 3, 2)
plt.imshow(gtInvLattice, cmap=plt.cm.gray)
plt.title(titlePrefix+'[Inverse]')
plt.subplot(2, 3, 3)
plt.imshow(gtResidual, cmap=plt.cm.gray)
plt.title(titlePrefix+'[residual]')
#plot jacobians and residual norm
detJacobian=computeJacobianField(GT)
plt.subplot(2, 3, 4)
plt.imshow(detJacobian, cmap=plt.cm.gray)
CS=plt.contour(X0,X1,detJacobian,levels=[0.0], colors='r')
plt.clabel(CS, inline=1, fontsize=10)
plt.title('det(J(d))')
detJacobianInverse=computeJacobianField(GTinv)
plt.subplot(2, 3, 5)
plt.imshow(detJacobianInverse, cmap=plt.cm.gray)
CS=plt.contour(X0,X1,detJacobianInverse,levels=[0.0], colors='r')
plt.clabel(CS, inline=1, fontsize=10)
plt.title('det(J(d^-1))')
nrm=np.sqrt(np.sum(np.array(GTres)**2,2))
plt.subplot(2, 3, 6)
plt.imshow(nrm, cmap=plt.cm.gray)
plt.title('||residual||_2')
g00, g01=sp.gradient(GTinv[...,0])
g10, g11=sp.gradient(GTinv[...,1])
#priorEnergy=g00**2+g01**2+g10**2+g11**2
return [gtLattice, gtInvLattice, gtResidual, detJacobian]
def initialize_iteration(self):
r'''
Precomputes the cross-correlation factors
'''
self.factors = tf.precompute_cc_factors_3d(self.fixed_image,
self.moving_image,
self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=np.float64)
i = 0
for grad in sp.gradient(self.moving_image):
self.gradient_moving[..., i] = grad
i += 1
self.gradient_fixed = np.empty(shape=(self.fixed_image.shape) +
(self.dim, ),
dtype=np.float64)
i = 0
for grad in sp.gradient(self.fixed_image):
self.gradient_fixed[..., i] = grad
i += 1
def gradient_M(f): dM = g.grid_M[1] - g.grid_M[0] dD = g.grid_D[1] - g.grid_D[0] g = scipy.gradient(f, dM, dD) result = [] # for a1 in g: # # add empty row, col # newcol = scipy.NaN * scipy.ones((1, len(g.grid_D)-1)) # a2 = scipy.hstack([a1, newcol]) # newrow = scipy.NaN * scipy.ones((len(g.grid_M), 1)) # a3 = scipy.vstack([a2, newrow]) # result.append(a3) return g
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the cross-correlation factors for efficient computation
of the gradient of the Cross Correlation w.r.t. the displacement field.
It also pre-computes the image gradients in the physical space by
re-orienting the gradients in the voxel space using the corresponding
affine transformations.
"""
self.factors = self.precompute_factors(self.static_image,
self.moving_image, self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(shape=(self.static_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the cross-correlation factors for efficient computation
of the gradient of the Cross Correlation w.r.t. the displacement field.
It also pre-computes the image gradients in the physical space by
re-orienting the gradients in the voxel space using the corresponding
affine transformations.
"""
self.factors = self.precompute_factors(self.static_image,
self.moving_image,
self.radius)
self.factors = np.array(self.factors)
self.gradient_moving = np.empty(
shape=(self.moving_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(
shape=(self.static_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
def estimateNewMultimodalRigidTransformation3D(left,
right,
rightQ,
numLevels,
previousBeta=None):
epsilon = 1e-9
sh = left.shape
center = (np.array(sh) - 1) / 2.0
X0, X1, X2 = np.mgrid[0:sh[0], 0:sh[1], 0:sh[2]]
X0 = X0 - center[0]
X1 = X1 - center[1]
X2 = X2 - center[2]
mask = np.ones_like(X0, dtype=np.int32)
if ((previousBeta != None) and (np.max(np.abs(previousBeta)) > epsilon)):
R = rcommon.getRotationMatrix(previousBeta[0:3])
X0new, X1new, X2new = (R[0, 0] * X0 + R[0, 1] * X1 + R[0, 2] * X2 +
center[0] + 2.0 * previousBeta[3],
R[1, 0] * X0 + R[1, 1] * X1 + R[1, 2] * X2 +
center[1] + 2.0 * previousBeta[4],
R[2, 0] * X0 + R[2, 1] * X1 + R[2, 2] * X2 +
center[2] + 2.0 * previousBeta[5])
left = ndimage.map_coordinates(
left, [X0new, X1new, X2new],
prefilter=const_prefilter_map_coordinates)
mask[...] = (X0new < 0) + (X0new > (sh[0] - 1))
mask[...] = mask + (X1new < 0) + (X1new > (sh[1] - 1))
mask[...] = mask + (X2new < 0) + (X2new > (sh[2] - 1))
mask[...] = 1 - mask
means, variances = tf.computeMaskedVolumeClassStatsCYTHON(
mask, left, numLevels, rightQ)
means = np.array(means)
weights = np.array([1.0 / x if (x > 0) else 0 for x in variances],
dtype=np.float64)
g0, g1, g2 = sp.gradient(left)
q = np.empty(shape=(X0.shape) + (6, ), dtype=np.float64)
q[..., 0] = g2 * X1 - g1 * X2
q[..., 1] = g0 * X2 - g2 * X0
q[..., 2] = g1 * X0 - g0 * X1
q[..., 3] = g0
q[..., 4] = g1
q[..., 5] = g2
diff = means[rightQ] - left
Aw, bw = tf.integrateMaskedWeightedTensorFieldProductsCYTHON(
mask, q, diff, numLevels, rightQ, weights)
beta = linalg.solve(Aw, bw)
return beta
def estimateRigidTransformation(left, right):
#compute the centered meshgrid
center=(np.array(right.shape)-1)/2.0
C,R=sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64), np.array(range(right.shape[0]), dtype=np.float64))
R=R-center[0]
C=C-center[1]
#parameter estimation
[dr, dc]=sp.gradient(right)
epsilon=R*dc-C*dr
c=np.array([epsilon,dr,dc]).transpose(1,2,0)
tensorProds=c[:,:,:,None]*c[:,:,None,:]
A=np.sum(np.sum(tensorProds, axis=0), axis=0)
diff=left-right
prod=c*diff[:,:,None]
b=np.sum(np.sum(prod, axis=0), axis=0)
beta=linalg.solve(A,b)
return beta
def estimateNewMonomodalDiffeomorphicField2D(moving, fixed, lambdaParam, maxOuterIter, previousDisplacement, previousDisplacementInverse):
'''
Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
as opposed as lambdaParam=150 used in the multimodal case
'''
innerTolerance=1e-4
displacement =np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
gradientField =np.empty(shape=(moving.shape)+(2,), dtype=np.float64)
totalDisplacement=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
totalDisplacementInverse=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
if(previousDisplacement!=None):
totalDisplacement[...]=previousDisplacement
totalDisplacementInverse[...]=previousDisplacementInverse
outerIter=0
framesToCapture=5
maxOuterIter=framesToCapture*((maxOuterIter+framesToCapture-1)/framesToCapture)
itersPerCapture=maxOuterIter/framesToCapture
plt.figure()
while(outerIter<maxOuterIter):
outerIter+=1
print 'Outer iter:', outerIter
warped=np.array(tf.warp_image(moving, totalDisplacement, None))
if((outerIter==1) or (outerIter%itersPerCapture==0)):
plt.subplot(1,framesToCapture+1, 1+outerIter/itersPerCapture)
rcommon.overlayImages(warped, fixed, False)
plt.title('Iter:'+str(outerIter-1))
sigmaField=np.ones_like(warped, dtype=np.float64)
deltaField=fixed-warped
gradientField[:,:,0], gradientField[:,:,1]=sp.gradient(warped)
maxVariation=1+innerTolerance
innerIter=0
displacement[...]=0
maxInnerIter=200
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, gradientField, lambdaParam, displacement, None)
#maxDisplacement=np.max(np.abs(displacement))
expd, invexpd=tf.vector_field_exponential(displacement, True)
totalDisplacement, stats=tf.compose_vector_fields(displacement, totalDisplacement)
#totalDisplacement=np.array(totalDisplacement)
totalDisplacementInverse, stats=tf.compose_vector_fields(totalDisplacementInverse, invexpd)
#totalDisplacementInverse=np.array(totalDisplacementInverse)
#if(maxDisplacement<outerTolerance):
#break
print "Iter: ",innerIter, "Max variation:",maxVariation
return totalDisplacement, totalDisplacementInverse
def estimateRotationOnly(left, right, maxAngleRads=0, thr=-1):
center=(np.array(right.shape)-1)/2.0
C,R=sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64), np.array(range(right.shape[0]), dtype=np.float64))
R=R-center[0]
C=C-center[1]
[dr, dc]=sp.gradient(right)
prod=R*dc-C*dr
diff=left-right
num=prod*diff
den=prod**2
if(thr>0):
N=np.sqrt((R*maxAngleRads)**2+(C*maxAngleRads)**2)
M=(N<thr)
theta=np.sum(num*M)/np.sum(den*M)
else:
theta=np.sum(num)/np.sum(den)
return theta
def compute_wall_distance(self):
"""
To compute the geodesic distance to the walls in using \
a fast-marching method
"""
phi = sp.ones(self.image_red.shape)
if (len(self.mask_id[0]) > 0):
phi[self.mask_id] = 0
self.wall_distance = skfmm.distance(phi, dx=self.pixel_size)
grad = sp.gradient(self.wall_distance, edge_order=2)
grad_X = grad[1] / self.pixel_size
grad_Y = grad[0] / self.pixel_size
norm = sp.sqrt(grad_X**2 + grad_Y**2)
norm = (norm > 0) * norm + (norm == 0) * 0.001
self.wall_grad_X = grad_X / norm
self.wall_grad_Y = grad_Y / norm
else:
self.wall_distance = 1.0e99 * sp.ones(self.image_red.shape)
def estimateRigidTransformation(left, right):
#compute the centered meshgrid
center = (np.array(right.shape) - 1) / 2.0
C, R = sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64),
np.array(range(right.shape[0]), dtype=np.float64))
R = R - center[0]
C = C - center[1]
#parameter estimation
[dr, dc] = sp.gradient(right)
epsilon = R * dc - C * dr
c = np.array([epsilon, dr, dc]).transpose(1, 2, 0)
tensorProds = c[:, :, :, None] * c[:, :, None, :]
A = np.sum(np.sum(tensorProds, axis=0), axis=0)
diff = left - right
prod = c * diff[:, :, None]
b = np.sum(np.sum(prod, axis=0), axis=0)
beta = linalg.solve(A, b)
return beta
def estimateRotationOnly(left, right, maxAngleRads=0, thr=-1):
center = (np.array(right.shape) - 1) / 2.0
C, R = sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64),
np.array(range(right.shape[0]), dtype=np.float64))
R = R - center[0]
C = C - center[1]
[dr, dc] = sp.gradient(right)
prod = R * dc - C * dr
diff = left - right
num = prod * diff
den = prod**2
if (thr > 0):
N = np.sqrt((R * maxAngleRads)**2 + (C * maxAngleRads)**2)
M = (N < thr)
theta = np.sum(num * M) / np.sum(den * M)
else:
theta = np.sum(num) / np.sum(den)
return theta
def estimateNewMonomodalDiffeomorphicField3D(moving, fixed, lambdaParam, maxOuterIter, previousDisplacement, reportProgress=False):
'''
Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
as opposed as lambdaParam=150 used in the multimodal case
'''
innerTolerance=1e-3
outerTolerance=1e-3
displacement =np.zeros(shape=(moving.shape)+(3,), dtype=np.float64)
residuals=np.zeros(shape=(moving.shape), dtype=np.float64)
gradientField =np.empty(shape=(moving.shape)+(3,), dtype=np.float64)
totalDisplacement=np.zeros(shape=(moving.shape)+(3,), dtype=np.float64)
if(previousDisplacement!=None):
totalDisplacement[...]=previousDisplacement
outerIter=0
while(outerIter<maxOuterIter):
outerIter+=1
if(reportProgress):
print 'Iter:',outerIter,'/',maxOuterIter
warped=np.array(tf.warp_volume(moving, totalDisplacement))
sigmaField=np.ones_like(warped, dtype=np.float64)
deltaField=fixed-warped
g0, g1, g2=sp.gradient(warped)
gradientField[:,:,:,0]=g0
gradientField[:,:,:,1]=g1
gradientField[:,:,:,2]=g2
maxVariation=1+innerTolerance
innerIter=0
maxResidual=0
displacement[...]=0
maxInnerIter=50
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField3DCYTHON(deltaField, sigmaField, gradientField, lambdaParam, totalDisplacement, displacement, residuals)
opt=np.max(residuals)
if(maxResidual<opt):
maxResidual=opt
maxDisplacement=np.max(np.abs(displacement))
totalDisplacement, stats=tf.compose_vector_fields3D(displacement, totalDisplacement)
if(maxDisplacement<outerTolerance):
break
print "Iter: ",outerIter, "Max lateral displacement:", maxDisplacement, "Max variation:",maxVariation, "Max residual:", maxResidual
if(previousDisplacement!=None):
return totalDisplacement-previousDisplacement
return totalDisplacement
def outlier_removed_fit(m, w=None, n_iter=10, polyord=7):
"""
Remove outliers using fited data.
Args:
m (:obj:`numpy array`): Phase curve.
n_iter (:obj:'int'): Number of iteration outlier removal
polyorder (:obj:'int'): Order of polynomial used.
Returns:
fit (:obj:'numpy array'): Curve with outliers removed
"""
if w is None:
w = sp.ones_like(m)
W = sp.diag(sp.sqrt(w))
m2 = sp.copy(m)
tv = sp.linspace(-1, 1, num=len(m))
A = sp.zeros([len(m), polyord])
for j in range(polyord):
A[:, j] = tv**(float(j))
A2 = sp.dot(W, A)
m2w = sp.dot(m2, W)
fit = None
for i in range(n_iter):
xhat = sp.linalg.lstsq(A2, m2w)[0]
fit = sp.dot(A, xhat)
# use gradient for central finite differences which keeps order
resid = sp.gradient(fit - m2)
std = sp.std(resid)
bidx = sp.where(sp.absolute(resid) > 2.0 * std)[0]
for bi in bidx:
A2[bi, :] = 0.0
m2[bi] = 0.0
m2w[bi] = 0.0
if debug_plot:
plt.plot(m2, label="outlier removed")
plt.plot(m, label="original")
plt.plot(fit, label="fit")
plt.legend()
plt.ylim([sp.minimum(fit) - std * 3.0, sp.maximum(fit) + std * 3.0])
plt.show()
return (fit)
def estimateNewRigidTransformation(left, right, previousBeta=None):
epsilon=1e-9
center=(np.array(right.shape)-1)/2.0
C,R=sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64), np.array(range(right.shape[0]), dtype=np.float64))
R=R-center[0]
C=C-center[1]
if((previousBeta!=None) and (np.max(np.abs(previousBeta))>epsilon)):
a=np.cos(previousBeta[0])
b=np.sin(previousBeta[0])
Rnew,Cnew=(a*R-b*C+2.0*previousBeta[1]+center[0], b*R+a*C+2.0*previousBeta[2]+center[1])
right=ndimage.map_coordinates(right, [Rnew,Cnew], prefilter=const_prefilter_map_coordinates)
[dr, dc]=sp.gradient(right)
epsilon=R*dc-C*dr
c=np.array([epsilon,dr,dc]).transpose(1,2,0)
tensorProds=c[:,:,:,None]*c[:,:,None,:]
A=np.sum(np.sum(tensorProds, axis=0), axis=0)
diff=left-right
prod=c*diff[:,:,None]
b=np.sum(np.sum(prod, axis=0), axis=0)
beta=linalg.solve(A,b)
return beta
def estimateNewMultimodalRigidTransformation2D_ecqmmf(moving,
fixed,
probs,
nclasses,
previousBeta=None):
epsilon = 1e-9
sh = moving.shape
center = (np.array(sh) - 1) / 2.0
X0, X1 = np.mgrid[0:sh[0], 0:sh[1]]
X0 = X0 - center[0]
X1 = X1 - center[1]
mask = np.ones_like(X0, dtype=np.int32)
if ((previousBeta != None) and (np.max(np.abs(previousBeta)) > epsilon)):
R = rcommon.getRotationMatrix2D(previousBeta[0])
X0new, X1new = (R[0, 0] * X0 + R[0, 1] * X1 + center[0] +
2.0 * previousBeta[1], R[1, 0] * X0 + R[1, 1] * X1 +
center[1] + 2.0 * previousBeta[2])
moving = ndimage.map_coordinates(
moving, [X0new, X1new], prefilter=const_prefilter_map_coordinates)
mask[...] = (X0new < 0) + (X0new > (sh[0] - 1))
mask[...] = mask + (X1new < 0) + (X1new > (sh[1] - 1))
mask[...] = 1 - mask
means, variances = tf.computeMaskedVolumeClassStatsProbsCYTHON(
mask, moving, probs)
means = np.array(means)
weights = np.array([1.0 / x if (x > 0) else 0 for x in variances],
dtype=np.float64)
g0, g1 = sp.gradient(moving)
q = np.empty(shape=(X0.shape) + (3, ), dtype=np.float64)
q[..., 0] = g1 * X0 - g0 * X1
q[..., 1] = g0
q[..., 2] = g1
expected = probs.dot(means)
diff = expected - moving
Aw, bw = tf.integrateMaskedWeightedTensorFieldProductsCYTHON(
mask, q, diff, numLevels, rightQ, weights)
beta = linalg.solve(Aw, bw)
return beta
def filter_high_gradients(data_map):
r"""
Filters the offset field to reduce the number of very steep gradients.
The magnitude of the gradient is taken and all values less than or
greater than +-99th percentile are removed and recalculated.
"""
#
logger.info('filtering offset map to remove steeply sloped cells')
#
zdir_grad, xdir_grad = sp.gradient(data_map)
mag = sp.sqrt(zdir_grad**2 + xdir_grad**2)
data_map += 1
data_vector = sp.ravel(data_map)
#
# setting regions outside of 99th percentile to 0 for cluster removal
val = calc_percentile(99, sp.ravel(mag))
data_map[zdir_grad < -val] = 0
data_map[zdir_grad > val] = 0
data_map[xdir_grad < -val] = 0
data_map[xdir_grad > val] = 0
#
logger.debug('\tremoving clusters isolated by high gradients')
offsets = DataField(data_map)
adj_mat = offsets.create_adjacency_matrix()
cs_num, cs_ids = csgraph.connected_components(csgraph=adj_mat,
directed=False)
cs_num, counts = sp.unique(cs_ids, return_counts=True)
cs_num = cs_num[sp.argsort(counts)][-1]
#
data_vector[sp.where(cs_ids != cs_num)[0]] = sp.nan
data_map = sp.reshape(data_vector, data_map.shape)
#
# re-interpolating for the nan regions
logger.debug('\tpatching holes left by cluster removal')
patch_holes(data_map)
#
return data_map
def estimateNewRotation(left, right, previousAngleRadians, maxAngleRads=0, thr=-1):
epsilon=1e-9
center=(np.array(right.shape)-1)/2.0
C,R=sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64), np.array(range(right.shape[0]), dtype=np.float64))
R=R-center[0]
C=C-center[1]
if(np.abs(previousAngleRadians)>epsilon):
a=np.cos(previousAngleRadians)
b=np.sin(previousAngleRadians)
Rnew,Cnew=(a*R-b*C+center[0], b*R+a*C+center[1])
right=ndimage.map_coordinates(right, [Rnew,Cnew], prefilter=const_prefilter_map_coordinates)
[dr, dc]=sp.gradient(right)
prod=R*dc-C*dr
diff=left-right
num=prod*diff
den=prod**2
theta=0
if(thr>0):
N=np.sqrt((R*maxAngleRads)**2+(C*maxAngleRads)**2)
M=(N<thr)
theta=np.sum(num*M)/np.sum(den*M)
else:
theta=np.sum(num)/np.sum(den)
return theta
def estimateNewRigidTransformation(left, right, previousBeta=None):
epsilon = 1e-9
center = (np.array(right.shape) - 1) / 2.0
C, R = sp.meshgrid(np.array(range(right.shape[1]), dtype=np.float64),
np.array(range(right.shape[0]), dtype=np.float64))
R = R - center[0]
C = C - center[1]
if ((previousBeta != None) and (np.max(np.abs(previousBeta)) > epsilon)):
a = np.cos(previousBeta[0])
b = np.sin(previousBeta[0])
Rnew, Cnew = (a * R - b * C + 2.0 * previousBeta[1] + center[0],
b * R + a * C + 2.0 * previousBeta[2] + center[1])
right = ndimage.map_coordinates(
right, [Rnew, Cnew], prefilter=const_prefilter_map_coordinates)
[dr, dc] = sp.gradient(right)
epsilon = R * dc - C * dr
c = np.array([epsilon, dr, dc]).transpose(1, 2, 0)
tensorProds = c[:, :, :, None] * c[:, :, None, :]
A = np.sum(np.sum(tensorProds, axis=0), axis=0)
diff = left - right
prod = c * diff[:, :, None]
b = np.sum(np.sum(prod, axis=0), axis=0)
beta = linalg.solve(A, b)
return beta
## I-------------wall2----------------I
## wall3 wall1
## I---wall0---pL--door--pR---wall0---I
dist_wall2 = y1 - dom.Y
dist_wall1 = x3 - dom.X
dist_wall3 = dom.X - x0
dist_wall0 = (dom.X<=x1)*(dom.Y-y0) + \
(dom.X>=x2)*(dom.Y-y0) + \
(dom.X>x1)*(dom.X<x2)*sp.minimum( \
sp.sqrt((dom.X-x1)**2+(dom.Y-y0)**2), \
sp.sqrt((dom.X-x2)**2+(dom.Y-y0)**2) \
)
wall_distance = sp.ma.MaskedArray(sp.minimum(sp.minimum(sp.minimum( \
dist_wall0,dist_wall1),dist_wall2),dist_wall3), mask=mask \
)
grad = sp.gradient(wall_distance, edge_order=2)
grad_X = grad[1] / pixel_size
grad_Y = grad[0] / pixel_size
norm = sp.sqrt(grad_X**2 + grad_Y**2)
wall_grad_X = grad_X / norm
wall_grad_Y = grad_Y / norm
dom.wall_distance = wall_distance
dom.wall_grad_X = wall_grad_X
dom.wall_grad_Y = wall_grad_Y
dom.plot()
dom.plot_wall_dist(id=2)
dom.plot_desired_velocity(id=3)
## Custom plot function
fig = plt.figure(10)
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 Gradient(potentiel):
Ey, Ex = gradient(potentiel)
Ex = -Ex
Ey = -Ey
return Ex, Ey
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the transfer functions (hidden random variables) and
variances of the estimators. Also pre-computes the gradient of both
input images. Note that once the images are transformed to the opposite
modality, the gradient of the transformed images can be used with the
gradient of the corresponding modality in the same fashion as
diff-demons does for mono-modality images. If the flag
self.use_double_gradient is True these gradients are averaged.
"""
sampling_mask = self.static_image_mask*self.moving_image_mask
self.sampling_mask = sampling_mask
staticq, self.staticq_levels, hist = self.quantize(self.static_image,
self.q_levels)
staticq = np.array(staticq, dtype=np.int32)
self.staticq_levels = np.array(self.staticq_levels)
staticq_means, staticq_vars = self.compute_stats(sampling_mask,
self.moving_image,
self.q_levels,
staticq)
staticq_means[0] = 0
self.staticq_means = np.array(staticq_means)
self.staticq_variances = np.array(staticq_vars)
self.staticq_sigma_sq_field = self.staticq_variances[staticq]
self.staticq_means_field = self.staticq_means[staticq]
self.gradient_moving = np.empty(
shape=(self.moving_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(
shape=(self.static_image.shape)+(self.dim,), dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
movingq, self.movingq_levels, hist = self.quantize(self.moving_image,
self.q_levels)
movingq = np.array(movingq, dtype=np.int32)
self.movingq_levels = np.array(self.movingq_levels)
movingq_means, movingq_variances = self.compute_stats(
sampling_mask, self.static_image, self.q_levels, movingq)
movingq_means[0] = 0
self.movingq_means = np.array(movingq_means)
self.movingq_variances = np.array(movingq_variances)
self.movingq_sigma_sq_field = self.movingq_variances[movingq]
self.movingq_means_field = self.movingq_means[movingq]
if self.use_double_gradient:
for i, grad in enumerate(sp.gradient(self.staticq_means_field)):
self.gradient_moving[..., i] += grad
for i, grad in enumerate(sp.gradient(self.movingq_means_field)):
self.gradient_static[..., i] += grad
def initialize_iteration(self):
r"""Prepares the metric to compute one displacement field iteration.
Pre-computes the transfer functions (hidden random variables) and
variances of the estimators. Also pre-computes the gradient of both
input images. Note that once the images are transformed to the opposite
modality, the gradient of the transformed images can be used with the
gradient of the corresponding modality in the same fashion as
diff-demons does for mono-modality images. If the flag
self.use_double_gradient is True these gradients are averaged.
"""
sampling_mask = self.static_image_mask * self.moving_image_mask
self.sampling_mask = sampling_mask
staticq, self.staticq_levels, hist = self.quantize(
self.static_image, self.q_levels)
staticq = np.array(staticq, dtype=np.int32)
self.staticq_levels = np.array(self.staticq_levels)
staticq_means, staticq_vars = self.compute_stats(
sampling_mask, self.moving_image, self.q_levels, staticq)
staticq_means[0] = 0
self.staticq_means = np.array(staticq_means)
self.staticq_variances = np.array(staticq_vars)
self.staticq_sigma_sq_field = self.staticq_variances[staticq]
self.staticq_means_field = self.staticq_means[staticq]
self.gradient_moving = np.empty(shape=(self.moving_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.moving_image)):
self.gradient_moving[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.moving_spacing is not None:
self.gradient_moving /= self.moving_spacing
if self.moving_direction is not None:
self.reorient_vector_field(self.gradient_moving,
self.moving_direction)
self.gradient_static = np.empty(shape=(self.static_image.shape) +
(self.dim, ),
dtype=floating)
for i, grad in enumerate(sp.gradient(self.static_image)):
self.gradient_static[..., i] = grad
# Convert moving image's gradient field from voxel to physical space
if self.static_spacing is not None:
self.gradient_static /= self.static_spacing
if self.static_direction is not None:
self.reorient_vector_field(self.gradient_static,
self.static_direction)
movingq, self.movingq_levels, hist = self.quantize(
self.moving_image, self.q_levels)
movingq = np.array(movingq, dtype=np.int32)
self.movingq_levels = np.array(self.movingq_levels)
movingq_means, movingq_variances = self.compute_stats(
sampling_mask, self.static_image, self.q_levels, movingq)
movingq_means[0] = 0
self.movingq_means = np.array(movingq_means)
self.movingq_variances = np.array(movingq_variances)
self.movingq_sigma_sq_field = self.movingq_variances[movingq]
self.movingq_means_field = self.movingq_means[movingq]
if self.use_double_gradient:
for i, grad in enumerate(sp.gradient(self.staticq_means_field)):
self.gradient_moving[..., i] += grad
for i, grad in enumerate(sp.gradient(self.movingq_means_field)):
self.gradient_static[..., i] += grad
def sampling(data, size, gauss):
dx, dy = scipy.gradient(data)
edges = np.abs(dx) + np.abs(dy)
return equalize(edges, size, gauss=gauss)
def estimateNewMonomodalSyNField2D(moving, fixed, fWarp, fInv, mWarp, mInv, lambdaParam, maxOuterIter):
'''
Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
as opposed as lambdaParam=150 used in the multimodal case
'''
innerTolerance=1e-4
outerTolerance=1e-3
if(mWarp!=None):
totalM=mWarp
totalMInv=mInv
else:
totalM=np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
totalMInv=np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
if(fWarp!=None):
totalF=fWarp
totalFInv=fInv
else:
totalF=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
totalFInv=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
outerIter=0
framesToCapture=5
maxOuterIter=framesToCapture*((maxOuterIter+framesToCapture-1)/framesToCapture)
itersPerCapture=maxOuterIter/framesToCapture
plt.figure()
while(outerIter<maxOuterIter):
outerIter+=1
print 'Outer iter:', outerIter
wmoving=np.array(tf.warp_image(moving, totalMInv))
wfixed=np.array(tf.warp_image(fixed, totalFInv))
if((outerIter==1) or (outerIter%itersPerCapture==0)):
plt.subplot(1,framesToCapture+1, 1+outerIter/itersPerCapture)
rcommon.overlayImages(wmoving, wfixed, False)
plt.title('Iter:'+str(outerIter-1))
#Compute forward update
sigmaField=np.ones_like(wmoving, dtype=np.float64)
deltaField=wfixed-wmoving
movingGradient =np.empty(shape=(wmoving.shape)+(2,), dtype=np.float64)
movingGradient[:,:,0], movingGradient[:,:,1]=sp.gradient(wmoving)
maxVariation=1+innerTolerance
innerIter=0
fw =np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
maxInnerIter=1000
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, movingGradient, lambdaParam, fw, None)
#fw*=0.5
totalF, stats=tf.compose_vector_fields(fw, totalF)
totalF=np.array(totalF);
meanDispF=np.mean(np.abs(fw))
#Compute backward field
sigmaField=np.ones_like(wfixed, dtype=np.float64)
deltaField=wmoving-wfixed
fixedGradient =np.empty(shape=(wfixed.shape)+(2,), dtype=np.float64)
fixedGradient[:,:,0], fixedGradient[:,:,1]=sp.gradient(wfixed)
maxVariation=1+innerTolerance
innerIter=0
mw =np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
maxInnerIter=1000
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, fixedGradient, lambdaParam, mw, None)
#mw*=0.5
totalM, stats=tf.compose_vector_fields(mw, totalM)
totalM=np.array(totalM);
meanDispM=np.mean(np.abs(mw))
totalFInv=np.array(tf.invert_vector_field_fixed_point(totalF, None, 20, 1e-3, None))
totalMInv=np.array(tf.invert_vector_field_fixed_point(totalM, None, 20, 1e-3, None))
totalF=np.array(tf.invert_vector_field_fixed_point(totalFInv, None, 20, 1e-3, None))
totalM=np.array(tf.invert_vector_field_fixed_point(totalMInv, None, 20, 1e-3, None))
# totalFInv=np.array(tf.invert_vector_field(totalF, 0.75, 100, 1e-6))
# totalMInv=np.array(tf.invert_vector_field(totalM, 0.75, 100, 1e-6))
# totalF=np.array(tf.invert_vector_field(totalFInv, 0.75, 100, 1e-6))
# totalM=np.array(tf.invert_vector_field(totalMInv, 0.75, 100, 1e-6))
if(meanDispM+meanDispF<2*outerTolerance):
break
print "Iter: ",innerIter, "Mean lateral displacement:", 0.5*(meanDispM+meanDispF), "Max variation:",maxVariation
return totalF, totalFInv, totalM, totalMInv
def estimateNewMultimodalSyNField3D(moving, fixed, fWarp, fInv, mWarp, mInv, initAffine, lambdaDisplacement, quantizationLevels, maxOuterIter, reportProgress=False):
'''
fwWarp: forward warp, the displacement field that warps moving towards fixed
bwWarp: backward warp, the displacement field that warps fixed towards moving
initAffine: the affine transformation to bring moving over fixed (this part is not symmetric)
'''
print 'Moving shape:',moving.shape,'. Fixed shape:',fixed.shape
innerTolerance=1e-3
outerTolerance=1e-3
fixedMask=(fixed>0).astype(np.int32)
movingMask=(moving>0).astype(np.int32)
if(fWarp!=None):
totalF=fWarp
totalFInv=fInv
else:
totalF =np.zeros(shape=(fixed.shape)+(3,), dtype=np.float64)
totalFInv =np.zeros(shape=(fixed.shape)+(3,), dtype=np.float64)
if(mWarp!=None):
totalM=mWarp
totalMInv=mInv
else:
totalM =np.zeros(shape=(moving.shape)+(3,), dtype=np.float64)
totalMInv=np.zeros(shape=(moving.shape)+(3,), dtype=np.float64)
finished=False
outerIter=0
while((not finished) and (outerIter<maxOuterIter)):
outerIter+=1
if(reportProgress):
print 'Iter:',outerIter,'/',maxOuterIter
#---E step---
wmoving=np.array(tf.warp_volume(moving, totalMInv, initAffine))
wmovingMask=np.array(tf.warp_discrete_volumeNN(movingMask, totalMInv, initAffine)).astype(np.int32)
wfixed=np.array(tf.warp_volume(fixed, totalFInv))
wfixedMask=np.array(tf.warp_discrete_volumeNN(fixedMask, totalFInv)).astype(np.int32)
fixedQ, grayLevels, hist=tf.quantizePositiveVolumeCYTHON(wfixed, quantizationLevels)
fixedQ=np.array(fixedQ, dtype=np.int32)
movingQ, grayLevels, hist=tf.quantizePositiveVolumeCYTHON(wmoving, quantizationLevels)
movingQ=np.array(movingQ, dtype=np.int32)
trust=wfixedMask*wmovingMask
meansMoving, variancesMoving=tf.computeMaskedVolumeClassStatsCYTHON(trust, wmoving, quantizationLevels, fixedQ)
meansFixed, variancesFixed=tf.computeMaskedVolumeClassStatsCYTHON(trust, wfixed, quantizationLevels, movingQ)
meansMoving[0]=0
meansFixed[0]=0
meansMoving=np.array(meansMoving)
meansFixed=np.array(meansFixed)
variancesMoving=np.array(variancesMoving)
sigmaFieldMoving=variancesMoving[fixedQ]
variancesFixed=np.array(variancesFixed)
sigmaFieldFixed=variancesFixed[movingQ]
deltaFieldMoving=meansMoving[fixedQ]-wmoving
deltaFieldFixed=meansFixed[movingQ]-wfixed
#--M step--
movingGradient =np.empty(shape=(moving.shape)+(3,), dtype=np.float64)
movingGradient[:,:,:,0], movingGradient[:,:,:,1], movingGradient[:,:,:,2]=sp.gradient(wmoving)
#iterate forward field
maxVariation=1+innerTolerance
innerIter=0
maxInnerIter=100
fw=np.zeros_like(totalF)
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField3DCYTHON(deltaFieldMoving, sigmaFieldMoving, movingGradient, lambdaDisplacement, totalF, fw, None)
del movingGradient
fw*=0.5
totalF=np.array(tf.compose_vector_fields3D(fw, totalF))#Multiply fw by 0.5??
nrm=np.sqrt(fw[...,0]**2+fw[...,1]**2+fw[...,2]**2)
del fw
#iterate backward field
fixedGradient =np.empty(shape=(fixed.shape)+(3,), dtype=np.float64)
fixedGradient[:,:,:,0], fixedGradient[:,:,:,1], fixedGradient[:,:,:,2]=sp.gradient(wfixed)
maxVariation=1+innerTolerance
innerIter=0
maxInnerIter=100
mw=np.zeros_like(totalM)
while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
innerIter+=1
maxVariation=tf.iterateDisplacementField3DCYTHON(deltaFieldFixed, sigmaFieldFixed, fixedGradient, lambdaDisplacement, totalM, mw, None)
del fixedGradient
mw*=0.5
totalM=np.array(tf.compose_vector_fields3D(mw, totalM))#Multiply bw by 0.5??
nrm=np.sqrt(mw[...,0]**2+mw[...,1]**2+mw[...,2]**2)
del mw
#invert fields
totalFInv=np.array(tf.invert_vector_field_fixed_point3D(totalF, 20, 1e-6))
totalMInv=np.array(tf.invert_vector_field_fixed_point3D(totalM, 20, 1e-6))
totalF=np.array(tf.invert_vector_field_fixed_point3D(totalFInv, 20, 1e-6))
totalM=np.array(tf.invert_vector_field_fixed_point3D(totalMInv, 20, 1e-6))
maxDisplacement=np.mean(nrm)
if((maxDisplacement<outerTolerance)or(outerIter>=maxOuterIter)):
finished=True
print "Iter: ",outerIter, "Mean displacement:", maxDisplacement, "Max variation:",maxVariation
return totalF, totalFInv, totalM, totalMInv
def parse(fname, level, step, window):
if not os.path.isfile(fname):
print 'Error: could not open %s' % fname
sys.exit('Stopping')
oname = fname + '.wig'
fp = open(oname, 'wt')
fp.write('track type=wiggle_0\n')
fedges = open(fname + '.edges.bed', 'w')
# mat file parsing parsing
from MAT import AffyFileParser
bar = AffyFileParser.CBARFileWriter()
print fname
bar.SetFileName(fname)
if not bar.Read():
raise Exception('Unable to properly read %s' % fname)
seq = AffyFileParser.CGDACSequenceResultItem()
data = AffyFileParser.BarSequenceResultData()
seq_range = range(bar.GetNumberSequences() - 1)
for s in seq_range:
bar.GetResults(s, seq)
name = seq.GetName()
if name in ['XIST', 'chloroplast', 'NC_000964.1']:
continue
read_counts = sp.zeros(sizes[name] // binsize + 1)
for i in range(0, seq.GetNumberDataPoints() - 1, step):
seq.GetData(i, 0, data)
x = data.iValue
seq.GetData(i, 1, data)
y = data.fValue
out = '%s\t%s\t%s\t%s\n' % (name, x - 1, x, y)
fp.write(out)
read_counts[x // binsize] += y
d = sp.gradient(read_counts)
d2 = sp.gradient(d)
d = sp.array([0] + list(d[:-1]))
d2 = sp.array([0, 0] + list(d2[:-2]))
#smoothed = smooth(read_counts, window_len=3)
#read_counts[(read_counts > -.5) & (read_counts < .5)] = 0
smoothed = blur_image(read_counts, window_size)
#smooth_d = sp.gradient(smoothed)
#smooth_d2 = sp.gradient(smooth_d)
pos_to_neg = sp.diff(sp.sign(smoothed)) < 0
#decreasing = (sp.diff(smoothed) < 0)
#for x_d in ((smoothed > 1) & (smooth_d < 1)).nonzero()[0]:
#for x_d in sp.nonzero(pos_to_neg & decreasing)[0]:
for x_d in sp.nonzero(pos_to_neg)[0]:
fedges.write('\t'.join(
map(str, [name, (x_d + 1) * binsize, (x_d + 2) * binsize])) +
'\n')
print '...saved bar data to: %s' % oname
def computeJacobianField(displacement):
g00,g01=sp.gradient(displacement[...,0])
g10,g11=sp.gradient(displacement[...,1])
return (1+g00)*(1+g11)-g10*g01
def plotgradlines(inputlist,fitiono,alt,times,paramlist=['Ne','Te','Ti']):
"""
Plots the values along a specific alittude.
"""
inputiono = makeionocombined(inputlist)
Iono1 = GeoData(readIono,[inputiono])
fitiono = IonoContainer.readh5(fitiono)
fitGeo = GeoData(readIono,[fitiono])
paramlist = ['Ne','Te','Ti']
(x,y,z) = inputiono.Cart_Coords.transpose()
r = sp.sqrt(x**2+y**2)*sp.sign(y)
incoords = sp.column_stack((r,z,sp.ones_like(z)))
ru,zu =[ sp.unique(r),sp.unique(z)]
Rmat,Zmat = sp.meshgrid(ru,zu)
zinput = sp.argmin(sp.absolute(zu-alt))
(xf,yf,zf) = fitiono.Cart_Coords.transpose()
rf = sp.sqrt(xf**2+yf**2)*sp.sign(yf)
outcoords = sp.column_stack((rf,zf,sp.ones_like(zf)))
rfu,zfu =[ sp.unique(rf),sp.unique(zf)]
Rfmat,Zfmat = sp.meshgrid(rfu,zfu)
zoutput = sp.argmin(sp.absolute(zfu-alt))
fitGeo.interpolate(incoords,Iono1.coordnames,method='linear',fill_value=sp.nan,twodinterp = True,oldcoords=outcoords)
uz = sp.unique(z)
ur = sp.unique(r)
(rmat,zmat) = sp.meshgrid(ur,uz)
inputdata = {}
for iparm in paramlist:
if iparm =='Nepow':
iparm='Ne'
curdata = Iono1.data[iparm][:,times[0]]
inputdata[iparm] = sp.reshape(curdata,Rmat.shape)[zinput]
outputdata = {}
for iparm in paramlist:
curdata = fitGeo.data[iparm][:, times[1]]
outputdata[iparm] = sp.reshape(curdata,Rmat.shape)[zinput]
fig, axvec = plt.subplots(len(paramlist),1,sharey=False,figsize=(12,5*len(paramlist)))
for ipn,iparam in enumerate(paramlist):
ax = axvec[ipn]
ax2 = ax.twinx()
p1, = ax.plot(ru,inputdata[iparam],'b-',label='In',linewidth=3)
p2, = ax.plot(ru,outputdata[iparam],'b--',label='Out',linewidth=3)
ax.set_title(iparam)
ax.set_xlabel('X Plane in km')
gi = sp.gradient(inputdata[iparam])/sp.gradient(ru)
go = sp.gradient(outputdata[iparam])/sp.gradient(ru)
p3, = ax2.plot(ru,gi,'g-',label='Grad In',linewidth=3)
p4, = ax2.plot(ru,go,'g--',label='Grad Out',linewidth=3)
ax.yaxis.label.set_color(p1.get_color())
ax2.yaxis.label.set_color(p3.get_color())
lines = [p1,p2,p3,p4]
ax.legend(lines,[l.get_label() for l in lines])
plt.tight_layout()
return(fig)
def estimateNewECQMMFMultimodalDeformationField2D(fixed, moving, nclasses, lambdaMeasureField, lambdaDisplacement, mu, maxOuterIter, maxInnerIter, tolerance, previousDisplacement=None):
sh=fixed.shape
X0,X1=np.mgrid[0:sh[0], 0:sh[1]]
displacement =np.empty(shape=(fixed.shape)+(2,), dtype=np.float64)
gradientField =np.empty(shape=(fixed.shape)+(2,), dtype=np.float64)
totalDisplacement=np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
gradientField =np.empty(shape=(fixed.shape)+(2,), dtype=np.float64)
residuals =np.zeros_like(fixed)
warped=None
if(previousDisplacement!=None):
totalDisplacement[...]=previousDisplacement
warped=ndimage.map_coordinates(moving, [X0+totalDisplacement[...,0], X1+totalDisplacement[...,1]], prefilter=True)
else:
warped=moving
#run soft segmentation on the fixed image
meansFixed, variancesFixed=ecqmmf.initialize_constant_models(fixed, nclasses)
meansFixed=np.array(meansFixed)
variancesFixed=np.array(variancesFixed)
segFixed, meansFixed, variancesFixed, probsFixed=ecqmmf.ecqmmf(fixed, nclasses, lambdaMeasureField, mu, maxOuterIter, maxInnerIter, tolerance)
meansFixed=np.array(meansFixed)
probsFixed=np.array(probsFixed)
#run soft segmentation on the warped image
meansWarped, variancesWarped=ecqmmf.initialize_constant_models(warped, nclasses)
meansWarped=np.array(meansWarped)
variancesWarped=np.array(variancesWarped)
segWarped, meansWarped, variancesWarped, probsWarped=ecqmmf.ecqmmf(warped, nclasses, lambdaMeasureField, mu, maxOuterIter, maxInnerIter, tolerance)
meansWarped=np.array(meansWarped)
probsWarped=np.array(probsWarped)
#inicialize the joint models (solve assignment problem)
ecqmmf_reg.initialize_coupled_constant_models(probsFixed, probsWarped, meansWarped)
#start optimization
outerIter=0
negLogLikelihood=np.zeros_like(probsFixed)
while(outerIter<maxOuterIter):
outerIter+=1
print "Outer:", outerIter
if(outerIter>1):#avoid warping twice at the first iteration
warped=ndimage.map_coordinates(moving, [X0+totalDisplacement[...,0], X1+totalDisplacement[...,1]], prefilter=True)
movingMask=(moving>0)*1.0
warpedMask=ndimage.map_coordinates(movingMask, [X0+totalDisplacement[...,0], X1+totalDisplacement[...,1]], order=0, prefilter=False)
warpedMask=warpedMask.astype(np.int32)
#--- optimize the measure field and the intensity models ---
ecqmmf_reg.compute_registration_neg_log_likelihood_constant_models(fixed, warped, meansFixed, meansWarped, negLogLikelihood)
#ecqmmf.initialize_normalized_likelihood(negLogLikelihood, probsWarped)
ecqmmf.initialize_maximum_likelihood(negLogLikelihood, probsWarped);
innerIter=0
mse=0
while(innerIter<maxInnerIter):
innerIter+=1
print "\tInner:",innerIter
ecqmmf.optimize_marginals(negLogLikelihood, probsWarped, lambdaMeasureField, mu, maxInnerIter, tolerance)
mseFixed=ecqmmf.update_constant_models(fixed, probsWarped, meansFixed, variancesFixed)
mseWarped=ecqmmf.update_constant_models(warped, probsWarped, meansWarped, variancesWarped)
mse=np.max([mseFixed, mseWarped])
if(mse<tolerance):
break
#---given the intensity models and the measure field, compute the displacement
deltaField=meansWarped[None, None, :]-warped[:,:,None]
gradientField[:,:,0], gradientField[:,:,1]=sp.gradient(warped)
maxDisplacement=ecqmmf_reg.optimize_ECQMMF_displacement_field_2D(deltaField, gradientField, probsWarped, lambdaDisplacement, displacement, residuals, maxInnerIter, tolerance)
totalDisplacement+=displacement
if(maxDisplacement<tolerance):
break
plt.figure()
plt.subplot(2,2,1)
plt.imshow(fixed, cmap=plt.cm.gray)
plt.title("fixed")
plt.subplot(2,2,2)
plt.imshow(warped, cmap=plt.cm.gray)
plt.title("moving")
plt.subplot(2,2,3)
plt.imshow(probsFixed.dot(meansFixed), cmap=plt.cm.gray)
plt.title("E[fixed]")
plt.subplot(2,2,4)
plt.imshow(probsWarped.dot(meansWarped), cmap=plt.cm.gray)
plt.title("E[moving]")
return totalDisplacement
def angleofgradient(x,*args, **kwargs): g0=scipy.gradient(x,*args,**kwargs) return numpy.angle(g0[0]+g0[1]*1J)
