def test_deprecated_params_attributes():
for t in ('projective', 'affine', 'similarity'):
tform = estimate_transform(t, SRC, DST)
assert_equal(tform._matrix, tform.params)
tform = estimate_transform('polynomial', SRC, DST, order=3)
assert_equal(tform._params, tform.params)
def test_deprecated_params_attributes():
for t in ('projective', 'affine', 'similarity'):
tform = estimate_transform(t, SRC, DST)
assert_equal(tform._matrix, tform.params)
tform = estimate_transform('polynomial', SRC, DST, order=3)
assert_equal(tform._params, tform.params)
def getLocalTransform(newOrigin, newDestiny, method='affine'):
# FIRST NORMAL
if (method == 'affine'):
try:
# if(self.matrixrank(self.coordRef[neighs])>0):
#hn = af.Affine_Fit(newOrigin, newDestiny)
if newOrigin.shape[0] < 5:
transform = tf.estimate_transform('similarity', newOrigin,
newDestiny)
else:
transform = tf.estimate_transform('affine', newOrigin,
newDestiny)
hn = transform.params
# hn,mask = cv2.findHomography(newOrigin,newDestiny)
message = "Using affine fit with " + str(
newOrigin.shape) + " neighbors."
return hn, message
except np.linalg.linalg.LinAlgError as err:
return [], err.message
except FloatingPointError as err:
return [], err.message
else:
if newOrigin.shape[0] < 10:
transform = tf.estimate_transform('similarity', newOrigin,
newDestiny)
hn = transform.params
else:
hn = cv2.findHomography(newOrigin,
newDestiny) # global are maintained
return hn
def test_estimate_transform():
for tform in ('euclidean', 'similarity', 'affine', 'projective',
'polynomial'):
estimate_transform(tform, SRC[:2, :], DST[:2, :])
with pytest.raises(ValueError):
estimate_transform('foobar',
SRC[:2, :], DST[:2, :])
def test_estimate_transform():
for tform in ('euclidean', 'similarity', 'affine', 'projective',
'polynomial'):
estimate_transform(tform, SRC[:2, :], DST[:2, :])
with pytest.raises(ValueError):
estimate_transform('foobar',
SRC[:2, :], DST[:2, :])
def test_deprecated_params_attributes():
for t in ('projective', 'affine', 'similarity'):
tform = estimate_transform(t, SRC, DST)
with expected_warnings(['`_matrix`.*deprecated']):
assert_equal(tform._matrix, tform.params)
tform = estimate_transform('polynomial', SRC, DST, order=3)
with expected_warnings(['`_params`.*deprecated']):
assert_equal(tform._params, tform.params)
def test_deprecated_params_attributes():
for t in ('projective', 'affine', 'similarity'):
tform = estimate_transform(t, SRC, DST)
with expected_warnings(['`_matrix`.*deprecated']):
assert_equal(tform._matrix, tform.params)
tform = estimate_transform('polynomial', SRC, DST, order=3)
with expected_warnings(['`_params`.*deprecated']):
assert_equal(tform._params, tform.params)
def applyGeometricTransformation(startXs, startYs, newXs, newYs, bbox, frame=None):
N, F = startXs.shape
newXs_th, newYs_th = np.zeros((N, F)), np.zeros((N, F))
newbbox = np.zeros((F, 4, 2), dtype=np.int)
for f in range(F):
startX, startY = startXs[:, f], startYs[:, f]
newX, newY = newXs[:, f], newYs[:, f]
valid_idx = np.logical_and(newX > -1, newY > -1)
startX, startY = startX[valid_idx], startY[valid_idx]
newX, newY = newX[valid_idx], newY[valid_idx]
n = len(startX)
src = np.hstack((startX.reshape((n,1)), startY.reshape((n,1))))
dst = np.hstack((newX.reshape((n,1)), newY.reshape((n,1))))
if COMBINE:
if frame is not None and frame > 170 and frame < 208:
sform = tf.estimate_transform(TRANSFORM_COMBINE, src, dst)
else:
sform = tf.estimate_transform(TRANSFORM, src, dst)
else:
sform = tf.estimate_transform(TRANSFORM, src, dst)
newXY_pred = sform(src)
error = np.sqrt(np.sum((newXY_pred - dst)**2, axis=1))
idx = error < ERROR_TH
num_inliers = np.sum(idx)
if frame is not None:
print("Num of inliers: ", num_inliers, "Frame", frame, "min error: ", np.min(error), "max error", np.max(error))
else:
print("Num of inliers:", num_inliers)
if(num_inliers <= 2):
return None, None, None
newXY_af = dst.copy()
newXY_af[np.logical_not(idx)] = [-1, -1]
newX_th, newY_th = newXY_af[:, 0], newXY_af[:, 1]
newX_th, newY_th = np.round(newX_th).astype(np.int), np.round(newY_th).astype(np.int)
n_th = len(newX_th)
newXs_th[:n_th, f], newYs_th[:n_th, f] = newX_th, newY_th
newXs_th[n_th:, f], newYs_th[n_th:, f] = -1, -1
b = bbox[f]
new_b = sform(b)
newbbox[f] = np.round(new_b).astype(np.int)
return newXs_th, newYs_th, newbbox
def test_projective_estimation():
# exact solution
tform = estimate_transform('projective', SRC[:4, :], DST[:4, :])
assert_almost_equal(tform(SRC[:4, :]), DST[:4, :])
# over-determined
tform2 = estimate_transform('projective', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
# via estimate method
tform3 = ProjectiveTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_projective_estimation():
# exact solution
tform = estimate_transform('projective', SRC[:4, :], DST[:4, :])
assert_almost_equal(tform(SRC[:4, :]), DST[:4, :])
# over-determined
tform2 = estimate_transform('projective', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
# via estimate method
tform3 = ProjectiveTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def test_affine_estimation():
# exact solution
tform = estimate_transform('affine', SRC[:3, :], DST[:3, :])
assert_array_almost_equal(tform(SRC[:3, :]), DST[:3, :])
# over-determined
tform2 = estimate_transform('affine', SRC, DST)
assert_array_almost_equal(tform2.inverse(tform2(SRC)), SRC)
# via estimate method
tform3 = AffineTransform()
tform3.estimate(SRC, DST)
assert_array_almost_equal(tform3._matrix, tform2._matrix)
def warp_2_ims(im_no_mu, im_mu):
pts1 = get_lms_all(im_no_mu)
pts2 = get_lms_all(im_mu)
pts_av = (pts1 + pts2) / 2
pts1 = add_boundaries(pts1, im_no_mu)
pts2 = add_boundaries(pts2, im_mu)
pts_av = add_boundaries(pts_av, im_mu)
M1 = estimate_transform('piecewise-affine', pts2, pts_av)
warped_im1 = warp(im_mu, M1.inverse, output_shape=im_size, mode='edge')
M2 = estimate_transform('piecewise-affine', pts1, pts_av)
warped_im2 = warp(im_no_mu, M2.inverse, output_shape=im_size, mode='edge')
added_ims = np.array((warped_im1 / 2 + warped_im2 / 2) * 255,
dtype=np.uint8)
all_ims = np.hstack((im_no_mu, im_mu, added_ims))
return added_ims
def get_transfrom_matrix(center_scale, output_size):
"""get transform matrix
"""
center, scale = center_scale[0], center_scale[1]
# todo: further add rot and shift here.
src_w = scale[0]
dst_w = output_size[0]
dst_h = output_size[1]
src_dir = np.array([0, src_w * -0.5])
dst_dir = np.array([0, dst_w * -0.5])
src = np.zeros((3, 2), dtype=np.float32)
dst = np.zeros((3, 2), dtype=np.float32)
src[0, :] = center
src[1, :] = center + src_dir
dst[0, :] = np.array([dst_w * 0.5, dst_h * 0.5])
dst[1, :] = np.array([dst_w * 0.5, dst_h * 0.5]) + dst_dir
src[2, :] = get_3rd_point(src[0, :], src[1, :])
dst[2, :] = get_3rd_point(dst[0, :], dst[1, :])
get_matrix = trans.estimate_transform("affine", src, dst)
matrix = get_matrix.params
return matrix.astype(np.float32)
def alignment(fp_file, image_path, save_path, ref_points=[]):
point_lines = read_file(fp_file)
image_lines = read_file(image_path)
if not point_lines or not image_lines:
print 'empty file'
return
if len(ref_points) == 0:
ref_points = np.float32(point_lines[0].split()).reshape((5, 2))
i = 0
for (point_line, image_line) in zip(point_lines, image_lines):
image_line = image_line.strip('\n')
point_line = point_line.strip('\n')
img_name = image_line.split()[0]
dir_name = image_line.split('/')[0]
exist_dirs = os.listdir(TARGET_ROOT)
if dir_name not in exist_dirs:
os.mkdir(TARGET_ROOT + dir_name)
img = skimage.io.imread(DATA_ROOT + img_name)
pts = np.float32(point_line.split()).reshape((5, 2))
tfrom = tf.estimate_transform('similarity', ref_points, pts)
warpimage = tf.warp(img, inverse_map=tfrom, output_shape=imgSize)
skimage.io.imsave(save_path + img_name, warpimage)
i = i + 1
print('\riter %d' % (i))
print 'done'
def transform_to_template(shape, template, transformation_type='similarity'):
"""Returns a transformed shape that is as close as possible to the given
template under a certain type of transformation.
Args:
shape (ndarray): An n x 2 array where each row represents a vertex in
the shape. The first column is the x-coordinate and
the second column is the y-coordinate.
template (ndarray): Another shape corresponding to the first input.
It must have the same array shape and type, and
corresponding rows must respresent corresponding
vertices. For example, the vertex respresented by
row **i** in the *input* will try to match as
closesly as possible to the vertex represented by
row **i** in the *template*.
transformation_type (str): The type of transformation to use when
fitting the shape to the template. The
string must be one of the ones specified by
`skimage.transform.estimate_transform`_.
Returns:
ndarray: Transformed shape of the same type and array shape as the
input shape.
.. _skimage.transform.estimate_transform: http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.estimate_transform
"""
transformation = estimate_transform(transformation_type, shape, template)
return matrix_transform(shape, transformation.params)
def __call__(self, sample):
image, labels, index, landmarks = sample['image'], sample[
'labels'], sample['index'], sample['landmarks']
dst = np.array([[-0.25, -0.1], [0.25, -0.1], [0.0, 0.1], [-0.15, 0.4],
[0.15, 0.4]])
tform = transform.estimate_transform('similarity', landmarks, dst)
def map_func1(coords):
tform2 = transform.SimilarityTransform(scale=1 / 32,
rotation=0,
translation=(-1.0, -1.0))
return tform.inverse(tform2(coords))
l, h, w = labels.shape
image = np.uint8(
transform.warp(
image, inverse_map=map_func1, output_shape=[64, 64, 3]) * 255)
labels = np.uint8(
transform.warp(labels.transpose(1, 2, 0),
inverse_map=map_func1,
output_shape=[64, 64, l]).transpose(2, 0, 1) * 255)
return {
'image': image,
'labels': labels,
'index': index,
'landmarks': landmarks
}
def align_to_template_similarity(self, image, gray, rect):
template_landmarks = get_template_landmark()
detected_landmarks = shape_to_np(self.predictor(gray, rect))
tf = transform.estimate_transform('similarity', detected_landmarks,
template_landmarks)
result = img_as_ubyte(
transform.warp(image,
inverse_map=tf.inverse,
output_shape=(self.desiredFaceWidth,
self.desiredFaceWidth, 3)))
# imshow(result)
# overlay template landmarks on result -- successful
# canvas = result
# for p in template_landmarks:
# x, y = p
# result[y, x] = [0, 255, 0] # OG
# surround
# result[y-1, x] = [0, 255, 0]
# result[y-1, x+1] = [0, 255, 0]
# result[y, x+1] = [0, 255, 0]
# result[y+1, x+1] = [0, 255, 0]
# result[y+1, x] = [0, 255, 0]
# result[y+1, x-1] = [0, 255, 0]
# result[y, x-1] = [0, 255, 0]
# result[y-1, x-1] = [0, 255, 0]
#
# imshow(canvas)
# #
# # save image as jpg -- successful
# result = Image.fromarray(result, mode='RGB')
# result.save('testing123_2.jpg')
return result
def get_cropping_transformation(image, face_detector, shape_predictor):
detected_faces = face_detector(image, 1)
if len(detected_faces) == 0:
print('warning: no detected face')
return None
d = detected_faces[
0].rect ## only use the first detected face (assume that each input image only contains one face)
left = d.left()
right = d.right()
top = d.top()
bottom = d.bottom()
old_size = (right - left + bottom - top) / 2
center = np.array([
right - (right - left) / 2.0,
bottom - (bottom - top) / 2.0 + old_size * 0.14
])
size = int(old_size * 1.58)
shape = shape_predictor(image, d)
coords = np.zeros((68, 2), dtype=int)
for i in range(0, 68):
coords[i] = (shape.part(i).x, shape.part(i).y)
src_pts = np.array([[center[0] - size / 2, center[1] - size / 2],
[center[0] - size / 2, center[1] + size / 2],
[center[0] + size / 2, center[1] - size / 2]])
DST_PTS = np.array([[0, 0], [0, 255], [255, 0]])
tform = estimate_transform('similarity', src_pts, DST_PTS)
return coords, tform
def __getitem__(self, index):
imagepath = self.imagepath_list[index]
imagename = imagepath.split('/')[-1].split('.')[0]
image = imread(imagepath)[:,:,:3]
h, w, _ = image.shape
if self.iscrop:
kptpath = os.path.join(self.kptfolder, imagename+'.npy')
kpt = np.load(kptpath)
left = np.min(kpt[:,0]); right = np.max(kpt[:,0])
top = np.min(kpt[:,1]); bottom = np.max(kpt[:,1])
old_size = (right - left + bottom - top)/2
center = np.array([right - (right - left) / 2.0, bottom - (bottom - top) / 2.0 ])#+ old_size*0.1])
size = int(old_size*self.scale)
src_pts = np.array([[center[0]-size/2, center[1]-size/2], [center[0] - size/2, center[1]+size/2], [center[0]+size/2, center[1]-size/2]])
else:
src_pts = np.array([[0, 0], [0, h-1], [w-1, 0]])
DST_PTS = np.array([[0,0], [0,self.resolution_inp - 1], [self.resolution_inp - 1, 0]])
tform = estimate_transform('similarity', src_pts, DST_PTS)
image = image/255.
dst_image = warp(image, tform.inverse, output_shape=(self.resolution_inp, self.resolution_inp))
dst_image = dst_image.transpose(2,0,1)
return {'image': torch.tensor(dst_image).float(),
'imagename': imagename,
'tform': tform,
'original_image': torch.tensor(image.transpose(2,0,1)).float(),
}
def map_func1(landmarks, coords):
dst = np.array([[-0.25,-0.1], [0.25, -0.1], [0.0, 0.1], [-0.15, 0.4], [0.15, 0.4]])
tform = transform.estimate_transform('similarity', np.array(landmarks, np.float), dst)
tform2 = transform.SimilarityTransform(scale=1/32, rotation=0, translation=(-1.0, -1.0))
ans = tform.inverse(tform2(coords))
#print(coords, ans)
return ans
def gen_data(name):
reftracker = scio.loadmat('data/images_tracker.00047.mat')['tracker']
desttracker = scio.loadmat('data/images_tracker/'+name+'.mat')['tracker']
refpos = np.floor(np.mean(reftracker, 0))
xxc, yyc = np.meshgrid(np.arange(1, 1801, dtype=np.int), np.arange(1, 2001, dtype=np.int))
#normalize x and y channels
xxc = (xxc - 600 - refpos[0]) * 1.0 / 600
yyc = (yyc - 600 - refpos[1]) * 1.0 / 600
maskimg = Image.open('data/meanmask.png')
maskc = np.array(maskimg, dtype=np.float)
maskc = np.pad(maskc, (600, 600), 'minimum')
# warp is an inverse transform, and so src and dst must be reversed here
tform = transform.estimate_transform('affine', desttracker + 600, reftracker + 600)
img_data = skio.imread('data/images_data/'+name+'.jpg')
# save org mat
warpedxx = transform.warp(xxc, tform, output_shape=xxc.shape)
warpedyy = transform.warp(yyc, tform, output_shape=xxc.shape)
warpedmask = transform.warp(maskc, tform, output_shape=xxc.shape)
warpedxx = warpedxx[600:1400, 600:1200, :]
warpedyy = warpedyy[600:1400, 600:1200, :]
warpedmask = warpedmask[600:1400, 600:1200, :]
img_h, img_w, _ = img_data.shape
mat = np.zeros((img_h, img_w, 6), dtype=np.float)
mat[:, :, 0] = (img_data[2] * 1.0 - 104.008) / 255
mat[:, :, 1] = (img_data[1] * 1.0 - 116.669) / 255
mat[:, :, 2] = (img_data[0] * 1.0 - 122.675) / 255
scio.savemat('portraitFCN_data/' + name + '.mat', {'img':mat})
mat_plus = np.zeros((img_h, img_w, 6), dtype=np.float)
mat_plus[:, :, 0:3] = mat
mat_plus[:, :, 3] = warpedxx
mat_plus[:, :, 4] = warpedyy
mat_plus[:, :, 5] = warpedmask
def crop_image(image, resolution=256):
"""
Crops the image to a desired size (resolution) to a square with black edges (in case the image is not square)
:param image: patch image
:param resolution: desired size for the image
:return: cropped image
"""
bounding_box = BoundingBox((0, 0, image.shape[1], image.shape[0]))
frame_image = skimage.img_as_float32(image)
left = bounding_box.left
right = bounding_box.right
top = bounding_box.top
bottom = bounding_box.bottom
old_size = (right - left + bottom - top) / 2
center = np.array([right - (right - left) / 2.0, bottom - (bottom - top) / 2.0])
size = int(old_size * 1.)
src_pts = np.array([[center[0] - size / 2, center[1] - size / 2], [center[0] - size / 2, center[1] + size / 2],
[center[0] + size / 2, center[1] - size / 2]])
dst_pts = np.array([[0, 0], [0, resolution - 1], [resolution - 1, 0]])
tform = estimate_transform('similarity', src_pts, dst_pts)
cropped_image = warp(frame_image, tform.inverse, output_shape=(resolution, resolution))
return cropped_image, tform
def test_find_transform_givensources(self):
from skimage.transform import estimate_transform, matrix_transform
source = np.array([
[1.4, 2.2],
[5.3, 1.0],
[3.7, 1.5],
[10.1, 9.6],
[1.3, 10.2],
[7.1, 2.0],
])
nsrc = source.shape[0]
scale = 1.5 # scaling parameter
alpha = np.pi / 8.0 # rotation angle
mm = scale * np.array([[np.cos(alpha), -np.sin(alpha)],
[np.sin(alpha), np.cos(alpha)]])
tx, ty = 2.0, 1.0 # translation parameters
transl = np.array([nsrc * [tx], nsrc * [ty]])
dest = (mm.dot(source.T) + transl).T
t_true = estimate_transform("similarity", source, dest)
# disorder dest points so they don't match the order of source
np.random.shuffle(dest)
t, (src_pts, dst_pts) = aa.find_transform(source, dest)
self.assertLess(t_true.scale - t.scale, 1e-10)
self.assertLess(t_true.rotation - t.rotation, 1e-10)
self.assertLess(np.linalg.norm(t_true.translation - t.translation),
1e-10)
self.assertEqual(src_pts.shape[0], dst_pts.shape[0])
self.assertEqual(src_pts.shape[1], 2)
self.assertEqual(dst_pts.shape[1], 2)
dst_pts_test = matrix_transform(src_pts, t.params)
self.assertLess(np.linalg.norm(dst_pts_test - dst_pts), 1e-10)
def extract_sift(image,lm=None, shape=[200,300], fix_points='outer',ttype='affine'):
if lm==None:lm = landmarks(image)
if np.any(np.isnan(lm)):
return np.nan*np.ones([out_shape,out_shape,image.shape[2]]).astype(np.float16), np.nan*np.zeros_like(lm)
dst = mean_face[:,p[fix_points]]
dst = dst-dst.mean(1)[:,None]
dst = dst/np.abs(dst).max()
dst *=shape[0]/2
dst +=shape[1]/2
print(dst.min())
print(dst.max())
src = lm[:,p[fix_points]]
tform = transform.estimate_transform(ttype, src.T,dst.T)
lm_reg = tform(lm.T).T
image = transform.warp(image,inverse_map=tform.inverse,output_shape=[shape[1],shape[1]])
image = exposure.equalize_hist(image,mask=image!=0)
S = 12
for l1,l2 in lm_reg.T:
x = np.arange(l2-S,l2+S)
y = np.arange(l1-S,l1+S)
for x_ in x:
for y_ in y:
image[x_,y_,0]=255
return image, lm_reg
def __init__(self, landmarks):
self.landmarks = landmarks
src = np.array(self.landmarks)
dst = np.array([[-0.25, -0.1], [0.25, -0.1], [0.0, 0.1], [-0.15, 0.4],
[0.15, 0.4]])
self.tform = transform.estimate_transform('similarity', src, dst)
def regMRI(data, reg_df, reg_id=1):
n_sample = data.shape[-1]
if n_sample != reg_df.shape[0]:
logging.error("Error, registration and data not match. Please check")
sys.exit()
n_landmark = int((reg_df.shape[1] - 1) / 2)
# reg_target = data[..., 0, reg_id]
_dst = reg_df.iloc[reg_id, 2:].values
_dst = _dst.reshape((n_landmark, 2))
max_dist = np.zeros(n_sample)
for i in range(n_sample):
if i == reg_id:
continue
else:
# epts = reg_df.iloc[i, 1:].values
_src = reg_df.iloc[i, 2:].values
_src = _src.reshape((n_landmark, 2))
idx_valid = np.isnan(_src[:, 0])
tform = transform.estimate_transform(ttype="similarity",
src=_src[~idx_valid, :],
dst=_dst[~idx_valid, :])
# forward transform used here, inverse transform used for warp
src_tform = tform(_src[~idx_valid, :])
dist = np.linalg.norm(src_tform - _dst[~idx_valid, :], axis=1)
max_dist[i] = dist.max()
for j in range(data[..., i].shape[-1]):
src_img = data[..., j, i].copy()
warped = transform.warp(src_img,
inverse_map=tform.inverse,
preserve_range=True)
data[..., j, i] = warped
return data, max_dist
def GetTarget(train_shapes, train_bboxes, gt_shapes, mean_rshape):
targets=[]
for i in range(len(train_shapes)):
# do similarity transformation to mean space
sim_trans=transform.estimate_transform('similarity', CenterShape(Shape2Relative(train_shapes[i], train_bboxes[i])), CenterShape(mean_rshape))
targets.append(sim_trans(Shape2Relative(gt_shapes[i], train_bboxes[i])-Shape2Relative(train_shapes[i], train_bboxes[i])))
return np.array(targets)
def calc_convergence(self, corr_points, em_points, min_points, refine_matrix):
em_points = np.array(em_points)
corr_points = np.array(corr_points)
corr_points_refined = []
if refine_matrix is None:
corr_points_refined = corr_points
else:
for i in range(len(corr_points)):
p = np.array([corr_points[i, 0], corr_points[i, 1], 1])
p_new = refine_matrix @ p
corr_points_refined.append(p_new[:2])
# corr_points_refined = np.array(corr_points)
corr_points_refined = np.array(corr_points_refined)
num_sims = len(em_points) - min_points + 1
num_iterations = 100
precision_refined = []
precision_free = []
precision_all = []
num_points = min_points
for i in range(num_sims):
precision_i_refined = []
precision_i_free = []
precision_i_all = []
for k in range(num_iterations):
indices = random.sample(range(len(em_points)), num_points)
p_em = em_points[indices]
p_corr = corr_points_refined[indices]
refine_matrix = tf.estimate_transform('affine', p_corr, p_em).params
calc_points = []
for l in range(len(corr_points)):
p = np.array([corr_points_refined[l, 0], corr_points_refined[l, 1], 1])
p_refined = refine_matrix @ p
calc_points.append(p_refined[:2])
diff_all = em_points - np.array(calc_points)
diff_refined = diff_all[indices]
diff_free = np.array([diff_all[i] for i in range(len(diff_all)) if i not in indices])
rms_all = np.sqrt(1 / len(diff_all) * (diff_all ** 2).sum())
rms_refined = np.sqrt(1 / len(diff_refined) * (diff_refined ** 2).sum())
if len(diff_free) > 0:
rms_free = np.sqrt(1 / len(diff_free) * (diff_free ** 2).sum())
else:
rms_free = 0
precision_i_refined.append(rms_refined)
precision_i_free.append(rms_free)
precision_i_all.append(rms_all)
precision_refined.append(np.mean(precision_i_refined))
precision_free.append(np.mean(precision_i_free))
precision_all.append(np.mean(precision_i_all))
num_points += 1
precision_refined = np.array(precision_refined) * self.pixel_size[0]
precision_free = np.array(precision_free) * self.pixel_size[0]
precision_all = np.array(precision_all) * self.pixel_size[0]
self.print('RMS error: ', precision_all[-1])
return [precision_refined, precision_free, precision_all]
def affine_fun(src, dst):
tform = tf.estimate_transform('affine', src, dst)
def affine_fun(x):
return tform(x)[0]
return affine_fun
def estimate_coordinate_transform(source, target, method, **method_kwargs):
"""Calculates a transformation from a source list of coordinates to a
target list of coordinates.
Parameters
----------
source : Nx2 array
(x, y) coordinate pairs from source image.
target : Nx2 array
(x, y) coordinate pairs from target image. Must be same shape as
'source'.
method : string, optional
Method to use for transform estimation.
**method_kwargs : optional
Additional arguments can be passed in specific to the particular
method. For example, 'order' for a polynomial transform estimation.
Returns
-------
transform : skimage.transform._geometric.GeometricTransform
An skimage transform object.
See Also
--------
skimage.transform.estimate_transform
"""
return tf.estimate_transform(method, source, target, **method_kwargs)
def __getitem__(self, index):
imagepath = self.imagepath_list[index]
imagename = imagepath.split('/')[-1].split('.')[0]
image = imread(imagepath)[:,:,:3]
kpt = scipy.io.loadmat(imagepath.replace('jpg', 'mat'))['pt3d_68'].T
left = np.min(kpt[:,0]); right = np.max(kpt[:,0]);
top = np.min(kpt[:,1]); bottom = np.max(kpt[:,1])
h, w, _ = image.shape
old_size = (right - left + bottom - top)/2
center = np.array([right - (right - left) / 2.0, bottom - (bottom - top) / 2.0 ])#+ old_size*0.1])
size = int(old_size*self.scale)
# crop image
src_pts = np.array([[center[0]-size/2, center[1]-size/2], [center[0] - size/2, center[1]+size/2], [center[0]+size/2, center[1]-size/2]])
DST_PTS = np.array([[0,0], [0,self.resolution_inp - 1], [self.resolution_inp - 1, 0]])
tform = estimate_transform('similarity', src_pts, DST_PTS)
image = image/255.
dst_image = warp(image, tform.inverse, output_shape=(self.resolution_inp, self.resolution_inp))
dst_image = dst_image.transpose(2,0,1)
return {'image': torch.tensor(dst_image).float(),
'imagename': imagename,
# 'tform': tform,
# 'original_image': torch.tensor(image.transpose(2,0,1)).float(),
}
def estimate_coordinate_transform(source, target, method, **method_kwargs):
"""Calculates a transformation from a source list of coordinates to a
target list of coordinates.
Parameters
----------
source : Nx2 array
(x, y) coordinate pairs from source image.
target : Nx2 array
(x, y) coordinate pairs from target image. Must be same shape as
'source'.
method : string, optional
Method to use for transform estimation.
**method_kwargs : optional
Additional arguments can be passed in specific to the particular
method. For example, 'order' for a polynomial transform estimation.
Returns
-------
transform : skimage.transform._geometric.GeometricTransform
An skimage transform object.
See Also
--------
skimage.transform.estimate_transform
"""
return tf.estimate_transform(method, source, target, **method_kwargs)
def calculate_transform(frame):
"""
Calculates affine transformation.
Write result to frame.tform
"""
if frame.isref:
print("No need to calculate for reference frame.")
return
print("Starting affine transform for frame number " + frame.number)
primary = []
secondary = []
m = 0
for i in frame.pairs:
if m > 11 or i[2] < 20:
break
#primary.append([i[0][0], i[0][1], 0])
#secondary.append([i[1][0], i[1][1], 0])
primary.append([i[0][0], i[0][1]])
secondary.append([i[1][0], i[1][1]])
m += 1
primary = np.squeeze(np.array(primary))
secondary = np.squeeze(np.array(secondary))
try:
frame.tform = tf.estimate_transform(ttype="affine", src=secondary, dst=primary)
except IndexError:
pass
def Apply(self, batched_data_dict, batch_size, istub):
if (batch_size != len(batched_data_dict[batched_data_dict.keys()[0]])):
print("[Error] Apply() batch size not matched...")
return None
else:
batched_result_dict = dict()
tform = estimate_transform('similarity',
batched_data_dict["src_pts"][0],
PRNetImageCropper.DST_PTS)
image = batched_data_dict["raw_image"][0] / 255.
# print(image.shape)
cropped_image = cv2.warpAffine(
image,
tform.params[:2],
dsize=(PRNetImageCropper.resolution_inp,
PRNetImageCropper.resolution_inp))
# print(cropped_image.shape)
batched_result_dict["tform_params"] = [tform.params]
batched_result_dict["cropped_image"] = [cropped_image]
batched_result_dict["output_flag"] = batched_data_dict[
"output_flag"]
return batched_result_dict
def main(base_dir):
BASE_DIR = base_dir
# Load the set of pictures
ic = io.ImageCollection(BASE_DIR + '*.JPG')
# Select points on the first picture
f, ax = plt.subplots(1,1)
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax.autoscale(enable=True, axis='both', tight=True);
plt.tight_layout(pad=0.4, w_pad=0.0, h_pad=0.0)
ax.imshow(ic[0])
coords = [plt.ginput(8, timeout=0)]
plt.close()
# Load first picture side-by side with second, select points.
# Scroll through images one-by-one
for i, img in enumerate(ic[1:]):
ax1 = plt.subplot2grid((6,10),(0,1), rowspan=6, colspan=9)
ax0 = plt.subplot2grid((6,10),(0,0))
for ax in [ax0, ax1]:
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.tight_layout(pad=0.4, w_pad=0.0, h_pad=0.0)
#f, (ax0,ax1) = plt.subplots(1,2)
ax0.imshow(ic[i])
for coord in coords[i]:
ax0.scatter(coord[0],coord[1])
ax1.imshow(img)
coords.append(plt.ginput(8, timeout=0))
plt.close()
# Use a similarity transformation to transform each one.
if not os.path.exists(BASE_DIR + 'corrected'):
os.mkdir(BASE_DIR + 'corrected')
np.save(BASE_DIR + 'corrected/coords.npy', coords)
io.imsave(BASE_DIR + 'corrected/0.jpg', ic[0])
for i, img in enumerate(ic[1:]):
tf = transform.estimate_transform('similarity', np.array(coords[0]), np.array(coords[i+1]))
# Use a translation transformation to center both images for display purposes
img_warped = transform.warp(img, inverse_map=tf,
output_shape=(1728,3072))
print BASE_DIR + 'corrected/%d.jpg' %(i+1)
print img_warped
io.imsave(BASE_DIR + 'corrected/%d.jpg' %(i+1), img_warped)
def calc_affine_transform(self, my_points):
my_points = self.calc_orientation(my_points)
self.log('Input points:\n', my_points)
side_list = np.linalg.norm(np.diff(my_points, axis=0), axis=1)
side_list = np.append(side_list, np.linalg.norm(my_points[0] - my_points[-1]))
self.side_length = np.mean(side_list)
self.log('ROI side length:', self.side_length, '\xb1', side_list.std())
cen = my_points.mean(0) - np.ones(2) * self.side_length / 2.
points_tmp = np.zeros_like(my_points)
points_tmp[0] = cen + (0, 0)
points_tmp[1] = cen + (self.side_length, 0)
points_tmp[2] = cen + (self.side_length, self.side_length)
points_tmp[3] = cen + (0, self.side_length)
self.tf_matrix = tf.estimate_transform('affine', my_points, points_tmp).params
nx, ny = self.data.shape
corners = np.array([[0, 0, 1], [nx, 0, 1], [nx, ny, 1], [0, ny, 1]]).T
self.tf_corners = np.dot(self.tf_matrix, corners)
self.tf_shape = tuple([int(i) for i in (self.tf_corners.max(1) - self.tf_corners.min(1))[:2]])
self.tf_matrix[:2, 2] -= self.tf_corners.min(1)[:2]
self.print('Transform matrix:\n', self.tf_matrix)
self.print('Shift: ', -self.tf_corners.min(1)[:2])
self.log('Assembled? ', self.assembled)
if not self._transformed:
if self.assembled:
self._orig_points = np.copy(my_points)
self.tf_matrix_orig = np.copy(self.tf_matrix)
else:
self._orig_points_region = np.copy(my_points)
self.tf_matrix_orig_region = np.copy(self.tf_matrix)
self.apply_transform(points_tmp)
def crop(self, image, kpt):
left = np.min(kpt[:, 0])
right = np.max(kpt[:, 0])
top = np.min(kpt[:, 1])
bottom = np.max(kpt[:, 1])
h, w, _ = image.shape
old_size = (right - left + bottom - top) / 2
center = np.array(
[right - (right - left) / 2.0,
bottom - (bottom - top) / 2.0]) #+ old_size*0.1])
# translate center
trans_scale = (np.random.rand(2) * 2 - 1) * self.trans_scale
center = center + trans_scale * old_size # 0.5
scale = np.random.rand() * (self.scale[1] -
self.scale[0]) + self.scale[0]
size = int(old_size * scale)
# crop image
src_pts = np.array([[center[0] - size / 2, center[1] - size / 2],
[center[0] - size / 2, center[1] + size / 2],
[center[0] + size / 2, center[1] - size / 2]])
DST_PTS = np.array([[0, 0], [0, self.image_size - 1],
[self.image_size - 1, 0]])
tform = estimate_transform('similarity', src_pts, DST_PTS)
# cropped_image = warp(image, tform.inverse, output_shape=(self.image_size, self.image_size))
# # change kpt accordingly
# cropped_kpt = np.dot(tform.params, np.hstack([kpt, np.ones([kpt.shape[0],1])]).T).T # np.linalg.inv(tform.params)
return tform
def similarity_fun(src, dst):
tform = tf.estimate_transform('similarity', src, dst)
def affine_fun(x):
return tform(x)[0]
return affine_fun
def infer(edge_image, edge_lengths, mu, phi, sigma2,
update_slice=slice(None),
scale_estimate=None,
rotation=0,
translation=(0, 0)):
# edge_points = np.array(np.where(edge_image)).T
# edge_points[:, [0, 1]] = edge_points[:, [1, 0]]
# edge_score = edge_image.shape[0] * np.exp(-edge_lengths[edge_image] / (0.25 * edge_image.shape[0])).reshape(-1, 1)
# edge_points = np.concatenate((edge_points, edge_score), axis=1)
#
# edge_nn = NearestNeighbors(n_neighbors=1).fit(edge_points)
edge_near = scipy.ndimage.distance_transform_edt(~edge_image)
edge_near_blur = gaussian(edge_near, 2)
Gy, Gx = np.gradient(edge_near_blur)
mag = np.sqrt(np.power(Gy, 2) + np.power(Gx, 2))
if scale_estimate is None:
scale_estimate = min(edge_image.shape) * 4
mu = (mu.reshape(-1, 2) - mu.reshape(-1, 2).mean(axis=0)).reshape(-1, 1)
average_distance = np.sqrt(np.power(mu.reshape(-1, 2), 2).sum(axis=1)).mean()
scale_estimate /= average_distance * np.sqrt(2)
h = np.zeros((phi.shape[1], 1))
psi = SimilarityTransform(scale=scale_estimate, rotation=rotation, translation=translation)
while True:
w = (mu + phi @ h).reshape(-1, 2)
image_points = matrix_transform(w, psi.params)[update_slice, :]
image_points = np.concatenate((image_points, np.zeros((image_points.shape[0], 1))), axis=1)
# closest_edge_point_indices = edge_nn.kneighbors(image_points)[1].flatten()
# closest_edge_points = edge_points[closest_edge_point_indices, :2]
closest_edge_points = gradient_step(Gy, Gx, mag, image_points)
w = mu.reshape(-1, 2)
psi = estimate_transform('similarity', w[update_slice, :], closest_edge_points)
image_points = matrix_transform(w, psi.params)[update_slice, :]
image_points = np.concatenate((image_points, np.zeros((image_points.shape[0], 1))), axis=1)
# closest_edge_point_indices = edge_nn.kneighbors(image_points)[1].flatten()
# closest_edge_points = edge_points[closest_edge_point_indices, :2]
closest_edge_points = gradient_step(Gy, Gx, mag, image_points)
mu_slice = mu.reshape(-1, 2)[update_slice, :].reshape(-1, 1)
K = phi.shape[-1]
phi_full = phi.reshape(-1, 2, K)
phi_slice = phi_full[update_slice, :].reshape(-1, K)
h = update_h(sigma2, phi_slice, closest_edge_points, mu_slice, psi)
w = (mu + phi @ h).reshape(-1, 2)
image_points = matrix_transform(w, psi.params)
update_slice = yield image_points, closest_edge_points
def similarity(reference, points, bone, properties_to_transform):
"""
Estimates a similarity transform
"""
tform = tf.estimate_transform('similarity', points, reference)
transformed = list(map(tform, [ bone[p] for p in properties_to_transform ]))
error = get_error(points, reference, tform)
return transformed, error
def test_similarity_estimation():
# exact solution
tform = estimate_transform('similarity', SRC[:2, :], DST[:2, :])
assert_array_almost_equal(tform(SRC[:2, :]), DST[:2, :])
assert_equal(tform._matrix[0, 0], tform._matrix[1, 1])
assert_equal(tform._matrix[0, 1], - tform._matrix[1, 0])
# over-determined
tform2 = estimate_transform('similarity', SRC, DST)
assert_array_almost_equal(tform2.inverse(tform2(SRC)), SRC)
assert_equal(tform2._matrix[0, 0], tform2._matrix[1, 1])
assert_equal(tform2._matrix[0, 1], - tform2._matrix[1, 0])
# via estimate method
tform3 = SimilarityTransform()
tform3.estimate(SRC, DST)
assert_array_almost_equal(tform3._matrix, tform2._matrix)
def test_euclidean_estimation():
# exact solution
tform = estimate_transform('euclidean', SRC[:2, :], SRC[:2, :] + 10)
assert_almost_equal(tform(SRC[:2, :]), SRC[:2, :] + 10)
assert_almost_equal(tform.params[0, 0], tform.params[1, 1])
assert_almost_equal(tform.params[0, 1], - tform.params[1, 0])
# over-determined
tform2 = estimate_transform('euclidean', SRC, DST)
assert_almost_equal(tform2.inverse(tform2(SRC)), SRC)
assert_almost_equal(tform2.params[0, 0], tform2.params[1, 1])
assert_almost_equal(tform2.params[0, 1], - tform2.params[1, 0])
# via estimate method
tform3 = EuclideanTransform()
tform3.estimate(SRC, DST)
assert_almost_equal(tform3.params, tform2.params)
def projective(reference, points, bone, properties_to_transform):
"""
Estimates a projective transform
"""
tform = tf.estimate_transform('projective', points, reference)
transformed = list(map(tform, [ bone[p] for p in properties_to_transform ]))
error = get_error(points, reference, tform)
return transformed, error
def test_polynomial_estimation():
# over-determined
tform = estimate_transform('polynomial', SRC, DST, order=10)
assert_array_almost_equal(tform(SRC), DST, 6)
# via estimate method
tform2 = PolynomialTransform()
tform2.estimate(SRC, DST, order=10)
assert_array_almost_equal(tform2._params, tform._params)
def shape_features(image, fix_points='Stable', feature_points='inner',lm=None):
if lm==None:lm = landmarks(image)
mf = mean_face[:,p[fix_points]]
lm_fix = lm[:,p[fix_points]]
if np.any(np.isnan(lm_fix)):return None,None
tform = transform.estimate_transform('affine', lm_fix.T,mf.T)
lm_reg = tform(lm.T).T
lm_reg = lm_reg[:,p[feature_points]]
X = lm_reg.flatten()
return X, lm
def test_essential_matrix_estimation():
src = np.array(
[
1.839035,
1.924743,
0.543582,
0.375221,
0.473240,
0.142522,
0.964910,
0.598376,
0.102388,
0.140092,
15.994343,
9.622164,
0.285901,
0.430055,
0.091150,
0.254594,
]
).reshape(-1, 2)
dst = np.array(
[
1.002114,
1.129644,
1.521742,
1.846002,
1.084332,
0.275134,
0.293328,
0.588992,
0.839509,
0.087290,
1.779735,
1.116857,
0.878616,
0.602447,
0.642616,
1.028681,
]
).reshape(-1, 2)
tform = estimate_transform("essential", src, dst)
# Reference values obtained using COLMAP SfM library.
tform_ref = np.array(
[[-0.0811666, 0.255449, -0.0478999], [-0.192392, -0.0531675, 0.119547], [0.177784, -0.22008, -0.015203]]
)
assert_almost_equal(tform.params, tform_ref, 6)
def test_fundamental_matrix_estimation():
src = np.array(
[
1.839035,
1.924743,
0.543582,
0.375221,
0.473240,
0.142522,
0.964910,
0.598376,
0.102388,
0.140092,
15.994343,
9.622164,
0.285901,
0.430055,
0.091150,
0.254594,
]
).reshape(-1, 2)
dst = np.array(
[
1.002114,
1.129644,
1.521742,
1.846002,
1.084332,
0.275134,
0.293328,
0.588992,
0.839509,
0.087290,
1.779735,
1.116857,
0.878616,
0.602447,
0.642616,
1.028681,
]
).reshape(-1, 2)
tform = estimate_transform("fundamental", src, dst)
# Reference values obtained using COLMAP SfM library.
tform_ref = np.array(
[[-0.217859, 0.419282, -0.0343075], [-0.0717941, 0.0451643, 0.0216073], [0.248062, -0.429478, 0.0221019]]
)
assert_almost_equal(tform.params, tform_ref, 6)
def main():
# image = data.coins() # or any NumPy array!
# edges = filter.sobel(image)
# io.imshow(edges)
# io.show()
image_file_name_0 = '/local/decarlo/projects/data/microCT/0_180/hdf4/tilt_020_020_0001.hdf'
image_file_name_180 = '/local/decarlo/projects/data/microCT/0_180/hdf4/tilt_020_020_0002.hdf'
image_file_name_white = '/local/decarlo/projects/data/microCT/0_180/hdf4/tilt_020_020_0003.hdf'
image_0 = read_hdf4(image_file_name_0, 'data')
image_180 = read_hdf4(image_file_name_180, 'data')
image_white = read_hdf4(image_file_name_white, 'data')
image_0 = normalize (image_0, image_white)
image_180 = normalize (image_180, image_white)
plt.imshow(image_0+image_180, cmap=plt.cm.hot)
plt.colorbar()
plt.show()
image_180 = np.fliplr(image_180)
tform = tf.estimate_transform('similarity', image_0, image_180)
a, grad = structural_similarity(image_0, image_180, gradient=True)
print a
print "grad shape", grad.shape
# print grad
plt.imshow(grad, cmap=plt.cm.hot)
plt.colorbar()
plt.show()
result = match_template(image_0, image_180)
print result.shape
ij = np.unravel_index(np.argmax(result), result.shape)
x, y = ij[::-1]
print x, y
im2, scale, angle, t = similarity(image_0, image_180)
print "Scale: ", scale, "Angle: ", angle, "Transforamtion Matrix: ", t
rot_axis_shift_x = -t[0]/2.0
rot_axis_tilt = -t[1]/1.0
print "Rotation Axis Shift (x, y):", "(", rot_axis_shift_x, ",", rot_axis_tilt,")"
def estimate_transform(src, dst):
""" Create source and destination feature match coordinates"""
src = np.array([keypoints1[elem] for elem in matches12[:,0]])
dst = np.array([keypoints2[elem] for elem in matches12[:,1]])
""" Estimate transform
Available transformations:
(‘similarity’, ‘affine’, ‘piecewise-affine’, ‘projective’, ‘polynomial’)
"""
tform = tf.estimate_transform('similarity', src, dst)
""" Error check transform (should return True)"""
assert np.allclose(tform.inverse(tform(src)), src) == False
return(tform)
def cnn_input_features(image,lm=None, face_size = 64, shape=[128,96], fix_points='outer',ttype='similarity',normalization='hist'):
if lm==None:lm = landmarks(image)
if np.any(np.isnan(lm)):
return np.nan*np.ones([shape[0],shape[1]]).astype(np.float16), np.nan*np.zeros_like(lm)
dst = mean_face[:,p[fix_points]]
dst = dst-dst.mean(1)[:,None]
dst = dst/(np.abs(dst).max())
dst = dst*face_size/2
dst+=np.array([shape[1],shape[0]])[:,None]/2
src = lm[:,p[fix_points]]
tform = transform.estimate_transform(ttype, src.T,dst.T)
lm_reg = tform(lm.T).T
image = transform.warp(image,inverse_map=tform.inverse,
output_shape=[shape[0],shape[1]]
)
return image, lm_reg
def calcuate_transform_from_shape_to_mean(self, shape):
# calculate the transform between shapes (ground trurh and mean)
# we convert the landmark format to numpy.array
# src store the landmark position information of shape in xml
# dst store the landmark position information of mean shape
src = self.convert_landmarks_to_nparray(
shape.get_normalized_landmarks(self.width, self.height))
dst = self.convert_landmarks_to_nparray(
self.mean_shape.get_normalized_landmarks(self.width, self.height))
# after format converted we can using numpy library find out
# transform matrix
tform = tf.estimate_transform(
'piecewise-affine', src, dst)
# print "\nthe tform form normalized shape to mean shape:\n"
# print tform._matrix
return tform
def main():
# setup constants
conf = set_conf()
# generate random key points
src_points = generate_points(conf)
# generate random transformation
tform = generate_transform(conf)
# compute transformed key points with gaussian noise
dst_points = similarity_transform(src_points, tform, conf)
# estimate the transformation by skimage
tform_estimated_skimage = tf.estimate_transform(
'similarity', src_points, dst_points)
# estimate the transformation by own implementation
tform_estimated_own = estimate_transform_own(src_points, dst_points)
# quantitatively compare two estimation methods
evaluate(src_points, dst_points,
tform, tform_estimated_skimage, tform_estimated_own)
# qualitatively compare two estimation methods
visualize(src_points, dst_points,
tform, tform_estimated_skimage, tform_estimated_own)
def match(self, image):
"""Matches an image to the baseline image.
Parameters
----------
image: M,N,3 ndarray
Image to be matched.
Returns
-------
transformed_image: M,N,3 ndarray
The input image transformed to match the baseline image at the
selected points.
"""
search_windows, search_coords = extract_patches(image,
self.windows,
pad=self.pad)
shifts = []
for window, template in zip(search_windows, self.templates):
shifts.append(find_max_correlation(window, template))
shifts = np.vstack(shifts)
# Convert coordinates from padded windows to absolute position
delta = search_coords[::2, [1, 0]] - self.windows[::2, [1, 0]]
points1 = self.windows[::2, [1, 0]]
points2 = points1 - shifts - delta
if self.tform_type == 'translate':
x, y = (-shifts - delta).ravel()
match_tform = transform.SimilarityTransform(translation=(-x, -y))
else:
match_tform = transform.estimate_transform(self.tform_type,
points2,
points1)
return (transform.warp(image, match_tform), match_tform)
def alignment(filePath, points, ref_points):
'''
@brief: 根据检测到的点，对其人脸图像
'''
assert(len(points) == len(ref_points))
num_point = len(ref_points) / 2
#参考图像的点
dst = np.empty((num_point, 2), dtype = np.int)
k = 0
for i in range(num_point):
for j in range(2):
dst[i][j] = ref_points[k]
k = k+1
#待对齐图像的点
src = np.empty((num_point, 2), dtype = np.int)
k = 0
for i in range(num_point):
for j in range(2):
src[i][j] = points[k]
k = k+1
#根据检测到的点，求其相应的仿射变换矩阵
tfrom = tf.estimate_transform('affine', dst,src)
#用opencv的试试,其只能采用三个点,计算矩阵M
# pts1 = np.float32([[src[0][0],src[0][1]],[src[1][0],src[1][1]],[src[2][0],src[2][1]]])
# pts2 = np.float32([[dst[0][0],dst[0][1]],[dst[1][0],dst[1][1]],[dst[2][0],dst[2][1]]])
# M = cv2.getAffineTransform(pts2,pts1)
#用最小二乘法的方法进行处理
pts3 = np.float32([[src[0][0],src[0][1]],[src[1][0],src[1][1]],[src[2][0],src[2][1]],[src[3][0],src[3][1]],[src[4][0],src[4][1]]])
pts4 = np.float32([[dst[0][0],dst[0][1]],[dst[1][0],dst[1][1]],[dst[2][0],dst[2][1]],[dst[3][0],dst[3][1]],[dst[4][0],dst[4][1]]])
N = compute_affine_transform(pts4, pts3)
#
im = skimage.io.imread(filePath)
if im.ndim == 3:
rows, cols, ch = im.shape
else:
rows, cols = im.shape
warpimage_cv2 = cv2.warpAffine(im, N, (cols, rows))
warpimage = tf.warp(im, inverse_map = tfrom)
return warpimage, warpimage_cv2
def lfw_imgs(alignment):
if alignment == 'landmarks':
dataset = dp.dataset.LFW('original')
imgs = dataset.imgs
landmarks = dataset.landmarks('68')
n_landmarks = 68
landmarks_mean = np.mean(landmarks, axis=0)
landmarks_mean = np.array([landmarks_mean[:n_landmarks],
landmarks_mean[n_landmarks:]])
aligned_imgs = []
for img, points in zip(imgs, landmarks):
points = np.array([points[:n_landmarks], points[n_landmarks:]])
transf = transform.estimate_transform('similarity',
landmarks_mean.T, points.T)
img = img / 255.
img = transform.warp(img, transf, order=3)
img = np.round(img*255).astype(np.uint8)
aligned_imgs.append(img)
imgs = np.array(aligned_imgs)
else:
dataset = dp.dataset.LFW(alignment)
imgs = dataset.imgs
return imgs
def fetch_example_anno_indygo(recipe, global_spec):
try:
img = fetch_path_local(recipe.path)
target_h = global_spec['target_h']
target_w = global_spec['target_w']
TARGETS = global_spec['TARGETS']
buckets = global_spec['buckets']
target_size = target_h
indygo_equalize = global_spec['indygo_equalize']
m = global_spec['margin']
diag = global_spec['diag']
if target_h != target_w:
raise NotImplementedError()
true_dist = np.zeros(shape=(WhaleTrainer.get_y_shape(TARGETS),), dtype=floatX)
if 'class_idx' in recipe:
inter = WhaleTrainer.get_interval('class', TARGETS)
assert(inter is not None)
assert(inter[0] == 0)
#print 'inter0', inter
true_dist[inter[0] + recipe.class_idx] = 1.0
#img = resize_simple(img, target_h)
crop_annos = recipe.annotations['auto_indygo']
idx = random.randint(0, len(crop_annos) - 1)
crop_anno = crop_annos[idx]
(x1, y1) = crop_anno['coord1']
(x2, y2) = crop_anno['coord2']
if 'point1' in recipe.annotations:
point_1 = recipe.annotations['point1'][0]
else:
point_1 = {'x': 0.0, 'y': 0.0}
if 'point2' in recipe.annotations:
point_2 = recipe.annotations['point2'][0]
else:
point_2 = {'x': 0.0, 'y': 0.0}
inter = WhaleTrainer.get_interval('widacryj', TARGETS)
if 'widacryj' in recipe.annotations and inter is not None:
widacryj_target = recipe.annotations['widacryj']
assert (widacryj_target >= 0 and widacryj_target < inter[1] - inter[0])
true_dist[inter[0] + widacryj_target] = 1
inter = WhaleTrainer.get_interval('new_conn', TARGETS)
if 'new_conn' in recipe.annotations and inter is not None:
new_conn_target_a = recipe.annotations['new_conn']
if new_conn_target_a == 0:
new_conn_target = 0
elif new_conn_target_a == 2:
new_conn_target = 1
else:
new_conn_target = -1
if new_conn_target != -1:
#print 'New_conn', new_conn_target
assert (new_conn_target >= 0 and new_conn_target < inter[1] - inter[0])
true_dist[inter[0] + new_conn_target] = 1
inter = WhaleTrainer.get_interval('symetria', TARGETS)
if 'symetria' in recipe.annotations and inter is not None:
symetria_target = recipe.annotations['symetria']
if symetria_target != -1:
assert (symetria_target >= 0 and symetria_target < inter[1] - inter[0])
true_dist[inter[0] + symetria_target] = 1
if diag:
dsts = [[m, m], [target_size - m, target_size - m]]
else:
dsts = [[target_size / 2, m], [target_size / 2, target_size - m]]
srcs = [[x1, y1], [x2, y2]]
def rot90(w):
return np.array([-w[1], w[0]], dtype=w.dtype)
if indygo_equalize:
s1 = np.array(srcs[0])
s2 = np.array(srcs[1])
w = s2 - s1
wp = rot90(w)
d1 = np.array(dsts[0])
d2 = np.array(dsts[1])
v = d2 - d1
vp = rot90(v)
srcs.append(list(s1 + wp))
dsts.append(list(d1 + vp))
# print '-------------'
# print 'srcs'
# print srcs
# print 'dsts'
# print dsts
# we want (wxp, wyp) transleted to
src = np.array(srcs)
dst = np.array(dsts)
tform_res = estimate_transform('affine', src, dst)
tform_center, tform_uncenter = build_center_uncenter_transforms2(target_w, target_h)
tform_augment, r = unpack(random_perturbation_transform(rng=np.random, **global_spec['augmentation_params']),
'tform', 'r')
tform_res += tform_center + tform_augment + tform_uncenter
img = fast_warp(img, AffineTransform(tform_res._inv_matrix), output_shape=(target_h, target_w))
img = transformation(img, global_spec, perturb=False)
res1 = tform_res((point_1['x'], point_1['y']))[0]
res2 = tform_res((point_2['x'], point_2['y']))[0]
bucket1_x = find_bucket(target_w, buckets, res1[0])
bucket1_y = find_bucket(target_h, buckets, res1[1])
bucket2_x = find_bucket(target_w, buckets, res2[0])
bucket2_y = find_bucket(target_h, buckets, res2[1])
inter = WhaleTrainer.get_interval('indygo_point1_x', TARGETS)
if bucket1_x != -1 and bucket1_y != -1 and inter is not None:
idx = inter[0] + bucket1_x
if idx < inter[1]:
true_dist[idx] = 1
inter = WhaleTrainer.get_interval('indygo_point1_y', TARGETS)
if bucket1_x != -1 and bucket1_y != -1 and inter is not None:
idx = inter[0] + bucket1_y
if idx < inter[1]:
true_dist[idx] = 1
inter = WhaleTrainer.get_interval('indygo_point2_x', TARGETS)
if bucket2_x != -1 and bucket2_y != -1 and inter is not None:
idx = inter[0] + bucket2_x
if idx < inter[1]:
true_dist[idx] = 1
inter = WhaleTrainer.get_interval('indygo_point2_y', TARGETS)
if bucket2_x != -1 and bucket2_y != -1 and inter is not None:
idx = inter[0] + bucket2_y
#print idx
if idx < inter[1]:
true_dist[idx] = 1
info = {
'perturb_params': r
}
#print 'buckets', res1, bucket1_x, bucket1_y
inter = WhaleTrainer.get_interval('conn', TARGETS)
if 'ryj_conn' in recipe.annotations and inter is not None:
ryj_conn_anno = recipe.annotations['ryj_conn']
class_idx = ryj_conn_anno['class']
true_dist[inter[0] + class_idx] = 1
def draw_point(img, x, y, color, w=7):
img[0, y:y+w, x:x+w] = color[0]
img[1, y:y+w, x:x+w] = color[1]
img[2, y:y+w, x:x+w] = color[2]
target_size = target_h
x1 = (float(target_size) / buckets) * bucket1_x
y1 = (float(target_size) / buckets) * bucket1_y
x2 = (float(target_size) / buckets) * bucket2_x
y2 = (float(target_size) / buckets) * bucket2_y
w = int(floor(target_size / buckets))
#draw_point(img, x1, y1, (0, 0, 2), w=w)
#draw_point(img, x2, y2, (2, 0, 0), w=w)
#draw_point(img, res1[0], res1[1], (0, 0, 2))
#draw_point(img, res2[0], res2[1], (2, 0, 0))
#print true_dist[447+2: 447+2+30]
#print 'rest4 took', ml_utils.elapsed_time_ms(timer)
return Bunch(x=img, y=true_dist, recipe=recipe, info=info)
except Exception as e:
print traceback.format_exc()
raise
def test_polynomial_default_order():
tform = estimate_transform('polynomial', SRC, DST)
tform2 = estimate_transform('polynomial', SRC, DST, order=2)
assert_array_almost_equal(tform2._params, tform._params)
def test_polynomial_init():
tform = estimate_transform('polynomial', SRC, DST, order=10)
# init with transformation parameters
tform2 = PolynomialTransform(tform._params)
assert_array_almost_equal(tform2._params, tform._params)
def test_projective_init():
tform = estimate_transform('projective', SRC, DST)
# init with transformation matrix
tform2 = ProjectiveTransform(tform._matrix)
assert_array_almost_equal(tform2._matrix, tform._matrix)
