def _get_rand_transform_matrix(self, image_size, d, batch_size): M = np.zeros((batch_size, 8)) for i in range(batch_size): tl_top = random.uniform(-d, d) # Top left corner, top tl_left = random.uniform(-d, d) # Top left corner, left bl_bottom = random.uniform(-d, d) # Bot left corner, bot bl_left = random.uniform(-d, d) # Bot left corner, left tr_top = random.uniform(-d, d) # Top right corner, top tr_right = random.uniform(-d, d) # Top right corner, right br_bottom = random.uniform(-d, d) # Bot right corner, bot br_right = random.uniform(-d, d) # Bot right corner, right transform = ProjectiveTransform() if i == 0: transform.estimate( np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) else: transform.estimate( np.array( ((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) M[i] = transform.params.flatten()[:8] return M
def apply_projection_transform(self, Xb, batch_size, image_size): d = image_size * 0.3 * self.intensity for i in np.random.choice(batch_size, int(batch_size * self.p), replace=False): tl_top = random.uniform(-d, d) tl_left = random.uniform(-d, d) bl_bottom = random.uniform(-d, d) bl_left = random.uniform(-d, d) tr_top = random.uniform(-d, d) tr_right = random.uniform(-d, d) br_bottom = random.uniform(-d, d) br_right = random.uniform(-d, d) transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) Xb[i] = warp(Xb[i], transform, output_shape=(image_size, image_size), order=1, mode='edge') return Xb
def apply_projection_transform(X, intensity=0.75, depth=1): no_samples=X.shape[0] image_size=X.shape[1] no_channels=X.shape[3] d = image_size * 0.3 * intensity indices_project = np.random.choice( X.shape[0], math.ceil(X.shape[0]*depth*0.5), replace=False) X_=[] for i in indices_project: tl_top = uniform(-d, d) # Top left corner, top margin tl_left = uniform(-d, d) # Top left corner, left margin bl_bottom = uniform(-d, d) # Bottom left corner, bottom margin bl_left = uniform(-d, d) # Bottom left corner, left margin tr_top = uniform(-d, d) # Top right corner, top margin tr_right =uniform(-d, d) # Top right corner, right margin br_bottom =uniform(-d, d) # Bottom right corner, bottom margin br_right = uniform(-d, d) # Bottom right corner, right margin transform = ProjectiveTransform() transform.estimate(np.array(( (tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top) )), np.array(( (0, 0), (0, image_size), (image_size, image_size), (image_size, 0) ))) X_.append(warp(X[i], transform, output_shape=(image_size, image_size), order = 1, mode = 'edge')) X_.append(warp(X[i], transform.inverse, output_shape=(image_size, image_size), order = 1, mode = 'edge')) return np.asarray(X_)
def apply_warp_augmentation_on_an_image(self, image): image_size = image.shape[0] #aff_tform = AffineTransform(scale=(1, 1/1.2), rotation=1, shear=0.7, translation=(210, 50)) aff_tform = AffineTransform(scale=(1, 1 / 1.2)) image = warp(image, aff_tform, output_shape=(image_size, image_size), order=1, mode='edge') x = image_size * 0.2 # top_right - x,y # bottom_left - x,y # top_right - x,y # bottom_right - x,y tl_x, tl_y, bl_x, bl_y, tr_x, tr_y, br_x, br_y = np.random.uniform( -x, x, size=8) src = np.array([[tl_y, tl_x], [bl_y, image_size - bl_x], [image_size - br_y, image_size - br_x], [image_size - tr_y, tr_x]]) dst = np.array([[0, 0], [0, image_size], [image_size, image_size], [image_size, 0]]) proj_tform = ProjectiveTransform() proj_tform.estimate(src, dst) image = warp(image, proj_tform, output_shape=(image_size, image_size), order=1, mode='edge') return image
def apply_projection_transform(X, intensity): image_size = X.shape[1] d = image_size * 0.3 * intensity tl_top = random.uniform(-d, d) tl_left = random.uniform(-d, d) bl_bottom = random.uniform(-d, d) bl_left = random.uniform(-d, d) tr_top = random.uniform(-d, d) tr_right = random.uniform(-d, d) br_bottom = random.uniform(-d, d) br_right = random.uniform(-d, d) transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) X = warp(X, transform, output_shape=(image_size, image_size), order=1, mode='edge') return X
def projection_transform(image, max_warp=0.8, height=32, width=32): #Warp Location d = height * 0.3 * np.random.uniform(0, max_warp) #Warp co-ordinates tl_top = np.random.uniform(-d, d) # Top left corner, top margin tl_left = np.random.uniform(-d, d) # Top left corner, left margin bl_bottom = np.random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = np.random.uniform(-d, d) # Bottom left corner, left margin tr_top = np.random.uniform(-d, d) # Top right corner, top margin tr_right = np.random.uniform(-d, d) # Top right corner, right margin br_bottom = np.random.uniform(-d, d) # Bottom right corner, bottom margin br_right = np.random.uniform(-d, d) # Bottom right corner, right margin ##Apply Projection transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, height - bl_bottom), (height - br_right, height - br_bottom), (height - tr_right, tr_top))), np.array(((0, 0), (0, height), (height, height), (height, 0)))) output_image = warp(image, transform, output_shape=(height, width), order=1, mode='edge') return output_image
def coord(contours, r, g, b, box_img): t = ProjectiveTransform() # Initiate Projective Transform # Use the Image and World Reference Points to Generate Source and Destination NumPy arrays for the transform src = np.asarray([i_bl, i_tl, i_tr, i_br]) dst = np.asarray([w_bl, w_tl, w_tr, w_br]) t.estimate(src, dst) # Prepare the transform model i_nos = 0 # Count number of objects of the color objects = [] # Start with an empty array for image coordinates for k_coord in contours: # Check each contour for a valid object y_k, x_k, w_k, h_k = cv2.boundingRect(k_coord) # Bound the individual contour with a rectangle if w_k > 40 and h_k > 40: # Only select objects bigger than a threshold - to filter out disturbances cv2.rectangle(box_img, (y_k, x_k), (y_k + w_k, x_k + h_k), (b, g, r), 2) # Draw a box on the image - to be subsequently printed on screen objects.append([x_k + h_k / 2, y_k + w_k / 2]) # Add the object to the array (image coordinates) i_nos += 1 # Increase the count of number of objects if i_nos == 0: # If there are no valid objects in the image world = [] # return empty array for world coordinates else: # If there are valid objects in the image world = t( objects ) # Carry out Projective Transform to populate the world coordinates array return i_nos, objects, world # return the no. of objects, image coordinates and world coordinates
def randomPerspective(im): ''' wrapper of Projective (or perspective) transform, from 4 random points selected from 4 corners of the image within a defined region. ''' region = 1 / 4 A = pl.array([[0, 0], [0, im.shape[0]], [im.shape[1], im.shape[0]], [im.shape[1], 0]]) B = pl.array([ [ int(randRange(0, im.shape[1] * region)), int(randRange(0, im.shape[0] * region)) ], [ int(randRange(0, im.shape[1] * region)), int(randRange(im.shape[0] * (1 - region), im.shape[0])) ], [ int(randRange(im.shape[1] * (1 - region), im.shape[1])), int(randRange(im.shape[0] * (1 - region), im.shape[0])) ], [ int(randRange(im.shape[1] * (1 - region), im.shape[1])), int(randRange(0, im.shape[0] * region)) ], ]) pt = ProjectiveTransform() pt.estimate(A, B) return warp(im, pt, output_shape=im.shape[:2])
def random_transform(cls, img): image_size = img.shape[0] d = image_size * 0.2 tl_top, tl_left, bl_bottom, bl_left, tr_top, tr_right, br_bottom, br_right = np.random.uniform( -d, d, size=8) # Bottom right corner, right margin aft = AffineTransform(scale=(1, 1 / 1.2)) img = warp(img, aft, output_shape=(image_size, image_size), order=1, mode='edge') transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) img = warp(img, transform, output_shape=(image_size, image_size), order=1, mode='edge') return img
def get_sprites(image, ctrs, debug=False): """ This function computes a projective transform from the source (mnist image) to the destination (contour) and extracts the warped sprite. """ # We make sure that we work on a local copy of the image img = image.copy() # We loop through the sprites sprts = [] for contour in ctrs: # We compute the projective transform source_points = np.array([[28, 28], [0, 28], [0, 0], [28, 0]]) destination_points = np.array(contour) transform = ProjectiveTransform() transform.estimate(source_points, destination_points) # We transform the image warped = warp(img, transform, output_shape=(28, 28)) if debug: _, axis = plt.subplots(nrows=2, figsize=(8, 3)) axis[0].imshow(img, cmap='gray') axis[0].plot(destination_points[:, 0], destination_points[:, 1], '.r') axis[0].set_axis_off() axis[1].imshow(warped, cmap='gray') axis[0].set_axis_off() plt.tight_layout() plt.show() sprts.append(warped) return sprts
def apply_projection_transform_(X, intensity): image_size = X.shape[1] d = image_size * 0.3 * intensity for i in range(X.shape[0]): tl_top = random.uniform(-d, d) # Top left corner, top margin tl_left = random.uniform(-d, d) # Top left corner, left margin bl_bottom = random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = random.uniform(-d, d) # Bottom left corner, left margin tr_top = random.uniform(-d, d) # Top right corner, top margin tr_right = random.uniform(-d, d) # Top right corner, right margin br_bottom = random.uniform(-d, d) # Bottom right corner, bottom margin br_right = random.uniform(-d, d) # Bottom right corner, right margin transform = ProjectiveTransform() transform.estimate(np.array(( (tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top) )), np.array(( (0, 0), (0, image_size), (image_size, image_size), (image_size, 0) ))) X[i] = warp(X[i], transform, output_shape=(image_size, image_size), order = 1, mode = 'edge') return X
def normalize_image(image, image_colored, rescale_param=0.5): image = image.copy() image_colored = image_colored.copy() image_scaled = rescale(image, rescale_param) edges = canny(image_scaled) selem = disk(1) edges = dilation(edges, selem) edges = (edges).astype(np.uint8) img, ext_contours, hierarchy = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) contour = max(ext_contours, key=cv2.contourArea) contour = contour.squeeze() epsilon = 0.05 * cv2.arcLength(contour, True) corners = cv2.approxPolyDP(contour, epsilon, True).squeeze() corners = (perspective.order_points(corners)) corners = corners / rescale_param size_square = min(image_scaled.shape) tform = ProjectiveTransform() tform.estimate(np.array([[0, 0], [1020, 0], [1020, 720], [0, 720]]), corners) image_warped = warp(image_colored, tform)[:720, :1020] img = img_as_ubyte(image_warped) img = adjusting_brightness(img[30:-5, 15:-15], a=1.7, b=2) return img, tform
def apply_projection_transform(Xb, batch_size, image_size): """ Applies projection transform to a random subset of images. Projection margins are randomised in a range depending on the size of the image. Range itself is subject to scaling depending on augmentation intensity. """ d = image_size * 0.3 * intensity for i in np.random.choice(batch_size, int(batch_size * p), replace = False): tl_top = random.uniform(-d, d) # Top left corner, top margin tl_left = random.uniform(-d, d) # Top left corner, left margin bl_bottom = random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = random.uniform(-d, d) # Bottom left corner, left margin tr_top = random.uniform(-d, d) # Top right corner, top margin tr_right = random.uniform(-d, d) # Top right corner, right margin br_bottom = random.uniform(-d, d) # Bottom right corner, bottom margin br_right = random.uniform(-d, d) # Bottom right corner, right margin transform = ProjectiveTransform() transform.estimate(np.array(( (tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top) )), np.array(( (0, 0), (0, image_size), (image_size, image_size), (image_size, 0) ))) Xb[i] = warp(Xb[i], transform, output_shape=(image_size, image_size), order = 1, mode = 'edge') return Xb
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 robustEstimate(ptsA, ptsB): """ Perform robust estimation on the given correspondences using RANSAC. Args: ---- ptsA: A 2 x N matrix of points. ptsB: A 2 x N matrix of points. Returns: ------- The number of inliers within the points. """ src, dst, N = [], [], ptsA.shape[1] for i in xrange(N): src.append((ptsA[0, i], ptsA[1, i])) dst.append((ptsB[0, i], ptsB[1, i])) src, dst = np.asarray(src), np.asarray(dst) model = ProjectiveTransform() model.estimate(src, dst) model_robust, inliers = ransac((src, dst), ProjectiveTransform, min_samples=3, residual_threshold=2, max_trials=100) return inliers
def projection_transform(self, x): image_size = x.shape[1] change = image_size * 0.3 * self.intensity x_return = np.empty(x.shape, dtype=x.dtype) indices = np.random.choice(x.shape[0], int(x.shape[0] * self.ratio), replace=False) for i in indices: changes = [] for _ in range(8): changes.append(random.uniform(-change, change)) transform = ProjectiveTransform() transform.estimate(np.array( ( (changes[0], changes[1]), # top left (changes[2], image_size - changes[3]), # bottom left (image_size - changes[4], changes[5]), # top right (image_size - changes[6], image_size - changes[7]) # bottom right )), np.array( ( (0, 0), (0, image_size), (image_size, 0), (image_size, image_size) )) ) x_return[i] = warp(x[i], transform, output_shape=(image_size, image_size), order=1, mode="edge") return x_return
def source_to_projection(src: List, verbose: bool = False): # for point in src: # print(round(point[0],3), round(point[1], 3)) src = np.asarray(src) # bottom_left, top_left, top_right, bottom_right dst = np.asarray([[0, 0], [0, 1], [1, 1], [1, 0]]) pt = ProjectiveTransform() pt.estimate(src, dst) return pt
def projection(self, tile: HipsTile) -> ProjectiveTransform: """Estimate projective transformation on a HiPS tile.""" corners = tile.meta.skycoord_corners.to_pixel(self.geometry.wcs) src = np.array(corners).T.reshape((4, 2)) dst = tile_corner_pixel_coordinates(tile.meta.width) pt = ProjectiveTransform() pt.estimate(src, dst) return pt
def _make_transform_to_crop(self, points, center_points): dst_points = self._get_points_to_transform(points, center_points) src_points = array([ (0, 0), (0, self.HEIGHT), (self.WIDTH, self.HEIGHT), (self.WIDTH, 0), ]) tform = ProjectiveTransform() tform.estimate(src_points, dst_points) return tform
def correct_warping(self): self.warpcorrected_keypoints = [] coordinates = np.array(self.coordinates[:4]) target_coordinates = np.asarray([[0, 0], [0, 1], [1, 1], [1, 0]]) t = ProjectiveTransform() t.estimate(coordinates,target_coordinates) for frame_count, keypoint_t in enumerate(self.keypoints): if np.size(keypoint_t) != 0: corrected_kp_t = t(keypoint_t[:,:2]) self.warpcorrected_keypoints.append(corrected_kp_t) else: self.warpcorrected_keypoints.append(np.array([])) return self.warpcorrected_keypoints
def test_projective_estimation(): # exact solution tform = estimate_transform('projective', SRC[:4, :], DST[:4, :]) assert_array_almost_equal(tform(SRC[:4, :]), DST[:4, :]) # over-determined tform2 = estimate_transform('projective', SRC, DST) assert_array_almost_equal(tform2.inverse(tform2(SRC)), SRC) # via estimate method tform3 = ProjectiveTransform() tform3.estimate(SRC, DST) assert_array_almost_equal(tform3._matrix, tform2._matrix)
def transform_img(x, y, path, cla): """ Projective transform of all images in a class """ #Scale as in LeCun scaler = MinMaxScaler(feature_range=(-0.1, 1.175)) all_img = os.listdir(path) #List structure so I can .append aux = x.tolist() for img in all_img: if int(img[0:2]) == cla: image_path = path + '/' + img #prepare parameters for randomization intensity = 0.75 image_read = cv2.imread(image_path, 0) #read in greyscale resize = cv2.resize(image_read, (32, 32), interpolation=cv2.INTER_CUBIC) image_shape = resize.shape image_size = image_shape[0] d = image_size * 0.3 * intensity #With these 8 parameters we can perform a transofrmation of the image in such a way #that the image is different enough from the original but not too different, since #we should be able to still recognize the class in the transformed image. tl_top = random.uniform(-d, d) # Top left corner, top margin tl_left = random.uniform(-d, d) # Top left corner, left margin bl_bottom = random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = random.uniform(-d, d) # Bottom left corner, left margin tr_top = random.uniform(-d, d) # Top right corner, top margin tr_right = random.uniform(-d, d) # Top right corner, right margin br_bottom = random.uniform(-d, d) # Bottom right corner, bottom margin br_right = random.uniform(-d, d) # Bottom right corner, right margin transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) warped = warp(image_read, transform, output_shape=(image_size, image_size), order=1, mode='edge') X_new = scaler.fit_transform(warped) warped = np.reshape(X_new, (32, 32, 1)) aux.append(warped) y.append(cla) return np.array(aux), y
def randomPerspective(im,mask): region = 1/4 A = pl.array([[0, 0], [0, im.shape[0]], [im.shape[1], im.shape[0]], [im.shape[1], 0]]) B = pl.array([[int(randRange(0, im.shape[1] * region)), int(randRange(0, im.shape[0] * region))], [int(randRange(0, im.shape[1] * region)), int(randRange(im.shape[0] * (1-region), im.shape[0]))], [int(randRange(im.shape[1] * (1-region), im.shape[1])), int(randRange(im.shape[0] * (1-region), im.shape[0]))], [int(randRange(im.shape[1] * (1-region), im.shape[1])), int(randRange(0, im.shape[0] * region))], ]) pt = ProjectiveTransform() pt.estimate(A, B) return warp(im, pt, output_shape=im.shape[:2]), warp(mask, pt, output_shape=im.shape[:2])
def projective_transform(image, original_corners, final_corners): ''' Correct perspective warping ''' original_corners = np.array(original_corners) final_corners = np.array(final_corners) w = np.max(final_corners[:, 0]) h = np.max(final_corners[:, 1]) tform = ProjectiveTransform() tform.estimate(final_corners, original_corners) warped = warp(image, tform, output_shape=(h, w)) return warped
def prep_image(self): """Takes the solved coordinate system and makes a piecewise \ transform on the origin image to the target image""" transform = ProjectiveTransform() self.coord_solver.coordinates = self.coord_solver.min_coords.copy() self.new_image = np.zeros(self.coord_solver.image.shape) coords = np.array([self.coord_solver.coordinates[x:x+2, y:y+2, :].reshape([4, 2]) for x in \ range(self.coord_solver.coordinates.shape[0]) for y in range(self.coord_solver.coordinates.shape[1]) \ if (self.coord_solver.coordinates[x:x+2, y:y+2, :].shape == (2, 2, 2))]) canonical_coords = np.indices((self.coord_solver.width, self.coord_solver.height)).T.astype('float32') flattened_canonical = np.array([canonical_coords[x:x+2, y:y+2, :].reshape([4, 2]) for x in \ range(canonical_coords.shape[0]-1) for y in range(canonical_coords.shape[1]-1)]) mesh_size = self.coord_solver.mesh_factor print "needs %s calcs" % coords.shape[0] for k in range(coords.shape[0]): src = mesh_size*coords[k, :, :] canon_coord = mesh_size*flattened_canonical[k, :, :] des = mesh_size*flattened_canonical[k, :, :] if not transform.estimate(src, des): raise Exception("estimate failed at %s" % str(k)) area_in_question_x = canon_coord[0, 0].astype(int) area_in_question_y = canon_coord[0, 1].astype(int) scaled_area = tf.warp(self.coord_solver.image, transform) self.new_image[area_in_question_y:area_in_question_y+mesh_size, \ area_in_question_x:area_in_question_x+mesh_size] += scaled_area[area_in_question_y:\ area_in_question_y+mesh_size, area_in_question_x:area_in_question_x+mesh_size]
def prep_image(self): """Takes the solved coordinate system and makes a piecewise \ transform on the origin image to the target image""" transform = ProjectiveTransform() self.coord_solver.coordinates = self.coord_solver.min_coords.copy() self.new_image = np.zeros(self.coord_solver.image.shape) coords = np.array([self.coord_solver.coordinates[x:x+2, y:y+2, :].reshape([4, 2]) for x in \ range(self.coord_solver.coordinates.shape[0]) for y in range(self.coord_solver.coordinates.shape[1]) \ if (self.coord_solver.coordinates[x:x+2, y:y+2, :].shape == (2, 2, 2))]) canonical_coords = np.indices((self.coord_solver.width, self.coord_solver.height)).T.astype('float32') flattened_canonical = np.array([canonical_coords[x:x+2, y:y+2, :].reshape([4, 2]) for x in \ range(canonical_coords.shape[0]-1) for y in range(canonical_coords.shape[1]-1)]) mesh_size = self.coord_solver.mesh_factor print "needs %s calcs" % coords.shape[0] coord_grid = np.indices(self.coord_solver.image.shape[:-1]).T.astype('float32').reshape(-1,2) for k in range(coords.shape[0]): des = mesh_size*coords[k, :, :] canon_coord = mesh_size*flattened_canonical[k, :, :] src = mesh_size*flattened_canonical[0, :, :] if not transform.estimate(des, canon_coord): raise Exception("estimate failed at %s" % str(k)) area_in_question_x = canon_coord[0, 0].astype(int) area_in_question_y = canon_coord[0, 1].astype(int) scaled_area = tf.warp(self.coord_solver.image, transform) area_path = path.Path([des[0],des[1],des[3],des[2],des[0]]) points_in_area = area_path.contains_points(coord_grid,radius=0.00001).reshape(self.coord_solver.image.shape[:-1]) self.new_image += scaled_area*points_in_area[:,:,np.newaxis]
def normalize_slice_projection(slice_pixel_array, crop_bounds, desired_width, desired_height): result = np.zeros((desired_height, desired_width)) #Crop bounds must be converted from (x, y) points to (y, x) points source_bounds = np.asarray([[0, 0], [0, desired_width], [desired_height, desired_width], [desired_height, 0]]) destination_bounds = np.asarray([[crop_bounds[0][1], crop_bounds[0][0]], [crop_bounds[1][1], crop_bounds[1][0]], [crop_bounds[2][1], crop_bounds[2][0]], [crop_bounds[3][1], crop_bounds[3][0]]]) projective_transform = ProjectiveTransform() if not projective_transform.estimate(source_bounds, destination_bounds): print("Cannot project from crop bounds to desired image dimensions") else: for x in range(0, desired_width): for y in range(0, desired_height): normalized_point = [y, x] transform = projective_transform(normalized_point) slice_point = transform[0] value = MathUtil.sample_image_bilinear(slice_pixel_array, slice_point[1], slice_point[0]) result[y][x] = value return result
def preprocess_image(im): im = resize_im(im, MAX_SIDE_LENGTH) gray = rgb2gray(im) # Get the edges of the receipt top_line, right_line, bottom_line, left_line = get_receipt_edges(gray) # Intersect to get corners TR = line_intersection(top_line, right_line) TL = line_intersection(top_line, left_line) BR = line_intersection(bottom_line, right_line) BL = line_intersection(bottom_line, left_line) # Warp so receipt corners are image corners transform = ProjectiveTransform() height = max([BL[1] - TL[1], BR[1] - TR[1]]) width = max([TR[0] - TL[0], BR[1] - BL[1]]) src_pts = np.array([TL, TR, BL, BR]) dest_pts = np.array([[0, 0], [width, 0], [0, height], [width, height]]) success = transform.estimate(src_pts, dest_pts) warped_im = warp(gray, transform.inverse)[:int(height), :int(width)] warped_gray = rgb2gray(warped_im) enhanced_gray = img_as_ubyte(adjust_log(warped_gray)) return enhanced_gray
def increase_data(images, nb_int, labels=None): image_size = images[0].shape[0] data_size = images.shape[0] for i in range(data_size): for j in range(nb_int): delta = random.uniform(-20, 20) # scale using augmentation intensity d = random.uniform(-10, 10) tl_top = random.uniform(-d, d) # Top left corner, top margin tl_left = random.uniform(-d, d) # Top left corner, left margin bl_bottom = random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = random.uniform(-d, d) # Bottom left corner, left margin tr_top = random.uniform(-d, d) # Top right corner, top margin tr_right = random.uniform(-d, d) # Top right corner, right margin br_bottom = random.uniform(-d, d) # Bottom right corner, bottom margin br_right = random.uniform(-d, d) # Bottom right corner, right margin transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) images = np.append(images, [ warp(images[i], transform, output_shape=(32, 32), order=1, mode='edge') ], axis=0) images = np.append(images, [ rotate(images[i], random.uniform(-delta, delta), mode='edge') ], axis=0) if labels is None: pass else: #labels = np.append(labels,labels[i]) labels = np.append(labels, labels[i]) if i % 100 == 0: print(i / data_size * 100, '% de progression') return (images, labels)
def skew(self): #return 5 versions of the original image skewed in 5 different random ways, #http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.ProjectiveTransform outputDirectory=self.initializeDirectory("skewed") #prepare the output directory for (fileName,image) in zip(self.inputFilenames, self.inputImageList): (imageLength, imageWidth,_) = image.shape skewExtend = int(max(imageLength, imageWidth) * 0.20) #Will distord the image by max 20% of max length, width for nbNewImages in range(5): #generate 5 skewed images d = skewExtend #distorsion applied is proportionnal to the parameter #define the distortions to apply topLeftTopShift = random.uniform(-d, d) topLeftLeftShift = random.uniform(-d, d) bottomLeftBottomShift = random.uniform(-d, d) bottomLeftLeftShift = random.uniform(-d, d) topRightTopShift = random.uniform(-d, d) topRightRightShift = random.uniform(-d, d) bottomRightBottomShift = random.uniform(-d, d) bottomRightRightShift = random.uniform(-d, d) #enable the projective transform transform = ProjectiveTransform() #tear the image transform.estimate(np.array(( (topLeftLeftShift , topLeftTopShift), (bottomLeftLeftShift, imageWidth- bottomLeftBottomShift), (imageLength - bottomRightRightShift, imageWidth - bottomRightBottomShift), (imageLength- topRightRightShift, topRightTopShift))), np.array(( (0,0), (0, imageWidth), (imageLength, imageWidth), (imageLength,0))) ) #apply the skew skewed = warp(image, transform, mode='edge') skewed = skewed*255 outputFilename = os.path.join(outputDirectory,"skewed"+str(nbNewImages)+"_"+str(fileName)) cv2.imwrite (outputFilename, skewed) #store skewed image if self.DBG: numberImages= len(os.listdir(outputDirectory)) print("[DEBUG] : Saved {} images in {} ".format(numberImages, outputDirectory))
def make_homography(shifts, horizon_line, resolution): horizon_line = resolution * horizon_line left_top_dx, left_top_dy = shifts[0][0] right_top_dx, right_top_dy = shifts[0][1] left_hor_dx, left_hor_dy = shifts[1][0] right_hor_dx, right_hor_dy = shifts[1][1] points_src = np.array( [ [0, 0], # left top [resolution, 0], # right top [0, horizon_line], # left bottom [resolution, horizon_line] ], dtype='float32') # right bottom points_tgt = np.array( [ [left_top_dx, left_top_dy], # left top [resolution + right_top_dx, right_top_dy], # right top [left_hor_dx, horizon_line + left_hor_dy], # left bottom [resolution + right_hor_dx, horizon_line + right_hor_dy] ], dtype='float32') # right bottom sky_transform = ProjectiveTransform() sky_transform.estimate(points_src, points_tgt) points_src = np.array( [ [0, horizon_line], # left horizon [resolution, horizon_line], # right horizon [0, resolution], # left bottom [resolution, resolution] ], dtype='float32') # right bottom points_tgt = np.array( [ [left_hor_dx, horizon_line - left_hor_dy], # left horizon [resolution + right_hor_dx, horizon_line - right_hor_dy ], # right horizon [left_top_dx, resolution - left_top_dy], # left bottom [resolution + right_top_dx, resolution - right_top_dy] ], dtype='float32') # right bottom earth_transform = ProjectiveTransform() earth_transform.estimate(points_src, points_tgt) return sky_transform, earth_transform
def perspective_warp(img, grid_corners): top_left, top_right, bottom_left, bottom_right = grid_corners 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.flip(grid_corners, 1) # Flip x and y axes dst = np.array([[0, 0], [L-1, 0], [0, L-1], [L-1, L-1]]) tf = ProjectiveTransform() tf.estimate(dst, src) warped_img = warp(img, tf, output_shape=(L, L)) return warped_img
def apply_projection_transform_extended(X, y, intensity, labels): X_extended = np.empty([0, X.shape[1], X.shape[2], X.shape[3]], dtype=X.dtype) y_extended = np.empty([0], dtype=y.dtype) image_size = X.shape[1] d = image_size * 0.3 * intensity for c in labels: X_temp = np.empty([0, X.shape[1], X.shape[2], X.shape[3]], dtype=X.dtype) X_temp = np.append(X_temp, X[y == c], axis=0) for i in range(X_temp.shape[0]): tl_top = random.uniform(-d, d) # Top left corner, top margin tl_left = random.uniform(-d, d) # Top left corner, left margin bl_bottom = random.uniform(-d, d) # Bottom left corner, bottom margin bl_left = random.uniform(-d, d) # Bottom left corner, left margin tr_top = random.uniform(-d, d) # Top right corner, top margin tr_right = random.uniform(-d, d) # Top right corner, right margin br_bottom = random.uniform(-d, d) # Bottom right corner, bottom margin br_right = random.uniform(-d, d) # Bottom right corner, right margin #http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.ProjectiveTransform transform = ProjectiveTransform() transform.estimate( np.array(((tl_left, tl_top), (bl_left, image_size - bl_bottom), (image_size - br_right, image_size - br_bottom), (image_size - tr_right, tr_top))), np.array(((0, 0), (0, image_size), (image_size, image_size), (image_size, 0)))) X_temp[i] = warp(X_temp[i], transform, output_shape=(image_size, image_size), order=1, mode='edge', preserve_range=True) X_extended = np.append(X_extended, X_temp, axis=0) y_extended = np.append( y_extended, np.full((X_extended.shape[0] - y_extended.shape[0]), c, dtype=int)) return X_extended, y_extended
class HomographyWidget(QtGui.QWidget): def __init__(self, parent=None): super(HomographyWidget, self).__init__(parent) self._initUI() # Initialize the UI def _initUI(self): # Widget parameters self.setMinimumWidth(300) # Create the figure self._fig = Figure() # Canvas configuration self._canvas = FigureCanvas(self._fig) self._canvas.setParent(self) self._canvas.mpl_connect('button_press_event', self._onPick) # Plot configuration self._plt = self._fig.add_subplot(111) self._plt.xaxis.set_visible(False) self._plt.yaxis.set_visible(False) # Finalize figure self._fig.subplots_adjust(wspace=0, hspace=0) # Reset the variables self.reset() # Create the layout vbox = QtGui.QVBoxLayout() # Add Canvas to the layout vbox.addWidget(self._canvas) # Set the layout self.setLayout(vbox) zp = ZoomPan() figZoom = zp.zoom_factory(self._plt) figPan = zp.pan_factory(self._plt) # Reset the variables to original state def reset(self): self._image = None self._render = None self._points = [] self._lastPoints = [] self._canvas.hide() # Set an image to the widget def setImage(self, image): self._image = image self._render = image self._canvas.show() self._redraw() # Get the image of the widget def getImage(self): pass def setHomography(self, points): # Save points self._lastPoints = points # Redraw canvas self._redraw() # Redraw the image and points def _redraw(self): # Clear the canvas self._plt.clear() if len(self._points) == 2 and len(self._lastPoints) == 4: # Get points src = self._pointsToVector(self._lastPoints) dest = self._pointsToVector(self._rectangle()) # Compute Transformation self._projective = ProjectiveTransform() self._projective.estimate(src, dest) # Prepare output image self._render = warp(self._image, self._projective.inverse) # Plot the image if self._render is not None: self._plt.autoscale(True) self._plt.imshow(self._render) self._plt.autoscale(False) # Plot the points if len(self._points) > 0: xs = [x for (x, _) in self._rectangle()] ys = [y for (_, y) in self._rectangle()] self._plt.plot(xs + [xs[0]], ys + [ys[0]], '-', color='green') xs = [x for (x, _) in self._points] ys = [y for (_, y) in self._points] self._plt.plot(xs + [xs[0]], ys + [ys[0]], 'o', color='blue') # Draw the canvas self._canvas.draw() # Handle click events def _onPick(self, event): if event.button == 3: self._redraw() elif event.button != 1: return # Get point position x = event.xdata y = event.ydata if x is None or y is None: return # For each existing points for px, py in self._points: # Compute distance to current point dst = np.sqrt((px - x) ** 2 + (py - y) ** 2) # If the distance is small remove it if dst < 10: self._removePoint(px, py) self._redraw() return # Delegate to add the point self._addPoint(x, y) # Redraw the image self._redraw() # Add a new point def _addPoint(self, x, y): # Count points n = len(self._points) # If less than 3 points just add it if n < 2: self._points.append((x, y)) return # Remove an existing point def _removePoint(self, x, y): # Remove the point self._points = list(filter(lambda v: v != (x, y), self._points)) def _rectangle(self): # Get xs and ys xs = [x for (x, _) in self._points] ys = [y for (_, y) in self._points] # Compute ranges xmax = max(xs) xmin = min(xs) ymax = max(ys) ymin = min(ys) # Return rectangle return [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)] def _pointsToVector(self, points): # Get points values x1, y1 = points[0] x2, y2 = points[1] x3, y3 = points[2] x4, y4 = points[3] # Return the vector return np.array([[x1, y1], [x2, y2], [x3, y3], [x4, y4]])