def set_canvas_background(self, image): if self.background_label is None: # initialize background image label (first call) #img = self.current_state.screenshot_rs #bg_img_tk = numpy_to_tk_image(np.zeros(img.shape)) img_heatmap = self._generate_heatmap() img_heatmap_rs = ia.imresize_single_image( img_heatmap, (img_heatmap.shape[0] * self.zoom_factor, img_heatmap.shape[1] * self.zoom_factor), interpolation="nearest") bg_img_tk = numpy_to_tk_image(img_heatmap_rs) self.background_label = Tkinter.Label(self.canvas, image=bg_img_tk) self.background_label.place(x=0, y=0, relwidth=1, relheight=1, anchor=Tkinter.NW) self.background_label.image = bg_img_tk #print("image size", image.shape) #print("image height, width", image.to_array().shape) image_rs = ia.imresize_single_image( image, (image.shape[0] * self.zoom_factor, image.shape[1] * self.zoom_factor), interpolation="nearest") image_tk = numpy_to_tk_image(image_rs) self.background_label.configure(image=image_tk) self.background_label.image = image_tk
def draw_frame_grids(self, scr, grids): grids_meta = [(0, "street boundaries"), (3, "crashables (except cars)"), (7, "street markings"), (4, "current lane"), (1, "cars"), (2, "cars in mirrors")] titles = [title for idx, title in grids_meta] grids = to_numpy(grids[0]) grids = [grids[idx] for idx, title in grids_meta] #self.grid_to_graph(scr, grids[0]) bgcolor = [0, 0, 0] image = np.zeros((720, 1280, 3), dtype=np.uint8) + bgcolor scr_main = ia.imresize_single_image( scr, (int(720 * 0.58), int(1280 * 0.58))) #util.draw_image(image, y=720-scr_main.shape[0], x=1080-scr_main.shape[1], other_img=scr_main, copy=False) util.draw_image(image, y=int((image.shape[0] - scr_main.shape[0]) / 2), x=1280 - scr_main.shape[1] - 2, other_img=scr_main, copy=False) image = util.draw_text( image, x=1280 - (scr_main.shape[1] // 2) - 125, y=image.shape[0] - int( (image.shape[0] - scr_main.shape[0]) / 2) + 10, text="Framerate matches the one that the model sees (10fps).", size=10, color=[128, 128, 128]) grid_rel_size = 0.19 scr_small = ia.imresize_single_image( scr, (int(720 * grid_rel_size), int(1280 * grid_rel_size))) grid_hms = [] for grid, title in zip(grids, titles): grid = (grid * 255).astype(np.uint8)[:, :, np.newaxis] grid = ia.imresize_single_image( grid, (int(720 * grid_rel_size), int(1280 * grid_rel_size)), interpolation="nearest") grid_hm = util.draw_heatmap_overlay(scr_small, grid / 255) grid_hm = np.pad(grid_hm, ((2, 0), (2, 2), (0, 0)), mode="constant", constant_values=np.average(bgcolor)) #grid_hm = np.pad(grid_hm, ((0, 20), (0, 0), (0, 0)), mode="constant", constant_values=0) #grid_hm[-20:, 2:-2, :] = [128, 128, 255] #grid_hm = util.draw_text(grid_hm, x=4, y=grid_hm.shape[0]-16, text=title, size=10, color=[255, 255, 255]) grid_hm = np.pad(grid_hm, ((40, 0), (0, 0), (0, 0)), mode="constant", constant_values=0) grid_hm = util.draw_text(grid_hm, x=4, y=20, text=title, size=12, color=[255, 255, 255]) grid_hms.append(grid_hm) grid_hms = ia.draw_grid(grid_hms, cols=2) util.draw_image(image, y=70, x=0, other_img=grid_hms, copy=False) return image
def screens_show_same_scene(scr1, scr2): scr1 = ia.imresize_single_image(scr1, (50, 70)) scr2 = ia.imresize_single_image(scr2, (50, 70)) hist1 = cv2.calcHist([scr1[..., 0], scr1[..., 1], scr1[..., 2]], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) hist2 = cv2.calcHist([scr2[..., 0], scr2[..., 1], scr2[..., 2]], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256]) diff = np.sum(np.abs(hist1 - hist2)) return diff <= MAX_PIXELDIFF
def downscale(im, h, w): """Downscale one or more images to size (h, w).""" if isinstance(im, list): return [downscale(i, h, w) for i in im] else: if im.ndim == 2: im = im[:, :, np.newaxis] im_rs = ia.imresize_single_image(im, (h, w), interpolation="cubic") return np.squeeze(im) else: return ia.imresize_single_image(im, (h, w), interpolation="cubic")
def do_augmentation(seqs, seq2_train, X_train, y_train): # Use seq_det to build augmentation. seq_det = seqs.to_deterministic() X_train_aug = seq2_train.augment_image(seq_det.augment_image(X_train)) y_train_aug = seq_det.augment_image(y_train) if y_train_aug.shape != (101, 101): X_train_aug = ia.imresize_single_image(X_train_aug, (101, 101), interpolation="linear") y_train_aug = ia.imresize_single_image(y_train_aug, (101, 101), interpolation="nearest") return np.array(X_train_aug), np.array(y_train_aug)
def draw_on_image(self, image, random_state): flake_size_sample = self.flake_size.draw_sample(random_state) flake_size_uniformity_sample = self.flake_size_uniformity.draw_sample( random_state) angle_sample = self.angle.draw_sample(random_state) speed_sample = self.speed.draw_sample(random_state) blur_sigma_fraction_sample = self.blur_sigma_fraction.draw_sample( random_state) height, width = image.shape[0:2] downscale_factor = np.clip(1.0 - flake_size_sample, 0.001, 1.0) height_down = int(height*downscale_factor) width_down = int(width*downscale_factor) noise = self._generate_noise( height_down, width_down, self.density, ia.derive_random_state(random_state) ) # gate the sampled noise via noise in range [0.0, 1.0] # this leads to less flakes in some areas of the image and more in # other areas gate_noise = iap.Beta(1.0, 1.0 - self.density_uniformity) noise = self._gate(noise, gate_noise, self.gate_noise_size, ia.derive_random_state(random_state)) noise = ia.imresize_single_image(noise, (height, width), interpolation="cubic") # apply a bit of gaussian blur and then motion blur according to # angle and speed sigma = max(height, width) * blur_sigma_fraction_sample sigma = np.clip(sigma, self.blur_sigma_limits[0], self.blur_sigma_limits[1]) noise_small_blur = self._blur(noise, sigma) noise_small_blur = self._motion_blur(noise_small_blur, angle=angle_sample, speed=speed_sample, random_state=random_state) # use contrast adjustment of noise to make the flake size a bit less # uniform then readjust the noise values to make them more visible # again gain = 1.0 + 2*(1 - flake_size_uniformity_sample) gain_adj = 1.0 + 5*(1 - flake_size_uniformity_sample) noise_small_blur = contrast.GammaContrast(gain).augment_image( noise_small_blur) noise_small_blur = noise_small_blur.astype(np.float32) * gain_adj noise_small_blur_rgb = np.tile( noise_small_blur[..., np.newaxis], (1, 1, 3)) # blend: # sum for a bit of glowy, hardly visible flakes # max for the main flakes image_f32 = image.astype(np.float32) image_f32 = self._blend_by_sum( image_f32, (0.1 + 20*speed_sample) * noise_small_blur_rgb) image_f32 = self._blend_by_max( image_f32, (1.0 + 20*speed_sample) * noise_small_blur_rgb) return image_f32
def load_images(n_batches=10, sleep=0.0, draw_text=True): batch_size = 4 astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) kps = ia.KeypointsOnImage([ia.Keypoint(x=15, y=25)], shape=astronaut.shape) counter = 0 for i in range(n_batches): if draw_text: batch_images = [] batch_kps = [] for b in range(batch_size): astronaut_text = ia.draw_text(astronaut, x=0, y=0, text="%d" % (counter, ), color=[0, 255, 0], size=16) batch_images.append(astronaut_text) batch_kps.append(kps) counter += 1 batch = ia.Batch(images=np.array(batch_images, dtype=np.uint8), keypoints=batch_kps) else: if i == 0: batch_images = np.array( [np.copy(astronaut) for _ in range(batch_size)], dtype=np.uint8) batch = ia.Batch( images=np.copy(batch_images), keypoints=[kps.deepcopy() for _ in range(batch_size)]) yield batch if sleep > 0: time.sleep(sleep)
def find_bbs(img, model, conf_threshold, input_size): """Find bounding boxes in an image.""" # pad image so that its square img_pad, (pad_top, pad_right, pad_bottom, pad_left) = to_aspect_ratio_add(img, 1.0, return_paddings=True) # resize padded image to desired input size # "linear" interpolation seems to be enough here for 400x400 or larger images # change to "area" or "cubic" for marginally better quality img_rs = ia.imresize_single_image(img_pad, (input_size, input_size), interpolation="linear") # convert to torch-ready input variable inputs_np = (np.array([img_rs]) / 255.0).astype(np.float32).transpose( 0, 3, 1, 2) inputs = torch.from_numpy(inputs_np) inputs = Variable(inputs, volatile=True) if GPU >= 0: inputs = inputs.cuda(GPU) # apply model and measure the model's time time_start = time.time() outputs_pred = model(inputs) time_req = time.time() - time_start # process the model's output (i.e. convert heatmaps to BBs) result = ModelResult(outputs_pred, inputs_np, img, (pad_top, pad_right, pad_bottom, pad_left)) bbs = result.get_bbs() return bbs, time_req
def example_multicore_augmentation(): print("Example: Multicore Augmentation") import skimage.data import imgaug as ia import imgaug.augmenters as iaa from imgaug.augmentables.batches import UnnormalizedBatch # Number of batches and batch size for this example nb_batches = 10 batch_size = 32 # Example augmentation sequence to run in the background augseq = iaa.Sequential( [iaa.Fliplr(0.5), iaa.CoarseDropout(p=0.1, size_percent=0.1)]) # For simplicity, we use the same image here many times astronaut = skimage.data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) # Make batches out of the example image (here: 10 batches, each 32 times # the example image) batches = [] for _ in range(nb_batches): batches.append(UnnormalizedBatch(images=[astronaut] * batch_size)) # Show the augmented images. # Note that augment_batches() returns a generator. for images_aug in augseq.augment_batches(batches, background=True): ia.imshow(ia.draw_grid(images_aug.images_aug, cols=8))
def _augment_images(self, images, random_state, parents, hooks): result = [] nb_images = len(images) height, width = self.dim[1], self.dim[0] pad_cval = self.pad_cval for i in sm.xrange(nb_images): image = images[i] # Calculate letterbox parameters resize_w, resize_h, x_pad, y_pad = self._compute_height_width_pad( image.shape, height, width) # Resize image_rs = ia.imresize_single_image( image, (resize_h, resize_w), interpolation=self.interpolation) # Add paddings pad_left, pad_right = x_pad, width - resize_w - x_pad pad_top, pad_bottom = y_pad, height - resize_h - y_pad if image_rs.ndim == 2: pad_vals = ((pad_top, pad_bottom), (pad_left, pad_right)) else: pad_vals = ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)) image_cr_pa = np.pad(image_rs, pad_vals, mode="constant", constant_values=pad_cval) result.append(image_cr_pa) if not isinstance(images, list): all_same_size = (len(set([image.shape for image in result])) == 1) if all_same_size: result = np.array(result, dtype=np.uint8) return result
def load_batches(): # Here, load 10 batches of size 4 each. # You can also load an infinite amount of batches, if you don't train # in epochs. batch_size = 4 nb_batches = 10 # Here, for simplicity we just always use the same image. astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) for i in range(nb_batches): # A list containing all images of the batch. batch_images = [] # A list containing IDs per image. This is not necessary for the # background augmentation and here just used to showcase that you # can transfer additional information. batch_data = [] # Add some images to the batch. for b in range(batch_size): batch_images.append(astronaut) batch_data.append((i, b)) # Create the batch object to send to the background processes. batch = ia.Batch( images=np.array(batch_images, dtype=np.uint8), data=batch_data ) yield batch
def Resize(it): """ Resizes images according to the resize dimensions image: (array) Image resize: (tuple of integers) New dimensions target: (Dictionary) Containing BBox, Area, Labels and Index Returns normalized_image, target """ image, target = it resize = res new_target = target.copy() bbs = BoundingBoxesOnImage([ BoundingBox(x1=new_target['boxes'][0].item(), y1=new_target['boxes'][1].item(), x2=new_target['boxes'][2].item(), y2=new_target['boxes'][3].item()) ], image.shape) img = ia.imresize_single_image(np.array(image), resize) new_bbs = bbs.on(img) bbox = torch.tensor( [new_bbs[0].x1, new_bbs[0].y1, new_bbs[0].x2, new_bbs[0].y2]) new_target['area'] = torch.tensor([ (new_bbs[0].x2 - new_bbs[0].x1) * (new_bbs[0].y2 - new_bbs[0].y1) ]) new_target['boxes'] = bbox.unsqueeze(0) return img, [new_target]
def load_images(n_batches=10, sleep=0.0, draw_text=True): batch_size = 4 astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) kps = ia.KeypointsOnImage([ia.Keypoint(x=15, y=25)], shape=astronaut.shape) counter = 0 for i in range(n_batches): if draw_text: batch_images = [] batch_kps = [] for b in range(batch_size): astronaut_text = ia.draw_text(astronaut, x=0, y=0, text="%d" % (counter,), color=[0, 255, 0], size=16) batch_images.append(astronaut_text) batch_kps.append(kps) counter += 1 batch = ia.Batch( images=np.array(batch_images, dtype=np.uint8), keypoints=batch_kps ) else: if i == 0: batch_images = np.array([np.copy(astronaut) for _ in range(batch_size)], dtype=np.uint8) batch = ia.Batch( images=np.copy(batch_images), keypoints=[kps.deepcopy() for _ in range(batch_size)] ) yield batch if sleep > 0: time.sleep(sleep)
def chapter_examples_bounding_boxes_projection(): import imgaug as ia from imgaug.augmentables.bbs import BoundingBox, BoundingBoxesOnImage ia.seed(1) # Define image with two bounding boxes image = ia.quokka(size=(256, 256)) bbs = BoundingBoxesOnImage([ BoundingBox(x1=25, x2=75, y1=25, y2=75), BoundingBox(x1=100, x2=150, y1=25, y2=75) ], shape=image.shape) # Rescale image and bounding boxes image_rescaled = ia.imresize_single_image(image, (512, 512)) bbs_rescaled = bbs.on(image_rescaled) # Draw image before/after rescaling and with rescaled bounding boxes image_bbs = bbs.draw_on_image(image, size=2) image_rescaled_bbs = bbs_rescaled.draw_on_image(image_rescaled, size=2) # ------------ save("examples_bounding_boxes", "projection.jpg", grid([image_bbs, image_rescaled_bbs], cols=2, rows=1), quality=90)
def example_background_augment_batches(): print("Example: Background Augmentation via augment_batches()") import imgaug as ia from imgaug import augmenters as iaa import numpy as np from skimage import data # Number of batches and batch size for this example nb_batches = 10 batch_size = 32 # Example augmentation sequence to run in the background augseq = iaa.Sequential( [iaa.Fliplr(0.5), iaa.CoarseDropout(p=0.1, size_percent=0.1)]) # For simplicity, we use the same image here many times astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) # Make batches out of the example image (here: 10 batches, each 32 times # the example image) batches = [] for _ in range(nb_batches): batches.append( np.array([astronaut for _ in range(batch_size)], dtype=np.uint8)) # Show the augmented images. # Note that augment_batches() returns a generator. for images_aug in augseq.augment_batches(batches, background=True): ia.imshow(ia.draw_grid(images_aug, cols=8))
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (64, 64)) print("image shape:", image.shape) print("Press any key or wait %d ms to proceed to the next image." % (TIME_PER_STEP, )) k = [1, 3, 5, 7, (3, 3), (1, 11)] cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.resizeWindow("aug", 64 * NB_AUGS_PER_IMAGE, 64) #cv2.imshow("aug", image[..., ::-1]) #cv2.waitKey(TIME_PER_STEP) for ki in k: aug = iaa.MedianBlur(k=ki) img_aug = [aug.augment_image(image) for _ in range(NB_AUGS_PER_IMAGE)] img_aug = np.hstack(img_aug) print("dtype", img_aug.dtype, "averages", np.average(img_aug, axis=tuple(range(0, img_aug.ndim - 1)))) #print("dtype", img_aug.dtype, "averages", img_aug.mean(axis=range(1, img_aug.ndim))) title = "k=%s" % (str(ki), ) img_aug = ia.draw_text(img_aug, x=5, y=5, text=title) cv2.imshow("aug", img_aug[..., ::-1]) # here with rgb2bgr cv2.waitKey(TIME_PER_STEP)
def __getitem__(self, index): """Get the corresponding image and label # Arguments index [int]: the index of the file in the dataset # Returns [FloatTensor]: image of shape CxHxW [int]: the object class """ filename = self.label[0][index] filepath = os.path.join(self.image_folder, filename) # load and transform image image = cv2.imread(filepath) if self.phase != 'test': image = augmenter.augment_image(image) image = ia.imresize_single_image(image, self.shape) image = image / 255 image = (image - self.mean) / self.std image = image.transpose(2, 0, 1) image = torch.FloatTensor(image) # load label object_class = self.label[1][index].item() - 1 return image, object_class
def _resize(self, image, bbs): image_rescaled = ia.imresize_single_image(image, sizes=(self.image_size, self.image_size)) bbs_rescaled = bbs.on(image_rescaled) return image_rescaled, bbs_rescaled.remove_out_of_image( ).clip_out_of_image()
def downscale_image(steering_wheel_image): """Downscale an image to the model's input sizes (height, width).""" return ia.imresize_single_image( steering_wheel_image, (MODEL_HEIGHT, MODEL_WIDTH), interpolation="linear" )
def test_use_size_arg_to_keep_at_same_size(self): # same example, keeps size at 3x3 via None and (int)3 or (float)1.0 size_args = [ None, (None, None), (3, None), (None, 3), (1.0, None), (None, 1.0) ] col0 = self.col(0) col1 = self.col(1) expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) expected = ia.imresize_single_image(expected, (3, 3), interpolation="nearest") for size_arg in size_args: with self.subTest(size=size_arg): observed = self.segmap.draw(size=size_arg) assert isinstance(observed, list) assert len(observed) == 1 assert np.array_equal(observed[0], expected)
def test_resize_image_to_segmentation_map(self): # resizing of image to segmap arr = np.int32([[0, 1, 1], [0, 1, 1], [0, 1, 1]]) segmap = ia.SegmentationMapsOnImage(arr, shape=(1, 3)) image = np.uint8([[0, 10, 20]]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) image_rs = ia.imresize_single_image(image, arr.shape[0:2], interpolation="cubic") a1 = 0.7 a0 = 1.0 - a1 observed = segmap.draw_on_image(image, alpha=a1, draw_background=True, resize="image") col0 = self.col(0) col1 = self.col(1) expected = np.uint8([[col0, col1, col1], [col0, col1, col1], [col0, col1, col1]]) expected = a0 * image_rs + a1 * expected d_max = np.max( np.abs(observed[0].astype(np.float32) - expected.astype(np.float32))) assert isinstance(observed, list) assert len(observed) == 1 assert observed[0].shape == expected.shape assert d_max <= 1.0 + 1e-4
def create_augimg(self, img, img_info): """ Create an augmented image and key points. Parameters img: as numpy array img_info: tuple with label and keypoints Return augmented image and keypoints """ label, points = img_info # print(points) kps_merge = [point for key_points in points for point in key_points] kps = KeypointsOnImage(kps_merge, shape=img.shape) # print(kps) if img.shape != self.dim: img = ia.imresize_single_image(img, self.dim[0:2]) kps = kps.on(img) # Augment keypoints and images. img_aug, kps_aug = seq(image=img, keypoints=kps) aug_points = [[kp.x, kp.y] for kp in kps_aug.keypoints] aug_points_dic = {'label': label, 'points': aug_points} return img_aug, aug_points_dic
def test_use_size_arg_to_resize_to_2x(self): # same example, with resizing to 2x the size double_size_args = [ (6, 6), (2.0, 2.0), 6, 2.0 ] col0 = self.col(0) col1 = self.col(1) expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) expected = ia.imresize_single_image(expected, (6, 6), interpolation="nearest") for double_size_arg in double_size_args: with self.subTest(size=double_size_arg): observed = self.segmap.draw(size=double_size_arg) assert isinstance(observed, list) assert len(observed) == 1 assert np.array_equal(observed[0], expected)
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (64, 64)) print("image shape:", image.shape) print("Press any key or wait %d ms to proceed to the next image." % (TIME_PER_STEP,)) k = [ 1, 3, 5, 7, (3, 3), (1, 11) ] cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.resizeWindow("aug", 64*NB_AUGS_PER_IMAGE, 64) for ki in k: aug = iaa.MedianBlur(k=ki) img_aug = [aug.augment_image(image) for _ in range(NB_AUGS_PER_IMAGE)] img_aug = np.hstack(img_aug) print("dtype", img_aug.dtype, "averages", np.average(img_aug, axis=tuple(range(0, img_aug.ndim-1)))) title = "k=%s" % (str(ki),) img_aug = ia.draw_text(img_aug, x=5, y=5, text=title) cv2.imshow("aug", img_aug[..., ::-1]) # here with rgb2bgr cv2.waitKey(TIME_PER_STEP)
def draw_heatmap_overlay(img, heatmap, alpha=0.5): #assert img.shape[0:2] == heatmap.shape[0:2] assert len(heatmap.shape) == 2 or (heatmap.ndim == 3 and heatmap.shape[2] == 1) assert img.dtype in [np.uint8, np.int32, np.int64] assert heatmap.dtype in [np.float32, np.float64] if heatmap.ndim == 3 and heatmap.shape[2] == 1: heatmap = np.squeeze(heatmap) if img.shape[0:2] != heatmap.shape[0:2]: heatmap_rs = np.clip(heatmap * 255, 0, 255).astype(np.uint8) heatmap_rs = ia.imresize_single_image(heatmap_rs[..., np.newaxis], img.shape[0:2], interpolation="nearest") heatmap = np.squeeze(heatmap_rs) / 255.0 cmap = plt.get_cmap('jet') heatmap_cmapped = cmap(heatmap) #img_heatmaps_cmapped = img_heatmaps_cmapped[:, :, 0:3] heatmap_cmapped = np.delete(heatmap_cmapped, 3, 2) #heatmap_cmapped = np.clip(heatmap_cmapped * 255, 0, 255).astype(np.uint8) heatmap_cmapped = heatmap_cmapped * 255 mix = (1 - alpha) * img + alpha * heatmap_cmapped mix = np.clip(mix, 0, 255).astype(np.uint8) return mix
def detect_cell(self, c: Candidate): """ Run detector on signle candidate and store results """ print('processing', c) center = c.coords + self.img_disp csz = c.cell_size * 3 ul_corner = center - csz dr_corner = center + csz if ul_corner[0] < 0 or ul_corner[1] < 0 or dr_corner[0] > self.img.shape[1] or dr_corner[1] > self.img.shape[0]: raise RuntimeError('Run out of bounds', ul_corner, dr_corner, self.img.shape) print(ul_corner, dr_corner) crop = self.img[int(round(ul_corner[1])):int(round(dr_corner[1])), int(round(ul_corner[0])):int(round(dr_corner[0])), :] cs = self.cell_detector.crop_size crop = ia.imresize_single_image(crop, sizes=(cs,cs)) with torch.no_grad(): inp = u.build_batch(crop).to(self.cell_detector.device) prediction = self.cell_detector.forward(inp) detection = Detection(idx=c.idx, prev_idx=c.prev_idx, zero=ul_corner - self.img_disp, crop_scales=(csz*2,csz*2), extractor=self.cell_detector.extract_data, prediction=prediction) if c.idx not in self.segment_map or self.segment_map[c.idx].confidence < detection.confidence: self.segment_map[c.idx] = detection dirs = self.guess_directions(detection) for i in range(4): conf = detection.nb_confidences[i] if conf > self.threshold: new_idx = (c.idx[0] + dirs[i][0], c.idx[1] + dirs[i][1]) cand = Candidate(idx=new_idx , prev_idx=c.idx, coords=detection.neighs[i], priority=conf, cell_size = detection.estim_cell_size()) heapq.heappush(self.front_pq, cand)
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (HEIGHT, WIDTH)) kps = [] for y in range(NB_ROWS): ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1)) for x in range(NB_COLS): xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1)) kp = (xcoord, ycoord) kps.append(kp) kps = set(kps) kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps] kps = ia.KeypointsOnImage(kps, shape=image.shape) bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2) bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape) seq = iaa.Affine(rotate=45) seq_det = seq.to_deterministic() image_aug = seq_det.augment_image(image) kps_aug = seq_det.augment_keypoints([kps])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] image_before = np.copy(image) image_before = kps.draw_on_image(image_before) image_before = bbs.draw_on_image(image_before) image_after = np.copy(image_aug) image_after = kps_aug.draw_on_image(image_after) image_after = bbs_aug.draw_on_image(image_after) ia.imshow(np.hstack([image_before, image_after])) imageio.imwrite("bb_aug.jpg", np.hstack([image_before, image_after]))
def background_process_augmentation_example_3(): # Number of batches and batch size for this example. nb_batches = 10 batch_size = 32 nb_epochs = 5 # Example augmentation sequence to run in the background. augseq = iaa.Sequential( [iaa.Fliplr(0.5), iaa.CoarseDropout(p=0.1, size_percent=0.1)]) # For simplicity, we use the same image here many times. astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) # Make batches out of the example image (here: 10 batches, each 32 times the example image). batches = [] for _ in range(nb_batches): batches.append( np.array([astronaut for _ in range(batch_size)], dtype=np.uint8)) for epoch in range(nb_epochs): # Note that augment_batches() returns a generator. for idx, images_aug in enumerate( augseq.augment_batches(batches, background=True)): # Show the augmented images. #ia.imshow(ia.draw_grid(images_aug, cols=8)) # Do something else with the batch here. print('Do something with batch ({}, {}).'.format(epoch, idx))
def load_batches(): # Here, load 10 batches of size 4 each. # You can also load an infinite amount of batches, if you don't train in epochs. batch_size = 4 nb_batches = 10 #1000000000 # Here, for simplicity we just always use the same image. astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) for i in range(nb_batches): # A list containing all images of the batch. batch_images = [] # A list containing IDs of images in the batch. This is not necessary # for the background augmentation and here just used to showcase that # you can transfer additional information. batch_data = [] # Add some images to the batch. for b in range(batch_size): batch_images.append(astronaut) batch_data.append((i, b)) # Create the batch object to send to the background processes. batch = ia.Batch(images=np.array(batch_images, dtype=np.uint8), data=batch_data) yield batch
def process_image_detection(image, boxes, labels, desired_w, desired_h, augment): # resize the image to standard size if (desired_w and desired_h) or augment: bbs = _to_bbs(boxes, labels, image.shape) if (desired_w and desired_h): # Rescale image and bounding boxes image = ia.imresize_single_image(image, (desired_w, desired_h)) bbs = bbs.on(image) if augment: aug_pipe = _create_augment_pipeline() image, bbs = aug_pipe(image=image, bounding_boxes=bbs) bbs = bbs.remove_out_of_image().clip_out_of_image() new_boxes, new_labels = _to_array(bbs) #if len(new_boxes) != len(boxes): # print(new_boxes) # print(boxes) # print("_________________") return image, np.array(new_boxes), new_labels else: return image, np.array(boxes), labels
def resize_and_rotate(filename): img = cv2.imread(filename)[:, :, ::-1] print('image opened: ' + filename) img = rotate_image(img,90) img = ia.imresize_single_image(img, (1024, 2048)) cv2.imwrite(filename, img) print('image rotated and resized saved as: ' + filename)
def add_row(self, title, images, subtitles): assert len(images) == len(subtitles) images_rs = [] for image in images: images_rs.append( ia.imresize_single_image( image, (self.image_height, self.image_width))) self.rows.append((title, images_rs, subtitles))
def chapter_augmenters_changecolortemperature(): fn_start = "color/changecolortemperature" image = imageio.imread( os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg")) image = ia.imresize_single_image(image, 0.2) aug = iaa.ChangeColorTemperature((1100, 10000)) run_and_save_augseq(fn_start + ".jpg", aug, [image] * 8, cols=3, rows=2)
def test_SegmentationMapOnImage_scale(): arr = np.int32([ [0, 1], [0, 2] ]) segmap = ia.SegmentationMapOnImage(arr, shape=(2, 2), nb_classes=3) segmap_scaled = segmap.resize((4, 4)) observed = segmap_scaled.arr expected = np.clip(ia.imresize_single_image(segmap.arr, (4, 4), interpolation="cubic"), 0, 1.0) assert np.allclose(observed, expected) assert np.array_equal(segmap_scaled.get_arr_int(), np.int32([ [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 2, 2], ])) segmap_scaled = segmap.resize((4, 4), interpolation="nearest") observed = segmap_scaled.arr expected = ia.imresize_single_image(segmap.arr, (4, 4), interpolation="nearest") assert np.allclose(observed, expected) assert np.array_equal(segmap_scaled.get_arr_int(), np.int32([ [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 2, 2], ])) segmap_scaled = segmap.resize(2.0) observed = segmap_scaled.arr expected = np.clip(ia.imresize_single_image(segmap.arr, 2.0, interpolation="cubic"), 0, 1.0) assert np.allclose(observed, expected) assert np.array_equal(segmap_scaled.get_arr_int(), np.int32([ [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 2, 2], [0, 0, 2, 2], ]))
def main(): for size in [0.1, 0.2, 1.0]: image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg", format="jpg") image = ia.imresize_single_image(image, size, "cubic") print(image.shape) augs = [ ("iaa.Fog()", iaa.Fog()) ] for descr, aug in augs: print(descr) images_aug = aug.augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug))
def _perspective_transform_augment_images(self, images, random_state, parents, hooks): result = images if not self.keep_size: result = list(result) matrices, max_heights, max_widths = self._create_matrices( [image.shape for image in images], random_state ) for i, (M, max_height, max_width) in enumerate(zip(matrices, max_heights, max_widths)): warped = cv2.warpPerspective(images[i], M, (max_width, max_height)) if warped.ndim == 2 and images[i].ndim == 3: warped = np.expand_dims(warped, 2) if self.keep_size: h, w = images[i].shape[0:2] warped = ia.imresize_single_image(warped, (h, w)) result[i] = warped return result
def main(): img = data.astronaut() img = ia.imresize_single_image(img, (64, 64)) aug = iaa.Fliplr(0.5) unseeded1 = aug.draw_grid(img, cols=8, rows=1) unseeded2 = aug.draw_grid(img, cols=8, rows=1) ia.seed(1000) seeded1 = aug.draw_grid(img, cols=8, rows=1) seeded2 = aug.draw_grid(img, cols=8, rows=1) ia.seed(1000) reseeded1 = aug.draw_grid(img, cols=8, rows=1) reseeded2 = aug.draw_grid(img, cols=8, rows=1) ia.seed(1001) reseeded3 = aug.draw_grid(img, cols=8, rows=1) reseeded4 = aug.draw_grid(img, cols=8, rows=1) all_rows = np.vstack([unseeded1, unseeded2, seeded1, seeded2, reseeded1, reseeded2, reseeded3, reseeded4]) ia.imshow(all_rows)
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (128, 128)) print("image shape:", image.shape) print("Press any key or wait %d ms to proceed to the next image." % (TIME_PER_STEP,)) configs = [ (1, 75, 75), (3, 75, 75), (5, 75, 75), (10, 75, 75), (10, 25, 25), (10, 250, 150), (15, 75, 75), (15, 150, 150), (15, 250, 150), (20, 75, 75), (40, 150, 150), ((1, 5), 75, 75), (5, (10, 250), 75), (5, 75, (10, 250)), (5, (10, 250), (10, 250)), (10, (10, 250), (10, 250)), ] cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.resizeWindow("aug", 128*NB_AUGS_PER_IMAGE, 128) for (d, sigma_color, sigma_space) in configs: aug = iaa.BilateralBlur(d=d, sigma_color=sigma_color, sigma_space=sigma_space) img_aug = [aug.augment_image(image) for _ in range(NB_AUGS_PER_IMAGE)] img_aug = np.hstack(img_aug) print("dtype", img_aug.dtype, "averages", np.average(img_aug, axis=tuple(range(0, img_aug.ndim-1)))) title = "d=%s, sc=%s, ss=%s" % (str(d), str(sigma_color), str(sigma_space)) img_aug = ia.draw_text(img_aug, x=5, y=5, text=title) cv2.imshow("aug", img_aug[..., ::-1]) # here with rgb2bgr cv2.waitKey(TIME_PER_STEP)
def example_background_augment_batches(): print("Example: Background Augmentation via augment_batches()") import imgaug as ia from imgaug import augmenters as iaa import numpy as np from skimage import data # Number of batches and batch size for this example nb_batches = 10 batch_size = 32 # Example augmentation sequence to run in the background augseq = iaa.Sequential([ iaa.Fliplr(0.5), iaa.CoarseDropout(p=0.1, size_percent=0.1) ]) # For simplicity, we use the same image here many times astronaut = data.astronaut() astronaut = ia.imresize_single_image(astronaut, (64, 64)) # Make batches out of the example image (here: 10 batches, each 32 times # the example image) batches = [] for _ in range(nb_batches): batches.append( np.array( [astronaut for _ in range(batch_size)], dtype=np.uint8 ) ) # Show the augmented images. # Note that augment_batches() returns a generator. for images_aug in augseq.augment_batches(batches, background=True): ia.imshow(ia.draw_grid(images_aug, cols=8))
def test_determinism(): reseed() images = [ ia.quokka(size=(128, 128)), ia.quokka(size=(64, 64)), ia.imresize_single_image(skimage.data.astronaut(), (128, 256)) ] images.extend([ia.quokka(size=(16, 16))] * 20) keypoints = [ ia.KeypointsOnImage([ ia.Keypoint(x=20, y=10), ia.Keypoint(x=5, y=5), ia.Keypoint(x=10, y=43)], shape=(50, 60, 3)) ] * 20 augs = [ iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.Sometimes(0.5, iaa.Fliplr(1.0)), iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))), # iaa.WithChannels([0], iaa.Add((-50, 50))), # iaa.Noop(name="Noop-nochange"), # iaa.Lambda( # func_images=lambda images, random_state, parents, hooks: images, # func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: keypoints_on_images, # name="Lambda-nochange" # ), # iaa.AssertLambda( # func_images=lambda images, random_state, parents, hooks: True, # func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: True, # name="AssertLambda-nochange" # ), # iaa.AssertShape( # (None, None, None, 3), # check_keypoints=False, # name="AssertShape-nochange" # ), iaa.Resize((0.5, 0.9)), iaa.CropAndPad(px=(-50, 50)), iaa.Pad(px=(1, 50)), iaa.Crop(px=(1, 50)), iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)), # iaa.ChangeColorspace(to_colorspace="GRAY"), iaa.Grayscale(alpha=(0.1, 1.0)), iaa.GaussianBlur((0.1, 3.0)), iaa.AverageBlur((3, 11)), iaa.MedianBlur((3, 11)), # iaa.Convolve(np.array([[0, 1, 0], # [1, -4, 1], # [0, 1, 0]])), iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)), iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)), iaa.EdgeDetect(alpha=(0.1, 1.0)), iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)), iaa.Add((-50, 50)), iaa.AddElementwise((-50, 50)), iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)), iaa.Multiply((0.6, 1.4)), iaa.MultiplyElementwise((0.6, 1.4)), iaa.Dropout((0.3, 0.5)), iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)), iaa.Invert(0.5), iaa.ContrastNormalization((0.6, 1.4)), iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1), rotate=(-20, 20), shear=(-20, 20), order=ia.ALL, mode=ia.ALL, cval=(0, 255)), iaa.PiecewiseAffine(scale=(0.1, 0.3)), iaa.ElasticTransformation(alpha=0.5) ] augs_affect_geometry = [ iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]), iaa.Sometimes(0.5, iaa.Fliplr(1.0)), iaa.Resize((0.5, 0.9)), iaa.CropAndPad(px=(-50, 50)), iaa.Pad(px=(1, 50)), iaa.Crop(px=(1, 50)), iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1), rotate=(-20, 20), shear=(-20, 20), order=ia.ALL, mode=ia.ALL, cval=(0, 255)), iaa.PiecewiseAffine(scale=(0.1, 0.3)), iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5)) ] for aug in augs: aug_det = aug.to_deterministic() images_aug1 = aug_det.augment_images(images) images_aug2 = aug_det.augment_images(images) aug_det = aug.to_deterministic() images_aug3 = aug_det.augment_images(images) images_aug4 = aug_det.augment_images(images) assert array_equal_lists(images_aug1, images_aug2), \ "Images (1, 2) expected to be identical for %s" % (aug.name,) assert array_equal_lists(images_aug3, images_aug4), \ "Images (3, 4) expected to be identical for %s" % (aug.name,) assert not array_equal_lists(images_aug1, images_aug3), \ "Images (1, 3) expected to be different for %s" % (aug.name,) for aug in augs_affect_geometry: aug_det = aug.to_deterministic() kps_aug1 = aug_det.augment_keypoints(keypoints) kps_aug2 = aug_det.augment_keypoints(keypoints) aug_det = aug.to_deterministic() kps_aug3 = aug_det.augment_keypoints(keypoints) kps_aug4 = aug_det.augment_keypoints(keypoints) assert keypoints_equal(kps_aug1, kps_aug2), \ "Keypoints (1, 2) expected to be identical for %s" % (aug.name,) assert keypoints_equal(kps_aug3, kps_aug4), \ "Keypoints (3, 4) expected to be identical for %s" % (aug.name,) assert not keypoints_equal(kps_aug1, kps_aug3), \ "Keypoints (1, 3) expected to be different for %s" % (aug.name,)
def add_row(self, title, images, subtitles): assert len(images) == len(subtitles) images_rs = [] for image in images: images_rs.append(ia.imresize_single_image(image, (self.image_height, self.image_width))) self.rows.append((title, images_rs, subtitles))
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (128, 128)) # check if scipy and cv2 remap similarly rs = ia.new_random_state(1) aug_scipy = ElasticTransformationScipy(alpha=30, sigma=3, random_state=rs, deterministic=True) aug_cv2 = ElasticTransformationCv2(alpha=30, sigma=3, random_state=rs, deterministic=True) augs_scipy = aug_scipy.augment_images([image] * 8) augs_cv2 = aug_cv2.augment_images([image] * 8) ia.imshow(ia.draw_grid(augs_scipy + augs_cv2, rows=2)) print("alpha=vary, sigma=0.25") augs = [iaa.ElasticTransformation(alpha=alpha, sigma=0.25) for alpha in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) print("alpha=vary, sigma=1.0") augs = [iaa.ElasticTransformation(alpha=alpha, sigma=1.0) for alpha in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) print("alpha=vary, sigma=3.0") augs = [iaa.ElasticTransformation(alpha=alpha, sigma=3.0) for alpha in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) print("alpha=vary, sigma=5.0") augs = [iaa.ElasticTransformation(alpha=alpha, sigma=5.0) for alpha in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) print("alpha=1.0, sigma=vary") augs = [iaa.ElasticTransformation(alpha=1.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) print("alpha=10.0, sigma=vary") augs = [iaa.ElasticTransformation(alpha=10.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)] images_aug = [aug.augment_image(image) for aug in augs] ia.imshow(ia.draw_grid(images_aug, cols=10)) kps = ia.KeypointsOnImage( [ia.Keypoint(x=1, y=1), ia.Keypoint(x=50, y=24), ia.Keypoint(x=42, y=96), ia.Keypoint(x=88, y=106), ia.Keypoint(x=88, y=53), ia.Keypoint(x=0, y=0), ia.Keypoint(x=128, y=128), ia.Keypoint(x=-20, y=30), ia.Keypoint(x=20, y=-30), ia.Keypoint(x=-20, y=-30)], shape=image.shape ) images = [] params = [ (0.0, 0.0), (0.2, 0.2), (2.0, 0.25), (0.25, 3.0), (2.0, 3.0), (6.0, 3.0), (12.0, 3.0), (50.0, 5.0), (100.0, 5.0), (100.0, 10.0) ] for (alpha, sigma) in params: images_row = [] seqs_row = [ iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=3), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=3), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=3), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=2), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=3), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=2), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=3), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=0), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=1), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=2), iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=3) ] for seq in seqs_row: seq_det = seq.to_deterministic() image_aug = seq_det.augment_image(image) kps_aug = seq_det.augment_keypoints([kps])[0] image_aug_kp = np.copy(image_aug) image_aug_kp = kps_aug.draw_on_image(image_aug_kp, size=3) images_row.append(image_aug_kp) images.append(np.hstack(images_row)) ia.imshow(np.vstack(images)) imageio.imwrite("elastic_transformations.jpg", np.vstack(images))
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (HEIGHT, WIDTH)) kps = [] for y in range(NB_ROWS): ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1)) for x in range(NB_COLS): xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1)) kp = (xcoord, ycoord) kps.append(kp) kps = set(kps) kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps] kps = ia.KeypointsOnImage(kps, shape=image.shape) bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2) bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape) pairs = [] params = [ {"rotate": 45}, {"translate_px": 20}, {"translate_percent": 0.1}, {"scale": 1.2}, {"scale": 0.8}, {"shear": 45}, {"rotate": 45, "cval": 255}, {"translate_px": 20, "mode": "constant"}, {"translate_px": 20, "mode": "edge"}, {"translate_px": 20, "mode": "symmetric"}, {"translate_px": 20, "mode": "reflect"}, {"translate_px": 20, "mode": "wrap"}, {"scale": 0.5, "order": 0}, {"scale": 0.5, "order": 1}, {"scale": 0.5, "order": 2}, {"scale": 0.5, "order": 3}, {"scale": 0.5, "order": 4}, {"scale": 0.5, "order": 5}, {"rotate": 45, "translate_px": 20, "scale": 1.2}, {"rotate": 45, "translate_px": 20, "scale": 0.8}, {"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL, "mode": ia.ALL, "cval": ia.ALL}, {"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL, "mode": ia.ALL, "cval": ia.ALL}, {"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL, "mode": ia.ALL, "cval": ia.ALL}, {"rotate": (-45, 45), "translate_px": (-20, 20), "scale": (0.8, 1.2), "order": ia.ALL, "mode": ia.ALL, "cval": ia.ALL} ] seqs_skimage = [iaa.Affine(backend="skimage", **p) for p in params] seqs_cv2 = [iaa.Affine(backend="auto", **p) for p in params] for seq_skimage, seq_cv2 in zip(seqs_skimage, seqs_cv2): seq_skimage_det = seq_skimage.to_deterministic() seq_cv2_det = seq_cv2.to_deterministic() seq_cv2_det.copy_random_state_(seq_skimage_det) image_aug_skimage = seq_skimage_det.augment_image(image) image_aug_cv2 = seq_cv2_det.augment_image(image) kps_aug_skimage = seq_skimage_det.augment_keypoints([kps])[0] kps_aug_cv2 = seq_cv2_det.augment_keypoints([kps])[0] bbs_aug_skimage = seq_skimage_det.augment_bounding_boxes([bbs])[0] bbs_aug_cv2 = seq_cv2_det.augment_bounding_boxes([bbs])[0] image_before_skimage = np.copy(image) image_before_cv2 = np.copy(image) image_before_skimage = kps.draw_on_image(image_before_skimage) image_before_cv2 = kps.draw_on_image(image_before_cv2) image_before_skimage = bbs.draw_on_image(image_before_skimage) image_before_cv2 = bbs.draw_on_image(image_before_cv2) image_after_skimage = np.copy(image_aug_skimage) image_after_cv2 = np.copy(image_aug_cv2) image_after_skimage = kps_aug_skimage.draw_on_image(image_after_skimage) image_after_cv2 = kps_aug_cv2.draw_on_image(image_after_cv2) image_after_skimage = bbs_aug_skimage.draw_on_image(image_after_skimage) image_after_cv2 = bbs_aug_cv2.draw_on_image(image_after_cv2) pairs.append(np.hstack((image_before_skimage, image_after_skimage, image_after_cv2))) ia.imshow(np.vstack(pairs)) imageio.imwrite("affine.jpg", np.vstack(pairs))
def test_SegmentationMapOnImage_draw(): arr = np.int32([ [0, 1, 1], [0, 1, 1], [0, 1, 1] ]) segmap = ia.SegmentationMapOnImage(arr, shape=(3, 3), nb_classes=2) # simple example with 2 classes observed = segmap.draw() col0 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[0] col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) assert np.array_equal(observed, expected) # same example, with resizing to 2x the size observed = segmap.draw(size=(6, 6)) expected = ia.imresize_single_image(expected, (6, 6), interpolation="nearest") assert np.array_equal(observed, expected) # custom choice of colors col0 = (10, 10, 10) col1 = (50, 51, 52) observed = segmap.draw(colors=[col0, col1]) expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) assert np.array_equal(observed, expected) # background_threshold, background_class and foreground mask arr_c0 = np.float32([ [0, 0, 0], [1.0, 0, 0], [0, 0, 0] ]) arr_c1 = np.float32([ [0, 1, 1], [0, 1, 1], [0.1, 1, 1] ]) arr = np.concatenate([ arr_c0[..., np.newaxis], arr_c1[..., np.newaxis] ], axis=2) segmap = ia.SegmentationMapOnImage(arr, shape=(3, 3)) observed, observed_fg = segmap.draw(background_threshold=0.01, return_foreground_mask=True) col0 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[0] col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] col2 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[2] expected = np.uint8([ [col0, col2, col2], [col1, col2, col2], [col2, col2, col2] ]) expected_fg = np.array([ [False, True, True], [True, True, True], [True, True, True] ], dtype=np.bool) assert np.array_equal(observed, expected) assert np.array_equal(observed_fg, expected_fg) # background_threshold, background_class and foreground mask # here with higher threshold so that bottom left pixel switches to background observed, observed_fg = segmap.draw(background_threshold=0.11, return_foreground_mask=True) col0 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[0] col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] col2 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[2] expected = np.uint8([ [col0, col2, col2], [col1, col2, col2], [col0, col2, col2] ]) expected_fg = np.array([ [False, True, True], [True, True, True], [False, True, True] ], dtype=np.bool) assert np.array_equal(observed, expected) assert np.array_equal(observed_fg, expected_fg)
def test_SegmentationMapOnImage_draw_on_image(): arr = np.int32([ [0, 1, 1], [0, 1, 1], [0, 1, 1] ]) segmap = ia.SegmentationMapOnImage(arr, shape=(3, 3), nb_classes=2) image = np.uint8([ [0, 10, 20], [30, 40, 50], [60, 70, 80] ]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) # only image visible observed = segmap.draw_on_image(image, alpha=0) assert np.array_equal(observed, image) # only segmap visible observed = segmap.draw_on_image(image, alpha=1.0, draw_background=True) col0 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[0] col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) assert np.array_equal(observed, expected) # only segmap visible - in foreground observed = segmap.draw_on_image(image, alpha=1.0, draw_background=False) col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] expected = np.uint8([ [image[0, 0, :], col1, col1], [image[1, 0, :], col1, col1], [image[2, 0, :], col1, col1] ]) assert np.array_equal(observed, expected) # overlay without background drawn a1 = 0.7 a0 = 1.0 - a1 observed = segmap.draw_on_image(image, alpha=a1, draw_background=False) col1 = np.uint8(ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1]) expected = np.float32([ [image[0, 0, :], a0*image[0, 1, :] + a1*col1, a0*image[0, 2, :] + a1*col1], [image[1, 0, :], a0*image[1, 1, :] + a1*col1, a0*image[1, 2, :] + a1*col1], [image[2, 0, :], a0*image[2, 1, :] + a1*col1, a0*image[2, 2, :] + a1*col1] ]) d_max = np.max(np.abs(observed.astype(np.float32) - expected)) assert observed.shape == expected.shape assert d_max <= 1.0 + 1e-4 # overlay with background drawn a1 = 0.7 a0 = 1.0 - a1 observed = segmap.draw_on_image(image, alpha=a1, draw_background=True) col0 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[0] col1 = ia.SegmentationMapOnImage.DEFAULT_SEGMENT_COLORS[1] expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) expected = a0 * image + a1 * expected d_max = np.max(np.abs(observed.astype(np.float32) - expected.astype(np.float32))) assert observed.shape == expected.shape assert d_max <= 1.0 + 1e-4 # resizing of segmap to image arr = np.int32([ [0, 1, 1] ]) segmap = ia.SegmentationMapOnImage(arr, shape=(3, 3), nb_classes=2) image = np.uint8([ [0, 10, 20], [30, 40, 50], [60, 70, 80] ]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) a1 = 0.7 a0 = 1.0 - a1 observed = segmap.draw_on_image(image, alpha=a1, draw_background=True, resize="segmentation_map") expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) expected = a0 * image + a1 * expected d_max = np.max(np.abs(observed.astype(np.float32) - expected.astype(np.float32))) assert observed.shape == expected.shape assert d_max <= 1.0 + 1e-4 # resizing of image to segmap arr = np.int32([ [0, 1, 1], [0, 1, 1], [0, 1, 1] ]) segmap = ia.SegmentationMapOnImage(arr, shape=(1, 3), nb_classes=2) image = np.uint8([ [0, 10, 20] ]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) image_rs = ia.imresize_single_image(image, arr.shape[0:2], interpolation="cubic") a1 = 0.7 a0 = 1.0 - a1 observed = segmap.draw_on_image(image, alpha=a1, draw_background=True, resize="image") expected = np.uint8([ [col0, col1, col1], [col0, col1, col1], [col0, col1, col1] ]) expected = a0 * image_rs + a1 * expected d_max = np.max(np.abs(observed.astype(np.float32) - expected.astype(np.float32))) assert observed.shape == expected.shape assert d_max <= 1.0 + 1e-4
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (64, 64)) keypoints_on_image = ia.KeypointsOnImage([ia.Keypoint(x=10, y=10)], shape=image.shape) images_arr = np.array([image for _ in range(NB_AUGS_PER_IMAGE)]) images_list = [image for _ in range(NB_AUGS_PER_IMAGE)] keypoints_on_images = [keypoints_on_image.deepcopy() for _ in range(NB_AUGS_PER_IMAGE)] print("image shape:", image.shape) print("Press ENTER or wait %d ms to proceed to the next image." % (TIME_PER_STEP,)) children = [ iaa.CoarseDropout(p=0.5, size_percent=0.05), iaa.AdditiveGaussianNoise(scale=0.1*255) ] n = [ None, 0, 1, len(children), len(children)+1, (1, 1), (1, len(children)), (1, len(children)+1), (1, None) ] cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.resizeWindow("aug", 64*NB_AUGS_PER_IMAGE, (2+4+4)*64) rows = [] for ni in n: aug = iaa.SomeOf(ni, children, random_order=False) rows.append(aug.augment_images(images_arr)) grid = to_grid(rows, None) cv2.imshow("aug", grid[..., ::-1]) # here with rgb2bgr cv2.waitKey(TIME_PER_STEP) for ni in n: print("------------------------") print("-- %s" % (str(ni),)) print("------------------------") aug = iaa.SomeOf(ni, children, random_order=False) aug_ro = iaa.SomeOf(ni, children, random_order=True) aug_det = aug.to_deterministic() aug_ro_det = aug_ro.to_deterministic() aug_kps = [] aug_kps.extend([aug_det.augment_keypoints(keypoints_on_images)] * 4) aug_kps.extend([aug_ro_det.augment_keypoints(keypoints_on_images)] * 4) aug_rows = [] aug_rows.append(images_arr) aug_rows.append(images_list) aug_rows.append(aug_det.augment_images(images_arr)) aug_rows.append(aug_det.augment_images(images_arr)) aug_rows.append(aug_det.augment_images(images_list)) aug_rows.append(aug_det.augment_images(images_list)) aug_rows.append(aug_ro_det.augment_images(images_arr)) aug_rows.append(aug_ro_det.augment_images(images_arr)) aug_rows.append(aug_ro_det.augment_images(images_list)) aug_rows.append(aug_ro_det.augment_images(images_list)) grid = to_grid(aug_rows, aug_kps) title = "n=%s" % (str(ni),) grid = ia.draw_text(grid, x=5, y=5, text=title) cv2.imshow("aug", grid[..., ::-1]) # here with rgb2bgr cv2.waitKey(TIME_PER_STEP)
def main(): image = data.astronaut() image = ia.imresize_single_image(image, (HEIGHT, WIDTH)) kps = [] for y in range(NB_ROWS): ycoord = BB_Y1 + int(y * (BB_Y2 - BB_Y1) / (NB_COLS - 1)) for x in range(NB_COLS): xcoord = BB_X1 + int(x * (BB_X2 - BB_X1) / (NB_ROWS - 1)) kp = (xcoord, ycoord) kps.append(kp) kps = set(kps) kps = [ia.Keypoint(x=xcoord, y=ycoord) for (xcoord, ycoord) in kps] kps = ia.KeypointsOnImage(kps, shape=image.shape) bb = ia.BoundingBox(x1=BB_X1, x2=BB_X2, y1=BB_Y1, y2=BB_Y2) bbs = ia.BoundingBoxesOnImage([bb], shape=image.shape) pairs = [] seqs = [ iaa.AffineCv2(rotate=45), iaa.AffineCv2(translate_px=20), iaa.AffineCv2(translate_percent=0.1), iaa.AffineCv2(scale=1.2), iaa.AffineCv2(scale=0.8), iaa.AffineCv2(shear=45), iaa.AffineCv2(rotate=45, cval=256), iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_CONSTANT), iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REPLICATE), iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REFLECT), iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_REFLECT_101), iaa.AffineCv2(translate_px=20, mode=cv2.BORDER_WRAP), iaa.AffineCv2(translate_px=20, mode="constant"), iaa.AffineCv2(translate_px=20, mode="replicate"), iaa.AffineCv2(translate_px=20, mode="reflect"), iaa.AffineCv2(translate_px=20, mode="reflect_101"), iaa.AffineCv2(translate_px=20, mode="wrap"), iaa.AffineCv2(scale=0.5, order=cv2.INTER_NEAREST), iaa.AffineCv2(scale=0.5, order=cv2.INTER_LINEAR), iaa.AffineCv2(scale=0.5, order=cv2.INTER_CUBIC), iaa.AffineCv2(scale=0.5, order=cv2.INTER_LANCZOS4), iaa.AffineCv2(scale=0.5, order="nearest"), iaa.AffineCv2(scale=0.5, order="linear"), iaa.AffineCv2(scale=0.5, order="cubic"), iaa.AffineCv2(scale=0.5, order="lanczos4"), iaa.AffineCv2(rotate=45, translate_px=20, scale=1.2), iaa.AffineCv2(rotate=45, translate_px=20, scale=0.8), iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL), iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL), iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL), iaa.AffineCv2(rotate=(-45, 45), translate_px=(-20, 20), scale=(0.8, 1.2), order=ia.ALL, mode=ia.ALL, cval=ia.ALL) ] for seq in seqs: seq_det = seq.to_deterministic() image_aug = seq_det.augment_image(image) #print(image_aug.dtype, np.min(image_aug), np.max(image_aug)) kps_aug = seq_det.augment_keypoints([kps])[0] bbs_aug = seq_det.augment_bounding_boxes([bbs])[0] image_before = np.copy(image) image_before = kps.draw_on_image(image_before) image_before = bbs.draw_on_image(image_before) image_after = np.copy(image_aug) image_after = kps_aug.draw_on_image(image_after) image_after = bbs_aug.draw_on_image(image_after) pairs.append(np.hstack((image_before, image_after))) ia.imshow(np.vstack(pairs)) imageio.imwrite("affinecv2.jpg", np.vstack(pairs))
def _augment_images(self, images, random_state, parents, hooks): iadt.gate_dtypes(images, allowed=["bool", "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64"], disallowed=["uint128", "uint256", "int128", "int256", "float16", "float32", "float64", "float96", "float128", "float256"], augmenter=self) nb_images = len(images) rss = ia.derive_random_states(random_state, 1+nb_images) n_segments_samples = self.n_segments.draw_samples((nb_images,), random_state=rss[0]) for i, (image, rs) in enumerate(zip(images, rss[1:])): # TODO this results in an error when n_segments is 0 replace_samples = self.p_replace.draw_samples((n_segments_samples[i],), random_state=rs) if np.max(replace_samples) == 0: # not a single superpixel would be replaced by its average color, # i.e. the image would not be changed, so just keep it pass else: image = images[i] min_value, _center_value, max_value = iadt.get_value_range_of_dtype(image.dtype) orig_shape = image.shape if self.max_size is not None: size = max(image.shape[0], image.shape[1]) if size > self.max_size: resize_factor = self.max_size / size new_height, new_width = int(image.shape[0] * resize_factor), int(image.shape[1] * resize_factor) image = ia.imresize_single_image(image, (new_height, new_width), interpolation=self.interpolation) image_sp = np.copy(image) segments = segmentation.slic(image, n_segments=n_segments_samples[i], compactness=10) nb_channels = image.shape[2] for c in sm.xrange(nb_channels): # segments+1 here because otherwise regionprops always misses # the last label regions = measure.regionprops(segments+1, intensity_image=image[..., c]) for ridx, region in enumerate(regions): # with mod here, because slic can sometimes create more superpixel # than requested. replace_samples then does not have enough # values, so we just start over with the first one again. if replace_samples[ridx % len(replace_samples)] >= 0.5: mean_intensity = region.mean_intensity image_sp_c = image_sp[..., c] if image_sp_c.dtype.kind in ["i", "u", "b"]: # After rounding the value can end up slightly outside of the value_range. # Hence, we need to clip. We do clip via min(max(...)) instead of np.clip # because the latter one does not seem to keep dtypes for dtypes with # large itemsizes (e.g. uint64). value = int(np.round(mean_intensity)) value = min(max(value, min_value), max_value) image_sp_c[segments == ridx] = value else: image_sp_c[segments == ridx] = mean_intensity if orig_shape != image.shape: image_sp = ia.imresize_single_image(image_sp, orig_shape[0:2], interpolation=self.interpolation) images[i] = image_sp return images