def create_captcha(text, shear=0.2, size=(20, 20)):
'''
生成模式为L的黑白图像，生成写有text的文字，斜切值为0.2
:param text: str
:param shear: 图片斜切率
:param size: 图片大小
:return:
'''
im = Image.new('L', size, color='black')
draw = ImageDraw.Draw(im)
draw.text(xy=(1, 1),
text=text,
fill=1,
font=ImageFont.truetype(r'Coval-Black.otf', 16))
image = np.array(im)
# 斜切效果
image = tf.warp(image, tf.AffineTransform(shear=shear))
# 保存训练图片
t = time.time()
name = str(text) + str(shear) + str(t) + '.png'
if not os.path.exists('Image'):
os.mkdir('Image')
im = Image.fromarray(np.uint8(image))
im.save(os.path.join('Image', name))
return image / image.max() # 图像做归一化处理，避免单值范围过大
def random_affine(img, img_mask):
flat_sum_mask = sum(img_mask.flatten())
(row, col) = img_mask.shape
angle = shear_deg = 0
zoom = 1
center_shift = np.array((1000, 1000)) / 2. - 0.5
tform_center = transform.SimilarityTransform(translation=-center_shift)
tform_uncenter = transform.SimilarityTransform(translation=center_shift)
big_img = np.zeros((1000, 1000, 3), dtype=np.uint8)
big_mask = np.zeros((1000, 1000), dtype=np.uint8)
big_img[190:(190 + row), 144:(144 + col)] = img
big_mask[190:(190 + row), 144:(144 + col)] = img_mask
affine = random.choice(["rotate", "zoom", "shear"])
if affine == "rotate":
angle = random.uniform(-90, 90)
if affine == "zoom":
zoom = random.uniform(0.5, 1.5)
if affine == "shear":
shear_deg = random.uniform(-25, 25)
# pdb.set_trace()
tform_aug = transform.AffineTransform(rotation=np.deg2rad(angle),
scale=(1 / zoom, 1 / zoom),
shear=np.deg2rad(shear_deg),
translation=(0, 0))
tform = tform_center + tform_aug + tform_uncenter
# pdb.set_trace()
img_tr = transform.warp((big_img), tform)
mask_tr = transform.warp((big_mask), tform)
# pdb.set_trace()
masktemp = cv2.cvtColor(
(img_tr * 255).astype(np.uint8), cv2.COLOR_BGR2GRAY) > 20
img_tr = img_tr[np.ix_(masktemp.any(1), masktemp.any(0))]
mask_tr = mask_tr[np.ix_(masktemp.any(1), masktemp.any(0))]
return (img_tr * 255).astype(np.uint8), (mask_tr * 255).astype(np.uint8)
def calculate_coordinates(self, type='Proj'):
""" In laboratory spectroscopy the transformation
should only be affine (Rotation,Translation and Shear).
But in general cases, the transformation could
also have deformation and the transformation is
a projection.
See Mathematical definition of affine
transformation and Projection (Homography) for more details. """
self.repere_init_array_ = self.input_data.loc[
self.input_data['Type'].str.contains('ef')].to_numpy()[:, 1:]
self.repere_final_array_ = self.output_data.loc[
self.output_data['Type'].str.contains('ef')].to_numpy()[:, 1:]
self.mesures_init_array_ = self.input_data.loc[
self.input_data['Type'].str.contains('easure')].to_numpy()[:, 1:]
if type == 'Affine':
self.transformation_ = tf.AffineTransform()
self.transformation_.estimate(self.repere_init_array_,
self.repere_final_array_)
self.mesures_final_array_ = self.transformation_(
self.mesures_init_array_)
if type == 'Proj':
self.transformation_ = tf.ProjectiveTransform()
self.transformation_.estimate(self.repere_init_array_,
self.repere_final_array_)
self.mesures_final_array_ = self.transformation_(
self.mesures_init_array_)
def __call__(self, sample):
"""
img (PIL Image): Image to be transformed.
Returns:
PIL Image: Affine transformed image.
"""
img, labels = sample['image'], sample['labels']
warp_boxes = sample['warp_boxes']
ret = self.get_params(self.degrees, self.translate, self.scale, self.shear, img.size)
img = TF.affine(img, *ret, resample=self.resample, fillcolor=self.fillcolor)
labels = TF.affine(labels, *ret, resample=self.resample, fillcolor=self.fillcolor)
orig_box = warp_boxes * 256. + 256.
# Affine boxes
center = (img.size[0] * 0.5 + 0.5, img.size[1] * 0.5 + 0.5)
matrix = np.array(TF._get_inverse_affine_matrix(center, *ret)).reshape(2, 3)
matrix = np.vstack([matrix, np.eye(3)[2]])
assert matrix.shape == (3, 3)
affine_trans = trans.AffineTransform(matrix=matrix)
new_boxes = affine_trans.inverse(orig_box.reshape(-1, 2)) * (1. / 256.) - 1
new_boxes = torch.from_numpy(new_boxes.reshape(-1, 4).astype(np.float32))
sample.update({'image': img,
'labels': labels,
'warp_boxes': new_boxes
})
return sample
def points_matcher(src, dst):
model = transform.AffineTransform()
# estimate rot and trans from src to dst (linear least square)
model.estimate(src=src, dst=dst)
return model.params
def deformation(image):
random_shear_angl = np.random.random() * np.pi / 6 - np.pi / 12
random_rot_angl = np.random.random(
) * np.pi / 7 - np.pi / 12 - random_shear_angl
random_x_scale = np.random.random() * .4 + .8
random_y_scale = np.random.random() * .4 + .8
random_x_trans = np.random.random(
) * image.shape[0] / 4 - image.shape[0] / 8
random_y_trans = np.random.random(
) * image.shape[1] / 4 - image.shape[1] / 8
dx = image.shape[0]/2. \
- random_x_scale * image.shape[0]/2 * np.cos(random_rot_angl)\
+ random_y_scale * image.shape[1]/2 * np.sin(random_rot_angl + random_shear_angl)
dy = image.shape[1]/2. \
- random_x_scale * image.shape[0]/2 * np.sin(random_rot_angl)\
- random_y_scale * image.shape[1]/2 * np.cos(random_rot_angl + random_shear_angl)
trans_mat = tf.AffineTransform(rotation=random_rot_angl,
translation=(dx + random_x_trans,
dy + random_y_trans),
shear=random_shear_angl,
scale=(random_x_scale, random_y_scale))
return tf.warp(image, trans_mat.inverse, output_shape=image.shape)
def shear_image(img: np.ndarray, shear_factor: float) -> np.ndarray:
# TODO: write description
# Create Afine transform
afine_tf = transform.AffineTransform(shear=shear_factor)
# Apply transform to image data
modified_img = transform.warp(img, inverse_map=afine_tf)
return (modified_img * 255.).astype('uint8')
def shear(name, img_arr):
shear_angle = random.uniform(0, MAX_SHEAR_ANGLE)
affine_tf = tf.AffineTransform(shear=shear_angle, rotation=-shear_angle)
sheared = tf.warp(img_arr, affine_tf, mode=FILL_MODE)
sheared_inv = tf.warp(img_arr, affine_tf.inverse, mode=FILL_MODE)
io.imsave(name + "_sheared" + IMG_TYPE, sheared)
io.imsave(name + "_sheared_inverse" + IMG_TYPE, sheared_inv)
def composeSkimage(foreground, mask, background, transX=0, transY=0):
"""
对于前景图和背景图大小相等的合成
@param
foreground: 待插入对象所在的原始图片
mask: 待对象在原始图片的掩码
background: 待插入的背景图
transX: 需要平移的横向距离，向右为正
transY：需要平移的纵向距离，向下为正
"""
# 平移前景图
tform = transform.AffineTransform(translation=(transX, transY))
foreAug = transform.warp(foreground, tform.inverse)
foreAug = img_as_ubyte(foreAug)
# foreAug = np.roll(foreground, transX, axis=1)
# foreAug = np.roll(foreAug, transY, axis=0)
# 平移mask
new_mask = np.roll(mask, transX, axis=1) # 向右平移
new_mask = np.roll(new_mask, transY, axis=0) # 向下平移
# subtract the foreground area from the background
background = background * (
1 - new_mask.reshape(mask.shape[0], mask.shape[1], 1))
# extract the object from the foreground
foreAug = foreAug * new_mask.reshape(mask.shape[0], mask.shape[1], 1)
composed_image = background + foreAug
composed_image = composed_image.astype(np.uint8)
io.imshow(composed_image)
plt.show()
return composed_image
def scale_down(image):
scale_x = random.uniform(1.1, 1.15)
scale_y = scale_x
c = (image.shape[0] / 2 * (1 - scale_x), image.shape[1] / 2 * (1 - scale_y))
transform = imgtf.AffineTransform(scale=(scale_x, scale_y), translation=c)
image = imgtf.warp(image, transform, mode='wrap', preserve_range=True)
return np.clip(image, 0, 255).astype(np.uint8)
def align_face(
self,
image,
face_rect, *,
dim=96,
border=0,
mask=FaceAlignMask.INNER_EYES_AND_BOTTOM_LIP
):
mask = np.array(mask.value)
landmarks = self.get_landmarks(image, face_rect)
proper_landmarks = border + dim * self.face_template[mask]
A = np.hstack([landmarks[mask], np.ones((3, 1))]).astype(np.float64)
B = np.hstack([proper_landmarks, np.ones((3, 1))]).astype(np.float64)
T = np.linalg.solve(A, B).T
return tr.warp(
image,
tr.AffineTransform(T).inverse,
output_shape=(dim + 2 * border, dim + 2 * border),
order=3,
mode='constant',
cval=0,
clip=True,
preserve_range=True
)
def data_aug(image, label, angle = 30, resize_rate = 0.9):
flip = random.randint(0, 1)
size = image.shape[0]
rsize = random.randint(np.floor(resize_rate * size), size)
w_s = random.randint(0, size - rsize)
h_s = random.randint(0, size - rsize)
sh = random.random()/2 - 0.25
rotate_angle = random.random()/180*np.pi*angle
# Create Afine transform
afine_tf = transform.AffineTransform(shear=sh,rotation=rotate_angle)
# Apply transform to image data
image = transform.warp(image, inverse_map=afine_tf,mode='edge')
label = transform.warp(label, inverse_map=afine_tf,mode='edge')
# Randomly cropping image frame
image = image[w_s:w_s+size, h_s:h_s+size,:]
label = label[w_s:w_s+size, h_s:h_s+size]
# Randomly flip frame
if flip:
image = image[:,::-1,:]
label = label[:,::-1]
return image, label
def apply_transformation(Tstack, trans_matrix):
"""
only applies transformation matrix calcluated from other slices
Parameters
----------
Tstack : uint16 3D array [x,y,t]
slice to be registered in time
trans_matrix :
transformation matrix
Returns
-------
outStack : uint16 3D array [x,y,t]
in time registered slice
"""
Tstack = np.transpose(Tstack, (2, 0, 1))
outStack = np.zeros(Tstack.shape).astype(np.float)
for t in range(Tstack.shape[0]):
tform = tf.AffineTransform(matrix=trans_matrix[t, :, :])
outStack[t, :, :] = tf.warp(Tstack[t, :, :], tform)
outStack = np.uint16(outStack * 2**16)
outStack = np.transpose(outStack, (1, 2, 0))
return outStack
def augment_img(self, img):
"""
Performs augmentation of the image if required and returns a tensor
"""
# logging.debug('Shape of the array: {}'.format(img.shape))
if self.aug_img is False:
# logging.debug('No augmentation max before image transform: {}'.format(np.max(np.max(img))))
return self.transform(img)
if random.random() < self.aug_dict['prob']:
img_transform = skitransform.AffineTransform(
scale=tuple([
random.uniform(self.aug_dict['lscale'],
self.aug_dict['uscale'])
] * 2),
rotation=random.uniform(-self.aug_dict['rot'],
self.aug_dict['rot']),
translation=(random.uniform(-self.aug_dict['trans'],
self.aug_dict['trans']),
random.uniform(-self.aug_dict['trans'],
self.aug_dict['trans'])))
img = skitransform.warp(img, img_transform)
if random.random() < self.aug_dict['flip_lr']:
img = np.fliplr(img)
# logging.debug('Augmentation max before image transform: {}'.format(np.max(np.max(img))))
return self.transform(np.uint8(img * 255))
else:
# logging.debug('Augmentation max before image transform (no aug): {}'.format(np.max(np.max(img))))
return self.transform(img)
def get_overlay(fifo):
# get the whole FIFO
ir_raw = fifo.read()
# trim to 128 bytes
ir_trimmed = ir_raw[0:128]
# go all numpy on it
ir = np.frombuffer(ir_trimmed, np.uint16)
# set the array shape to the sensor shape (16x4)
ir = ir.reshape((16, 4))[::-1, ::-1]
ir = img_as_float(ir)
# stretch contrast on our heat map
p2, p98 = np.percentile(ir, (2, 98))
ir = exposure.rescale_intensity(ir, in_range=(p2, p98))
# increase even further? (optional)
# ir = exposure.equalize_hist(ir)
# turn our array into pretty colors
cmap = plt.get_cmap('spectral')
rgba_img = cmap(ir)
rgb_img = np.delete(rgba_img, 3, 2)
# align the IR array with the camera
tform = transform.AffineTransform(scale=SCALE,
rotation=ROT,
translation=OFFSET)
ir_aligned = transform.warp(rgb_img,
tform.inverse,
mode='constant',
output_shape=im.shape)
# turn it back into a ubyte so it'll display on the preview overlay
ir_byte = img_as_ubyte(ir_aligned)
# return buffer
return np.getbuffer(ir_byte)
def scale(x, severity=3):
c = [(1 / .9, 1 / .9), (1 / .8, 1 / .8), (1 / .7, 1 / .7),
(1 / .6, 1 / .6), (1 / .5, 1 / .5)][severity - 1]
aff = transform.AffineTransform(scale=c)
a1, a2 = aff.params[0, :2]
b1, b2 = aff.params[1, :2]
a3 = 13.5 * (1 - a1 - a2)
b3 = 13.5 * (1 - b1 - b2)
aff = transform.AffineTransform(scale=c, translation=[a3, b3])
x = np.array(x) / 255.
x = transform.warp(x, inverse_map=aff)
x = np.clip(x, 0, 1) * 255
return x.astype(np.float32)
def do_shear(img_X,img_Y,sh,horz):
if len(img_X) > 0:
h,w = img_X.shape[:2]
else:
h,w = img_Y.shape[:2]
matrix = np.zeros((3,3))
matrix[0,0] = 1.0
matrix[1,1] = 1.0
matrix[2,2] = 1.0
if horz:
matrix[0,1] = sh
matrix[0,2] = -np.sin(sh)* w / 2
else:
matrix[1,0] = sh
matrix[1,2] = -np.sin(sh)* h / 2
# Create Afine transform
afine_tf = transform.AffineTransform(matrix)
#print(afine_tf.params)
# Apply transform to image data
if len(img_X) > 0:
img_X = transform.warp(img_X, inverse_map=afine_tf,mode='edge', order=3)
if len(img_Y) > 0:
img_Y = transform.warp(img_Y, inverse_map=afine_tf,mode='edge', order=0)
return img_X, img_Y
def process_LK(self, sparse_flag='sd', f_tail='_lksd'):
if sparse_flag == 'sd':
input_data = [self.prev_frame2, self.prev_frame1, self.now_frame]
# print(np.array(input_data,np.uint8).shape)
pts_source, pts_target_container = sparse_sd(
np.array(input_data, np.uint8), lead_steps=self.pre_end + 1)
else:
pts_source, pts_target_container = sparse_linear(
np.array(input_data, np.uint8), lead_steps=self.pre_end + 1)
trf = sktf.AffineTransform()
nowcasts = []
print(self.pre_end + 1)
for lead_step in range(self.pre_step, self.pre_end + 1, self.pre_step):
print('Predict:::::', lead_step, ' hours later with lk')
pts_target = pts_target_container[lead_step]
# estimate transformation matrix
# based on source and traget points
trf.estimate(pts_source, pts_target)
# make a nowcast
nowcst_frame = sktf.warp(input_data[-1] / 255, trf.inverse)
nowcst_frame = nowcst_frame * 255.0
# out_pic = self.out_path + self.fn_head + self.fn_mid1 + str(self.start_ind + lead_step) + \
# self.fn_mid2 + str(self.ch).zfill(2) + f_tail + '.jpg'
# cv2.imwrite(out_pic, nowcst_frame)
nowcasts.append(nowcst_frame)
return np.array(nowcasts)
def augment_transform(image, label):
'''
This function randomly:
- translates the input image by +-width_range and +-height_range (percentage).
- scales the image by y_scaling and x_scaling (percentage)
- shears the image by shearing_factor (radians)
'''
ty = random.uniform(-random_y_translation, random_y_translation)
tx = random.uniform(-random_x_translation, random_x_translation)
sx = random.uniform(1. - random_y_scaling, 1. + random_y_scaling)
sy = random.uniform(1. - random_x_scaling, 1. + random_x_scaling)
s = random.uniform(-random_shearing, random_shearing)
gamma = random.uniform(0.001, 2)
image = exposure.adjust_gamma(image, gamma)
st = skimage_tf.AffineTransform(scale=(sx, sy),
shear=s,
translation=(tx * image.shape[1],
ty * image.shape[0]))
augmented_image = skimage_tf.warp(image, st, cval=1.0)
return transform(augmented_image * 255., label)
def rescale(img_as_array,min_xy_scale_factor):
"""Randomly downscales the x and y ranges of an image while zero-padding
image to retain the input image size shape. Newly downscaled image
occupies the upper-left most region of the output image.
Please note this function is not commutative. See augment() function.
Args:
img_as_array: image as 3D numpy array.
min_xy_scale_factor: lower bound of downscaling factor for x and y
values.
Returns:
image: rescaled imaged as 3D numpy uint8 array.
scale_xy: randomly determined downscale factors as tuple of x and y
factors.
"""
scale_x = random.uniform(min_xy_scale_factor,1.0)
scale_y = random.uniform(min_xy_scale_factor,1.0)
scale_xy = (scale_x, scale_y)
scale_xy_inverted = (1/scale_x, 1/scale_y)
affine_transform = transform.AffineTransform(scale=scale_xy_inverted)
return transform.warp(img_as_array, affine_transform, map_args={},
output_shape=None, order=1, mode='constant',
cval=140.0, clip=True,
preserve_range=True).astype(np.uint8), \
scale_xy
def transform_point(point_list, transform_parameters):
scale_x, scale_y = transform_parameters['zy'], transform_parameters['zx']
translate_x_px, translate_y_px = transform_parameters[
'ty'], transform_parameters['tx']
rotate = transform_parameters['theta']
shear = transform_parameters['shear']
flip_horizontal = transform_parameters.get('flip_horizontal', False)
flip_vertical = transform_parameters.get('flip_vertical', False)
if scale_x != 1.0 or scale_y != 1.0 or translate_x_px != 0 or translate_y_px != 0 or rotate != 0 \
or shear != 0:
matrix_to_topleft = skimage_tf.SimilarityTransform(
translation=[-0.5, -0.5])
matrix_transforms = skimage_tf.AffineTransform(
scale=(scale_x, scale_y),
translation=(translate_x_px, translate_y_px),
rotation=math.radians(rotate),
shear=math.radians(shear))
matrix_to_center = skimage_tf.SimilarityTransform(
translation=[0.5, 0.5])
matrix = (matrix_to_topleft + matrix_transforms + matrix_to_center)
point_list = skimage_tf.matrix_transform(point_list, matrix.params)
if flip_horizontal or flip_vertical:
matrix_to_topleft = skimage_tf.SimilarityTransform(
translation=[-0.5, -0.5])
point_list = skimage_tf.matrix_transform(point_list,
matrix_to_topleft.params)
if flip_horizontal:
point_list = [(-x, y) for x, y in point_list]
if flip_vertical:
point_list = [(x, -y) for x, y in point_list]
matrix_to_center = skimage_tf.SimilarityTransform(
translation=[0.5, 0.5])
point_list = skimage_tf.matrix_transform(point_list,
matrix_to_center.params)
return point_list
def translate(img_as_array,output_size,scale_xy):
"""Translates an image and pads with zeros. The provided x and y
rescaling factors from a previous rescaling operation ensures that a
randomly chosen translation does not cause the output image to lose any
pixels. Please note this function is not commutative. See augment()
function.
Args:
img_as_array: image as 3D numpy array.
output_size: tuple of height, width values indicating desired output
image size.
Returns:
image: image the size of output_size as 3D numpy uint8 array.
translation_xy: randomly determined x and y translations of the image
as tuple.
"""
scaled_width = (int(output_size[0]*scale_xy[0]))
scaled_height = (int(output_size[1]*scale_xy[1]))
translation_x = random.randint(0, (output_size[0]-scaled_width))
translation_y = random.randint(0, (output_size[1]-scaled_height))
translation_xy = (-translation_x, -translation_y)
affine_transform = transform.AffineTransform(translation=(translation_xy))
return transform.warp(img_as_array, affine_transform, map_args={},
output_shape=None, order=1, mode='constant',
cval=140.0, clip=True,
preserve_range=True).astype(np.uint8), \
translation_xy
def shift(image, vector):
vector = (-vector[0], -vector[1])
shifted = transform.warp(image,
transform.AffineTransform(translation=vector),
mode='wrap',
preserve_range=True)
return shifted.astype(image.dtype)
def transform_vis_im_to_IR_coordinate_system(im):
T = transform.AffineTransform(T_IR2v)
im = transform.warp(im, T, output_shape=(hIR, wIR))
imNew = np.zeros_like(im)
newcameramtx, roi = cv2.getOptimalNewCameraMatrix(K, dist, (wIR, hIR), 1,
(wIR, hIR))
mapx, mapy = cv2.initUndistortRectifyMap(K, dist, None, newcameramtx,
(wIR, hIR), 5)
SCALE = 1.15
mapx = cv2.resize(mapx,
None,
fx=SCALE,
fy=SCALE,
interpolation=cv2.INTER_LINEAR)
mapy = cv2.resize(mapy,
None,
fx=SCALE,
fy=SCALE,
interpolation=cv2.INTER_LINEAR)
for x in range(mapx.shape[1]):
for y in range(mapx.shape[0]):
try:
x2 = int(mapx[y, x])
y2 = int(mapy[y, x])
imNew[y2, x2, :] = im[int(y / SCALE), int(x / SCALE), :]
except:
no_match = True #just do nothing
return imNew
def warpAffine(img,M,shape=None):
if shape is None:
shape=img.shape
if M.shape[0]==2: #OpenCV takes 2x3 instead of 3x3
M = np.concatenate((M,np.array([[0.0,0.0,1.0]])),axis=0)
T = transform.AffineTransform(M)
return transform.warp(img,T,output_shape=shape)
def random_shear(image, gt_image, std=3.5,
lower=-10, upper=10, expand=True):
assert lower < upper
assert std > 0
angle = truncated_normal(mean=0, std=std, lower=lower,
upper=upper)
pi_angle = angle * np.pi / 360
afine_tf = tf.AffineTransform(shear=pi_angle)
image_r = (tf.warp(image / 255, inverse_map=afine_tf) * 255 + 0.4)\
.astype(np.int)
gt_image_r = tf.warp(gt_image / 255, inverse_map=afine_tf,
order=0)
gt_image_r = ((255 * gt_image_r) + 0.4).astype(np.int)
gt_image[10, 10] = 255
if DEBUG:
if not np.all(np.unique(gt_image_r) == np.unique(gt_image)):
logging.info("np.unique(gt_image_r): {}".format(
np.unique(gt_image_r)))
logging.info("np.unique(gt_image): {}".format(np.unique(gt_image)))
assert(False)
return image_r, gt_image_r
def _estimate_single(self, predicted, measured):
assert predicted.shape == self.shape
assert measured.shape == self.shape
flow = optical_flow_tvl1(predicted, measured)
flow[[1,0],] = flow[[0,1],]
xy_flow = self.xy_lin - flow
_Afunc_coord_warp = lambda transform_vec: self._coordinate_warp(transform_vec, self.xy_lin, xy_flow)
#estimate transform matrix from optical flow
results = sop.fmin_l_bfgs_b(_Afunc_coord_warp, np.array([0.0,0,0]))
transform_final = results[0]
if results[2]["warnflag"]:
transform_final *= 0.0
print("Transform estimation not converged")
#inverse warp measured image
transform_mat = np.array([np.cos(transform_final[0]), \
-np.sin(transform_final[0]), \
np.sin(transform_final[0]), \
np.cos(transform_final[0]), \
transform_final[1], \
transform_final[2]])
aff_mat = np.array([transform_mat[[0,1,4]], transform_mat[[2,3,5]],[0,0,1]])
tform = transform.AffineTransform(matrix = aff_mat)
measured_warp = transform.warp(measured, tform.inverse, cval = 1.0)
return measured_warp, transform_final
def build_augmentation_transform(zoom=1.0, rotation=0, shear=0, translation=(0, 0)):
tform_augment = transform.AffineTransform(scale=(1/zoom, 1/zoom),
rotation=np.deg2rad(rotation),
shear=np.deg2rad(shear),
translation=translation)
tform = tform_center + tform_augment + tform_uncenter # shift to center, augment, shift back (for the rotation/shearing)
return tform
def convert_affine_to_transform(D, shape):
"""Converts an affine transform on a diffraction pattern to a suitable
form for skimage.transform.warp()
Parameters
----------
D : np.array
Affine transform to be applied
shape : tuple
Shape tuple in form (y,x) for the diffraction pattern
Returns
-------
transformation : np.array
3x3 numpy array of the transformation to be applied.
"""
shift_x = (shape[1] - 1) / 2
shift_y = (shape[0] - 1) / 2
tf_shift = tf.SimilarityTransform(translation=[-shift_x, -shift_y])
tf_shift_inv = tf.SimilarityTransform(translation=[shift_x, shift_y])
# This defines the transform you want to perform
distortion = tf.AffineTransform(matrix=D)
# skimage transforms can be added like this, does matrix multiplication,
# hence the need for the brackets. (Note tf.warp takes the inverse)
transformation = (tf_shift + (distortion + tf_shift_inv)).inverse
return transformation
def affine_transformation(z, matrix, order, **kwargs):
"""Apply an affine transformation to a 2-dimensional array.
Parameters
----------
z : np.array
Array to be transformed
matrix : np.array
3x3 numpy array specifying the affine transformation to be applied.
order : int
Interpolation order.
kwargs :
To be passed to skimage.warp
Returns
-------
trans : array
Affine transformed diffraction pattern.
"""
# These three lines account for the transformation center not being (0,0)
shift_y, shift_x = np.array(z.shape[:2]) / 2.
tf_shift = tf.SimilarityTransform(translation=[-shift_x, -shift_y])
tf_shift_inv = tf.SimilarityTransform(translation=[shift_x, shift_y])
# This defines the transform you want to perform
transformation = tf.AffineTransform(matrix=matrix)
#skimage transforms can be added like this, actually matrix multiplication,
#hence the need for the brackets. (Note tf.warp takes the inverse)
trans = tf.warp(z, (tf_shift + (transformation + tf_shift_inv)).inverse,
order=order,
**kwargs)
return trans
