def f(x, datareg, rot):
# x : input parameters. If x.shape[0] = 6, optimization is performed for rigid transforms. If x.shape[0]=3, optimization is performed only for translation
# datareg : container containing all required information for minimization
# rot : input array that may contain list of rotation values (in this case, only translation is estimated)
if x.shape[0] == 6:
realParameter = (
x - datareg.Kcte
) / datareg.K # x is the parameter of the transformation multiplied by datareg.K
else:
realParameter = np.zeros(
6
) # x is the parameter of the transformation multiplied by datareg.K
realParameter[0:3] = np.copy(x)
realParameter[3:6] = np.copy(rot)
realParameter = (
realParameter - datareg.Kcte
) / datareg.K # x is the parameter of the transformation multiplied by datareg.K
Mref2in = computeMref2in(
realParameter, datareg) #Compute transform from refimage to inputimage
#Apply current transform on input image and mask
warpedarray = affine_transform(datareg.inputarray,
Mref2in[0:3, 0:3],
offset=Mref2in[0:3, 3],
output_shape=datareg.refarray.shape,
order=1,
mode='constant',
cval=np.nan,
prefilter=False)
warpedmask = affine_transform(datareg.inputmask,
Mref2in[0:3, 0:3],
offset=Mref2in[0:3, 3],
output_shape=datareg.refarray.shape,
order=0,
mode='constant',
cval=0,
prefilter=False)
#Compute similarity criterion
index = np.multiply(~np.isnan(warpedarray), warpedmask > 0)
index = np.multiply(datareg.refindex, index)
refval = datareg.refarray[index]
inval = warpedarray[index]
res = datareg.criterium.compute(refval, inval)
#Check if overlap between the two images is enough ... otherwise return infinity
overlap = np.sum(index) * 100.0 / np.sum(datareg.refindex)
if overlap < 5.0:
res = 100000 # np.inf to remove warning during execution
#print '-----------------'
#print "compute"
#print realParameter
#print res
#print '-----------------'
return res
def rotation_zoom3D(X, y):
"""
Rotate a 3D image with alfa, beta and gamma degree respect the axis x, y and z respectively.
The three angles are chosen randomly between 0-30 degrees
"""
alpha, beta, gamma = np.random.random_sample(3) * np.pi / 2
Rx = np.array([[1, 0, 0], [0, np.cos(alpha), -np.sin(alpha)],
[0, np.sin(alpha), np.cos(alpha)]])
Ry = np.array([[np.cos(beta), 0, np.sin(beta)], [0, 1, 0],
[-np.sin(beta), 0, np.cos(beta)]])
Rz = np.array([[np.cos(gamma), -np.sin(gamma), 0],
[np.sin(gamma), np.cos(gamma), 0], [0, 0, 1]])
R_rot = np.dot(np.dot(Rx, Ry), Rz)
a, b = 0.8, 1.2
alpha, beta, gamma = (b - a) * np.random.random_sample(3) + a
R_scale = np.array([[alpha, 0, 0], [0, beta, 0], [0, 0, gamma]])
R = np.dot(R_rot, R_scale)
X_rot = np.empty_like(X)
for channel in range(X.shape[-1]):
X_rot[:, :, :, channel] = affine_transform(X[:, :, :, channel],
R,
offset=0,
order=1,
mode='constant')
y_rot = affine_transform(y, R, offset=0, order=0, mode='constant')
return X_rot, y_rot
def rotation3D(X, y):
"""
Rotate a 3D image with alfa, beta and gamma degree respect the axis x, y and z respectively.
The three angles are chosen randomly between 0-30 degrees
"""
alpha, beta, gamma = np.random.randint(0, 31, size=3) / 180 * np.pi
Rx = np.array([[1, 0, 0], [0, np.cos(alpha), -np.sin(alpha)],
[0, np.sin(alpha), np.cos(alpha)]])
Ry = np.array([[np.cos(beta), 0, np.sin(beta)], [0, 1, 0],
[-np.sin(beta), 0, np.cos(beta)]])
Rz = np.array([[np.cos(gamma), -np.sin(gamma), 0],
[np.sin(gamma), np.cos(gamma), 0], [0, 0, 1]])
R = np.dot(np.dot(Rx, Ry), Rz)
X_rot = np.empty_like(X)
for channel in range(X.shape[-1]):
X_rot[:, :, :, channel] = affine_transform(X[:, :, :, channel],
R,
offset=0,
order=3,
mode='constant')
y_rot = affine_transform(y, R, offset=0, order=0, mode='constant')
return X_rot, y_rot
def rotation3D(X, y):
# 3D random rotations between 0°-30°
channel_y = np.shape(y)[0]
alpha, beta, gamma = np.random.randint(0, 31, size=3) / 180 * np.pi
Rx = np.array([[1, 0, 0], [0, np.cos(alpha), -np.sin(alpha)],
[0, np.sin(alpha), np.cos(alpha)]])
Ry = np.array([[np.cos(beta), 0, np.sin(beta)], [0, 1, 0],
[-np.sin(beta), 0, np.cos(beta)]])
Rz = np.array([[np.cos(gamma), -np.sin(gamma), 0],
[np.sin(gamma), np.cos(gamma), 0], [0, 0, 1]])
R = np.dot(np.dot(Rx, Ry), Rz)
X_rot = np.empty_like(X)
y_rot = np.empty_like(y)
for channel in range(X.shape[0]):
X_rot[channel, :, :, :] = affine_transform(X[channel, :, :, :],
R,
offset=0,
order=3,
mode='constant')
for i in range(channel_y):
y_rot[i, :] = affine_transform(y[i, :],
R,
offset=0,
order=0,
mode='constant')
return X_rot, y_rot
def sample(self, lesion):
# We first go from subject space to train space of the VAE
# Since we are using scipy affine transform that takes an INVERSE transformation
# we pass to the function the inverse of subjectToTrainMat, so trainToSubjectMat
lesionTrainSpace = affine_transform(lesion,
self.trainToSubjectMat,
output_shape=self.net_shape,
order=1)
# We go through the VAE to get the factorized prior
# tensorflow wants a 5 dimensional input where the first dimension is batch number
# and last dimension is number of channels, both set to 1 in our case.
expandedLesion = np.expand_dims(np.expand_dims(lesionTrainSpace, 0), 4)
lesionVAETrainSpace = np.squeeze(
np.squeeze(
self.sess.run(self.net,
{self.lesionPlaceholder: expandedLesion}), 4), 0)
# We then go back to subject space from train space
# Also here, since we are using scipy affine transform that takes an INVERSE transformation
# we pass to the function the inverse of trainToSubjectMat, so subjectToTrainMat
lesionPriorVAE = affine_transform(lesionVAETrainSpace,
self.subjectToTrainMat,
output_shape=self.imageSize,
order=1)
return lesionPriorVAE
def transform(self, xb, yb):
xb, yb = super(Affine3DTransformBatchIterator,
self).transform(xb, yb)
# Skip if affine_p is 0. Setting affine_p may be useful for quickly
# disabling affine transformation
if self.affine_p == 0:
return xb, yb
seed = np.random.randint(clock())
xb_transformed = xb.copy()
if isinstance(xb, dict):
for k in self.input_layers:
np.random.seed(seed)
x_t = np.random.permutation(xb_transformed[k])
for i in range(int(x_t.shape[0] * self.affine_p)):
t = random_affine3d_matrix()
img_transformed = affine_transform(x_t[i], t)
xb_transformed[k][i] = img_transformed
else:
np.random.seed(seed)
xb_transformed = np.random.permutation(xb)
for i in range(int(xb.shape[0] * self.affine_p)):
t = random_affine3d_matrix
img_transformed = affine_transform(xb[i], t)
xb_transformed[i] = img_transformed
return xb_transformed, yb
def scale_and_rotate_image(im, angle=0.0, scale=None, order=5):
""" Scale and then rotate and image in x, y axes
Applies scale then rotates
:param im: Image
:param angle: Angle in radians
:param scale: Scale [scale_x, scale_y]
:param order: Order of interpolation (0-5)
:return:
"""
from scipy.ndimage.interpolation import affine_transform
nchan, npol, ny, nx = im.shape
c_in = 0.5 * numpy.array([ny, nx])
c_out = 0.5 * numpy.array([ny, nx])
rot = numpy.array([[numpy.cos(angle), -numpy.sin(angle)],
[numpy.sin(angle), numpy.cos(angle)]])
inv_rot = rot.T
if scale is None:
scale = [1.0, 1.0]
newim = copy_image(im)
inv_scale = numpy.diag(scale)
inv_transform = numpy.dot(inv_scale, inv_rot)
offset = c_in - numpy.dot(inv_transform, c_out)
for chan in range(nchan):
for pol in range(npol):
if im.data.dtype == "complex":
newim.data[chan, pol] = affine_transform(im.data[chan, pol].real,
inv_transform,
offset=offset,
order=order,
output_shape=(ny, nx)) + \
1.0j * affine_transform(im.data[chan, pol].imag,
inv_transform,
offset=offset,
order=order,
output_shape=(ny, nx))
elif im.data.dtype == "float":
newim.data[chan, pol] = affine_transform(im.data[chan,
pol].real,
inv_transform,
offset=offset,
order=order,
output_shape=(ny, nx))
else:
raise ValueError("Cannot process data type {}".format(
im.data.dtype))
return newim
def afine(img, dx, dy, sx, sy, angle):
imat=np.identity(2)
imat[0,0]=imat[0,0]*sx
imat[1,1]=imat[1,1]*sy
#print imat
#anglemat=np.identity(2)
img =affine_transform(img, imat)
#return img
a=radians(angle)
transform=np.array([[cos(a),-sin(a)],[sin(a),cos(a)]])
centre=0.5*np.array(img.shape)
offset=(centre-centre.dot(transform)).dot(np.linalg.inv(transform))
finoff = -1*offset + [dx,dy]
return affine_transform(img, transform, finoff)
def collate(depth, tiles, outputDirectory=None, outputAccumulo=None, layer="RGB", splineOrder=3):
"""Performs the part of the reducing step of the Hadoop map-reduce job after all data have been collected.
Actions: combine deep images to produce more shallow images.
* depth: depth of input images; output images have (depth - 1)
* tiles: dictionary of tiles built up by this procedure (this function adds to tiles)
* outputDirectory: local filesystem directory for debugging output (usually the output goes to Accumulo)
* outputAccumulo: Java virtual machine containing AccumuloInterface classes
* layer: name of the layer
* splineOrder: order of the spline used to calculate the affine_transformation (see SciPy docs); must be between 0 and 5
"""
for depthIndex, longIndex, latIndex, l in tiles.keys():
if l == layer and depthIndex == depth:
parentDepth, parentLongIndex, parentLatIndex = tileParent(depthIndex, longIndex, latIndex)
if (parentDepth, parentLongIndex, parentLatIndex, layer) not in tiles:
shape = tiles[depthIndex, longIndex, latIndex, layer][0].shape
outputRed = numpy.zeros(shape, dtype=numpy.uint8)
outputGreen = numpy.zeros(shape, dtype=numpy.uint8)
outputBlue = numpy.zeros(shape, dtype=numpy.uint8)
outputMask = numpy.zeros(shape, dtype=numpy.uint8)
tiles[parentDepth, parentLongIndex, parentLatIndex, layer] = outputRed, outputGreen, outputBlue, outputMask
outputRed, outputGreen, outputBlue, outputMask = tiles[parentDepth, parentLongIndex, parentLatIndex, layer]
rasterYSize, rasterXSize = outputRed.shape
inputRed, inputGreen, inputBlue, inputMask = tiles[depthIndex, longIndex, latIndex, layer]
trans = numpy.matrix([[2., 0.], [0., 2.]])
offset = 0., 0.
affine_transform(inputRed, trans, offset, (rasterYSize, rasterXSize), inputRed, splineOrder)
affine_transform(inputGreen, trans, offset, (rasterYSize, rasterXSize), inputGreen, splineOrder)
affine_transform(inputBlue, trans, offset, (rasterYSize, rasterXSize), inputBlue, splineOrder)
affine_transform(inputMask, trans, offset, (rasterYSize, rasterXSize), inputMask, splineOrder)
longOffset, latOffset = tileOffset(depthIndex, longIndex, latIndex)
if longOffset == 0:
longSlice = slice(0, rasterXSize/2)
else:
longSlice = slice(rasterXSize/2, rasterXSize)
if latOffset == 0:
latSlice = slice(rasterYSize/2, rasterYSize)
else:
latSlice = slice(0, rasterYSize/2)
outputRed[latSlice,longSlice] = inputRed[0:rasterYSize/2,0:rasterXSize/2]
outputGreen[latSlice,longSlice] = inputGreen[0:rasterYSize/2,0:rasterXSize/2]
outputBlue[latSlice,longSlice] = inputBlue[0:rasterYSize/2,0:rasterXSize/2]
outputMask[latSlice,longSlice] = inputMask[0:rasterYSize/2,0:rasterXSize/2]
image = Image.fromarray(numpy.dstack((outputRed, outputGreen, outputBlue, outputMask)))
if outputDirectory is not None:
image.save("%s/%s.png" % (outputDirectory, tileName(parentDepth, parentLongIndex, parentLatIndex)), "PNG", options="optimize")
if outputAccumulo is not None:
buff = BytesIO()
image.save(buff, "PNG", options="optimize")
outputAccumulo.write("%s-%s" % (tileName(parentDepth, parentLongIndex, parentLatIndex), layer), "{}", buff.getvalue())
def anat2epispace(anatdata, subject, xfmname, order=1):
"""Resamples data from anatomical space into epi space
Parameters
----------
anatdata : ndarray
data in anatomical space
subject : str
Name of subject
xfmname : str
Name of transform
order : int
Order of spline interpolation
Returns
-------
epidata : ndarray
data in EPI space
"""
from scipy.ndimage.interpolation import affine_transform
anatref = db.get_anat(subject)
target = db.get_xfm(subject, xfmname, "coord")
allxfm = Transform(anatref.get_affine(), anatref.shape).inv * target.inv
#allxfm = xfm * Transform(anat.get_affine(), anat.shape)
rotpart = allxfm.xfm[:3, :3]
transpart = allxfm.xfm[:3,-1]
return affine_transform(anatdata.T, rotpart, offset=transpart, output_shape=target.shape[::-1], cval=np.nan, order=order).T
def rotate(self,rot_mat):
"""
Rotate the 3D model
"""
displace = np.array([self.R,self.R,self.R])
offset = -np.dot(rot_mat,displace) + displace
self.array = affine_transform(self.array,rot_mat,offset)
def csnormalize(image, f=0.75):
"""Center and size-normalize an image."""
bimage = 1 * (image > mean([amax(image), amin(image)]))
w, h = bimage.shape
[xs, ys] = mgrid[0:w, 0:h]
s = sum(bimage)
if s < 1e-4: return image
s = 1.0 / s
cx = sum(xs * bimage) * s
cy = sum(ys * bimage) * s
sxx = sum((xs - cx)**2 * bimage) * s
sxy = sum((xs - cx) * (ys - cy) * bimage) * s
syy = sum((ys - cy)**2 * bimage) * s
w, v = eigh(array([[sxx, sxy], [sxy, syy]]))
l = sqrt(amax(w))
if l > 0.01:
scale = f * max(image.shape) / (4.0 * l)
else:
scale = 1.0
m = array([[1.0 / scale, 0], [0.0, 1.0 / scale]])
w, h = image.shape
c = array([cx, cy])
d = c - dot(m, array([w / 2, h / 2]))
image = interpolation.affine_transform(image, m, offset=d, order=1)
return image
def normalize(self,img,order=1,dtype=dtype('f'),cval=0):
assert img.shape==self.shape
h,w = self.shape
M = array([[self.scale,self.scale*self.m],[0,self.scale]])
offset = (self.offset,0)
shape = (self.target_height,int(w/self.scale))
return interpolation.affine_transform(img,M,offset=offset,output_shape=shape,order=order,cval=cval,output=dtype)
def view_3d(self, x, scale=0.7, alpha=1.0, bg_val=-1):
"""
Visualize the 3d pictures as expanded slideshow
args:
x: 3d matrix (img_h, img_w, img_z)
sclae: define the distance between slides
alpha: visibility
bg_val: background value
"""
# List of images instead 3d matrix
x = x.numpy()
images = [x[i, :, :] for i in range(self.crop_size)]
# Define size of new picture
stacked_height = 2 * self.pic_size
stacked_width = int(
self.pic_size + (self.crop_size - 1) * self.pic_size * scale
)
stacked = np.full((stacked_height, stacked_width), bg_val)
# Go over each slide
for i in range(self.crop_size):
# The first image will be right most and on the "bottom" of the stack.
o = (self.crop_size - i - 1) * self.pic_size * scale
out = affine_transform(
images[i][0, :, :],
self.T,
offset=[o, -o],
output_shape=stacked.shape,
cval=bg_val,
)
stacked[out != bg_val] = out[out != bg_val]
# plot the image series
plt.imshow(stacked, alpha=alpha, interpolation="nearest", cmap="gray")
def deskew_block(block, mat=None, out_shape=None, padval=0):
extradims = block.ndim - 3
last3dims = (0,) * extradims + (slice(None),) * 3
array = block[last3dims]
deskewed = affine_transform(array, mat, output_shape=tuple(out_shape[-3:]), order=0)
return deskewed[(None,) * extradims + (...,)]
def affine_transformations(self,set):
DA_set = dataset(set)
# for every samples in the training set
for i in range(set.X.shape[0]):
# making an affine transformation of the coordinate of the points of the image
# (x',y') = A(x,y) + B
# result is rotation, translation, scaling on each axis
# to adjust a and b, limit the size of the dataset
# a = .1 # best for CNN MNIST, 128 samples
A = np.identity(n=2)+self.rng.uniform(low=-self.affine_transform_a,high=self.affine_transform_a,size=(2, 2))
# b = .5 # best for CNN MNIST, 128 samples
B = self.rng.uniform(low=-self.affine_transform_b,high=self.affine_transform_b,size=(2))
# for every channels
for j in range(set.X.shape[1]):
DA_set.X[i][j]=affine_transform(set.X[i][j],A,offset=B,order=2)
# max_rot = 15
# angle = self.rng.random_integers(-max_rot,max_rot)
# DA_set.X[i] = rotate(DA_set.X[i].reshape(28,28),angle, reshape=False).reshape(784)
return DA_set
def _transform_img(img,
transform_matrix,
is_h_flip,
is_v_flip,
elastic_inds
):
final_affine_matrix = transform_matrix[:2, :2]
final_offset = transform_matrix[:2, 2]
img_aug = affine_transform(
img,
final_affine_matrix,
final_offset,
order=0,
mode='reflect',
output=np.float32,
cval=0.)
if is_h_flip:
img_aug = img_aug[::-1, :]
if is_v_flip:
img_aug = img_aug[:, ::-1]
if elastic_inds is not None:
img_aug = map_coordinates(img_aug, elastic_inds, order=1).reshape((img.shape))
return img_aug
def shear_back(self, img, inv_shear):
"""
TODO
Parameters
----------
img : numpy.ndarray (N,N),
array of diffraction intensities
inv_shear : numpy.ndarray (2,2),
inverse shear matrix
Returns
-------
numpy.ndarray (N,N),
sheared array of diffraction intensities
"""
roll = img.shape[0] / 2 - 1
ss = np.max(self.box) * inv_shear
A1 = np.array([[1, 0, -roll], [0, 1, -roll], [0, 0, 1]])
A2 = np.array([[ss[1, 0], ss[0, 0], roll], [ss[1, 1], ss[0, 1], roll],
[0, 0, 1]])
A3 = np.linalg.inv(np.dot(A2, A1))
A4 = A3[0:2, 0:2]
A5 = A3[0:2, 2]
img = affine_transform(img, A4, A5, mode="constant")
return img
def transformimage(self, img):
# self.cof: change-of-frame matrix for coordinates (x,y)
if self.isidentity():
return img
if self.transfotype == transformationType.translation:
# shift: takes transformation vector for coordinates (y,x)
return ndtransform.shift(
img, -self.cof[1::-1], cval=self.cval, **self.interpolationargs
)
else:
if self.islinearidentity():
# shift: takes transformation vector for coordinates (y,x)
return ndtransform.shift(
img, -self.cof[1::-1, 2], cval=self.cval, **self.interpolationargs
)
elif self.isprojidentity():
# affine_transform: takes change-of-frame matrix
# for coordinates (y,x)
return ndtransform.affine_transform(
img,
self.cof[0:2, 0:2].T,
offset=self.cof[1::-1, 2],
cval=self.cval,
**self.interpolationargs
)
else:
raise NotImplementedError()
def zoom_and_rotate_patch(patch, angle, zoom):
theta = np.deg2rad(angle)
rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],
[np.sin(theta),
np.cos(theta), 0], [0, 0, 1]])
transform_matrix = rotation_matrix
zoom_matrix = np.array([[zoom, 0, 0], [0, zoom, 0], [0, 0, 1]])
transform_matrix = np.dot(transform_matrix, zoom_matrix)
d, h, w = patch.shape
transform_matrix = transform_matrix_offset_center(transform_matrix, h, w)
patch = np.rollaxis(patch, 0, 0)
final_affine_matrix = transform_matrix[:2, :2]
final_offset = transform_matrix[:2, 2]
channel_images = [
affine_transform(x_channel,
final_affine_matrix,
final_offset,
order=1,
mode='reflect') for x_channel in patch
]
patch = np.stack(channel_images, axis=0)
patch = np.rollaxis(patch, 0, 1)
return patch
def deskew(image):
c, v = moments(image)
alpha = v[0, 1] / v[0, 0]
affine = np.array([[1, 0], [alpha, 1]])
ocenter = np.array(image.shape) / 2.0
offset = c - np.dot(affine, ocenter)
return interpolation.affine_transform(image, affine, offset=offset)
def extract(image, y0, x0, y1, x1, mode='nearest', cval=0):
h, w = image.shape
ch, cw = y1 - y0, x1 - x0
y, x = clip(y0, 0, max(h - ch, 0)), clip(x0, 0, max(w - cw, 0))
sub = image[y:y + ch, x:x + cw]
# print("extract", image.dtype, image.shape)
try:
r = interpolation.shift(sub, (y - y0, x - x0),
mode=mode,
cval=cval,
order=0)
if cw > w or ch > h:
pady0, padx0 = max(-y0, 0), max(-x0, 0)
r = interpolation.affine_transform(r,
eye(2),
offset=(pady0, padx0),
cval=1,
output_shape=(ch, cw))
return r
except RuntimeError:
# workaround for platform differences between 32bit and 64bit
# scipy.ndimage
dtype = sub.dtype
sub = array(sub, dtype='float64')
sub = interpolation.shift(sub, (y - y0, x - x0),
mode=mode,
cval=cval,
order=0)
sub = array(sub, dtype=dtype)
return sub
def imageResampling(inputimage, outputspacing, order=1):
#inputimage : a nibabel image
#outputspacing : a numpy array with three scaling factors
#order : order for spline based interpolation (0: nn, 1 : linear, ...)
M1 = np.diag(outputspacing)
T1 = outputspacing / 2
inputspacing = inputimage.header.get_zooms()[0:3]
M2 = np.diag(np.asarray(inputspacing))
T2 = np.asarray(inputspacing) / 2
M = np.linalg.inv(homogeneousMatrix(M2, T2)).dot(homogeneousMatrix(M1, T1))
outputaffine = np.dot(inputimage.affine, M)
T = M[0:3, 3]
M = M[0:3, 0:3]
zoom = np.diag(M[0:3, 0:3])
outputshape = np.ceil(
(inputimage.get_data().shape[0:3]) / zoom).astype(int)
inputarray = inputimage.get_data()
inputarray = np.reshape(inputarray, inputarray.shape[0:3])
outputarray = affine_transform(inputarray,
M,
offset=T,
output_shape=outputshape,
order=order,
mode='constant',
cval=0.0,
prefilter=False)
return nibabel.Nifti1Image(outputarray, outputaffine)
def deskew_block(block, mat=None, out_shape=None, padval=0):
try:
from ._cupy_affine import affine_transform
backend_name = 'CuPy'
except ImportError:
logger.warning(
"Could not import CuPy. "
"Falling back to PyOpenCL for affine transforms"
)
try:
from ._ocl_affine import affine_transform
backend_name = 'PyOpenCL'
except ImportError:
from scipy.ndimage.interpolation import affine_transform
backend_name = 'SciPy'
logger.warning(
"Could not import CuPy or PyOpenCL. "
"Falling back to SciPy for CPU affine transforms"
)
extradims = block.ndim - 3
last3dims = (0,) * extradims + (slice(None),) * 3
array = block[last3dims]
t_start = time()
deskewed = affine_transform(array, mat, output_shape=tuple(out_shape[-3:]), order=0)
logger.debug(f"\tduration ({backend_name}): {time() - t_start} s")
return deskewed[(None,) * extradims + (...,)]
def instantiateAt(self, x, y, nativeScale=False):
from scipy.ndimage.interpolation import affine_transform
psf = np.zeros_like(self.psfbases[0])
#print 'psf', psf.shape
dx = (x - self.x0) / self.xscale
dy = (y - self.y0) / self.yscale
i = 0
#print 'dx',dx,'dy',dy
for d in range(self.degree + 1):
#print 'degree', d
for j in range(d + 1):
k = d - j
#print 'x',j,'y',k,
#print 'component', i
amp = dx**j * dy**k
#print 'amp', amp,
# PSFEx manual pg. 111 ?
ii = j + (self.degree + 1) * k - (k * (k - 1)) / 2
#print 'ii', ii, 'vs i', i
psf += self.psfbases[ii] * amp
#print 'basis rms', np.sqrt(np.mean(self.psfbases[i]**2)),
i += 1
#print 'psf sum', psf.sum()
#print 'min', psf.min(), 'max', psf.max()
if (self.scale or nativeScale) and self.sampling != 1:
ny, nx = psf.shape
spsf = affine_transform(psf, [1. / self.sampling] * 2,
offset=nx / 2 * (self.sampling - 1.))
return spsf
return psf
def set_requested_array(self, name, array, array_name):
if name != self.current_simulation:
return
if array_name == 'organ':
self.organ_array = affine_transform(array,
self.scale,
output_shape=np.floor(np.array(array.shape)/self.scale),
cval=0, output=np.uint8, prefilter=True,
order=0).astype(np.uint8)
elif array_name == 'organ_map':
self.organ_map = {array['organ'][i]: str(array['organ_name'][i], encoding='utf-8') for i in range(len(array))}
elif array_name == 'organ_material_map':
self.organ_material_map = {array['organ'][i]: str(array['material_name'][i], encoding='utf-8') for i in range(len(array))}
if self.organ_array is not None and self.organ_map is not None and self.organ_material_map is not None:
self.layoutAboutToBeChanged.emit()
self._data = {}
self._data_keys = []
for key, value in self.organ_map.items():
self._data[key] = [value, self.organ_material_map.get(key, 'Unknown'), 0, 0]
self._data_keys.append(key)
self.dose_z_lenght = list(range(self.organ_array.shape[0]))
# self.dataChanged.emit(self.index(0, 0), self.index(len(self._data), 2))
self.request_array_slice.emit(self.current_simulation, 'dose', 0, 0)
self.layoutChanged.emit()
self.hide_view.emit(False)
def apply_transform(x,
transform_matrix,
channel_axis=0,
fill_mode='constant',
cval=0.):
"""Apply the image transformation specified by a matrix.
Arguments:
x: 2D numpy array, single image.
transform_matrix: Numpy array specifying the geometric transformation.
channel_axis: Index of axis for channels in the input tensor.
fill_mode: Points outside the boundaries of the input
are filled according to the given mode
(one of `{'constant', 'nearest', 'reflect', 'wrap'}`).
cval: Value used for points outside the boundaries
of the input if `mode='constant'`.
Returns:
The transformed version of the input.
"""
x = np.rollaxis(x, channel_axis, 0)
final_affine_matrix = transform_matrix[:2, :2]
final_offset = transform_matrix[:2, 2]
channel_images = [
interpolation.affine_transform(x_channel,
final_affine_matrix,
final_offset,
order=0,
mode=fill_mode,
cval=cval) for x_channel in x
]
x = np.stack(channel_images, axis=0)
x = np.rollaxis(x, 0, channel_axis + 1)
return x
def affine_transformations(self, set):
DA_set = dataset(set)
# for every samples in the training set
for i in range(set.X.shape[0]):
# making an affine transformation of the coordinate of the points of the image
# (x',y') = A(x,y) + B
# result is rotation, translation, scaling on each axis
# to adjust a and b, limit the size of the dataset
# a = .1 # best for CNN MNIST, 128 samples
A = np.identity(n=2) + self.rng.uniform(
low=-self.affine_transform_a,
high=self.affine_transform_a,
size=(2, 2))
# b = .5 # best for CNN MNIST, 128 samples
B = self.rng.uniform(low=-self.affine_transform_b,
high=self.affine_transform_b,
size=(2))
# for every channels
for j in range(set.X.shape[1]):
DA_set.X[i][j] = affine_transform(set.X[i][j],
A,
offset=B,
order=2)
# max_rot = 15
# angle = self.rng.random_integers(-max_rot,max_rot)
# DA_set.X[i] = rotate(DA_set.X[i].reshape(28,28),angle, reshape=False).reshape(784)
return DA_set
def anat2epispace(anatdata, subject, xfmname, order=1):
"""Resamples data from anatomical space into epi space
Parameters
----------
anatdata : ndarray
data in anatomical space
subject : str
Name of subject
xfmname : str
Name of transform
order : int
Order of spline interpolation
Returns
-------
epidata : ndarray
data in EPI space
"""
from scipy.ndimage.interpolation import affine_transform
anatref = db.get_anat(subject)
target = db.get_xfm(subject, xfmname, "coord")
allxfm = Transform(anatref.get_affine(), anatref.shape).inv * target.inv
#allxfm = xfm * Transform(anat.get_affine(), anat.shape)
rotpart = allxfm.xfm[:3, :3]
transpart = allxfm.xfm[:3, -1]
return affine_transform(anatdata.T,
rotpart,
offset=transpart,
output_shape=target.shape[::-1],
cval=np.nan,
order=order).T
def epi2anatspace(volumedata, order=1):
"""Resample an epi volume data into anatomical space using scipy.
Parameters
----------
volumedata : VolumeData
The input epi volumedata object.
order : int
The order of the resampler, in terms of splines. 0 is nearest, 1 is linear.
Returns
-------
anatspace : ndarray
The ND array of the anatomy space data
"""
from scipy.ndimage.interpolation import affine_transform
ds = dataset.normalize(volumedata)
volumedata = ds#.data
anat = db.get_anat(volumedata.subject, "raw")
xfm = db.get_xfm(volumedata.subject, volumedata.xfmname, "coord")
#allxfm = Transform(anat.get_affine(), anat.shape).inv * xfm.inv
allxfm = xfm * Transform(anat.get_affine(), anat.shape)
rotpart = allxfm.xfm[:3, :3]
transpart = allxfm.xfm[:3,-1]
return affine_transform(volumedata.volume.T.squeeze(), rotpart,
offset=transpart, output_shape=anat.shape[::-1],
cval=np.nan, order=order).T
def undo_transform(self, sample, metadata=None):
assert "rotation" in metadata
assert "scale" in metadata
assert "translation" in metadata
# Opposite rotation, same axes
angle, axes = -metadata['rotation'][0], metadata['rotation'][1]
scale = 1 / np.array(metadata['scale'])
translation = -np.array(metadata['translation'])
# Undo rotation
dict_params = {
"rotation": [angle, axes],
"scale": scale,
"translation": [0, 0, 0],
"undo": True
}
data_out, _ = self.__call__(sample, dict_params)
data_out = affine_transform(data_out,
np.identity(3),
order=1,
offset=translation,
output_shape=sample.shape).astype(
sample.dtype)
return data_out, metadata
def rgeometry(im, eps=0.04, delta=0.8, cval=None, severity=1):
"""
affine transform
"""
if severity == 0:
return im
if cval is None:
cval = [0] * im.shape[2]
elif isinstance(cval, (float, int)):
cval = [cval] * im.shape[2]
severity = abs(severity)
eps = severity * eps
delta = severity * delta
m = np.array([[1 + eps * randn(), 0.0],
[eps * randn(), 1.0 + eps * randn()]])
c = np.array(im.shape[:2]) * 0.5
d = c - np.dot(m, c) + np.array([randn() * delta, randn() * delta])
im = cv2.split(im)
im = [
interpolation.affine_transform(i,
m,
offset=d,
order=1,
mode='constant',
cval=cval[e]) for e, i in enumerate(im)
]
im = cv2.merge(im)
return np.array(im)
def csnormalize(image,f=0.75):
"""Center and size-normalize an image."""
bimage = 1*(image>mean([amax(image),amin(image)]))
w,h = bimage.shape
[xs,ys] = mgrid[0:w,0:h]
s = sum(bimage)
if s<1e-4: return image
s = 1.0/s
cx = sum(xs*bimage)*s
cy = sum(ys*bimage)*s
sxx = sum((xs-cx)**2*bimage)*s
sxy = sum((xs-cx)*(ys-cy)*bimage)*s
syy = sum((ys-cy)**2*bimage)*s
w,v = eigh(array([[sxx,sxy],[sxy,syy]]))
l = sqrt(amax(w))
if l>0.01:
scale = f*max(image.shape)/(4.0*l)
else:
scale = 1.0
m = array([[1.0/scale,0],[0.0,1.0/scale]])
w,h = image.shape
c = array([cx,cy])
d = c-dot(m,array([w/2,h/2]))
image = interpolation.affine_transform(image,m,offset=d,order=1)
return image
def rotate(v, angle=None, rm=None, c1=None, c2=None, loc_r=None, siz2=None, default_val=float('NaN')):
if (angle is not None):
assert (rm is None)
angle = N.array(angle, dtype=N.float).flatten()
rm = AA.rotation_matrix_zyz(angle)
if (rm is None):
rm = N.eye(v.ndim)
siz1 = N.array(v.shape, dtype=N.float)
if (c1 is None):
c1 = ((siz1 - 1) / 2.0)
else:
c1 = c1.flatten()
assert (c1.shape == (3,))
if (siz2 is None):
siz2 = siz1
siz2 = N.array(siz2, dtype=N.float)
if (c2 is None):
c2 = ((siz2 - 1) / 2.0)
else:
c2 = c2.flatten()
assert (c2.shape == (3,))
if (loc_r is not None):
loc_r = N.array(loc_r, dtype=N.float).flatten()
assert (loc_r.shape == (3,))
c2 += loc_r
c = ((- rm.dot(c2)) + c1)
vr = SNI.affine_transform(input=v, matrix=rm, offset=c, output_shape=siz2.astype(N.int), cval=default_val)
return vr
def instantiateAt(self, x, y, nativeScale=False):
from scipy.ndimage.interpolation import affine_transform
psf = np.zeros_like(self.psfbases[0])
#print 'psf', psf.shape
dx = (x - self.x0) / self.xscale
dy = (y - self.y0) / self.yscale
i = 0
#print 'dx',dx,'dy',dy
for d in range(self.degree + 1):
#print 'degree', d
for j in range(d+1):
k = d - j
#print 'x',j,'y',k,
#print 'component', i
amp = dx**j * dy**k
#print 'amp', amp,
# PSFEx manual pg. 111 ?
ii = j + (self.degree+1) * k - (k * (k-1))/ 2
#print 'ii', ii, 'vs i', i
psf += self.psfbases[ii] * amp
#print 'basis rms', np.sqrt(np.mean(self.psfbases[i]**2)),
i += 1
#print 'psf sum', psf.sum()
#print 'min', psf.min(), 'max', psf.max()
if (self.scale or nativeScale) and self.sampling != 1:
ny,nx = psf.shape
spsf = affine_transform(psf, [1./self.sampling]*2,
offset=nx/2 * (self.sampling - 1.))
return spsf
return psf
def transform(self, Xb, yb):
Xb, yb = super(ImageTransformationIterator, self).transform(Xb, yb)
for i, img in enumerate(Xb[:, 0, :, :]):
c_in = 0.5 * np.array(img.shape)
c_out = np.array(
(14.0 + random.randint(-1, 1), 14.0 + random.randint(-1, 1)))
theta = 20 * (random.random() - 0.5) * math.pi / 180.0
scaling = np.diag(([
1. + 0.4 * (random.random() - 0.5),
1. + 0.4 * (random.random() - 0.5)
]))
transform = np.array([[math.cos(theta), -math.sin(theta)],
[math.sin(theta),
math.cos(theta)]]).dot(scaling)
offset = c_in - c_out.dot(transform)
dst = affine_transform(img,
transform.T,
order=2,
offset=offset,
output_shape=(28, 28),
cval=0.0,
output=np.float32)
dst[dst < 0.01] = 0.
Xb[i, 0] = dst
return Xb, yb
def transform_image(image, T, origin='center', inverse=False):
# image: 2 or 3 dimensional image (h, w, c)
# T: 3x3 augmented transformation matrix.
# origin: 'center' or 'topleft': where is the origin of the T transformation.
# inverse: T is defined as the transformation from the output to the input (invers).
# If inverse is False, T is inversed.
# now the transformation is from the input to the output
if image.ndim == 3:
# do the transformation for every channel
num_channels = image.shape[2]
transformed_channels = []
for i in range(num_channels):
transformed_channels.append(transform_image(image[..., i], T, origin=origin, inverse=inverse))
return np.stack(transformed_channels, axis=-1)
if image.ndim != 2:
raise ValueError('Wrong number of dimensions.')
h, w = image.shape
if not inverse:
T_i = np.linalg.inv(T)
else:
T_i = T
if origin == 'center':
c = (h / 2, w / 2)
else:
c = (0, 0)
T_o = [[1, 0, c[0]], [0, 1, c[1]], [0, 0, 1]] @ T_i @ [[1, 0, -c[0]], [0, 1, -c[1]], [0, 0, 1]]
transformed = affine_transform(image, T_o, mode='constant')
return transformed
def affineRotAroundCenter(arr, theta, axis=[0, 0, 1]):
"""
scipy based rotation about center of cube, CPU
:param arr: 3D array to be rotated
:param theta: radients
:param axis: axis
:return: ratated 3D array
"""
def Mrot3d(axis, theta):
axis = np.array(axis)
return expm(np.cross(np.eye(3), axis / norm(axis) * theta))
def Mrot2d(theta):
return np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
dim = len(arr.shape)
if dim == 2:
M = Mrot2d(theta)
elif dim == 3:
M = Mrot3d(axis, theta)
else:
raise RuntimeError(
"Affine rotation cannot rotate array with shape %s" %
(arr.shape, ))
center = 0.5 * (np.array(arr.shape) - np.ones((dim, )))
return affine_transform(arr,
M,
mode="nearest",
offset=center - M.dot(center))
def extract_centered(image, shape, center):
"""Extracts a patch of size `shape` centered on `center`."""
center = array(center) - array(shape) / 2.0
return interpolation.affine_transform(1.0 * image,
diag([1, 1]),
offset=center,
output_shape=shape,
order=1)
def deskew_image(image):
# From https://fsix.github.io/mnist/Deskewing.html
c, v = moments(image)
alpha = v[0, 1] / v[0, 0]
affine = np.array([[1, 0], [alpha, 1]])
ocenter = np.array(image.shape) / 2.0
offset = c - np.dot(affine, ocenter)
return interpolation.affine_transform(image, affine, offset=offset)
def deskew(image):
"""deskew image"""
image = numpy.reshape(image, (28, 28)) if image.shape != (28, 28) else image
c,v = moments(image)
alpha = v[0,1]/v[0,0]
affine = numpy.array([[1,0],[alpha,1]])
ocenter = numpy.array(image.shape)/2.0
offset = c-numpy.dot(affine,ocenter)
return interpolation.affine_transform(image,affine,offset=offset)
def scale_to_h(img,target_height,order=1,dtype=np.dtype('f'),cval=0):
h,w = img.shape
scale = target_height*1.0/h
target_width = int(scale*w)
output = interpolation.affine_transform(1.0*img,np.eye(2)/scale,order=order,
output_shape=(target_height,target_width),
mode='constant',cval=cval)
output = np.array(output,dtype=dtype)
return output
def extract_centered_scaled(image,shape,center,scale):
"""Extracts a patch of size `shape` centered on `center`
and scaled by `scale`."""
scale = 1.0/scale
rshape = scale*array(shape)
center = array(center)-rshape/2.0
result = interpolation.affine_transform(1.0*image,diag([scale,scale]),offset=center,
output_shape=shape,order=1)
return result
def anat2epispace(anatdata, subject, xfmname, order=1):
anatref = surfs.getAnat(subject)
target = surfs.getXfm(subject, xfmname, "coord")
allxfm = Transform(anatref.get_affine(), anatref.shape).inv * target.inv
#allxfm = xfm * Transform(anat.get_affine(), anat.shape)
rotpart = allxfm.xfm[:3, :3]
transpart = allxfm.xfm[:3,-1]
return affine_transform(anatdata.T, rotpart, offset=transpart, output_shape=target.shape[::-1], cval=np.nan, order=order).T
def rotate(self, fig, angle=None):
if angle is None:
angle = np.random.uniform(low=0.0, high=2.0*np.pi)
matrix = np.array([
[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)]])
in_center = 0.5*np.array(fig.data.shape)
offset = in_center - in_center.dot(matrix)
fig.data = interpolation.affine_transform(fig.data, matrix.T,
offset=offset)
def zoomOutImage(parentKey, childKeys, childImages, splineOrder):
rasterYSize, rasterXSize = childImages[0].shape[0:2]
outputRed = numpy.zeros((rasterYSize, rasterXSize), dtype=numpy.uint8)
outputGreen = numpy.zeros((rasterYSize, rasterXSize), dtype=numpy.uint8)
outputBlue = numpy.zeros((rasterYSize, rasterXSize), dtype=numpy.uint8)
outputMask = numpy.zeros((rasterYSize, rasterXSize), dtype=numpy.uint8)
for key, image in zip(childKeys, childImages):
inputRed = image[:,:,0]
inputGreen = image[:,:,1]
inputBlue = image[:,:,2]
inputMask = image[:,:,3]
trans = numpy.matrix([[2., 0.], [0., 2.]])
offset = 0., 0.
inputRed = affine_transform(inputRed, trans, offset, (rasterYSize, rasterXSize), None, splineOrder)
inputGreen = affine_transform(inputGreen, trans, offset, (rasterYSize, rasterXSize), None, splineOrder)
inputBlue = affine_transform(inputBlue, trans, offset, (rasterYSize, rasterXSize), None, splineOrder)
inputMask = affine_transform(inputMask, trans, offset, (rasterYSize, rasterXSize), None, splineOrder)
depth, longIndex, latIndex, layer, timestamp = key.split("-")
depth = int(depth[1:])
longIndex = int(longIndex)
latIndex = int(latIndex)
longOffset, latOffset = tileOffset(depth, longIndex, latIndex)
if longOffset == 0:
longSlice = slice(0, rasterXSize/2)
else:
longSlice = slice(rasterXSize/2, rasterXSize)
if latOffset == 0:
latSlice = slice(rasterYSize/2, rasterYSize)
else:
latSlice = slice(0, rasterYSize/2)
outputRed[latSlice,longSlice] = inputRed[0:rasterYSize/2,0:rasterXSize/2]
outputGreen[latSlice,longSlice] = inputGreen[0:rasterYSize/2,0:rasterXSize/2]
outputBlue[latSlice,longSlice] = inputBlue[0:rasterYSize/2,0:rasterXSize/2]
outputMask[latSlice,longSlice] = inputMask[0:rasterYSize/2,0:rasterXSize/2]
return numpy.dstack((outputRed, outputGreen, outputBlue, outputMask))
def ocropy_degrade(im, distort=1.0, dsigma=20.0, eps=0.03, delta=0.3, degradations=[(0.5, 0.0, 0.5, 0.0)]):
"""
Degrades and distorts a line using the same noise model used by ocropus.
Args:
im (PIL.Image): Input image
distort (float):
dsigma (float):
eps (float):
delta (float):
degradations (list): list returning 4-tuples corresponding to
the degradations argument of ocropus-linegen.
Returns:
PIL.Image in mode 'L'
"""
w, h = im.size
# XXX: determine correct output shape from transformation matrices instead
# of guesstimating.
image = Image.new('L', (int(1.5*w), 4*h), 255)
image.paste(im, (int((image.size[0] - w) / 2), int((image.size[1] - h) / 2)))
a = pil2array(image.convert('L'))
(sigma,ssigma,threshold,sthreshold) = degradations[np.random.choice(len(degradations))]
sigma += (2*np.random.rand()-1)*ssigma
threshold += (2*np.random.rand()-1)*sthreshold
a = a*1.0/np.amax(a)
if sigma>0.0:
a = gaussian_filter(a,sigma)
a += np.clip(np.random.randn(*a.shape)*0.2,-0.25,0.25)
m = np.array([[1+eps*np.random.randn(),0.0],[eps*np.random.randn(),1.0+eps*np.random.randn()]])
w,h = a.shape
c = np.array([w/2.0,h/2])
d = c-np.dot(m, c)+np.array([np.random.randn()*delta, np.random.randn()*delta])
a = affine_transform(a, m, offset=d, order=1, mode='constant', cval=a[0,0])
a = np.array(a>threshold,'f')
[[r,c]] = find_objects(np.array(a==0,'i'))
r0 = r.start
r1 = r.stop
c0 = c.start
c1 = c.stop
a = a[r0-5:r1+5,c0-5:c1+5]
if distort > 0:
h,w = a.shape
hs = np.random.randn(h,w)
ws = np.random.randn(h,w)
hs = gaussian_filter(hs, dsigma)
ws = gaussian_filter(ws, dsigma)
hs *= distort/np.amax(hs)
ws *= distort/np.amax(ws)
def f(p):
return (p[0]+hs[p[0],p[1]],p[1]+ws[p[0],p[1]])
a = geometric_transform(a, f, output_shape=(h,w), order=1, mode='constant', cval=np.amax(a))
im = array2pil(a).convert('L')
return im
def zoom(self):
"""
zoom each color plane proportional to its wavelength
zoom shrinks in proportion to wavelength
"""
X, Y = self.X, self.Y
coeff = self.internal_pop()
offset = [X*(1.0-coeff)/2.0, Y*(1.0-coeff)/2.0]
kernel = [[coeff, 0.0], [0.0, coeff]]
self.internal_push(affine_transform(
self.internal_pop(), kernel, offset=offset, prefilter=False))
def anat2epispace(anatdata, subject, xfmname, order=1):
from scipy.ndimage.interpolation import affine_transform
anatref = db.get_anat(subject)
target = db.get_xfm(subject, xfmname, "coord")
allxfm = Transform(anatref.get_affine(), anatref.shape).inv * target.inv
#allxfm = xfm * Transform(anat.get_affine(), anat.shape)
rotpart = allxfm.xfm[:3, :3]
transpart = allxfm.xfm[:3,-1]
return affine_transform(anatdata.T, rotpart, offset=transpart, output_shape=target.shape[::-1], cval=np.nan, order=order).T
def scale(self, fig, scale=None):
if scale is None:
scale = np.random.uniform(low=self.min_size/self.max_size,
high=1.0)
matrix = np.array([[1.0/scale, 0.0], [0.0, 1.0/scale]])
in_center = 0.5*np.array(fig.data.shape)
offset = in_center - in_center.dot(matrix)
in_center = 0.5*np.array(fig.data.shape)
offset = in_center - in_center.dot(matrix)
fig.data = interpolation.affine_transform(fig.data, matrix,
offset=offset)
fig.size *= scale
def scale_to_h(img, target_height, order=1, dtype=np.dtype('f'), cval=0):
h, w = img.shape
scale = target_height*1.0/h
target_width = int(scale*w)
with warnings.catch_warnings():
warnings.simplefilter('ignore', UserWarning)
output = interpolation.affine_transform(1.0*img, np.ones(2)/scale,
order=order,
output_shape=(target_height,
target_width),
mode='constant', cval=cval)
output = np.array(output, dtype=dtype)
return output
def test_net(
net,
x,
b_name='\033[30mbaseline\033[0m',
f_name='\033[30mfollow\033[0m',
loc_name='\033[33mloc_net\033[0m'
):
import theano
import lasagne
c = color_codes()
# We try to get the last weights to keep improving the net over and over
x_test = np.split(x, 2, axis=1)
b_inputs = (b_name, x_test[0])
f_inputs = (f_name, x_test[1])
inputs = dict([b_inputs, f_inputs])
print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +
'Predicting (' + c['b'] + 'images' + c['nc'] + c['g'] + ')' + c['nc'])
print(' Testing vector shape ='
' (' + ','.join([str(length) for length in x.shape]) + ')')
y_test = net.predict(inputs)
print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +
'Predicting (' + c['b'] + 'transformations' + c['nc'] + c['g'] + ')' + c['nc'])
f = theano.function(
[
net.layers_[b_name].input_var,
net.layers_[f_name].input_var
],
lasagne.layers.get_output(
net.layers_[loc_name],
{
b_name: net.layers_[b_name].input_var,
f_name: net.layers_[f_name].input_var
}
),
name='registration'
)
rand_transf = [random_affine3d_matrix(x_range=1/36.0, y_range=1/36.0, z_range=1/36.0) for x_t in x_test[0]]
x_test_random = np.stack([affine_transform(x_t, t) for x_t, t in zip(x_test[0], rand_transf)])
transforms = f(x_test_random, x_test[0])
for tt, t in zip(transforms, rand_transf):
print('%s %s' % (','.join(['%f' % ts for ts in t[0, :]]), ','.join(['%f' % tts for tts in tt[:4]])))
print('%s = %s' % (','.join(['%f' % ts for ts in t[1, :]]), ','.join(['%f' % tts for tts in tt[4:8]])))
print('%s %s' % (','.join(['%f' % ts for ts in t[2, :]]), ','.join(['%f' % tts for tts in tt[8:12]])))
return y_test, transforms
def horizontal_shear(im, degree):
rad = degree / 180.0 * math.pi
padding_x = int(abs(np.tan(rad)) * im.shape[0])
padding_y = im.shape[0]
if rad > 0:
im_pad = np.concatenate(
(255 * np.ones((padding_y, padding_x), dtype=int), im), axis=1)
elif rad < 0:
im_pad = np.concatenate(
(im, 255 * np.ones((padding_y, padding_x), dtype=int)), axis=1)
else:
im_pad = im
shear_matrix = np.array([[1, 0],
[np.tan(rad), 1]])
sheared_im = affine_transform(im_pad, shear_matrix, cval=255.0)
return sheared_im
def setupVolumes(self):
if (self.imBg is not None) and (self.imFg is not None):
self.mgr = VolumeRenderingManager(_gray_data)
self.ren.AddVolume(self.mgr.volume)
print 'Transforming volume...'
self.imFg_t =\
affine_transform(self.imFg,
matrix=self.matrix[0:3, 0:3],
offset=self.matrix[0:3, 3],
output_shape=self.imBg.shape)
print 'Done'
imOut = self.imBg * self.imFg_t
imOut[imOut < 0.0] = 0.0
imOut[imOut > 1.0] = 1.0
self.mgr.setInput((imOut * 255.0).astype(np.uint8))
self.mgr.update()
def extract_keypoint(img, keypoint, patch_shape, scale):
x = keypoint[0]
y = keypoint[1]
a = keypoint[2]
b = keypoint[3]
c = keypoint[4]
A = np.array([[c, b], [b, a]])
u, s, v = np.linalg.svd(A)
s = 1/np.sqrt(s)
A = np.dot(u, np.dot(np.diag(s), v))
A = A * scale * 2/patch_shape[0]
offset = np.array([y, x])
offset -= np.dot(A, np.array([patch_shape[0], patch_shape[1]]))/2
patch = affine_transform(img, A, offset=offset, output_shape=patch_shape,
order=1, prefilter=False)
return patch
def extract_centered_scaled_barred(image,shape,center,scale,bar=None):
"""Extracts a patch of size `shape` centered on `center`
and scaled by `scale`. Optionally adds a "bar" to the left side
of the image, usually used to indicate the baseline and x-line
of a text line."""
scale = 1.0/scale
rshape = scale*array(shape)
center = array(center)-rshape/2.0
result = interpolation.affine_transform(1.0*image,diag([scale,scale]),offset=center,
output_shape=shape,order=1)
if bar is not None:
bar = array(bar,'f')
bar -= center[0]
bar /= scale
result[int(bar[0]):int(bar[1]),0] = amax(result)
return result
def distort_line(im, distort=3.0, sigma=10, eps=0.03, delta=0.3):
"""
Distorts a line image.
Run BEFORE degrade_line as a white border of 5 pixels will be added.
Args:
im (PIL.Image): Input image
distort (float):
sigma (float):
eps (float):
delta (float):
Returns:
PIL.Image in mode 'L'
"""
w, h = im.size
# XXX: determine correct output shape from transformation matrices instead
# of guesstimating.
logger.debug(u'Pasting source image into canvas')
image = Image.new('L', (int(1.5*w), 4*h), 255)
image.paste(im, (int((image.size[0] - w) / 2), int((image.size[1] - h) / 2)))
line = pil2array(image.convert('L'))
# shear in y direction with factor eps * randn(), scaling with 1 + eps *
# randn() in x/y axis (all offset at d)
logger.debug(u'Performing affine transformation')
m = np.array([[1 + eps * np.random.randn(), 0.0], [eps * np.random.randn(), 1.0 + eps * np.random.randn()]])
c = np.array([w/2.0, h/2])
d = c - np.dot(m, c) + np.array([np.random.randn() * delta, np.random.randn() * delta])
line = affine_transform(line, m, offset=d, order=1, mode='constant', cval=255)
hs = gaussian_filter(np.random.randn(4*h, int(1.5*w)), sigma)
ws = gaussian_filter(np.random.randn(4*h, int(1.5*w)), sigma)
hs *= distort/np.amax(hs)
ws *= distort/np.amax(ws)
def _f(p):
return (p[0] + hs[p[0], p[1]], p[1] + ws[p[0], p[1]])
logger.debug(u'Performing geometric transformation')
im = array2pil(geometric_transform(line, _f, order=1, mode='nearest'))
logger.debug(u'Cropping canvas to content box')
im = im.crop(ImageOps.invert(im).getbbox())
return im
def at(self, x, y, nativeScale=True):
"""
Returns an image of the PSF at the given pixel coordinates.
"""
psf = np.zeros_like(self.psfbases[0])
# print('Evaluating PsfEx at', x,y)
for term, base in zip(self.polynomials(x, y), self.psfbases):
# print(' polynomial', term, 'x base w/ range', base.min(), base.max())
psf += term * base
if nativeScale and self.sampling != 1:
from scipy.ndimage.interpolation import affine_transform
ny, nx = psf.shape
spsf = affine_transform(psf, [1.0 / self.sampling] * 2, offset=nx / 2 * (self.sampling - 1.0))
return spsf
return psf
def extract(image,y0,x0,y1,x1,mode='nearest',cval=0):
h,w = image.shape
ch,cw = y1-y0,x1-x0
y,x = np.clip(y0,0,max(h-ch,0)),np.clip(x0,0,max(w-cw, 0))
sub = image[y:y+ch,x:x+cw]
# print("extract", image.dtype, image.shape)
try:
r = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
if cw > w or ch > h:
pady0, padx0 = max(-y0, 0), max(-x0, 0)
r = interpolation.affine_transform(r, np.eye(2), offset=(pady0, padx0), cval=1, output_shape=(ch, cw))
return r
except RuntimeError:
# workaround for platform differences between 32bit and 64bit
# scipy.ndimage
dtype = sub.dtype
sub = np.array(sub,dtype='float64')
sub = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
sub = np.array(sub,dtype=dtype)
return sub
