def test_slow_warp_nonint_oshape(): image = np.random.rand(5, 5) assert_raises(ValueError, warp, image, lambda xy: xy, output_shape=(13.1, 19.5)) warp(image, lambda xy: xy, output_shape=(13.0001, 19.9999))
def random_trans_single_output(pic_array): # randomly transform the pic_array, which is a numpy nd array # flipping do_hori_flip = np.random.binomial(1, 0.5) if do_hori_flip: pic_array = np.fliplr(pic_array) do_vert_flip = np.random.binomial(1, 0.5) if do_vert_flip: pic_array = np.flipud(pic_array) # rotation pic_array = rotate(pic_array, np.random.random_integers(0, 360), mode='constant', cval=1) # scaling scale_ratio = log(np.random.uniform(2.5, 4.5)) afine_tf = tf.AffineTransform(scale=(scale_ratio, scale_ratio)) pic_array = tf.warp(pic_array, afine_tf, mode='constant', cval=1) # translation trans_length = np.random.random_integers(-6, 6, 2) trans_length = (trans_length[0], trans_length[1]) afine_tf = tf.AffineTransform(translation=trans_length) pic_array = tf.warp(pic_array, afine_tf, mode='constant', cval=1) return pic_array
def test(): img = skimage.img_as_float(data.lena()) img_size = img.shape[:2] trans = get_transform(20,15,1.05, 0.02, img_size) img_transformed = transform.warp(img, trans) obj_func = lambda x: transform_and_compare(img_transformed, img, x) x0 = np.array([0,0,1, 0]) results = optimize.fmin_bfgs(obj_func, x0) transform_estimated = get_simple_transform(results) transform_optimal = transform.AffineTransform(np.linalg.inv(trans._matrix)) params_optimal = np.concatenate([transform_optimal.translation, transform_optimal.scale[0:1], [transform_optimal.rotation]]) img_registered = transform.warp(img_transformed, transform_estimated) err_original = mean_sq_diff(img_transformed, img) err_optimal = transform_and_compare(img_transformed, img, params_optimal) err_actual = transform_and_compare(img_transformed, img, results) err_relative = err_optimal/err_original print "Params optimal:", params_optimal print "Params estimated:", results print "Error without registration:", err_original print "Error of optimal registration:", err_optimal print "Error of estimated transformation %f (%.2f %% of intial)" % (err_actual, err_relative*100.) plt.figure() plt.subplot(121) plt.imshow(img_transformed) plt.subplot(122) plt.imshow(img_registered)
def random_translate_images(self, data, xtrans_r=None, ytrans_r=None): if xtrans_r is None: if self.xtrans_bound is None: xtrans_r = [-5, 5] else: xtrans_r = self.xtrans_bound if ytrans_r is None: if self.ytrans_bound is None: ytrans_r = [-5, 5] else: ytrans_r = self.ytrans_bound if data.ndim == 3: for i in xrange(data[0].shape[0]): xtrans = self.rng.random_integers(xtrans_r[0], xtrans_r[1]) ytrans = self.rng.random_integers(ytrans_r[0], ytrans_r[1]) map_args = { "xtranslate": xtrans, "ytranslate": ytrans, } data[i] = st.warp(data, translate, map_args=map_args) else: xtrans = self.rng.random_integers(xtrans_r[0], xtrans_r[1]) ytrans = self.rng.random_integers(ytrans_r[0], ytrans_r[1]) map_args = { "xtranslate": xtrans, "ytranslate": ytrans, } data = st.warp(data, translate, map_args=map_args) return data
def generate_transformations(image, fileName): MAX_IMAGE_PIXEL = 96 transformed_images = [image] # ====================== # Scale 1 original image # ====================== similarity_transform = SimilarityTransform(scale=0.75) image_scaled = warp(image, similarity_transform, mode='wrap') transformed_images.append(image_scaled) # sc.misc.imsave(folder + '/' + fileName.split('.')[0] + '/' + fileName.split('.')[0] + '_scale1.jpg', image_scaled) # ====================== # Scale 2 original image # ====================== similarity_transform = SimilarityTransform(scale=1.25) image_scaled = warp(image, similarity_transform, mode='wrap') transformed_images.append(image_scaled) # sc.misc.imsave(folder + '/' + fileName.split('.')[0] + '/' + fileName.split('.')[0] + '_scale2.jpg', image_scaled) # ======================================= # Rotate image by intervals of 45 degrees # ======================================= result = (generate_tranformations_for_rotated_image(image,fileName, degrees) for degrees in [45, 90, 135, 180, 225, 270, 315]) transformed_images.extend(flatten(result)) return transformed_images
def find_alpha(base_img, img, model_robust): # what type of interpolation # 0: nearest-neighbor # 1: bi-linear warp_order = 1 output_shape, corner_min = find_output_shape(base_img, model_robust, channel) #print("output_shape", output_shape, corner_min) #print(model_robust.scale, model_robust.translation, model_robust.rotation) # This in-plane offset is the only necessary transformation for the base image offset = SimilarityTransform(translation= -corner_min) base_warped = warp(base_img[:,:,channel], offset.inverse, order=warp_order, output_shape = output_shape, cval=-1) base_color = warp(base_img, offset.inverse, order=warp_order, output_shape = output_shape, cval=-1) # warp image corners to new position in mosaic transform = (model_robust + offset).inverse #img_warped = warp(img[:,:,channel], transform, order=warp_order, # output_shape=output_shape, cval=-1) img_color = warp(img, transform, order=warp_order, output_shape=output_shape, cval=-1) #base_mask = (base_warped != -1) #base_warped[~base_mask] = 0 img_mask = (img_warped != -1) #img_warped[~img_mask] = 0 #convert to rgb base_alpha = add_alpha(base_color, base_mask) img_alpha = np.dstack((img_color, img_mask)) #base_alpha = np.dstack((base_color, base_mask)) #plt.imsave(tmp_base, base_alpha ) #plt.imsave(tmp_img, img_alpha ) #cmd = [path_to_enblend, tmp_base, tmp_img, '-o', tmp_out] #p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE) #output, err = p.communicate(b"input data that is passed to subprocess' stdin") #rc = p.returncode # remove alpha channel if os.path.exists(tmp_out): out = imread(tmp_out)[:,:,:3] else: print("couldnt find out image") print(rc, output, err) plt.figure() plt.imshow(base_alpha) plt.figure()# plt.imshow(img_alpha) plt.show() out = base_alpha[:,:,:3] #if you don't have enblend, you can use one of these #merged_img = simple_merge(base_warped, img_warped, base_mask, img_mask) #merged_img = minimum_cost_merge(base_warped, img_warped, base_mask, img_mask) #merged_edges = remove_empty_edges(merged_img) return tmp_alpha
def gen_data(name): reftracker = scio.loadmat('data/images_tracker.00047.mat') desttracker = scio.loadmat('data/images_tracker/'+name+'.mat') 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/meanask.png') maskc = np.array(maskimg, dtype=np.float) maskc = np.pad(maskc, (600, 600), 'minimum') tform = transform.ProjectiveTransform() tform.estimate(reftracker + 600, desttracker + 600) img_data = skio.imread('data/images_data/'+name+'.jpg') # save org mat warpedxx = transform.warp(img_data, tform, output_shape=xxc.shape) warpedyy = transform.warp(img_data, tform, output_shape=xxc.shape) warpedmask = transform.warp(img_data, 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 test_slow_warp_nonint_oshape(): image = np.random.rand(5, 5) with testing.raises(ValueError): warp(image, lambda xy: xy, output_shape=(13.1, 19.5)) warp(image, lambda xy: xy, output_shape=(13.0001, 19.9999))
def find_mask(base_name, base_img, img_name, img, model_robust, channel): # what type of interpolation # 0: nearest-neighbor # 1: bi-linear warp_order = 1 output_shape, corner_min = find_output_shape(base_img, model_robust, channel) # This in-plane offset is the only necessary transformation for the base image offset = SimilarityTransform(translation= -corner_min) base_warped = warp(base_img[:,:,channel], offset.inverse, order=warp_order, output_shape = output_shape, cval=-1) base_color = warp(base_img, offset.inverse, order=warp_order, output_shape = output_shape, cval=-1) # warp image corners to new position in mosaic transform = (model_robust + offset).inverse img_warped = warp(img[:,:,channel], transform, order=warp_order, output_shape=output_shape, cval=-1) img_color = warp(img, transform, order=warp_order, output_shape=output_shape, cval=-1) base_mask = (base_warped != -1) base_warped[~base_mask] = 0 img_mask = (img_warped != -1) img_warped[~img_mask] = 0 plt.imsave("img_mask.jpg", img_mask) #convert to rgb img_alpha = np.dstack((img_color, img_mask)) base_alpha = np.dstack((base_color, base_mask)) td = config.tmp_dir tmp_base = os.path.join(td, 'tmp_' + '.'.join(base_name.split('.')[:-1]) + '.png') tmp_img = os.path.join(td, 'tmp_' + '.'.join(img_name.split('.')[:-1]) + '.png') tmp_out = os.path.join(td, 'tmp_out_' + '.'.join(base_name.split('.')[:-1]) + '.png') plt.imsave(tmp_base, base_alpha) plt.imsave(tmp_img, img_alpha) cmd = ['enblend', tmp_base, tmp_img, '-o', tmp_out] p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE) output, err = p.communicate(b"input data that is passed to subprocess' stdin") rc = p.returncode #if you don't have enblend, you can use one of these #merged_img = simple_merge(base_warped, img_warped, base_mask, img_mask) #merged_img = minimum_cost_merge(base_warped, img_warped, base_mask, img_mask) #merged_edges = remove_empty_edges(merged_img) # remove alpha channel if os.path.exists(tmp_out): out = imread(tmp_out) oute = remove_empty_alpha(out) os.remove(tmp_base) os.remove(tmp_img) os.remove(tmp_out) return oute[:,:,:3] else: print("Could not find out", tmp_out, rc) raise Exception("failed cmd %s" %cmd)
def test_warp_clip(): x = 2 * np.ones((5, 5), dtype=np.double) matrix = np.eye(3) outx = warp(x, matrix, order=0, clip=False) assert_array_almost_equal(x, outx) outx = warp(x, matrix, order=0, clip=True) assert_array_almost_equal(x / 2, outx)
def translate_images(self, data, xtrans=0, ytrans=0): map_args = { "xtrans": xtrans, "ytrans": ytrans, } if data.ndim == 3: for i in xrange(data[0].shape[0]): data[i] = st.warp(data, translate, map_args=map_args) else: data = st.warp(data, translate, map_args=map_args) return data
def test_warp_tform(): x = np.zeros((5, 5), dtype=np.double) x[2, 2] = 1 theta = - np.pi / 2 tform = SimilarityTransform(scale=1, rotation=theta, translation=(0, 4)) x90 = warp(x, tform, order=1) assert_almost_equal(x90, np.rot90(x)) x90 = warp(x, tform.inverse, order=1) assert_almost_equal(x90, np.rot90(x))
def test_warp_identity(): img = img_as_float(rgb2gray(data.astronaut())) assert len(img.shape) == 2 assert np.allclose(img, warp(img, AffineTransform(rotation=0))) assert not np.allclose(img, warp(img, AffineTransform(rotation=0.1))) rgb_img = np.transpose(np.asarray([img, np.zeros_like(img), img]), (1, 2, 0)) warped_rgb_img = warp(rgb_img, AffineTransform(rotation=0.1)) assert np.allclose(rgb_img, warp(rgb_img, AffineTransform(rotation=0))) assert not np.allclose(rgb_img, warped_rgb_img) # assert no cross-talk between bands assert np.all(0 == warped_rgb_img[:, :, 1])
def test_warp(): x = np.zeros((5, 5), dtype=np.uint8) x[2, 2] = 255 x = img_as_float(x) theta = - np.pi / 2 tform = SimilarityTransform(scale=1, rotation=theta, translation=(0, 4)) x90 = warp(x, tform, order=1) assert_array_almost_equal(x90, np.rot90(x)) x90 = warp(x, tform.inverse, order=1) assert_array_almost_equal(x90, np.rot90(x))
def align_stack(im, alignNs=r_[0:100], print_status=True, do_plot=False): """Realign a stack to an image -- default to mean image from near the start Args: im alignNs: frameNs to average to give the alignment reference image print_status: give updates for long calcs to terminal do_plot: show a plot with alignment calculations Returns: aligned stack, same size as input stack, padded with zeros where shifted """ # run alignment calculations, saving result in a dataframe aligntarg = im[:100,:,:].mean(axis=0) tL = [] nfrdo = im.shape[0] if print_status: print('Computing offsets ({} frames)... '.format(nfrdo), end='') for iF in range(nfrdo): tL.append(feature.register_translation(aligntarg, im[iF,:,:])) regDf = pd.DataFrame(tL, columns=('coords','err','phasediff')) regDf['row'] = [x[0][0] for x in tL] regDf['col'] = [x[0][1] for x in tL] if do_plot: gs = mpl.gridspec.GridSpec(2,2) fig = plt.figure() plt.subplot(gs[0,0]) plt.plot(regDf.err) plt.title('translation-independent error') plt.ylabel('RMS error') plt.subplot(gs[0,1]) plt.plot(regDf.col) plt.plot(regDf.row) plt.title('row and col pixel offsets') plt.legend(['col','row']) # do the shifts regim = im.copy()*0 maxv = im.max() if print_status: print('Aligning frames... ', end='') for iF in range(nfrdo): #debug range(nframes): regim[iF,:,:] = transform.warp(im[iF,:,:]*1.0/maxv, \ transform.SimilarityTransform(translation=(-1*regDf.col[iF],-regDf.row[iF]))) * maxv t = transform.warp(im[iF,:,:]*1.0/maxv, \ transform.SimilarityTransform(translation=(-1*regDf.col[iF],-regDf.row[iF]))) * maxv if print_status and iF % 500 == 0: print('%d (%d,%d)'%(iF,-regDf.col[iF],-regDf.row[iF]), end=' ') if print_status: print('Done.') return regim
def test_warp_identity(): lena = img_as_float(rgb2gray(data.lena())) assert len(lena.shape) == 2 assert np.allclose(lena, warp(lena, AffineTransform(rotation=0))) assert not np.allclose(lena, warp(lena, AffineTransform(rotation=0.1))) rgb_lena = np.transpose(np.asarray([lena, np.zeros_like(lena), lena]), (1, 2, 0)) warped_rgb_lena = warp(rgb_lena, AffineTransform(rotation=0.1)) assert np.allclose(rgb_lena, warp(rgb_lena, AffineTransform(rotation=0))) assert not np.allclose(rgb_lena, warped_rgb_lena) # assert no cross-talk between bands assert np.all(0 == warped_rgb_lena[:, :, 1])
def random_transformation(img1, img2): shape_x, shape_y = img1.shape rot = (random.random() - 0.5) * math.pi / 4 trans_x = int((random.random() - 0.5) * shape_x / 8) trans_y = int((random.random() - 0.5) * shape_y / 8) scale = 1. / 1.1 + random.random() * (1.1 - 1. / 1.1) pixel_scale = 1. / 1.1 + random.random() * (1.1 - 1. / 1.1) trans = transform.SimilarityTransform( scale=scale, rotation=rot, translation=(trans_x, trans_y)) return \ (pixel_scale * transform.warp(img1.astype(float), trans, mode='nearest')), \ (transform.warp(img2.astype(float), trans, mode='nearest'))
def test_warp_matrix(): x = np.zeros((5, 5), dtype=np.double) x[2, 2] = 1 refx = np.zeros((5, 5), dtype=np.double) refx[1, 1] = 1 matrix = np.array([[1, 0, 1], [0, 1, 1], [0, 0, 1]]) # _warp_fast outx = warp(x, matrix, order=1) assert_almost_equal(outx, refx) # check for ndimage.map_coordinates outx = warp(x, matrix, order=5)
def warp_img(img, transform, output_shape): try: warped = warp(img, transform, order=1, mode="constant", output_shape=output_shape, clip=True, cval=0) return warped except Exception, e: logging.error("Error warping image %s img shape %s, output shape %s" % (e, img.shape, output_shape)) return None
def warp_image_by_corner_points_projection(corner_points, image): """Given corner points of a Sudoku, warps original selection to a square image. :param corner_points: :type: corner_points: list :param image: :type image: :return: :rtype: """ # Clarify by storing in named variables. top_left, top_right, bottom_left, bottom_right = np.array(corner_points) top_edge = np.linalg.norm(top_right - top_left) bottom_edge = np.linalg.norm(bottom_right - bottom_left) left_edge = np.linalg.norm(top_left - bottom_left) right_edge = np.linalg.norm(top_right - bottom_right) L = int(np.ceil(max([top_edge, bottom_edge, left_edge, right_edge]))) src = np.array([top_left, top_right, bottom_left, bottom_right]) dst = np.array([[0, 0], [L - 1, 0], [0, L - 1], [L - 1, L - 1]]) tr = ProjectiveTransform() tr.estimate(dst, src) warped_image = warp(image, tr, output_shape=(L, L)) out = resize(warped_image, (500, 500)) return out
def magnify(self, i, subtract_background=True): """Extract a source from the image for the purpose of PSF estimation. :param int i: index of the source :param bool subtract_background=True: do background subtraction :rtype: array """ psf_grid = self.psf_grid psf_size = psf_grid.psf_size psf_mag = psf_grid.psf_mag scale = (1/psf_mag, 1/psf_mag) translation = self.pos[i]-(psf_size/2-0.5)/psf_mag tf = AffineTransform(scale=scale, translation=translation) src = warp(self.data.T, tf, output_shape=(psf_size, psf_size), preserve_range=True, order=3) # using affine_transform from scipy #matrix = np.array([[1/psf_mag, 0],[0, 1/psf_mag]]) #offset = self.pos[i]-(psf_size/2-0.5)/psf_mag #src = np.transpose(affine_transform(self.data, matrix, offset=offset, # output_shape=(psf_size, psf_size), order=3)) if subtract_background: src -= self.flux0[i] return ma.masked_where(src >= self.adusat, src)
def warp_image_by_interp_borders(edges, image): left_edge, top_edge, right_edge, bottom_edge = edges left_edge = left_edge[::-1, :] bottom_edge = bottom_edge[::-1, :] def _mapping_fcn(points): map_x = (points[:, 0] / float(points[-1, 0])) map_y = (points[:, 1] / float(points[-1, 1])) top_mapping = np.array(np.round(map_x * (len(top_edge) - 1)), 'int') bottom_mapping = np.array(np.round(map_x * (len(bottom_edge) - 1)), 'int') left_mapping = np.array(np.round(map_y * (len(left_edge) - 1)), 'int') right_mapping = np.array(np.round(map_y * (len(right_edge) - 1)), 'int') map_x = np.array([map_x, map_x]).T map_y = np.array([map_y, map_y]).T p1s = (left_edge[left_mapping, :] * (1 - map_x)) + (right_edge[right_mapping, :] * map_x) p2s = (top_edge[top_mapping, :] * (1 - map_y)) + (bottom_edge[bottom_mapping, :] * map_y) return (p1s + p2s) / 2 d_top_edge = np.linalg.norm(top_edge[0, :] - top_edge[-1, :]) d_bottom_edge = np.linalg.norm(bottom_edge[0, :] - bottom_edge[-1, :]) d_left_edge = np.linalg.norm(left_edge[0, :] - left_edge[-1, :]) d_right_edge = np.linalg.norm(right_edge[0, :] - right_edge[-1, :]) d = int(np.ceil(max([d_top_edge, d_bottom_edge, d_left_edge, d_right_edge]))) return warp(image, _mapping_fcn, output_shape=(600, 600))
def run3(self): """ Cette fonction test des alternatives à SIFT et ORB. Ne fonctionne pas.""" for x in xrange(len(self.stack)-1): print('Traitement image ' + str(x+1)) im1,im2 = 255.*gaussian_filter(self.stack[x,...], sqrt(self.initial_sigma**2 - 0.25)), 255.*gaussian_filter(self.stack[x+1,...], sqrt(self.initial_sigma**2 - 0.25)) im1,im2 = enhance_contrast(normaliser(im1), square(3)), enhance_contrast(normaliser(im2), square(3)) im1, im2 = normaliser(im1), normaliser(im2) b = cv2.BRISK() #b.create("Feature2D.BRISK") k1,d1 = b.detectAndCompute(im1,None) k2,d2 = b.detectAndCompute(im2,None) bf = cv2.BFMatcher(cv2.NORM_HAMMING) matches = bf.match(d1,d2) g1,g2 = [],[] for i in matches: g1.append(k1[i.queryIdx].pt) g2.append(k2[i.trainIdx].pt) model, inliers = ransac((np.array(g1), np.array(g2)), AffineTransform, min_samples=3, residual_threshold=self.min_epsilon, max_trials=self.max_trials, stop_residuals_sum=self.min_inlier_ratio) self.stack[x+1,...] = warp(self.stack[x+1,...], AffineTransform(rotation=model.rotation, translation=model.translation), output_shape=self.stack[x+1].shape) self.stack = self.stack.astype(np.uint8)
def img_augment(img, translation=0.0, scale=1.0, rotation=0.0, gamma=1.0, contrast=1.0, hue=0.0, border_mode='constant'): if not (np.all(np.isclose(translation, [0.0, 0.0])) and np.isclose(scale, 1.0) and np.isclose(rotation, 0.0)): img_center = np.array(img.shape[:2]) / 2.0 scale = (scale, scale) transf = transform.SimilarityTransform(translation=-img_center) transf += transform.SimilarityTransform(scale=scale, rotation=rotation) translation = img_center + translation transf += transform.SimilarityTransform(translation=translation) img = transform.warp(img, transf, order=3, mode=border_mode) if not np.isclose(gamma, 1.0): img **= gamma colorspace = 'rgb' if not np.isclose(contrast, 1.0): img = color.convert_colorspace(img, colorspace, 'hsv') colorspace = 'hsv' img[..., 1:] **= contrast if not np.isclose(hue, 0.0): img = color.convert_colorspace(img, colorspace, 'hsv') colorspace = 'hsv' img[..., 0] += hue img[img[..., 0] > 1.0, 0] -= 1.0 img[img[..., 0] < 0.0, 0] += 1.0 img = color.convert_colorspace(img, colorspace, 'rgb') if np.min(img) < 0.0 or np.max(img) > 1.0: raise ValueError('Invalid values in output image.') return img
def test_fast_homography(): img = rgb2gray(data.lena()).astype(np.uint8) img = img[:, :100] theta = np.deg2rad(30) scale = 0.5 tx, ty = 50, 50 H = np.eye(3) S = scale * np.sin(theta) C = scale * np.cos(theta) H[:2, :2] = [[C, -S], [S, C]] H[:2, 2] = [tx, ty] tform = ProjectiveTransform(H) coords = warp_coords(tform.inverse, (img.shape[0], img.shape[1])) for order in range(4): for mode in ('constant', 'reflect', 'wrap', 'nearest'): p0 = map_coordinates(img, coords, mode=mode, order=order) p1 = warp(img, tform, mode=mode, order=order) # import matplotlib.pyplot as plt # f, (ax0, ax1, ax2, ax3) = plt.subplots(1, 4) # ax0.imshow(img) # ax1.imshow(p0, cmap=plt.cm.gray) # ax2.imshow(p1, cmap=plt.cm.gray) # ax3.imshow(np.abs(p0 - p1), cmap=plt.cm.gray) # plt.show() d = np.mean(np.abs(p0 - p1)) assert d < 0.001
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 run4(self): """ Cette fonction recadre les images grâce à SURF et RANSAC, fonctionne bien.""" for x in xrange(len(self.stack)-1): print('Traitement image ' + str(x+1)) im1,im2 = 255.*gaussian_filter(self.stack[x,...], sqrt(self.initial_sigma**2 - 0.25)), 255.*gaussian_filter(self.stack[x+1,...], sqrt(self.initial_sigma**2 - 0.25)) im1,im2 = enhance_contrast(normaliser(im1), square(5)), enhance_contrast(normaliser(im2), square(5)) im1, im2 = normaliser(im1), normaliser(im2) b = cv2.SURF() #b.create("Feature2D.BRISK") k1,d1 = b.detectAndCompute(im1,None) k2,d2 = b.detectAndCompute(im2,None) bf = cv2.BFMatcher() matches = bf.knnMatch(d1,d2, k=2) # Apply ratio test good = [] for m,n in matches: if m.distance < 0.75*n.distance: good.append(m) g1,g2 = [],[] for i in good: g1.append(k1[i.queryIdx].pt) g2.append(k2[i.trainIdx].pt) model, inliers = ransac((np.array(g1), np.array(g2)), AffineTransform, min_samples=3, residual_threshold=self.min_epsilon, max_trials=self.max_trials, stop_residuals_sum=self.min_inlier_ratio) self.stack[x+1,...] = warp(self.stack[x+1,...], AffineTransform(rotation=model.rotation, translation=model.translation), output_shape=self.stack[x+1].shape) self.stack = self.stack.astype(np.uint8)
def shift(img): """Shift a binary image randomly within the frame Uses a convex hull calculation to make sure it doesn't translate the image out of the frame. """ hull = morphology.convex_hull_image(1-img) horizontal = np.where(np.sum(hull, axis=0) > 0)[0] vertical = np.where(np.sum(hull, axis=1) > 0)[0] max_left = -np.min(horizontal) max_right = img.shape[1] - np.max(horizontal) max_down = -np.min(vertical) max_up = img.shape[0] - np.max(vertical) shift_x = np.random.randint(max_left, max_right) shift_y = np.random.randint(max_down, max_up) #print "SHIFT", shift_x, shift_y def shift(xy): xy[:, 0] -= shift_x xy[:, 1] -= shift_y return xy return np.logical_not(transform.warp(np.logical_not(img), shift))
def swirl(image, center=None, strength=1, radius=100, rotation=0): """Perform a swirl transformation. Parameters ---------- image : ndarray Input image. center : (x,y) tuple or (2,) ndarray Center coordinate of transformation. strength : float The amount of swirling applied. radius : float The extent of the swirl in pixels. The effect dies out rapidly beyond `radius`. rotation : float Additional rotation applied to the image. Returns ------- swirled : ndarray Swirled version of the input. """ if center is None: center = np.array(image.shape)[:2] / 2 warp_args = {'center': center, 'rotation': rotation, 'strength': strength, 'radius': radius} return transform.warp(image, _swirl_mapping, map_args=warp_args)
def warp(self, image, matrix): """Warp the point's coordinates according to an affine transformation matrix. Args: image The image which's dimensions to use. matrix The affine transformation matrix (from scikit-image) """ assert not self.is_normalized # This method draws the point as a white pixel on a black image, # then warps that image according to the matrix # then reads out the new position of the pixel # (if its not found / outside of the image then the coordinates will be unchanged). # This is a very wasteful process as many pixels have to be warped instead of just one. # There is probably a better method for that, but I don't know it. image_pnt = np.zeros((image.get_height(), image.get_width()), dtype=np.uint8) image_pnt[self.y, self.x] = 255 image_pnt_warped = tf.warp( image_pnt, matrix, mode=WARP_KEYPOINTS_MODE, cval=WARP_KEYPOINTS_CVAL, order=WARP_KEYPOINTS_INTERPOLATION_ORDER, ) maxindex = np.argmax(image_pnt_warped) if maxindex == 0 and image_pnt_warped[0, 0] < 0.5: # dont change coordinates # print("Note: Coordinate (%d, %d) not changed" % (self.y, self.x)) pass else: (y, x) = np.unravel_index(maxindex, image_pnt_warped.shape) self.y = y self.x = x
faces = face_detector(image) if not faces: print(f'Warning: There is no face in {x}') continue else: for face_id, current_face in enumerate(faces): img_name = f'{x[:-4]}_{face_id + 1}' current_fl = landmark_locator(image, current_face) affine = compute_transformation_matrix(image, current_fl, False, target_face_scale=1.3, inverse=False).params aligned_face = warp(image, affine, output_shape=(256, 256, 3)) io.imsave(os.path.join(save_url, f'{img_name}.png'), img_as_ubyte(aligned_face)) print("Finish Stage 2 ...\n") # Stage 3: Face Restore print("Running Stage 3: Face Enhancement") stage_3_input_mask = "./" stage_3_input_face = stage_2_output_dir stage_3_output_dir = os.path.join(output_folder, "stage_3_face_output") if not os.path.exists(stage_3_output_dir): os.makedirs(stage_3_output_dir) single_save_url = os.path.join(stage_3_output_dir, "each_img")
def diffrot_map(smap, time=None, dt: u.s = None, pad=False, **diffrot_kwargs): """ Function to apply solar differential rotation to a sunpy map. Parameters ---------- smap : `~sunpy.map` Original map that we want to transform. time : sunpy-compatible time date/time at which the input co-ordinate will be rotated to. dt : `~astropy.units.Quantity` or `astropy.time.Time` Desired interval between the input map and returned map. pad : `bool` Whether to create a padded map for submaps to don't loose data Returns ------- diffrot_map : `~sunpy.map` A map with the result of applying solar differential rotation to the input map. """ # Only this function needs scikit image from skimage import transform from sunpy.image.util import to_norm, un_norm # Import map here for performance reasons. import sunpy.map if (time is not None) and (dt is not None): raise ValueError('Only a time or an interval is accepted') elif not (time or dt): raise ValueError( 'Either a time or an interval (`dt=`) needs to be provided') elif time: new_time = parse_time(time) dt = (new_time - smap.date).to(u.s) else: new_time = smap.date + dt # Check for masked maps if smap.mask is not None: smap_data = np.ma.array(smap.data, mask=smap.mask) else: smap_data = smap.data submap = False # Check whether the input is a submap if ((2 * smap.rsun_obs > smap.top_right_coord.Tx - smap.bottom_left_coord.Tx) or (2 * smap.rsun_obs > smap.top_right_coord.Ty - smap.bottom_left_coord.Ty)): submap = True if pad: # Calculating the largest distance between the corners and their rotation values deltax = deltay = 0 for corner in product(*product([0 * u.pix], smap.dimensions)): corner_world = smap.pixel_to_world(*corner) corner_world_rotated = solar_rotate_coordinate( corner_world, new_time, **diffrot_kwargs) corner_px_rotated = smap.world_to_pixel(corner_world_rotated) dx = np.abs(corner_px_rotated.x - corner[0]) dy = np.abs(corner_px_rotated.y - corner[1]) deltax = dx if dx > deltax else deltax deltay = dy if dy > deltay else deltay deltax = np.int(np.ceil(deltax.value)) deltay = np.int(np.ceil(deltay.value)) # Create a new `smap` with the padding around it smap_data = np.pad(smap.data, ((deltay, deltay), (deltax, deltax)), 'constant', constant_values=0) smap_meta = deepcopy(smap.meta) smap_meta['naxis2'], smap_meta['naxis1'] = smap_data.shape smap_meta['crpix1'] += deltax smap_meta['crpix2'] += deltay smap = sunpy.map.Map(smap_data, smap_meta) warp_args = {'smap': smap, 'dt': dt} warp_args.update(diffrot_kwargs) # Apply solar differential rotation as a scikit-image warp out = transform.warp(to_norm(smap_data), inverse_map=_warp_sun_coordinates, map_args=warp_args) # Recover the original intensity range. out = un_norm(out, smap.data) # Update the meta information with the new date and time, and reference pixel. out_meta = deepcopy(smap.meta) if out_meta.get('date_obs', False): del out_meta['date_obs'] out_meta['date-obs'] = "{}".format(new_time.strftime('%Y-%m-%dT%H:%M:%S')) if submap: crval_rotated = solar_rotate_coordinate(smap.reference_coordinate, new_time, **diffrot_kwargs) out_meta['crval1'] = crval_rotated.Tx.value out_meta['crval2'] = crval_rotated.Ty.value return sunpy.map.Map((out, out_meta))
from skimage import data from skimage import transform as tf from skimage.feature import CENSURE from skimage.color import rgb2gray import matplotlib.pyplot as plt import utils.Image_loader as il img_orig = il.get_sample() tform = tf.AffineTransform(rotation=0.5, scale=(0.5, 0.5)) img_warp = tf.warp(img_orig, tform) detector = CENSURE() fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6)) detector.detect(img_orig) ax[0].imshow(img_orig, cmap=plt.cm.gray) ax[0].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0], 2**detector.scales, facecolors='none', edgecolors='r') ax[0].set_title("Original Image") detector.detect(img_warp) ax[1].imshow(img_warp, cmap=plt.cm.gray) ax[1].scatter(detector.keypoints[:, 1], detector.keypoints[:, 0],
def deshear(filename): image = io.imread(filename) distortion = image.shape[1] - image.shape[0] shear = tf.AffineTransform(shear=math.atan(distortion / image.shape[0])) return tf.warp(image, shear)[:, distortion:]
def RndTform(img,val): Ih,Iw = img[0].shape[:2] sgn = torch.randint(0,2,(1,)).item() * 2 - 1 if sgn>0: dw = val dh = 0 else: dw = 0 dh = val def rd(d): return torch.empty(1).uniform_(-d,d).item() def fd(d): return torch.empty(1).uniform_(-dw,d).item() # generate a random projective transform # adapted from https://navoshta.com/traffic-signs-classification/ tl_top = rd(dh) tl_left = fd(dw) bl_bottom = rd(dh) bl_left = fd(dw) tr_top = rd(dh) tr_right = fd( min(Iw * 3/4 - tl_left,dw) ) br_bottom = rd(dh) br_right = fd( min(Iw * 3/4 - bl_left,dw) ) tform = stf.ProjectiveTransform() tform.estimate(np.array(( (tl_left, tl_top), (bl_left, Ih - bl_bottom), (Iw - br_right, Ih - br_bottom), (Iw - tr_right, tr_top) )), np.array(( [0, 0 ], [0, Ih - 1 ], [Iw-1, Ih-1 ], [Iw-1, 0] ))) # determine shape of output image, to preserve size # trick take from the implementation of skimage.transform.rotate corners = np.array([ [0, 0 ], [0, Ih - 1 ], [Iw-1, Ih-1 ], [Iw-1, 0] ]) corners = tform.inverse(corners) minc = corners[:, 0].min() minr = corners[:, 1].min() maxc = corners[:, 0].max() maxr = corners[:, 1].max() out_rows = maxr - minr + 1 out_cols = maxc - minc + 1 output_shape = np.around((out_rows, out_cols)) # fit output image in new shape translation = (minc, minr) tform4 = stf.SimilarityTransform(translation=translation) tform = tform4 + tform # normalize tform.params /= tform.params[2, 2] ret = [] for i in range(len(img)): img2 = stf.warp(img[i], tform, output_shape=output_shape, cval=1.0) img2 = stf.resize(img2, (Ih,Iw), preserve_range=True).astype(np.float32) ret.append(img2) return ret
print(tform2(coord)) print(tform2.inverse(tform(coord))) ###################################################################### # Image warping # ============= # # Geometric transformations can also be used to warp images: text = data.text() tform = tf.SimilarityTransform(scale=1, rotation=math.pi / 4, translation=(text.shape[0] / 2, -100)) rotated = tf.warp(text, tform) back_rotated = tf.warp(rotated, tform.inverse) fig, ax = plt.subplots(nrows=3) ax[0].imshow(text, cmap=plt.cm.gray) ax[1].imshow(rotated, cmap=plt.cm.gray) ax[2].imshow(back_rotated, cmap=plt.cm.gray) for a in ax: a.axis('off') plt.tight_layout() ###################################################################### # Parameter estimation
def transform_IR_im_to_vis_coordinate_system(im): im = undistort_IR_im(im) T = transform.AffineTransform(T_v2IR) return transform.warp(im, T, output_shape=(hv, wv))
def main(): path = '/usr/local/hdd/rita/DL/model_ZT113_150/' output_path = '/usr/local/hdd/rita/registration/ransac/brief/mostSimilar/bla/' real_path = '/usr/local/hdd/rita/registration/ransac/brief/mostSimilar/original_he/' masks = sorted([f for f in os.listdir(path) if f.endswith('_dl.png')]) he = sorted([f for f in os.listdir(real_path) if f.endswith('.tif')]) mostSimilar_mask = getMostSimilar(masks, path) mostSimilarImg = io.imread(os.path.join(path, mostSimilar_mask)) mostSimilar = mostSimilar_mask.split(".small")[0] mostSimilarRealImg = io.imread(os.path.join(real_path, mostSimilar)) if False: imageio.imwrite(output_path + mostSimilar + '_ransac.png', img_as_ubyte(mostSimilarRealImg)) out = open(os.path.join(output_path, "eval.txt"), "a") out.write("Base: " + mostSimilar + "\n") mostSimilarImg = rgb2gray(mostSimilarImg) for i in range(len(masks)): if not masks[i] == mostSimilar_mask: mask_img = rgb2gray(io.imread(os.path.join(path, masks[i]))) real_name = masks[i].split(".small")[0] real_img = io.imread(os.path.join(real_path, real_name)) rescale_trans = np.amin([ real_img.shape[0] / mask_img.shape[0], real_img.shape[1] / mask_img.shape[1] ]) trans = start_ransac(img1=mostSimilarImg, img2=mask_img, brief=True, common_factor=0.25) rescaled_transform = rescale_transform_matrix( trans, rescale_trans) reg = warp(real_img, np.linalg.inv(rescaled_transform)) imageio.imwrite(output_path + real_name + '_ransac.png', img_as_ubyte(reg)) out.write( real_name + "\t" + str(difference(mostSimilarImg, mask_img)) + "\t" + str( difference( mostSimilarImg, rgb2gray(warp(mask_img, np.linalg.inv(trans))))) + "\n") out.close() chan_output_path = '/usr/local/hdd/rita/registration/ransac/brief/mostSimilar/channels_reg/' chan_path = '/usr/local/hdd/rita/registration/ransac/brief/mostSimilar/channels/' light = sorted( [f for f in os.listdir(chan_path) if f.endswith('_light.jpg')]) he_reg = sorted( [f for f in os.listdir(output_path) if f.endswith('_ransac.png')]) cha0 = sorted( [f for f in os.listdir(chan_path) if f.endswith('_ch00.tif')]) cha2 = sorted( [f for f in os.listdir(chan_path) if f.endswith('_ch02.tif')]) cha3 = sorted( [f for f in os.listdir(chan_path) if f.endswith('_ch03.tif')]) cha4 = sorted( [f for f in os.listdir(chan_path) if f.endswith('_ch04.tif')]) cha5 = sorted( [f for f in os.listdir(chan_path) if f.endswith('_ch05.tif')]) for i in range(len(he_reg)): light_img = io.imread(os.path.join(chan_path, light[i])) he_img = io.imread(os.path.join(output_path, he_reg[i])) print(he_img.shape) if light_img.shape[0] * light_img.shape[1] > he_img.shape[ 0] * he_img.shape[1]: first_rescale = np.amin([ light_img.shape[0] / he_img.shape[0], light_img.shape[1] / he_img.shape[1] ]) light_resc = transform.rescale(light_img, 1 / first_rescale, multichannel=False) print(light_img.shape) print(light_resc.shape) common_factor = 1 / np.amax([ light_resc.shape[0] / 150, light_resc.shape[1] / 150, he_img.shape[0] / 150, he_img.shape[1] / 150 ]) trans = start_ransac(img1=rgb2gray(he_img), img2=rgb2gray(light_resc), brief=False, common_factor=common_factor) rescaled_transform = rescale_transform_matrix( trans, 1 / first_rescale) reg = warp(light_img, np.linalg.inv(rescaled_transform)) ch0 = io.imread(os.path.join(chan_path, cha0[i])) ch2 = io.imread(os.path.join(chan_path, cha2[i])) ch3 = io.imread(os.path.join(chan_path, cha3[i])) ch4 = io.imread(os.path.join(chan_path, cha4[i])) ch5 = io.imread(os.path.join(chan_path, cha5[i])) reg_ch0 = warp(ch0, np.linalg.inv(rescaled_transform)) reg_ch2 = warp(ch2, np.linalg.inv(rescaled_transform)) reg_ch3 = warp(ch3, np.linalg.inv(rescaled_transform)) reg_ch4 = warp(ch4, np.linalg.inv(rescaled_transform)) reg_ch5 = warp(ch5, np.linalg.inv(rescaled_transform)) imageio.imwrite(chan_output_path + cha0[i] + '_ransac.png', img_as_ubyte(reg_ch0)) imageio.imwrite(chan_output_path + cha2[i] + '_ransac.png', img_as_ubyte(reg_ch2)) imageio.imwrite(chan_output_path + cha3[i] + '_ransac.png', img_as_ubyte(reg_ch3)) imageio.imwrite(chan_output_path + cha4[i] + '_ransac.png', img_as_ubyte(reg_ch4)) imageio.imwrite(chan_output_path + cha5[i] + '_ransac.png', img_as_ubyte(reg_ch5)) imageio.imwrite(chan_output_path + light[i] + '_ransac.png', img_as_ubyte(reg)) else: first_rescale = np.amin([ he_img.shape[0] / light_img.shape[0], he_img.shape[1] / light_img.shape[1] ]) he_resc = transform.rescale(he_img, 1 / first_rescale, multichannel=False) common_factor = 1 / np.amax([ light_img.shape[0] / 150, light_img.shape[1] / 150, he_resc.shape[0] / 150, he_resc.shape[1] / 150 ]) trans = start_ransac(img1=rgb2gray(he_resc), img2=rgb2gray(light_img), brief=False, common_factor=common_factor) reg = warp(light_img, np.linalg.inv(trans)) imageio.imwrite(chan_output_path + light[i] + '_ransac.png', img_as_ubyte(reg))
def start_ransac(img1, img2, brief, common_factor=0.25): #https://www.researchgate.net/publication/264197576_scikit-image_Image_processing_in_Python img1 = transform.rescale(img1, common_factor, multichannel=False) img2 = transform.rescale(img2, common_factor, multichannel=False) print(img1.shape) print(img2.shape) if brief: #BRIEF keypoints1 = corner_peaks(corner_harris(img1), min_distance=5) keypoints2 = corner_peaks(corner_harris(img2), min_distance=5) extractor = BRIEF() extractor.extract(img1, keypoints1) keypoints1 = keypoints1[extractor.mask] descriptors1 = extractor.descriptors extractor.extract(img2, keypoints2) keypoints2 = keypoints2[extractor.mask] descriptors2 = extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) else: #ORB orb = ORB(n_keypoints=1000, fast_threshold=0.05) orb.detect_and_extract(img1) keypoints1 = orb.keypoints desciptors1 = orb.descriptors orb.detect_and_extract(img2) keypoints2 = orb.keypoints desciptors2 = orb.descriptors matches12 = match_descriptors(desciptors1, desciptors2, cross_check=True) src = keypoints2[matches12[:, 1]][:, ::-1] dst = keypoints1[matches12[:, 0]][:, ::-1] model_robust, inliers = \ ransac((src, dst), transform.SimilarityTransform, min_samples=4, residual_threshold=2) #r, c = img2.shape[:2] #corners = np.array([[0, 0], # [0, r], # [c, 0], #[c,r]]) #warped_corners = model_robust(corners) #all_corners = np.vstack((warped_corners, corners)) #corner_min = np.min(all_corners, axis=0) #corner_max = np.max(all_corners, axis=0) #output_shape = (corner_max - corner_min) #output_shape = np.ceil(output_shape[::-1]) #offset = transform.SimilarityTransform(translation=-corner_min) #Not really cool rescaling #offset_tmatrix = np.copy(offset.params) #offset_tmatrix[0, 2] = offset_tmatrix[0, 2]/common_factor #offset_tmatrix[0, 2] = offset_tmatrix[0, 2]/rescale_trans #offset_tmatrix[1, 2] = offset_tmatrix[1, 2]/common_factor #offset_tmatrix[1, 2] = offset_tmatrix[1, 2]/rescale_trans model_robust_tmatrix = np.copy(model_robust.params) model_robust_tmatrix[0, 2] = model_robust_tmatrix[0, 2] / common_factor #model_robust_tmatrix[0, 2] = model_robust_tmatrix[0, 2]/rescale_trans model_robust_tmatrix[1, 2] = model_robust_tmatrix[1, 2] / common_factor #model_robust_tmatrix[1, 2] = model_robust_tmatrix[1, 2]/rescale_trans #model_robust_offset_tmatrix = np.copy((model_robust+offset).params) #model_robust_offset_tmatrix[0, 2] = offset_tmatrix[0, 2] + model_robust_tmatrix[0, 2] #model_robust_offset_tmatrix[1, 2] = offset_tmatrix[1, 2] + model_robust_tmatrix[1, 2] #factor2 = 1.05 #img3_ = warp(img3, np.linalg.inv(offset_tmatrix), output_shape=(img3.shape[0]*factor2, img3.shape[1]*factor2)) #img4_ = warp(img4, np.linalg.inv(model_robust_offset_tmatrix), output_shape=(img3.shape[0]*factor2, img3.shape[1]*factor2)) img1_ = img1 #= warp(img1, offset.inverse, output_shape=output_shape, cval=-1) img2_ = warp( img2, model_robust.inverse, cval=-1 ) #(model_robust+offset).inverse, output_shape=output_shape, cval=-1) fig = plt.figure(constrained_layout=True) gs = fig.add_gridspec(3, 2) f_ax1 = fig.add_subplot(gs[0, :]) plot_matches(f_ax1, img1, img2, keypoints1, keypoints2, matches12) f_ax1.axis('off') #f_ax1.set_title(filename1+" vs. "+filename2) f_ax2 = fig.add_subplot(gs[1, 0]) f_ax2.imshow(img1) f_ax2.axis('off') f_ax2.set_title("img1") f_ax3 = fig.add_subplot(gs[1, 1]) f_ax3.imshow(img1_) f_ax3.axis('off') f_ax3.set_title("img1_") #f_ax4 = fig.add_subplot(gs[1, 2]) #f_ax4.imshow(img3_) #f_ax4.axis('off') #f_ax4.set_title("img3_") f_ax5 = fig.add_subplot(gs[2, 0]) f_ax5.imshow(img2) f_ax5.axis('off') f_ax5.set_title("img2") f_ax6 = fig.add_subplot(gs[2, 1]) f_ax6.imshow(img2_) f_ax6.axis('off') f_ax6.set_title("img2_") #f_ax7 = fig.add_subplot(gs[2, 2]) #f_ax7.imshow(img4_) #f_ax7.axis('off') #f_ax7.set_title("img4_") plt.show() return model_robust_tmatrix '''
def mix_lesions(lesion_bg, lesion_fg, mask_bg, mask_fg, gauss_sigma=0): height, width = lesion_bg.shape[:2] # Histogram matching for i in range(3): lesion_bg_masked = ma.array(lesion_bg[..., i], mask=~mask_bg) lesion_fg[..., i] = _histogram_matching(lesion_fg[..., i], lesion_bg_masked) rotation = randint(0, 90) lesion_fg = rotate(lesion_fg, rotation, mode='reflect', preserve_range=True).astype('uint8') mask_fg = rotate(mask_fg, rotation, mode='constant', cval=0, preserve_range=True).astype('uint8') cm_fg = center_of_mass(mask_fg) cm_bg = center_of_mass(mask_bg) tf_ = SimilarityTransform(scale=1, rotation=0, translation=(cm_fg[1] - cm_bg[1], cm_fg[0] - cm_bg[0])) lesion_fg = warp(lesion_fg, tf_, mode='constant', preserve_range=True).astype('uint8') mask_fg = warp(mask_fg, tf_, mode='constant', cval=0, preserve_range=True).astype('uint8') cm_fg = center_of_mass(mask_fg) # Cut mask cut_mask = np.zeros(mask_fg.shape) cut_mask[cut_mask.shape[0] // 2:, :] = 255 cut_mask = rotate(cut_mask, randint(0, 90), mode='reflect', preserve_range=True).astype('uint8') tf_cm = SimilarityTransform(scale=1, rotation=0, translation=(width // 2 - cm_bg[1], height // 2 - cm_bg[0])) cut_mask = warp(cut_mask, tf_cm, mode='constant', cval=0, preserve_range=True).astype('uint8') mask_fg = np.where(np.logical_and(mask_fg, cut_mask), 255, 0) # Calculate mask bounding box coords = np.argwhere(mask_fg == 255) y0, x0 = coords.min(axis=0) y1, x1 = coords.max(axis=0) + 1 # Convert mask to 3 channels mask_fg = np.dstack((mask_fg, mask_fg, mask_fg)) # Convert it to float mask_fg = mask_fg.astype('float') # And normalize it to 0.0~1.0 mask_fg *= (1.0 / 255.0) # Apply Gaussian Blur to the mask mask_fg = gaussian(mask_fg, sigma=gauss_sigma, multichannel=True, preserve_range=True) out = np.copy(lesion_bg) out_ = (lesion_bg * (1.0 - mask_fg) + lesion_fg * mask_fg).astype('uint8') out = np.where(mask_fg == 0, lesion_bg, out_) return out
def test_const_cval_out_of_range(): img = np.random.randn(100, 100) cval = -10 warped = warp(img, AffineTransform(translation=(10, 10)), cval=cval) assert np.sum(warped == cval) == (2 * 100 * 10 - 10 * 10)
def findGrains(self, minGrainSize=10): # Check a EBSD map is linked self.checkEbsdLinked() # Initialise the grain map self.grains = np.copy(self.boundaries) self.grainList = [] # List of points where no grain has been set yet unknownPoints = np.where(self.grains == 0) numPoints = unknownPoints[0].shape[0] totalPoints = numPoints # Start counter for grains grainIndex = 1 # Loop until all points (except boundaries) have been assigned # to a grain or ignored while numPoints > 0: # report progress yield 1. - numPoints / totalPoints # Flood fill first unknown point and return grain object currentGrain = self.floodFill(unknownPoints[1][0], unknownPoints[0][0], grainIndex) grainSize = len(currentGrain) if grainSize < minGrainSize: # if grain size less than minimum, ignore grain and set # values in grain map to -2 for coord in currentGrain.coordList: self.grains[coord[1], coord[0]] = -2 else: # add grain and size to lists and increment grain label self.grainList.append(currentGrain) grainIndex += 1 # update unknown points unknownPoints = np.where(self.grains == 0) numPoints = unknownPoints[0].shape[0] # Now link grains to those in ebsd Map # Warp DIC grain map to EBSD frame dicGrains = self.grains warpedDicGrains = tf.warp( np.ascontiguousarray(dicGrains.astype(float)), self.ebsdTransformInv, output_shape=(self.ebsdMap.yDim, self.ebsdMap.xDim), order=0).astype(int) # Initalise list to store ID of corresponding grain in EBSD map. # Also stored in grain objects self.ebsdGrainIds = [] for i in range(len(self.grainList)): # Find grain by masking the native ebsd grain image with # selected grain from the warped dic grain image. The modal # value is the EBSD grain label. modeId, _ = mode(self.ebsdMap.grains[warpedDicGrains == i + 1]) self.ebsdGrainIds.append(modeId[0] - 1) self.grainList[i].ebsdGrainId = modeId[0] - 1 self.grainList[i].ebsdGrain = self.ebsdMap.grainList[modeId[0] - 1] self.grainList[i].ebsdMap = self.ebsdMap
from skimage import data, transform import numpy as np import matplotlib.pyplot as plt image = data.text() plt.imshow(image, cmap=plt.cm.gray) target = np.array(plt.ginput(4)) source = np.array([(0, 0), (0, 50), (300, 50), (300, 0)]) plt.close() pt = transform.ProjectiveTransform() pt.estimate(source, target) warped = transform.warp(image, pt, output_shape=(50, 300)) f, (ax0, ax1) = plt.subplots(1, 2) ax0.imshow(image, cmap=plt.cm.gray) ax1.imshow(warped, cmap=plt.cm.gray) plt.show()
mnist = MNIST() np.random.seed(1234) k = 0 params = [] for i in range(30): print('it ' + str(i)) tfparam = np.array([[1.1, 0., 0.], [0., 1.1, 0.], [0., 0., 1.]]) tfseed = (np.random.rand(3, 3) - 0.5) * np.array([[0.2, 0.2, 6], [0.2, 0.2, 6], [0, 0, 0]]) print(tfseed) tfparam += tfseed tform = transform.AffineTransform(tfparam) print(tfparam) # variant_mnist = [transform.warp(x + 0.5, tform) for x in mnist.test_data[:10, :, :, :]] variant_mnist = [transform.warp(x + 0.5, tform) for x in mnist.test_data] variant_mnist = np.reshape(variant_mnist, (10000, 28, 28, 1)) - 0.5 mnist_test_result = model.model.predict(variant_mnist) amr = np.argmax(mnist_test_result, axis=1) aml = np.argmax(mnist.test_labels, axis=1) wrong_indices = (amr != aml) right_indices = ~wrong_indices acc = (1 - np.sum(wrong_indices) / aml.shape[0]) print("acc = %f" % acc) if acc > 0.95: print('save #%d' % i) params.append(tfparam) np.save('exp_affine_in_%d.npy' % k, mnist_test_result) print(mnist_test_result.shape) k += 1
def merge_full_image(data_left, data_right, left_index, right_index, model_robust, verbose=1, hist_match=1): """ merge the whole CT slice Parameters: -------------------------------------------- data_left: to be stitched left CT volumn data_right: to be stitched right CT volumn left_index: index of CT """ # get the slice of the left image and right image image_left = np.squeeze(data_left[:, :, left_index]) image_right = np.squeeze(data_right[:, 1:, right_index]) # match histogram if hist_match: image_left = histogram_matching(image_left, image_right, verbose=0) # get the size of the image size_right = np.shape(image_right) size_left = np.shape(image_left) ############################################################################# ### calculate the output shape of the stitched image ############################################################################# # number of columns for the stitched image n_col = np.add(size_right, size_left)[1] # image0 = image_left # image1 = image_right r, c = image_right.shape[:2] c = n_col corners = np.array([[0, 0], [0, r], [c, 0], [c, r]]) warped_corners = model_robust(corners) # also include rotation all_corners = np.vstack((warped_corners, corners)) corner_min = np.min(all_corners, axis=0) corner_max = np.max(all_corners, axis=0) output_shape = (corner_max - corner_min) if warped_corners[0][0] < 0: offset_box = -warped_corners[0][0] + 102 else: offset_box = warped_corners[0][0] output_shape[0] = n_col - offset_box output_shape = np.ceil(output_shape[::-1]) ############################################################################# ### merge the two image by shifting them to the correct positions ############################################################################# offset = EuclideanTransform(translation=(0, 0)) # move the left image image0_ = warp(image_left, offset.inverse, output_shape=output_shape, cval=-1) # pad -1 to the left image to the same shape as output_shape offset = EuclideanTransform(translation=(size_left[1] - 99, 0)) # move the right image image1_ = warp(image_right, (model_robust + offset).inverse, output_shape=output_shape, cval=-1) # use the image registion model - model_robust with the offset translation movement image_merge = image1_ + image0_ image_merge[np.where( image_merge > 0)] = (image_merge[np.where(image_merge > 0)] - 2) / 2 # average the overlap part ############################################################################## if verbose: plt.figure(figsize=(10, 5)) plt.subplot(121) plt.imshow(image_left, cmap='gray') plt.title('left image', fontsize=20) plt.axis('off') plt.subplot(122) plt.imshow(image_right, cmap='gray') plt.title('right image', fontsize=20) plt.axis('off') plt.figure(figsize=(10, 5)) plt.imshow(image_merge[10:-10, :], cmap='gray') plt.title('stitched image', fontsize=20) plt.axis('off') return (image_merge)
def rotate(img, rot_amt): rot = tf.AffineTransform(rotation=rot_amt) img = tf.warp(img, inverse_map=rot, mode='reflect') return img
trans_names = ['similarity', 'affine', 'piecewise-affine', 'projective'] # transform list fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10, 10)) for tform_type, axis in zip(trans_names, axes.flat): # looping through transforms # build the model tform = transform.estimate_transform(tform_type, np.array(src), np.array(dst)) # use the model raw_corrected_Z = transform.warp(moving, inverse_map=tform.inverse, output_shape=np.shape(moving)) # one way to do correlations corr = stats.pearsonr(np.reshape(fixed, [1024 * 1024, 1]), np.reshape(raw_corrected_Z, [1024 * 1024, 1]))[0][0] # visualize the transformation axis.set_title(tform_type + ' - Pearson corr: ' + str(np.round(corr, 3))) axis.imshow(raw_corrected_Z) fig.suptitle('Different transforms applied to the images', y=1.03) fig.tight_layout() ############################################################################## # delete the h5_file
def _calculate_transform_matrix(frame_RGB, frame_thermal, thermal_canny_percentage = 4, rgb_canny_percentage = 4, division_depth = 6, desired_thermal_scale = 1, denoise_weight_rgb = 0.3, denoise_weight_thermal = 0.1, degree = 2, plot = False): ''' Calculate the second degree polynomial transformation matrix to map the thermal frame on the RGB frame. Parameters ---------- frame_RGB : ndarray RGB frame without alpha. frame_thermal : ndarray 2D Thermal frame resized to have the same size with RGB frame. thermal_canny_percentage : int, optional Coverage of the edges for the canny output. Recommended: 2 to 6, default: 4. rgb_canny_percentage : int, optional Coverage of the edges for the canny output. Recommended: 3 to 8, default: 4. division_depth : int, optional Maximum region count for the vertical division. Needs to be chosen proportionally with the frames' quality and information density. Smallest division should not have a smaller width than the expected shift, but the outliers are mostly handled. Default: 8. Returns ------- ndarray 2x6 second degree polynomial transformation matrix. ''' rgb_edge = _canny_with_TV(frame_RGB, denoise_weight_rgb, rgb_canny_percentage) therm_edge = _canny_with_TV(frame_thermal, denoise_weight_thermal, thermal_canny_percentage) orig_width, orig_height = rgb_edge.shape half_width, half_height = int(orig_width/2), int(orig_height/2) rgb_proc = np.zeros((orig_width*2, orig_height*2)) rgb_proc[half_width:half_width*3,half_height:half_height*3] = rgb_edge therm_proc = np.zeros((orig_width*2, orig_height*2)) therm_proc[half_width:half_width*3,half_height:half_height*3] = therm_edge max_width, max_height = rgb_proc.shape[:2] # Divide image into vertical areas and save the centers before a possible shift. points_x = [] points_y = [] weights = [] for region_count in (np.logspace(0,division_depth,division_depth, base = 2)).astype(int): # Determine division limits region_divisions_with_zero = np.linspace(0, max_width, num = region_count, endpoint = False, dtype = int) region_divisions = region_divisions_with_zero[1:] all_region_bounds = np.append(region_divisions_with_zero, max_width) # Divide the frames into the regions lum_regions = np.hsplit(rgb_proc,region_divisions) therm_regions = np.hsplit(therm_proc,region_divisions) region_divisions_with_zero = np.insert(region_divisions, 0, 0) # Calculate the shifts for each region and save the points. Weight of a point # is proportional with its size ( thus, amount of information) and its # closeness to the center of the image ( which is the expected location # of the baby) for ind, (lumreg, thermreg) in enumerate(zip(lum_regions, therm_regions)): shifts, error, _ = feature.register_translation(thermreg.astype(int), lumreg.astype(int), 10) min_h, min_w = shifts reg_width = all_region_bounds[ind+1] - region_divisions_with_zero[ind] point_y = max_height/2-min_h point_x = region_divisions_with_zero[ind] + reg_width/2 - min_w points_y.append(point_y) points_x.append(point_x) sum_t = np.count_nonzero(thermreg) sum_r = np.count_nonzero(lumreg) try: weights.append(sum_t*sum_r/(sum_t+sum_r)) except ZeroDivisionError: weights.append(0) # weights.append(reg_width*max_height) # weights.append( (division_depth - region_count + 1) * abs(point_x-(max_width/2))/max_width ) # Remove the points that are certainly miscalculations: First filter by # the location of the cameras, then remove outliers (i.e. points more than 1 iqr away # from the closest percentile.) clean_mask_1 = np.array([True if y > max_height*11/20 else False for y in points_y]) clean_mask_1 = np.array([True if True else False for y in points_y]) semiclean_points_x = np.array(points_x)[clean_mask_1] semiclean_points_y = np.array(points_y)[clean_mask_1] semiclean_weights = np.array(weights)[clean_mask_1] from collections import Counter #weighted percentiles q1, q3 = np.percentile(list(Counter(dict(zip(semiclean_points_y, semiclean_weights.astype(int)))).elements()), [25 ,75]) #q1, q3 = np.percentile(semiclean_points_y, [25 ,75]) iqr_y = (q3-q1)*1 clean_mask_2 = np.array([True if q1 - iqr_y < y < q3 + iqr_y else False for y in semiclean_points_y]) clean_points_x = np.array(semiclean_points_x)[clean_mask_2] clean_points_y = np.array(semiclean_points_y)[clean_mask_2] clean_weights = np.array(semiclean_weights)[clean_mask_2] # Create the polynomial features and fit the regression. poly = PolynomialFeatures(degree=degree) X_t = poly.fit_transform(np.array(clean_points_x).reshape((-1,1))) clf = LinearRegression() clf.fit(X_t, clean_points_y, sample_weight = clean_weights) points = np.linspace(0,max_width,10) data = poly.fit_transform(points.reshape((-1,1))) line = clf.predict(data) # Create a grid of values from the regression to estimate the transformation matrix. x_points_grid = np.array([points , points, points, points, points]) y_points_grid = np.array([line-20, line-10, line, line+10, line+20]) src = np.array([(x-half_width,y-half_height) for x,y in zip(x_points_grid.flatten(), y_points_grid.flatten())]) cent = max_height/2 y_points_truegrid = np.broadcast_to(np.array([[cent-20], [cent-10], [cent], [cent+10], [cent+20]]), y_points_grid.shape) dest = np.array([(x-half_width,y-half_height) for x,y in zip(x_points_grid.flatten(), y_points_truegrid.flatten())]) trans = transform.PolynomialTransform() trans.estimate(src*desired_thermal_scale,dest*desired_thermal_scale,degree) if plot: import cv2 fig, ax = plt.subplots(nrows=1, ncols=5, figsize = (20,5)) ax[0].imshow(frame_thermal) ax[0].set_title('thermal frame. Initial res: 80x60') ax[1].imshow(frame_RGB) ax[1].set_title('RGB frame. Initial res: 640x480') ax[2].imshow(frame_thermal) ax[2].scatter(points_x, points_y,color = 'r') ax[2].scatter(clean_points_x, clean_points_y,color = 'g') ax[2].plot(points, line,scalex = False, scaley= False) ax[2].set_xlim(0,max_height) ax[2].set_ylim(max_width,0) ax[2].set_title('Corr. points and the quadratic fit. Red: outliers.') ax[3].imshow(therm_proc) ax[3].set_title('Edges of thermal frame') warped = transform.warp(frame_thermal,trans) scaled_aligned_thermal = cv2.applyColorMap((warped*256).astype('uint8'), cv2.COLORMAP_JET)[...,::-1] overlay = cv2.addWeighted(scaled_aligned_thermal, 0.3, (frame_RGB).astype('uint8'), 0.7, 0) ax[4].imshow(overlay) ax[4].set_title('final overlay') return trans.params
# --- Convert the images to gray level: color is not supported. image0 = rgb2gray(image0) image1 = rgb2gray(image1) # --- Compute the optical flow v, u = optical_flow_tvl1(image0, image1) # --- Use the estimated optical flow for registration nr, nc = image0.shape row_coords, col_coords = np.meshgrid(np.arange(nr), np.arange(nc), indexing='ij') image1_warp = warp(image1, np.array([row_coords + v, col_coords + u]), mode='edge') # build an RGB image with the unregistered sequence seq_im = np.zeros((nr, nc, 3)) seq_im[..., 0] = image1 seq_im[..., 1] = image0 seq_im[..., 2] = image0 # build an RGB image with the registered sequence reg_im = np.zeros((nr, nc, 3)) reg_im[..., 0] = image1_warp reg_im[..., 1] = image0 reg_im[..., 2] = image0 # build an RGB image with the registered sequence target_im = np.zeros((nr, nc, 3))
def shear(img, shear_amt): shear = tf.AffineTransform(shear=shear_amt) img = tf.warp(img, inverse_map=shear, mode='reflect') return img
def mainMeshWarp(): '''1. read image and load new landmarks (nod)''' image = cv2.imread('../../github/vrn-07231340/examples/trump-12.jpg') imageTmp = copy.deepcopy(image) rows, cols = image.shape[0], image.shape[1] originLandmark2D = getLandmark2D(image) targetLandmark2DPath = '../../data/talkingphoto/IMG_2294/IMG_2294_26.png.txt' targetLandmark2D = readPoints(targetLandmark2DPath)[:68] '''2. 新建source mesh''' gridSize = 50 src_rows = np.linspace(0, rows, gridSize) # 10 行 src_cols = np.linspace(0, cols, gridSize) # 20 列 src_rows, src_cols = np.meshgrid(src_rows, src_cols) src = np.dstack([src_cols.flat, src_rows.flat])[0] '''!!! IMPORTANT DEEPCOPY!!!''' dst = copy.deepcopy(src) '''triTxt''' # triTxtPath = './meshTri_640_640(trump-12).txt' triList = generateMeshTriTxt(image, 50, 50, originLandmark2D) '''3. SKIMAGE画一个椭圆, 并且得到椭圆内所有的网格点''' rr, cc = ellipse_perimeter(originLandmark2D[ELLIPSE_CENTER][1], originLandmark2D[ELLIPSE_CENTER][0], 200, 260, orientation=30) tmp = rr rr = cc cc = tmp # print rr.shape, cc.shape ellipseVerts = np.dstack([rr, cc])[0] # 椭圆边长上所有点 # print ellipseVerts mask = points_in_poly(src, ellipseVerts) pointsInEllipseList = [] indexInEllipseList = [] for i, (s, m) in enumerate(zip(src, mask)): if m == True: pointsInEllipseList.append(s) indexInEllipseList.append(i) # print len(indexInEllipseList) # x=pointsInEllipseList[i][1], y=pointsInEllipseList[i][0] pointsInEllipseArray = np.asarray(pointsInEllipseList) '''swap collums of pointsInEllipseList''' # x=pointsInEllipseList[i][0], y=pointsInEllipseList[i][1] # pointsInEllipseArray[:, [0, 1]] = pointsInEllipseArray[:, [1, 0]] # image[cc, rr] = 255 # draw ellipse perimeter on image drawPointsOnImg(pointsInEllipseArray, imageTmp, 'r') '''4. compute delta (68) of each new landmark X(Y) and old landmark X(Y)''' deltaAllLandmarksList = [] for i in range(len(targetLandmark2D)): deltaAllLandmarksList.append([ targetLandmark2D[i][0] - originLandmark2D[i][0], targetLandmark2D[i][1] - originLandmark2D[i][1] ]) # deltaAllLandmarksArray = np.asarray(deltaAllLandmarksList) # print deltaAllLandmarksList '''5. compute delta of each point in ellipse''' radius = 5 * rows / float(gridSize) targetPointsModifiedInEllipseList = [] isPointsInEllipseModifiedList = [] deltaOfMeshPointsInEllipseList = [] for meshPoint in pointsInEllipseArray: _, _, landmarksInSmallGridArray, deltaInSmallGridArray = getLandmarksInSmallGrid( meshPoint, originLandmark2D, deltaAllLandmarksList, radius=radius) '''画smallGrid以及其内的所有landmarks的delta''' # imageTmp = copy.deepcopy(image) # cv2.circle(imageTmp, (int(meshPoint[0]), # int(meshPoint[1])), int(radius), (0, 255, 0), 2) # if landmarksInSmallGridArray.shape[0] != 0: # for (deltaX, deltaY), (landmarkX, landmarkY) in zip(deltaInSmallGridArray, landmarksInSmallGridArray): # cv2.line(imageTmp, (int(landmarkX), int(landmarkY)), (int( # landmarkX+deltaX), int(landmarkY+deltaY)), (255, 0, 0), 2) # cv2.circle(imageTmp, (int(landmarkX+deltaX), # int(landmarkY+deltaY)), 2, (0, 0, 255), -1) # cv2.imshow('imgTmp', imageTmp) # cv2.waitKey(50) deltaXOfMeshPoint = 0 deltaYOfMeshPoint = 0 if deltaInSmallGridArray.shape[0] != 0: for i, (deltaInSmallGrid, landmarkInSmallGrid) in enumerate( zip(deltaInSmallGridArray, landmarksInSmallGridArray)): deltaInSmallGridX = deltaInSmallGrid[0] deltaInSmallGridY = deltaInSmallGrid[1] deltaXOfMeshPoint = deltaXOfMeshPoint + deltaInSmallGridX / \ twoPointsDistance(meshPoint, landmarkInSmallGrid) deltaYOfMeshPoint = deltaYOfMeshPoint + deltaInSmallGridY / \ twoPointsDistance(meshPoint, landmarkInSmallGrid) targetMeshPointX = meshPoint[0] + deltaXOfMeshPoint targetMeshPointY = meshPoint[1] + deltaYOfMeshPoint deltaOfMeshPointsInEllipseList.append( [deltaXOfMeshPoint, deltaYOfMeshPoint]) if deltaXOfMeshPoint == 0 and deltaYOfMeshPoint == 0: isPointsInEllipseModifiedList.append(False) else: isPointsInEllipseModifiedList.append(True) '''画每一个meshPoint的起点和终点''' # cv2.line(imageTmp, (int(meshPoint[0]), int(meshPoint[1])), # (int(targetMeshPointX), int(targetMeshPointY)), (0, 255, 0), 1) # cv2.circle(imageTmp, (int(meshPoint[0]), int(meshPoint[1])), # 2, (0, 255, 0), -1) # cv2.circle(imageTmp, (int(targetMeshPointX), int(targetMeshPointY)), # 2, (255, 0, 0), -1) # if deltaXOfMeshPoint != 0 or deltaYOfMeshPoint != 0: # cv2.imshow('imageTmp', imageTmp) # cv2.waitKey(0) targetPointsModifiedInEllipseList.append( [targetMeshPointX, targetMeshPointY]) targetPointsModifiedInEllipseArray = np.asarray( targetPointsModifiedInEllipseList) # drawPointsOnImg(pointsInEllipseArray, imageTmp, 'b') # drawPointsOnImg(targetPointsModifiedInEllipseArray, imageTmp, 'r') assert pointsInEllipseArray.shape[0] == len(isPointsInEllipseModifiedList) assert pointsInEllipseArray.shape[0] == len(deltaOfMeshPointsInEllipseList) '''5.1 compute rest points in ellipse (hair)''' targetPointsNotModifiedInEllipseList = [] for i, meshPoint in enumerate(pointsInEllipseArray): deltaXOfMeshPointNotModified = 0 deltaYOfMeshPointNotModified = 0 if isPointsInEllipseModifiedList[i] == False: meshPointsOnSameColumnArray, meshPointsIndexOnSameColumnList = getMeshPointsOnSameColumn( meshPoint, pointsInEllipseArray) for meshPointOnSameColumn, meshPointIndexOnSameColumn in zip( meshPointsOnSameColumnArray, meshPointsIndexOnSameColumnList): deltaXOfMeshPointOnSameColumn = deltaOfMeshPointsInEllipseList[ meshPointIndexOnSameColumn][0] deltaYOfMeshPointOnSameColumn = deltaOfMeshPointsInEllipseList[ meshPointIndexOnSameColumn][1] deltaXOfMeshPointNotModified = deltaXOfMeshPointNotModified + \ deltaXOfMeshPointOnSameColumn / \ twoPointsDistance(meshPoint, meshPointOnSameColumn) deltaYOfMeshPointNotModified = deltaYOfMeshPointNotModified + \ deltaYOfMeshPointOnSameColumn / \ twoPointsDistance(meshPoint, meshPointOnSameColumn) targetMeshPointXNotModified = meshPoint[0] + \ deltaXOfMeshPointNotModified targetMeshPointYNotModified = meshPoint[1] + \ deltaYOfMeshPointNotModified targetPointsNotModifiedInEllipseList.append( [targetMeshPointXNotModified, targetMeshPointYNotModified]) targetPointsNotModifiedInEllipseArray = np.asarray( targetPointsNotModifiedInEllipseList) assert targetPointsNotModifiedInEllipseArray.shape == targetPointsModifiedInEllipseArray.shape '''5.2 merge targetPointsModifiedInEllipseArray and targetPointsNotModifiedInEllipseArray''' targetPointsInEllipseList = [] for targetPointModifiedInEllipse, targetPointNotModifiedInEllipse, isPointInEllipseModified in zip( targetPointsModifiedInEllipseArray, targetPointsNotModifiedInEllipseArray, isPointsInEllipseModifiedList): if isPointInEllipseModified == True: targetPointsInEllipseList.append(targetPointModifiedInEllipse) else: targetPointsInEllipseList.append(targetPointNotModifiedInEllipse) '''6. compute final target mesh''' # print targetPointsInEllipseList.shape drawPointsOnImg(targetPointsInEllipseList, imageTmp, 'b') # targetPointsInEllipseList[:, [0, 1] # ] = targetPointsInEllipseList[:, [1, 0]] dst[indexInEllipseList] = targetPointsInEllipseList '''draw src and dst mesh on image''' # drawPointsOnImg(src, imageTmp, 'g') # drawPointsOnImg(dst, imageTmp, 'b') cv2.imwrite('./tmp.png', imageTmp) '''7. PiecewiseAffineTransform without landmarks''' tform = PiecewiseAffineTransform() tform.estimate(dst, src) out = warp(image, tform) '''8. imshow and imwrite without landmarks for skimage''' imshow('out_pat_wo', out) cv2.imwrite('./out_pat_wo.png', out * 255) '''7.1 mesh warp with landmarks wirtten by meself''' '''SEE EXP03''' # '''draw dst triangle''' # imgTmp = copy.copy(image) # for tri in triList: # a, b, c = tri.split() # a = int(a) # b = int(b) # c = int(c) # z1 = (int(dst[a][0]), int(dst[a][1])) # z2 = (int(dst[b][0]), int(dst[b][1])) # z3 = (int(dst[c][0]), int(dst[c][1])) # cv2.line(imgTmp, z1, z2, (255, 255, 255), 1) # cv2.line(imgTmp, z2, z3, (255, 255, 255), 1) # cv2.line(imgTmp, z3, z1, (255, 255, 255), 1) # cv2.imshow('tmp', imgTmp) # cv2.waitKey(1) # imgMorph = morph_modify_for_meshwarp(src, dst, image, triList) '''8.1 imshow and imwrite with landmarks by myself''' '''SEE EXP03''' # imshow('imgMorph', imgMorph) # cv2.imwrite('./out_wo.png', imgMorph) '''7.2 PiecewiseAffineTransform with landmarks''' originLandmark2DArray = np.asarray(originLandmark2D) src = np.concatenate((src, originLandmark2DArray), axis=0) targetLandmark2DArray = np.asarray(targetLandmark2D) dst = np.concatenate((dst, targetLandmark2DArray), axis=0) tform = PiecewiseAffineTransform() tform.estimate(dst, src) out = warp(image, tform) '''8.2 imshow and imwrite with landmarks for skimage''' imshow('out_pat_w', out) cv2.imwrite('./out_pat_w.png', out * 255) # cv2.imwrite('./ori.jpg', image) # # fig, ax = plt.subplots() # # ax.imshow(out) # # ax.scatter(pointsInEllipseArray[:, 0], pointsInEllipseArray[:, 1], # # marker='+', color='b', s=5) # # ax.plot(tform.inverse(src)[:, 0], tform.inverse(src)[:, 1], '.r') # # plt.show() '''7.3 mesh warp with landmarks wirtten by meself''' originLandmark2DArray = np.asarray(originLandmark2D) src = np.concatenate((src, originLandmark2DArray), axis=0) targetLandmark2DArray = np.asarray(targetLandmark2D) dst = np.concatenate((dst, targetLandmark2DArray), axis=0) '''draw dst triangle''' # imgTmp = copy.copy(image) # for tri in triList: # a, b, c = tri.split() # a = int(a) # b = int(b) # c = int(c) # z1 = (int(dst[a][0]), int(dst[a][1])) # z2 = (int(dst[b][0]), int(dst[b][1])) # z3 = (int(dst[c][0]), int(dst[c][1])) # cv2.line(imgTmp, z1, z2, (255, 255, 255), 1) # cv2.line(imgTmp, z2, z3, (255, 255, 255), 1) # cv2.line(imgTmp, z3, z1, (255, 255, 255), 1) # cv2.imshow('tmp', imgTmp) # cv2.waitKey(1) imgMorph = morph_modify_for_meshwarp(src, dst, image, triList) '''8.3 imshow and imwrite with landmarks by myself''' imshow('imgMorph', imgMorph) cv2.imwrite('./out_w.png', imgMorph)
def apply_translation(img): translated = 255*warp(img, transform.SimilarityTransform(translation=(np.random.uniform(-5, 5), np.random.uniform(-5, 5))),mode='edge') translated = translated.astype(np.uint8) return translated.astype(np.uint8)
def _perform(self): do_plot = (self.config.instrument.plot_level >= 3) self.logger.info("Extracting arc spectra") # Double check if not self.action.args.original_filename: self.logger.error("No traces found") return self.action.args # All is ready original_filename = self.action.args.original_filename self.logger.info("Trace table found: %s" % original_filename) # trace = read_table(tab=tab, indir='redux', suffix='trace') # Find and read control points from continuum bars if hasattr(self.context, 'trace'): trace = self.context.trace else: trace = read_table( input_dir=os.path.join(self.config.instrument.cwd, self.config.instrument.output_directory), file_name=original_filename) self.context.trace = {} for key in trace.meta.keys(): self.context.trace[key] = trace.meta[key] middle_row = self.context.trace['MIDROW'] window = self.context.trace['WINDOW'] self.action.args.reference_bar_separation = self.context.trace[ 'REFDELX'] self.action.args.contbar_image_number = self.context.trace['CBARSNO'] self.action.args.contbar_image = self.context.trace['CBARSFL'] self.action.args.arc_number = self.action.args.ccddata.header['FRAMENO'] self.action.args.arc_image = self.action.args.ccddata.header['OFNAME'] self.action.args.source_control_points = trace['src'] self.action.args.destination_control_points = trace['dst'] self.action.args.bar_id = trace['barid'] self.action.args.slice_id = trace['slid'] self.logger.info("Fitting spatial control points") transformation = tf.estimate_transform( 'polynomial', self.action.args.source_control_points, self.action.args.destination_control_points, order=3) self.logger.info("Transforming arc image") warped_image = tf.warp(self.action.args.ccddata.data, transformation) # Write warped arcs if requested if self.config.instrument.saveintims: from kcwidrp.primitives.kcwi_file_primitives import kcwi_fits_writer # write out warped image self.action.args.ccddata.data = warped_image kcwi_fits_writer(self.action.args.ccddata, table=self.action.args.table, output_file=self.action.args.name, output_dir=self.config.instrument.output_directory, suffix="warped") self.logger.info("Transformed arcs produced") # extract arcs self.logger.info("Extracting arcs") arcs = [] # sectors for bkgnd subtraction sectors = 16 for xyi, xy in enumerate(self.action.args.source_control_points): if xy[1] == middle_row: xi = int(xy[0]+0.5) arc = np.median( warped_image[:, (xi - window):(xi + window + 1)], axis=1) # divide spectrum into sectors div = int((len(arc)-100) / sectors) # get minimum for each sector xv = [] yv = [] for i in range(sectors): mi = np.nanargmin(arc[50+i*div:50+(i+1)*div]) mn = np.nanmin(arc[50+i*div:50+(i+1)*div]) xv.append(mi+50+i*div) yv.append(mn) # fit minima to model background res = np.polyfit(xv, yv, 3) xp = np.arange(len(arc)) bkg = np.polyval(res, xp) # resulting model # plot if requested if do_plot: p = figure(title=self.action.args.plotlabel + "ARC # %d" % len(arcs), x_axis_label="Y CCD Pixel", y_axis_label="Flux", plot_width=self.config.instrument.plot_width, plot_height=self.config.instrument.plot_height) p.line(xp, arc, legend_label='Arc', color='blue') p.line(xp, bkg, legend_label='Bkg', color='red') bokeh_plot(p, self.context.bokeh_session) q = input("Next? <cr>, q to quit: ") if 'Q' in q.upper(): do_plot = False # subtract model background arc -= bkg # add to arcs list arcs.append(arc) # Did we get the correct number of arcs? if len(arcs) == self.config.instrument.NBARS: self.logger.info("Extracted %d arcs" % len(arcs)) self.context.arcs = arcs else: self.logger.error("Did not extract %d arcs, extracted %d" % (self.config.instrument.NBARS, len(arcs))) log_string = ExtractArcs.__module__ self.action.args.ccddata.header['HISTORY'] = log_string self.logger.info(log_string) return self.action.args
def inverse_transform(img, src, dst, original_image_size): tform3 = tf.ProjectiveTransform() tform3.estimate(src, dst) warped = tf.warp(img, tform3.inverse, output_shape=original_image_size) return np.round(warped * 255).astype(np.uint8)
# Rotation invariance of ORB features from skimage import data from skimage import transform as tf from skimage.feature import (match_descriptors, corner_harris, corner_peaks, ORB, plot_matches) from skimage.color import rgb2gray import matplotlib.pyplot as plt img1 = rgb2gray(data.astronaut()) img2 = tf.rotate(img1, 135) tform = tf.AffineTransform(scale=(3.5, 1.1), rotation=0.5, translation=(0, -200)) img3 = tf.warp(img1, tform) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img2) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img3) keypoints3 = descriptor_extractor.keypoints descriptors3 = descriptor_extractor.descriptors
def forward_transform(img, src, dst, target_size): tform3 = tf.ProjectiveTransform() tform3.estimate(src, dst) warped = tf.warp(img, tform3, output_shape=(target_size, target_size)) return np.round(warped * 255).astype(np.uint8)
def main(): # Let's import first frame of videofile, and show it print('Choose videofile for making calib curves') file = get_filenames() file = file[0] # get just single file instead of list print('Importing file ', file) frame = skvideo.io.vread(file, num_frames=1) # import just first frame frame = rgb2gray(frame[0]) # get element instead of list, make grayscale # plt.figure() # plt.imshow(frame, cmap=plt.cm.gray) # plt.show() # Compensate angle if its needed finish = False angle = 0 while finish == False: angle, finish = rotate_image(frame, angle) if angle != 0: frame = rotate(frame, angle) # Detect center of lightspot, show quadrants: centroid = threshold_centroid(frame) print('Showing first frame of video with quadrants...') plot_im_w_quadrants(frame, centroid, fig_title='1st frame with quadrants') # Demonstrate how shifted image looks like print('Image shifted for 5px in each axis will look like this:') transform = AffineTransform(translation=(5, 5)) shifted = warp(frame, transform, mode='constant', preserve_range=True) plot_im_w_quadrants(shifted, centroid, fig_title='5 px shift') print( 'If you want to have max test shift as shown above, just press enter') print( '(If lightspot is partially out of field of view, better to choose smaller shift)' ) print( 'Otherwise manually enter desired shift of image in px, and press enter' ) print('Note: the same shift will be used for each axis') max_shift = input() if max_shift == '': max_shift = 5 else: max_shift = float(max_shift) print('Images will be shifted from 0 to %s px' % max_shift) k_px_um = input('Enter px to um coefficient (scale):\n') k_px_um = float(k_px_um) # Shift images along x axis shifted_im = [] # specify parameters for calculations # generate dx value for linear shift # x_shift = np.array([0.1*dx for dx in range(0, max_shift+1)]) dx = 0.1 x_shift = np.arange(0, max_shift * (1 + dx), dx * max_shift) # k_px_um = 1.36 # scale px to um normalization = False # don't scale signal over SUM shift_vs_sig = True # calculate shift from signal, not other way for dx in x_shift: transform = AffineTransform(translation=(dx, dx)) # shift along both axis shifted_im.append( warp(frame, transform, mode='constant', preserve_range=True)) # Calculate the intensities Il = np.array([]) Iz = np.array([]) Isum = np.array([]) for i in range(len(shifted_im)): Iz, Il, Isum = calc_intensities(shifted_im[i], centroid, Iz, Il, Isum) # Show calculated intensity difference vs displacement and get linear fit coefficients of the calibration: # without normalization plot_shift_curves(k_px_um=k_px_um, Il=Il, Iz=Iz, Isum=Isum, x_shift=x_shift, normalization=False, shift_vs_sig=shift_vs_sig) k_x, b_x, k_y, b_y = calc_calib_line(x_shift=x_shift, y_shift=x_shift, k_px_um=k_px_um, Il=Il, Iz=Iz, normalization=False, shift_vs_sig=shift_vs_sig) # with normalization plot_shift_curves(k_px_um=k_px_um, Il=Il, Iz=Iz, Isum=Isum, x_shift=x_shift, normalization=True, shift_vs_sig=shift_vs_sig) k_x_norm, b_x_norm, k_y_norm, b_y_norm = calc_calib_line( x_shift=x_shift, y_shift=x_shift, k_px_um=k_px_um, Il=Il, Iz=Iz, Isum=Isum, normalization=True, shift_vs_sig=shift_vs_sig) return k_x, b_x, k_y, b_y, k_x_norm, b_x_norm, k_y_norm, b_y_norm
def rotate_images(data_folder, rots_per_pic): """Rotates images and produces the new coordinates for their facial keypoint markers. Creates rotated files and new markers in the same folder where the input files came from. Input path should exist. Number of rotations should be a natural number. Parameters ---------- data_folder : String Folder containing raw data to be processed. rots_per_pic : Integer Number of rotations to be produced per image. """ print "Rotating images..." #search for images in folder iteratively old_paths = [] for folder, subs, files in os.walk(data_folder): for filename in files: if filename.endswith('.png') or filename.endswith('.jpg'): old_paths.append(os.path.join(folder, filename)) #sorts the paths obtained old_paths.sort() old_paths_with_sums = {} for filename in old_paths: old_paths_with_sums[filename] = 0 #counts how many times the images were already processed new_paths = [] all_files_sum = 0 already_processed_sum = 0 for filename in old_paths: if "processed" not in filename: all_files_sum = all_files_sum + 1 new_paths.append(filename) print('File found:') print filename else: already_processed_sum = already_processed_sum + 1 matching = [ s for s in new_paths if ((filename.partition("_processed_")[0] + ".png") == s or ( filename.partition("_processed_")[0] + ".jpg") == s) ] for i in matching: old_paths_with_sums[i] = old_paths_with_sums[i] + 1 if old_paths_with_sums[i] >= rots_per_pic: new_paths.remove(i) print('File already processed ' + str(old_paths_with_sums[i]) + ' time(s):') print(i) else: print('File processed ' + str(old_paths_with_sums[i]) + ' time(s):') print(i) processed_sum = 0 too_big_angles_sum = 0 no_desc_found_sum = 0 markers_out_of_mesh = 0 for current_path in new_paths: #rotates image as many times as needed to achieve the desired number of rotations for i in range(int(rots_per_pic) - old_paths_with_sums[current_path]): path = current_path #loads files generated by Zface if they exist and are not empty if (os.path.isfile(path + '.mesh3D') and os.path.isfile(path + '.mesh2D') and os.path.isfile(path + '.ctrl2D') and os.path.isfile(path + '.pars') and os.stat(path + '.mesh3D').st_size != 0 and os.stat(path + '.mesh2D').st_size != 0 and os.stat(path + '.ctrl2D').st_size != 0 and os.stat(path + '.pars').st_size != 0): src3 = np.loadtxt(path + '.mesh3D') src2 = np.loadtxt(path + '.mesh2D') ctrl2 = np.loadtxt(path + '.ctrl2D') scale = np.loadtxt(path + '.pars')[0] translx = np.loadtxt(path + '.pars')[1] transly = np.loadtxt(path + '.pars')[2] pitch = np.loadtxt(path + '.pars')[3] yaw = np.loadtxt(path + '.pars')[4] roll = np.loadtxt(path + '.pars')[5] #tests wether or not initial rotation is too large if (abs(yaw) < radians(30) and abs(pitch) < radians(15)): image = data.load(path) rows, cols = image.shape[0], image.shape[1] x = src3[:, 0] y = src3[:, 1] z = src3[:, 2] #transform 3D mesh from normalized space and rotation to actual space and rotation x = x * cos(roll) + y * -sin(roll) y = x * sin(roll) + y * cos(roll) z = z x = x * cos(yaw) + z * sin(yaw) y = y z = x * -sin(yaw) + z * cos(yaw) x = x y = y * cos(pitch) + z * -sin(pitch) z = y * sin(pitch) + z * cos(pitch) x = x * scale + translx y = y * scale + transly #ortographically projects the 3D mesh to 2D (this will be our source for the Piecewise Affine Transform) src_cols = x src_rows = y src_rows, src_cols = np.meshgrid(src_rows, src_cols, sparse=True) src = np.dstack([src_cols.flat, src_rows.flat])[0] #transforms it back to normalized space x = (x - translx) / scale y = (y - transly) / scale #rotates it back to 0 rotation yaw = -yaw pitch = -pitch roll = -roll #adds random rotation real_yaw = radians(random.uniform(-30, 30)) real_pitch = radians(random.uniform(-15, 15)) real_roll = 0 yaw = yaw + real_yaw pitch = pitch + real_pitch roll = roll + real_roll x = x * cos(roll) + y * -sin(roll) y = x * sin(roll) + y * cos(roll) z = z x = x * cos(yaw) + z * sin(yaw) y = y z = x * -sin(yaw) + z * cos(yaw) x = x y = y * cos(pitch) + z * -sin(pitch) z = y * sin(pitch) + z * cos(pitch) #transforms it back to real space x = x * scale + translx y = y * scale + transly #orthographic projection of new coordinates will be the destination for PiecewiseAffineTransform dst_cols = x dst_rows = y dst = np.vstack([dst_cols, dst_rows]).T out_rows = rows out_cols = cols #looks for triangles formed by Delaunay triangularion, extracts the ones associated with each facial keypoint marker tform = PiecewiseAffineTransform() src_triangles, dst_triangles = tform.estimate( src[:, 0:2], dst) ctrl2_transforms = [] for current_ctrl2 in ctrl2: for i in range(len(src_triangles)): triangle = polygon.Path(src_triangles[i]) if triangle.contains_point(current_ctrl2): ctrl2_transforms.append(tform.affines[i]) break if len(ctrl2_transforms) != 49: markers_out_of_mesh = markers_out_of_mesh + 1 print "didn't process image, because can't find all shape parameters:" print path continue out_ctrl2 = [] for i in range(len(ctrl2_transforms)): #performs transformation on marker out_ctrl2.append(ctrl2_transforms[i](ctrl2[i])) out_ctrl2 = np.transpose((np.transpose(out_ctrl2)[0], np.transpose(out_ctrl2)[1])) out_ctrl2 = np.squeeze(out_ctrl2) #transforms image to the new surface triangle by triangle using Delaunay triangulation, then interpolation to smooth it out tform = PiecewiseAffineTransform() tform.estimate(dst, src[:, 0:2]) out_image = warp(image, tform, output_shape=(out_rows, out_cols)) out_path = path[:-4] + '_processed' + '_yaw_' + str( real_yaw) + '_pitch_' + str( real_pitch) + '_roll_' + str(real_roll) + path[-4:] #saves image and marker points imsave(out_path, out_image) np.savetxt(out_path + '_0.txt', out_ctrl2) processed_sum = processed_sum + 1 print(str(processed_sum) + '. file processed:') print(path) else: too_big_angles_sum = too_big_angles_sum + 1 print( "didn't process image, because of too big original rotation:" ) print(path) else: no_desc_found_sum = no_desc_found_sum + 1 print( "didn't process image, beacuse descriptor documents not found:" ) print(path) out_paths = [] for folder, subs, files in os.walk(data_folder): for filename in files: if filename.endswith('.png') or filename.endswith('.jpg'): if "processed" in filename: out_path = os.path.join(folder, filename).replace(data_folder, "") out_paths.append(out_path) #writes paths of generated images into contents filename = data_folder + '/contents' with open(filename, 'w') as f: f.write('\n'.join(out_paths)) print "Shuffling contents..." #shuffles contents shuffle_contents(filename) #prints some statistics about the process on the screen print print("Statistics:") print("-----------") print("Files found: " + str(all_files_sum)) if all_files_sum != 0: print("Already processed: " + str(already_processed_sum)) print("Got processed now: " + str(processed_sum)) print( "All processed: " + str( (processed_sum + already_processed_sum) * 100 / all_files_sum) + "%") print("Can't be processed because of too big angles: " + str(too_big_angles_sum * 100 / all_files_sum) + "%") print("Can't be processed because of no decriptors: " + str(no_desc_found_sum * 100 / all_files_sum) + "%") print("Can't be processed because of markers outside of mesh: " + str(markers_out_of_mesh * 100 / all_files_sum) + "%")
def fast_warp(img, tf, output_shape=(50, 50), mode='constant', order=1): m = tf.params return warp(img, m, output_shape=output_shape, mode=mode, order=order)
def make_cube_helper(argument): """Warp each slice""" logger = argument['logger'] logger.info("Transforming image slice %d" % (argument['slice_number'] + 1)) # input params slice_number = argument['slice_number'] xsize = argument['xsize'] ysize = argument['ysize'] tform = argument['geom']['tform'][slice_number] xl0 = argument['geom']['xl0'][slice_number] xl1 = argument['geom']['xl1'][slice_number] # slice data slice_img = argument['img'][:, xl0:xl1] slice_var = argument['std'][:, xl0:xl1] slice_msk = argument['msk'][:, xl0:xl1] slice_flg = argument['flg'][:, xl0:xl1] if 'obj' in argument: slice_obj = argument['obj'][:, xl0:xl1] else: slice_obj = None if 'sky' in argument: slice_sky = argument['sky'][:, xl0:xl1] else: slice_sky = None if 'del' in argument: slice_del = argument['del'][:, xl0:xl1] else: slice_del = None # do the warping warped = tf.warp(slice_img, tform, order=3, output_shape=(ysize, xsize)) varped = tf.warp(slice_var, tform, order=3, output_shape=(ysize, xsize)) marped = tf.warp(slice_msk, tform, order=3, output_shape=(ysize, xsize)) farped = tf.warp(slice_flg, tform, order=3, output_shape=(ysize, xsize), preserve_range=True) if slice_obj is not None: oarped = tf.warp(slice_obj, tform, order=3, output_shape=(ysize, xsize)) else: oarped = None if slice_sky is not None: sarped = tf.warp(slice_sky, tform, order=3, output_shape=(ysize, xsize)) else: sarped = None if slice_del is not None: darped = tf.warp(slice_del, tform, order=3, output_shape=(ysize, xsize), preserve_range=True) else: darped = None return argument['slice_number'], warped, varped, marped, farped, \ oarped, sarped, darped