def main(): black_and_white = iaa.RandomColorsBinaryImageColorizer( color_true=255, color_false=0) print("alpha=1.0, black and white") image = ia.quokka_square((128, 128)) aug = iaa.Canny(alpha=1.0, colorizer=black_and_white) ia.imshow(ia.draw_grid(aug(images=[image] * (5*5)))) print("alpha=1.0, random color") image = ia.quokka_square((128, 128)) aug = iaa.Canny(alpha=1.0) ia.imshow(ia.draw_grid(aug(images=[image] * (5*5)))) print("alpha=1.0, sobel ksize=[3, 13], black and white") image = ia.quokka_square((128, 128)) aug = iaa.Canny(alpha=1.0, sobel_kernel_size=[3, 7], colorizer=black_and_white) ia.imshow(ia.draw_grid(aug(images=[image] * (5*5)))) print("alpha=1.0, sobel ksize=3, black and white") image = ia.quokka_square((128, 128)) aug = iaa.Canny(alpha=1.0, sobel_kernel_size=3, colorizer=black_and_white) ia.imshow(ia.draw_grid(aug(images=[image] * (5*5)))) print("fully random") image = ia.quokka_square((128, 128)) aug = iaa.Canny() ia.imshow(ia.draw_grid(aug(images=[image] * (5*5))))
def generate_cartoon(): ia.seed(1) image1 = imageio.imread( os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg")) image2 = imageio.imread( os.path.join(INPUT_IMAGES_DIR, "1024px-Salad_platter.jpg")) image1 = iaa.Resize({ "width": 256, "height": "keep-aspect-ratio" })(image=image1) image2 = iaa.Resize({ "width": 256, "height": "keep-aspect-ratio" })(image=image2) images_aug = [image1] images_aug.extend(iaa.Cartoon()(images=[image1] * 3)) images_aug.append(image2) images_aug.extend(iaa.Cartoon()(images=[image2] * 3)) # if we use a single draw_grid() call here, the function will currently # add an ugly black border at the bottom of the first row, because the # height of image1 is lower than of image2 and it will ensure that both # rows have the same height row1 = ia.draw_grid(images_aug[0:4], cols=4, rows=1) row2 = ia.draw_grid(images_aug[4:], cols=4, rows=1) _save("cartoon.jpg", np.vstack([row1, row2]))
def main(): image = ia.quokka_square((128, 128)) images_aug = [] for mul in np.linspace(0.0, 2.0, 10): aug = iaa.MultiplyHueAndSaturation(mul) image_aug = aug.augment_image(image) images_aug.append(image_aug) for mul_hue in np.linspace(0.0, 5.0, 10): aug = iaa.MultiplyHueAndSaturation(mul_hue=mul_hue) image_aug = aug.augment_image(image) images_aug.append(image_aug) for mul_saturation in np.linspace(0.0, 5.0, 10): aug = iaa.MultiplyHueAndSaturation(mul_saturation=mul_saturation) image_aug = aug.augment_image(image) images_aug.append(image_aug) ia.imshow(ia.draw_grid(images_aug, rows=3)) images_aug = [] images_aug.extend(iaa.MultiplyHue().augment_images([image] * 10)) images_aug.extend(iaa.MultiplySaturation().augment_images([image] * 10)) ia.imshow(ia.draw_grid(images_aug, rows=2))
def main(): aug = iaa.BlendAlphaMask( iaa.SomeColorsMaskGen(), iaa.OneOf([iaa.TotalDropout(1.0), iaa.AveragePooling(8)])) aug2 = iaa.BlendAlphaSomeColors( iaa.OneOf([iaa.TotalDropout(1.0), iaa.AveragePooling(8)])) urls = [ ("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/" "Sarcophilus_harrisii_taranna.jpg/" "320px-Sarcophilus_harrisii_taranna.jpg"), ("https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/" "Vincent_van_Gogh_-_Wheatfield_with_crows_-_Google_Art_Project.jpg/" "320px-Vincent_van_Gogh_-_Wheatfield_with_crows_-_Google_Art_Project" ".jpg"), ("https://upload.wikimedia.org/wikipedia/commons/thumb/0/0c/" "Galerella_sanguinea_Zoo_Praha_2011-2.jpg/207px-Galerella_sanguinea_" "Zoo_Praha_2011-2.jpg"), ("https://upload.wikimedia.org/wikipedia/commons/thumb/9/96/" "Ambrosius_Bosschaert_the_Elder_%28Dutch_-_Flower_Still_Life_-_" "Google_Art_Project.jpg/307px-Ambrosius_Bosschaert_the_Elder_%28" "Dutch_-_Flower_Still_Life_-_Google_Art_Project.jpg") ] for url in urls: img = imageio.imread(url) ia.imshow(ia.draw_grid(aug(images=[img] * 25), cols=5, rows=5)) ia.imshow(ia.draw_grid(aug2(images=[img] * 25), cols=5, rows=5))
def main(): image = data.astronaut() cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.imshow("aug", image) cv2.waitKey(TIME_PER_STEP) # for value in cycle(np.arange(-255, 255, VAL_PER_STEP)): for value in np.arange(-255, 255, VAL_PER_STEP): aug = iaa.AddToHueAndSaturation(value=value) img_aug = aug.augment_image(image) img_aug = iaa.pad(img_aug, bottom=40) img_aug = ia.draw_text(img_aug, x=0, y=img_aug.shape[0] - 38, text="value=%d" % (value, ), size=30) cv2.imshow("aug", img_aug) cv2.waitKey(TIME_PER_STEP) images_aug = iaa.AddToHueAndSaturation( value=(-255, 255), per_channel=True).augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug)) image = ia.quokka_square((128, 128)) images_aug = [] images_aug.extend(iaa.AddToHue().augment_images([image] * 10)) images_aug.extend(iaa.AddToSaturation().augment_images([image] * 10)) ia.imshow(ia.draw_grid(images_aug, rows=2))
def main(): augs = [("iaa.Rot90(-1, keep_size=False)", iaa.Rot90(-1, keep_size=False)), ("iaa.Rot90(0, keep_size=False)", iaa.Rot90(0, keep_size=False)), ("iaa.Rot90(1, keep_size=False)", iaa.Rot90(1, keep_size=False)), ("iaa.Rot90(2, keep_size=False)", iaa.Rot90(2, keep_size=False)), ("iaa.Rot90(3, keep_size=False)", iaa.Rot90(3, keep_size=False)), ("iaa.Rot90(4, keep_size=False)", iaa.Rot90(4, keep_size=False)), ("iaa.Rot90(-1, keep_size=True)", iaa.Rot90(-1, keep_size=True)), ("iaa.Rot90(0, keep_size=True)", iaa.Rot90(0, keep_size=True)), ("iaa.Rot90(1, keep_size=True)", iaa.Rot90(1, keep_size=True)), ("iaa.Rot90(2, keep_size=True)", iaa.Rot90(2, keep_size=True)), ("iaa.Rot90(3, keep_size=True)", iaa.Rot90(3, keep_size=True)), ("iaa.Rot90(4, keep_size=True)", iaa.Rot90(4, keep_size=True)), ("iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)), ("iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)), ("iaa.Rot90((0, 4), keep_size=False)", iaa.Rot90((0, 4), keep_size=False)), ("iaa.Rot90((0, 4), keep_size=True)", iaa.Rot90((0, 4), keep_size=True)), ("iaa.Rot90((1, 3), keep_size=False)", iaa.Rot90((1, 3), keep_size=False)), ("iaa.Rot90((1, 3), keep_size=True)", iaa.Rot90((1, 3), keep_size=True))] image = ia.data.quokka(0.25) print("--------") print("Image + Keypoints") print("--------") kps = ia.quokka_keypoints(0.25) for name, aug in augs: print(name, "...") aug_det = aug.to_deterministic() images_aug = aug_det.augment_images([image] * 16) kps_aug = aug_det.augment_keypoints([kps] * 16) images_aug = [ kps_aug_i.draw_on_image(image_aug_i, size=5) for image_aug_i, kps_aug_i in zip(images_aug, kps_aug) ] ia.imshow(ia.draw_grid(images_aug)) print("--------") print("Image + Heatmaps (low res)") print("--------") hms = ia.quokka_heatmap(0.10) for name, aug in augs: print(name, "...") aug_det = aug.to_deterministic() images_aug = aug_det.augment_images([image] * 16) hms_aug = aug_det.augment_heatmaps([hms] * 16) images_aug = [ hms_aug_i.draw_on_image(image_aug_i)[0] for image_aug_i, hms_aug_i in zip(images_aug, hms_aug) ] ia.imshow(ia.draw_grid(images_aug))
def main(): augs = [ ("iaa.Rot90(-1, keep_size=False)", iaa.Rot90(-1, keep_size=False)), ("iaa.Rot90(0, keep_size=False)", iaa.Rot90(0, keep_size=False)), ("iaa.Rot90(1, keep_size=False)", iaa.Rot90(1, keep_size=False)), ("iaa.Rot90(2, keep_size=False)", iaa.Rot90(2, keep_size=False)), ("iaa.Rot90(3, keep_size=False)", iaa.Rot90(3, keep_size=False)), ("iaa.Rot90(4, keep_size=False)", iaa.Rot90(4, keep_size=False)), ("iaa.Rot90(-1, keep_size=True)", iaa.Rot90(-1, keep_size=True)), ("iaa.Rot90(0, keep_size=True)", iaa.Rot90(0, keep_size=True)), ("iaa.Rot90(1, keep_size=True)", iaa.Rot90(1, keep_size=True)), ("iaa.Rot90(2, keep_size=True)", iaa.Rot90(2, keep_size=True)), ("iaa.Rot90(3, keep_size=True)", iaa.Rot90(3, keep_size=True)), ("iaa.Rot90(4, keep_size=True)", iaa.Rot90(4, keep_size=True)), ("iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)), ("iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)), ("iaa.Rot90((0, 4), keep_size=False)", iaa.Rot90((0, 4), keep_size=False)), ("iaa.Rot90((0, 4), keep_size=True)", iaa.Rot90((0, 4), keep_size=True)), ("iaa.Rot90((1, 3), keep_size=False)", iaa.Rot90((1, 3), keep_size=False)), ("iaa.Rot90((1, 3), keep_size=True)", iaa.Rot90((1, 3), keep_size=True)) ] image = ia.quokka(0.25) print("--------") print("Image + Keypoints") print("--------") kps = ia.quokka_keypoints(0.25) for name, aug in augs: print(name, "...") aug_det = aug.to_deterministic() images_aug = aug_det.augment_images([image] * 16) kps_aug = aug_det.augment_keypoints([kps] * 16) images_aug = [kps_aug_i.draw_on_image(image_aug_i, size=5) for image_aug_i, kps_aug_i in zip(images_aug, kps_aug)] ia.imshow(ia.draw_grid(images_aug)) print("--------") print("Image + Heatmaps (low res)") print("--------") hms = ia.quokka_heatmap(0.10) for name, aug in augs: print(name, "...") aug_det = aug.to_deterministic() images_aug = aug_det.augment_images([image] * 16) hms_aug = aug_det.augment_heatmaps([hms] * 16) images_aug = [hms_aug_i.draw_on_image(image_aug_i)[0] for image_aug_i, hms_aug_i in zip(images_aug, hms_aug)] ia.imshow(ia.draw_grid(images_aug))
def main(): image = ia.quokka_square((256, 256)) ia.imshow( ia.draw_grid([ iaa.quantize_colors_uniform(image, 2), iaa.quantize_colors_uniform(image, 4), iaa.quantize_colors_uniform(image, 8), iaa.quantize_colors_uniform(image, 16), iaa.quantize_colors_uniform(image, 32), iaa.quantize_colors_uniform(image, 64) ], cols=6) ) aug = iaa.UniformColorQuantization((2, 16)) ia.imshow(ia.draw_grid(aug(images=[image] * 16)))
def run(clazz): image = ia.quokka_square((128, 128)) aug = clazz(2) ia.imshow(ia.draw_grid(aug.augment_images([image] * (5 * 5)))) aug = clazz(2, keep_size=False) ia.imshow(ia.draw_grid(aug.augment_images([image] * (5 * 5)))) aug_pool = clazz(((0, 10), (0, 10))) aug_blur = clazz(((0, 10), (0, 10))) ia.imshow( np.hstack([ ia.draw_grid(aug_pool.augment_images([image] * (4 * 5)), cols=4), ia.draw_grid(aug_blur.augment_images([image] * (4 * 5)), cols=4) ]))
def main(): image = ia.quokka_square() images_aug = [] for kelvin in np.linspace(1000, 10000, 64): images_aug.append(iaa.ChangeColorTemperature(kelvin)(image=image)) ia.imshow(ia.draw_grid(images_aug))
def create_visualization(image, y_pred, y_true): """Creates the qualitative results to visualize """ # format prediction and ground truth y_pred = np.argmax(y_pred, axis=-1).astype(np.uint8) y_true = np.argmax(y_true, axis=-1).astype(np.uint8) # format raw image # put values between 0 and 255 (before it was between 0 and 1) image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) image = image * 255. image = image.astype(np.uint8) # generate segmaps y_pred = SegmentationMapsOnImage(y_pred, shape=image.shape) y_true = SegmentationMapsOnImage(y_true, shape=image.shape) grid_image = ia.draw_grid([ image, y_true.draw_on_image(image)[0], y_pred.draw_on_image(image)[0] ], cols=3) return grid_image
def main(): for size in [64, 128, 256, 512, 1024]: for nb_bits in [1, 2, 3, 4, 5, 6, 7, 8]: time_iaa = timeit.timeit( "iaa.quantize_uniform_to_n_bits(image, %d)" % (nb_bits, ), number=1000, setup=("import imgaug as ia; " "import imgaug.augmenters as iaa; " "image = ia.quokka_square((%d, %d))" % (size, size))) time_pil = timeit.timeit( "np.asarray(" "PIL.ImageOps.posterize(PIL.Image.fromarray(image), %d)" ")" % (nb_bits, ), number=1000, setup=("import numpy as np; " "import PIL.Image; " "import PIL.ImageOps; " "import imgaug as ia; " "image = ia.quokka_square((%d, %d))" % (size, size))) print("[size=%04d, bits=%d] iaa=%.4f pil=%.4f" % (size, nb_bits, time_iaa, time_pil)) image = ia.quokka_square((128, 128)) images_q = [ iaa.quantize_uniform_to_n_bits(image, nb_bits) for nb_bits in [1, 2, 3, 4, 5, 6, 7, 8] ] ia.imshow(ia.draw_grid(images_q, cols=8, rows=1))
def main(): aug = iaa.Cutout(fill_mode=["gaussian", "constant"], cval=(0, 255), fill_per_channel=0.5) image = ia.quokka() images_aug = aug(images=[image] * 16) ia.imshow(ia.draw_grid(images_aug, cols=4, rows=4))
def main(): for size in [64, 128, 256, 512, 1024]: for threshold in [64, 128, 192]: time_iaa = timeit.timeit( "iaa.solarize(image, %d)" % (threshold, ), number=1000, setup=("import imgaug as ia; " "import imgaug.augmenters as iaa; " "image = ia.quokka_square((%d, %d))" % (size, size))) time_pil = timeit.timeit( "np.asarray(" "PIL.ImageOps.solarize(PIL.Image.fromarray(image), %d)" ")" % (threshold, ), number=1000, setup=("import numpy as np; " "import PIL.Image; " "import PIL.ImageOps; " "import imgaug as ia; " "image = ia.quokka_square((%d, %d))" % (size, size))) print("[size=%04d, thresh=%03d] iaa=%.4f pil=%.4f" % (size, threshold, time_iaa, time_pil)) image = ia.quokka_square((128, 128)) images_aug = iaa.Solarize(1.0)(images=[image] * (5 * 5)) ia.imshow(ia.draw_grid(images_aug))
def generate_solarize(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] images_aug.extend(iaa.Solarize(p=1.0)(images=[image] * (2 * 8 - 1))) _save("solarize.jpg", ia.draw_grid(images_aug, cols=8, rows=2))
def create_visualization(pred_dep, gt_dep, pred_seg, gt_seg, img): pred_dep = cv2.cvtColor(pred_dep, cv2.COLOR_GRAY2BGR) pred_dep = (pred_dep * 255).astype(np.uint8) gt_dep = cv2.cvtColor(gt_dep, cv2.COLOR_GRAY2BGR) gt_dep = (gt_dep * 255).astype(np.uint8) # dep_heatmap = dep_heatmap.astype(np.float32)/255. # dep_overlay = dep_overlay.astype(np.float32)/255. img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) img = (img * 255).astype(np.uint8) # generate segmaps pred_seg = np.argmax(pred_seg, axis=-1).astype(np.uint8) gt_seg = np.argmax(gt_seg, axis=-1).astype(np.uint8) pred_seg = SegmentationMapsOnImage(pred_seg, shape=img.shape) gt_seg = SegmentationMapsOnImage(gt_seg, shape=img.shape) grid_image = ia.draw_grid( [ img, pred_seg.draw_on_image(img)[0], gt_seg.draw_on_image(img)[0], pred_dep, gt_dep # dep_heatmap, # dep_overlay, ], cols=5) return grid_image
def generate_imgcorruptlike(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [] augnames = [ "Original", "GaussianNoise", "ShotNoise", "ImpulseNoise", "SpeckleNoise", "GaussianBlur", "GlassBlur", "DefocusBlur", "MotionBlur", "ZoomBlur", "Fog", "Frost", "Snow", "Spatter", "Contrast", "Brightness", "Saturate", "JpegCompression", "Pixelate", "ElasticTransform" ] for augname in augnames: if augname == "Original": image_aug = np.copy(image) else: aug = getattr(iaa.imgcorruptlike, augname) image_aug = aug(severity=3)(image=image) image_aug = iaa.pad(image_aug, top=30, cval=255) image_aug = ia.draw_text(image_aug, y=6, x=2, text=augname, color=(0, 0, 0), size=15) images_aug.append(image_aug) _save("imgcorruptlike.jpg", ia.draw_grid(images_aug, cols=5, rows=4))
def generate_dropout2d(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] images_aug.extend(iaa.Dropout2d(p=0.5)(images=[image] * (2 * 8 - 1))) _save("dropout2d.jpg", ia.draw_grid(images_aug, cols=8, rows=2))
def generate_randaugment(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] images_aug.extend(iaa.RandAugment(m=20)(images=[image] * (2 * 8 - 1))) _save("randaugment.jpg", ia.draw_grid(images_aug, cols=8, rows=2))
def generate_with_polar_warping(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] aug = iaa.WithPolarWarping(iaa.CropAndPad(percent=(-0.1, 0.1))) images_aug.extend(aug(images=[image] * 7)) images_aug.append(image) aug = iaa.WithPolarWarping( iaa.Affine(translate_percent={ "x": (-0.2, 0.2), "y": (-0.2, 0.2) }, rotate=(-35, 35), scale=(0.8, 1.2), shear={ "x": (-15, 15), "y": (-15, 15) })) images_aug.extend(aug(images=[image] * 7)) images_aug.append(image) aug = iaa.WithPolarWarping(iaa.AveragePooling((2, 8))) images_aug.extend(aug(images=[image] * 7)) _save("withpolarwarping.jpg", ia.draw_grid(images_aug, cols=8, rows=3))
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 chapter_examples_segmentation_maps_bool_small(): import imageio import numpy as np import imgaug as ia from imgaug.augmentables.segmaps import SegmentationMapsOnImage # Load an example image (uint8, 128x128x3). image = ia.quokka(size=(128, 128), extract="square") # Create an example mask (bool, 128x128). # Here, we arbitrarily place a square on the image. segmap = np.zeros((128, 128, 1), dtype=bool) segmap[28:71, 35:85, 0] = True segmap = SegmentationMapsOnImage(segmap, shape=image.shape) # Draw three columns: (1) original image, # (2) original image with mask on top, (3) only mask cells = [ image, segmap.draw_on_image(image)[0], segmap.draw(size=image.shape[:2])[0] ] # Convert cells to a grid image and save. grid_image = ia.draw_grid(cells, cols=3) # imageio.imwrite("example_segmaps_bool.jpg", grid_image) save("examples_segmentation_maps", "bool_small.jpg", grid_image, quality=90)
def chapter_examples_segmentation_maps_bool_full(): import imgaug as ia from imgaug import augmenters as iaa import imageio import numpy as np ia.seed(1) # Load an example image (uint8, 128x128x3). image = ia.quokka(size=(128, 128), extract="square") # Create an example mask (bool, 128x128). # Here, we just randomly place a square on the image. segmap = np.zeros((128, 128), dtype=bool) segmap[28:71, 35:85] = True segmap = ia.SegmentationMapOnImage(segmap, shape=image.shape) # Define our augmentation pipeline. seq = iaa.Sequential( [ iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels iaa.Sharpen((0.0, 1.0)), # sharpen the image iaa.Affine( rotate=(-45, 45)), # rotate by -45 to 45 degrees (affects heatmaps) iaa.ElasticTransformation( alpha=50, sigma=5) # apply water effect (affects heatmaps) ], random_order=True) # Augment images and heatmaps. images_aug = [] segmaps_aug = [] for _ in range(5): seq_det = seq.to_deterministic() images_aug.append(seq_det.augment_image(image)) segmaps_aug.append(seq_det.augment_segmentation_maps([segmap])[0]) # We want to generate an image of original input images and heatmaps before/after augmentation. # It is supposed to have five columns: (1) original image, (2) augmented image, # (3) augmented heatmap on top of augmented image, (4) augmented heatmap on its own in jet # color map, (5) augmented heatmap on its own in intensity colormap, # We now generate the cells of these columns. # # Note that we add a [0] after each heatmap draw command. That's because the heatmaps object # can contain many sub-heatmaps and hence we draw command returns a list of drawn sub-heatmaps. # We only used one sub-heatmap, so our lists always have one entry. cells = [] for image_aug, segmap_aug in zip(images_aug, segmaps_aug): cells.append(image) # column 1 cells.append(segmap.draw_on_image(image)) # column 2 cells.append(image_aug) # column 3 cells.append(segmap_aug.draw_on_image(image_aug)) # column 4 cells.append(segmap_aug.draw(size=image_aug.shape[:2])) # column 5 # Convert cells to grid image and save. grid_image = ia.draw_grid(cells, cols=5) #imageio.imwrite("example_segmaps_bool.jpg", grid_image) save("examples_segmentation_maps", "bool_full.jpg", grid_image, quality=90)
def main(): image = ia.quokka_square((200, 200)) kpsoi = ia.quokka_keypoints((200, 200), extract="square") aug = iaa.Jigsaw(10, 10) images_aug, kpsois_aug = aug(images=[image] * 16, keypoints=[kpsoi] * 16) images_show = [kpsoi_aug.draw_on_image(image_aug) for image_aug, kpsoi_aug in zip(images_aug, kpsois_aug)] ia.imshow(ia.draw_grid(images_show)) gen_time = timeit.timeit( "iaa.generate_jigsaw_destinations(10, 10, 2, rng)", number=128, setup=( "import imgaug.augmenters as iaa; " "import imgaug.random as iarandom; " "rng = iarandom.RNG(0)" ) ) print("Time to generate 128x dest:", gen_time) destinations = iaa.generate_jigsaw_destinations(10, 10, 1, seed=1) image_jig = iaa.apply_jigsaw(image, destinations) ia.imshow(image_jig)
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 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 test(self): ia.seed(1) # Load an example image (uint8, 128x128x3). image = ia.quokka(size=(128, 128), extract="square") # Create an example segmentation map (int32, 128x128). # Here, we just randomly place some squares on the image. # Class 0 is the background class. segmap = np.zeros((128, 128), dtype=np.int32) segmap[28:71, 35:85] = 1 segmap[10:25, 30:45] = 2 segmap[10:25, 70:85] = 3 segmap[10:110, 5:10] = 4 segmap[118:123, 10:110] = 5 segmap = ia.SegmentationMapOnImage(segmap, shape=image.shape, nb_classes=1 + 5) # Define our augmentation pipeline. seq = iaa.Sequential( [ iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels iaa.Sharpen((0.0, 1.0)), # sharpen the image iaa.Affine(rotate=( -45, 45)), # rotate by -45 to 45 degrees (affects heatmaps) iaa.ElasticTransformation( alpha=50, sigma=5) # apply water effect (affects heatmaps) ], random_order=True) # Augment images and heatmaps. images_aug = [] segmaps_aug = [] for _ in range(5): seq_det = seq.to_deterministic() images_aug.append(seq_det.augment_image(image)) segmaps_aug.append(seq_det.augment_segmentation_maps([segmap])[0]) # We want to generate an image of original input images and heatmaps before/after augmentation. # It is supposed to have five columns: (1) original image, (2) augmented image, # (3) augmented heatmap on top of augmented image, (4) augmented heatmap on its own in jet # color map, (5) augmented heatmap on its own in intensity colormap, # We now generate the cells of these columns. # # Note that we add a [0] after each heatmap draw command. That's because the heatmaps object # can contain many sub-heatmaps and hence we draw command returns a list of drawn sub-heatmaps. # We only used one sub-heatmap, so our lists always have one entry. cells = [] for image_aug, segmap_aug in zip(images_aug, segmaps_aug): cells.append(image) # column 1 cells.append(segmap.draw_on_image(image)) # column 2 cells.append(image_aug) # column 3 cells.append(segmap_aug.draw_on_image(image_aug)) # column 4 cells.append(segmap_aug.draw(size=image_aug.shape[:2])) # column 5 # Convert cells to grid image and save. grid_image = ia.draw_grid(cells, cols=5) ia.show_grid(cells, cols=5)
def generate_posterize(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] for nbits in np.arange(7)[::-1]: images_aug.append(iaa.Posterize(1 + nbits)(image=image)) _save("posterize.jpg", ia.draw_grid(images_aug, cols=8, rows=1))
def generate_add_to_brightness(): ia.seed(1) image = ia.quokka((128, 128)) images_aug = [image] for value in np.linspace(-100, 100, 7): images_aug.append(iaa.AddToBrightness(value)(image=image)) _save("addtobrightness.jpg", ia.draw_grid(images_aug, cols=8, rows=1))
def main(): image = ia.quokka(size=0.5) print(image.shape) kps = [ ia.KeypointsOnImage( [ ia.Keypoint(x=123, y=102), ia.Keypoint(x=182, y=98), ia.Keypoint(x=155, y=134), #ia.Keypoint(x=255, y=213), #ia.Keypoint(x=375, y=205), #ia.Keypoint(x=323, y=279), #ia.Keypoint(x=265, y=223), #ia.Keypoint(x=385, y=215), #ia.Keypoint(x=333, y=289), #ia.Keypoint(x=275, y=233), #ia.Keypoint(x=395, y=225), #ia.Keypoint(x=343, y=299), ia.Keypoint(x=-20, y=20) ], shape=(image.shape[0], image.shape[1]) ) ] #kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ #iaa.PiecewiseAffine(scale=0), iaa.PiecewiseAffine(scale=0.05), iaa.PiecewiseAffine(scale=0.1), iaa.PiecewiseAffine(scale=0.2) ] #print("original", image.shape) misc.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs: images_aug = [] for _ in range(16): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] #img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) #print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) images_aug.append(img_aug_kps) #misc.imshow(img_aug_kps) print(aug.name) misc.imshow(ia.draw_grid(images_aug))
def main(): image = ia.quokka(size=0.5) print(image.shape) kps = [ ia.KeypointsOnImage( [ ia.Keypoint(x=123, y=102), ia.Keypoint(x=182, y=98), ia.Keypoint(x=155, y=134), #ia.Keypoint(x=255, y=213), #ia.Keypoint(x=375, y=205), #ia.Keypoint(x=323, y=279), #ia.Keypoint(x=265, y=223), #ia.Keypoint(x=385, y=215), #ia.Keypoint(x=333, y=289), #ia.Keypoint(x=275, y=233), #ia.Keypoint(x=395, y=225), #ia.Keypoint(x=343, y=299), ia.Keypoint(x=-20, y=20) ], shape=(image.shape[0], image.shape[1])) ] #kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ #iaa.PiecewiseAffine(scale=0), iaa.PiecewiseAffine(scale=0.05), iaa.PiecewiseAffine(scale=0.1), iaa.PiecewiseAffine(scale=0.2) ] #print("original", image.shape) ia.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs: images_aug = [] for _ in range(16): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] #img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) #print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) images_aug.append(img_aug_kps) #ia.imshow(img_aug_kps) print(aug.name) ia.imshow(ia.draw_grid(images_aug))
def create_visualization(pred, gt, img, heatmap, overlay): pred = cv2.cvtColor(pred, cv2.COLOR_GRAY2BGR) gt = cv2.cvtColor(gt, cv2.COLOR_GRAY2BGR) heatmap = heatmap.astype(np.float32) / 255. overlay = overlay.astype(np.float32) / 255. img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) grid_image = ia.draw_grid([img, pred, gt, heatmap, overlay], cols=5) return grid_image
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 main(): image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg", format="jpg") augs = [ ("iaa.SnowflakesLayer()", iaa.SnowflakesLayer( density=0.05, density_uniformity=0.5, flake_size=0.9, flake_size_uniformity=0.5, angle=(-45, 45), speed=(0.001, 0.04), blur_sigma_fraction=(0.75*0.0001, 0.75*0.001)) ) ] for descr, aug in augs: print(descr) images_aug = aug.augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug))
def main(): img = ia.quokka(0.5) augs = [ ("iaa.AdditivePoissonNoise(0)", iaa.AdditivePoissonNoise(0)), ("iaa.AdditivePoissonNoise(10.0)", iaa.AdditivePoissonNoise(10.0)), ("iaa.AdditivePoissonNoise(20.0)", iaa.AdditivePoissonNoise(20.0)), ("iaa.AdditivePoissonNoise(50.0)", iaa.AdditivePoissonNoise(50.0)), ("iaa.AdditivePoissonNoise((10.0, 20))", iaa.AdditivePoissonNoise((10.0, 20))), ("iaa.AdditivePoissonNoise([10.0, 20.0, 50])", iaa.AdditivePoissonNoise([10.0, 20.0, 50])), ("iaa.AdditivePoissonNoise(20, per_channel=True)", iaa.AdditivePoissonNoise(50, per_channel=True)), ] for descr, aug in augs: print(descr) imgs_aug = aug.augment_images([img] * 16) ia.imshow(ia.draw_grid(imgs_aug))
def main(): img = ia.quokka(0.5) mul = 0.01 augs = [ ("iaa.ImpulseNoise(p=0*mul)", iaa.ImpulseNoise(p=0*mul)), ("iaa.ImpulseNoise(p=1*mul)", iaa.ImpulseNoise(p=1*mul)), ("iaa.ImpulseNoise(p=2*mul)", iaa.ImpulseNoise(p=2*mul)), ("iaa.ImpulseNoise(p=3*mul)", iaa.ImpulseNoise(p=3*mul)), ("iaa.ImpulseNoise(p=(0*mul, 1*mul))", iaa.ImpulseNoise(p=(0*mul, 1*mul))), ("iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul])", iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul])) ] for descr, aug in augs: print(descr) imgs_aug = aug.augment_images([img] * 16) ia.imshow(ia.draw_grid(imgs_aug))
def main(): image = ia.quokka(size=0.5) kps = [ia.KeypointsOnImage( [ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)], shape=(image.shape[0]*2, image.shape[1]*2) )] kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ iaa.PerspectiveTransform(scale=0.01, name="pt001", keep_size=True), iaa.PerspectiveTransform(scale=0.1, name="pt01", keep_size=True), iaa.PerspectiveTransform(scale=0.2, name="pt02", keep_size=True), iaa.PerspectiveTransform(scale=0.3, name="pt03", keep_size=True), iaa.PerspectiveTransform(scale=(0, 0.3), name="pt00to03", keep_size=True) ] print("original", image.shape) misc.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs: images_aug = [] for _ in range(16): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) #print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) images_aug.append(img_aug_kps) #misc.imshow(img_aug_kps) print(aug.name) misc.imshow(ia.draw_grid(images_aug)) print("----------------") print("6 channels") print("----------------") image6 = np.dstack([image, image]) image6_aug = augs[1].augment_image(image6) misc.imshow( np.hstack([image6_aug[..., 0:3], image6_aug[..., 3:6]]) )
def main(): parser = argparse.ArgumentParser(description="Contrast check script") parser.add_argument("--per_channel", dest="per_channel", action="store_true") args = parser.parse_args() augs = [] for p in [0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]: augs.append(("GammaContrast " + str(p), iaa.GammaContrast(p, per_channel=args.per_channel))) for cutoff in [0.25, 0.5, 0.75]: for gain in [5, 10, 15, 20, 25]: augs.append(("SigmoidContrast " + str(cutoff) + " " + str(gain), iaa.SigmoidContrast(gain, cutoff, per_channel=args.per_channel))) for gain in [0.0, 0.25, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]: augs.append(("LogContrast " + str(gain), iaa.LogContrast(gain, per_channel=args.per_channel))) for alpha in [-1.0, 0.5, 0, 0.5, 1.0, 2.0, (0.5, 1.5), [0.5, 1.0, 1.5]]: augs.append(("LinearContrast " + str(alpha), iaa.LinearContrast(alpha, per_channel=args.per_channel))) augs.append(("AllChannelsHistogramEqualization", iaa.AllChannelsHistogramEqualization())) augs.append(("HistogramEqualization (Lab)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.Lab))) augs.append(("HistogramEqualization (HSV)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HSV))) augs.append(("HistogramEqualization (HLS)", iaa.HistogramEqualization(to_colorspace=iaa.HistogramEqualization.HLS))) for clip_limit in [0.1, 1, 5, 10]: for tile_grid_size_px in [3, 7]: augs.append(("AllChannelsCLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px), iaa.AllChannelsCLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px, per_channel=args.per_channel))) for clip_limit in [1, 5, 10, 100, 200]: for tile_grid_size_px in [3, 7, 15]: augs.append(("CLAHE %d %dx%d" % (clip_limit, tile_grid_size_px, tile_grid_size_px), iaa.CLAHE(clip_limit=clip_limit, tile_grid_size_px=tile_grid_size_px))) images = [data.astronaut()] * 16 images = ia.imresize_many_images(np.uint8(images), (128, 128)) for name, aug in augs: print("-----------") print(name) print("-----------") images_aug = aug.augment_images(images) images_aug[0] = images[0] grid = ia.draw_grid(images_aug, rows=4, cols=4) ia.imshow(grid)
def main(): image = data.astronaut() cv2.namedWindow("aug", cv2.WINDOW_NORMAL) cv2.imshow("aug", image) cv2.waitKey(TIME_PER_STEP) # for value in cycle(np.arange(-255, 255, VAL_PER_STEP)): for value in np.arange(-255, 255, VAL_PER_STEP): aug = iaa.AddToHueAndSaturation(value=value) img_aug = aug.augment_image(image) img_aug = ia.pad(img_aug, bottom=40) img_aug = ia.draw_text(img_aug, x=0, y=img_aug.shape[0]-38, text="value=%d" % (value,), size=30) cv2.imshow("aug", img_aug) cv2.waitKey(TIME_PER_STEP) images_aug = iaa.AddToHueAndSaturation(value=(-255, 255), per_channel=True).augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug))
def draw_grid(images_aug, keypoints_aug): if keypoints_aug is None: keypoints_aug = [] for bidx in range(len(images_aug)): keypoints_aug.append([None for image in images_aug[bidx]]) images_kps_batches = [] for bidx in range(len(images_aug)): images_kps_batch = [] for image, kps in zip(images_aug[bidx], keypoints_aug[bidx]): if kps is None: image_kps = image else: image_kps = kps.draw_on_image(image, size=5, color=[255, 0, 0]) images_kps_batch.append(image_kps) images_kps_batches.extend(images_kps_batch) grid = ia.draw_grid(images_kps_batches, cols=len(images_aug[0])) return grid
def main(): image = imageio.imread("https://upload.wikimedia.org/wikipedia/commons/8/89/Kukle%2CCzech_Republic..jpg", format="jpg") augs = [ ("iaa.FastSnowyLandscape(64, 1.5)", iaa.FastSnowyLandscape(64, 1.5)), ("iaa.FastSnowyLandscape(128, 1.5)", iaa.FastSnowyLandscape(128, 1.5)), ("iaa.FastSnowyLandscape(200, 1.5)", iaa.FastSnowyLandscape(200, 1.5)), ("iaa.FastSnowyLandscape(64, 2.5)", iaa.FastSnowyLandscape(64, 2.5)), ("iaa.FastSnowyLandscape(128, 2.5)", iaa.FastSnowyLandscape(128, 2.5)), ("iaa.FastSnowyLandscape(200, 2.5)", iaa.FastSnowyLandscape(200, 2.5)), ("iaa.FastSnowyLandscape(64, 3.5)", iaa.FastSnowyLandscape(64, 3.5)), ("iaa.FastSnowyLandscape(128, 3.5)", iaa.FastSnowyLandscape(128, 3.5)), ("iaa.FastSnowyLandscape(200, 3.5)", iaa.FastSnowyLandscape(200, 3.5)), ("iaa.FastSnowyLandscape()", iaa.FastSnowyLandscape()) ] for descr, aug in augs: print(descr) images_aug = aug.augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug))
def main(): augs = [ ("0", iaa.JpegCompression(compression=0)), ("1", iaa.JpegCompression(compression=1)), ("25", iaa.JpegCompression(compression=25)), ("50", iaa.JpegCompression(compression=50)), ("75", iaa.JpegCompression(compression=75)), ("99", iaa.JpegCompression(compression=99)), ("100", iaa.JpegCompression(compression=100)), ("(0, 50)", iaa.JpegCompression(compression=(0, 50))), ("(50, 100)", iaa.JpegCompression(compression=(50, 100))), ("(0, 100)", iaa.JpegCompression(compression=(0, 100))), ] image = ia.quokka(size=(256, 256), extract="square") images = np.uint8([image] * (5*5)) for i, (name, aug) in enumerate(augs): print(i, name) images_aug = aug.augment_images(images) ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def main(): image = ia.quokka(size=0.5) print(image.shape) kps = [ ia.KeypointsOnImage( [ ia.Keypoint(x=123, y=102), ia.Keypoint(x=182, y=98), ia.Keypoint(x=155, y=134), ia.Keypoint(x=-20, y=20) ], shape=(image.shape[0], image.shape[1]) ) ] print("image shape:", image.shape) augs = [ iaa.PiecewiseAffine(scale=0.05), iaa.PiecewiseAffine(scale=0.1), iaa.PiecewiseAffine(scale=0.2) ] ia.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs: images_aug = [] for _ in range(16): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) images_aug.append(img_aug_kps) print(aug.name) ia.imshow(ia.draw_grid(images_aug))
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, (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))
import imgaug as ia import imageio import numpy as np # Load an example image (uint8, 128x128x3). image = ia.quokka(size=(128, 128), extract="square") # Create an example mask (bool, 128x128). # Here, we just randomly place a square on the image. segmap = np.zeros((128, 128), dtype=bool) segmap[28:71, 35:85] = True segmap = ia.SegmentationMapOnImage(segmap, shape=image.shape) # Draw three columns: (1) original image, (2) original image with mask on top, (3) only mask cells = [ image, segmap.draw_on_image(image), segmap.draw(size=image.shape[:2]) ] # Convert cells to grid image and save. grid_image = ia.draw_grid(cells, cols=3) imageio.imwrite("example_segmaps_bool.jpg", grid_image)
def main(): quokka = ia.quokka(size=0.5) h, w = quokka.shape[0:2] heatmap = np.zeros((h, w), dtype=np.float32) heatmap[70:120, 90:150] = 0.1 heatmap[30:70, 50:65] = 0.5 heatmap[20:50, 55:85] = 1.0 heatmap[120:140, 0:20] = 0.75 heatmaps = ia.HeatmapsOnImage(heatmap[..., np.newaxis], quokka.shape) print("Affine...") aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128) quokka_aug = aug.augment_image(quokka) heatmaps_aug = aug.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("Affine with mode=edge...") aug = iaa.Affine(translate_px={"x": 20}, mode="edge") quokka_aug = aug.augment_image(quokka) heatmaps_aug = aug.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("PiecewiseAffine...") aug = iaa.PiecewiseAffine(scale=0.04) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("PerspectiveTransform...") aug = iaa.PerspectiveTransform(scale=0.04) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("ElasticTransformation alpha=3, sig=0.5...") aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("ElasticTransformation alpha=10, sig=3...") aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("CopAndPad mode=constant...") aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("CopAndPad mode=constant + percent...") aug = iaa.CropAndPad(percent=(-0.05, 0.05, 0.1, -0.1), pad_mode="constant", pad_cval=128) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("CropAndPad mode=edge...") aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge") aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) ) print("Resize...") aug = iaa.Resize(0.5, interpolation="nearest") aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow(ia.draw_grid([heatmaps_drawn[0], heatmaps_aug_drawn[0]], cols=2)) print("Alpha...") aug = iaa.Alpha(0.7, iaa.Affine(rotate=20)) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0] heatmaps_drawn = heatmaps.draw_on_image(quokka) heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ heatmaps_drawn[0], heatmaps_aug_drawn[0] ]) )
def main(): image = ia.quokka(size=0.5) kps = [ia.KeypointsOnImage( [ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)], shape=(image.shape[0]*2, image.shape[1]*2) )] kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ iaa.CropAndPad(px=50, name="pad-by-50px"), iaa.CropAndPad(px=(10, 20, 30, 40), name="pad-by-10-20-30-40px"), iaa.CropAndPad(percent=0.1, name="pad-by-01percent"), iaa.CropAndPad(percent=(0.01, 0.02, 0.03, 0.04), name="pad-by-001-002-003-004percent"), iaa.CropAndPad(px=-20, name="crop-by-20px"), iaa.CropAndPad(px=(-10, -20, -30, -40), name="crop-by-10-20-30-40px"), iaa.CropAndPad(percent=-0.1, name="crop-by-01percent"), iaa.CropAndPad(percent=(-0.01, -0.02, -0.03, -0.04), name="crop-by-001-002-003-004percent") ] augs_many = [ iaa.Crop(px=(0, 50), name="native-crop-0-to-50px"), iaa.Crop(px=iap.DiscreteUniform(0, 50), name="native-crop-0-to-50px-iap"), iaa.Pad(px=(0, 50), pad_mode="linear_ramp", pad_cval=(0, 255), name="native-pad-0-to-50px-pad-modes"), iaa.CropAndPad(px=(0, 50), sample_independently=False, name="pad-by-0-to-50px-same"), iaa.CropAndPad(px=(0, 50), name="pad-by-0-to-50px"), iaa.CropAndPad(px=(0, 50), pad_mode=ia.ALL, pad_cval=(0, 255), name="pad-by-0-to-50px-random-pad-modes-cvals"), iaa.CropAndPad(px=((0, 50), (0, 50), (0, 50), (0, 50)), name="pad-by-0-to-50px-each"), iaa.CropAndPad(percent=(0, 0.1), sample_independently=False, name="pad-by-0-to-01percent-same"), iaa.CropAndPad(percent=(0, 0.1), name="pad-by-0-to-01percent"), iaa.CropAndPad(percent=(0, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255), name="pad-by-0-to-01percent-random-pad-modes-cvals"), iaa.CropAndPad(percent=((0, 0.1), (0, 0.1), (0, 0.1), (0, 0.1)), name="pad-by-0-to-01percent-each"), iaa.CropAndPad(px=(-50, 0), name="crop-by-50-to-0px"), iaa.CropAndPad(px=((-50, 0), (-50, 0), (-50, 0), (-50, 0)), name="crop-by-50-to-0px-each"), iaa.CropAndPad(percent=(-0.1, 0), name="crop-by-01-to-0percent"), iaa.CropAndPad(percent=((-0.1, 0), (-0.1, 0), (-0.1, 0), (-0.1, 0)), name="crop-by-01-to-0percent-each"), iaa.CropAndPad(px=(-50, 50), name="pad-and-crop-by-50px") ] print("original", image.shape) ia.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Same aug per image") print("-----------------") for aug in augs: img_aug = aug.augment_image(image) kps_aug = aug.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) ia.imshow(img_aug_kps) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs_many: images_aug = [] for _ in range(64): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) images_aug.append(img_aug_kps) print(aug.name) ia.imshow(ia.draw_grid(images_aug))
def main(): quokka = ia.quokka(size=0.5) h, w = quokka.shape[0:2] c = 4 segmap = np.zeros((h, w, c), dtype=np.float32) segmap[70:120, 90:150, 0] = 1.0 segmap[30:70, 50:65, 1] = 1.0 segmap[20:50, 55:85, 2] = 1.0 segmap[120:140, 0:20, 3] = 1.0 segmap = ia.SegmentationMapOnImage(segmap, quokka.shape) print("Affine...") aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128) quokka_aug = aug.augment_image(quokka) segmaps_aug = aug.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("Affine with mode=edge...") aug = iaa.Affine(translate_px={"x": 20}, mode="edge") quokka_aug = aug.augment_image(quokka) segmaps_aug = aug.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("PiecewiseAffine...") aug = iaa.PiecewiseAffine(scale=0.04) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("PerspectiveTransform...") aug = iaa.PerspectiveTransform(scale=0.04) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("ElasticTransformation alpha=3, sig=0.5...") aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("ElasticTransformation alpha=10, sig=3...") aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("CopAndPad mode=constant...") aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("CropAndPad mode=edge...") aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge") aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) ) print("Resize...") aug = iaa.Resize(0.5, interpolation="nearest") aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow(ia.draw_grid([segmaps_drawn, segmaps_aug_drawn], cols=2)) print("Alpha...") aug = iaa.Alpha(0.7, iaa.Affine(rotate=20)) aug_det = aug.to_deterministic() quokka_aug = aug_det.augment_image(quokka) segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0] segmaps_drawn = segmap.draw_on_image(quokka) segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug) ia.imshow( np.hstack([ segmaps_drawn, segmaps_aug_drawn ]) )
def main(): # test 2d image misc.imshow(iaa.Scale(64).augment_image(data.camera())) # test many images images = [ia.quokka(size=0.5), ia.quokka(size=0.5)] images_aug = iaa.Scale(64).augment_images(images) misc.imshow(np.hstack(images_aug)) image = ia.quokka(size=0.5) kps = [ia.KeypointsOnImage( [ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)], shape=(image.shape[0]*2, image.shape[1]*2) )] kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs = [ iaa.Scale("keep", name="keep"), iaa.Scale(32, name="i32"), iaa.Scale(0.5, name="f05"), iaa.Scale({"height": 32}, name="height32"), iaa.Scale({"width": 32}, name="width32"), iaa.Scale({"height": "keep", "width": 32}, name="keep-width32"), iaa.Scale({"height": 32, "width": "keep"}, name="height32-keep"), iaa.Scale({"height": "keep", "width": "keep"}, name="keep-keep"), iaa.Scale({"height": 32, "width": 64}, name="height32width64"), iaa.Scale({"height": 64, "width": "keep-aspect-ratio"}, name="height64width-kar"), iaa.Scale({"height": "keep-aspect-ratio", "width": 64}, name="height-kar_width64") ] augs_many = [ iaa.Scale((32, 128), name="tuple-32-128"), iaa.Scale([32, 64, 128], name="list-32-64-128"), iaa.Scale({"height": (32, 128), "width": "keep"}, name="height-32-64_width-keep"), iaa.Scale({"height": (32, 128), "width": "keep-aspect-ratio"}, name="height-32-128_width-kar"), iaa.Scale({"height": (32, 128), "width": (32, 128)}, name="height-32-128_width-32-128") ] print("original", image.shape) misc.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Same size per image") print("-----------------") for aug in augs: img_aug = aug.augment_image(image) kps_aug = aug.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) misc.imshow(img_aug_kps) print("-----------------") print("Random per image") print("-----------------") for aug in augs_many: images_aug = [] for _ in range(64): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) #print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0]) images_aug.append(img_aug_kps) print(aug.name) misc.imshow(ia.draw_grid(images_aug)) print("nearest/cv2.INTER_NEAREST/cubic") misc.imshow(np.hstack([ iaa.Scale(64, interpolation="nearest").augment_image(image), iaa.Scale(64, interpolation=cv2.INTER_NEAREST).augment_image(image), iaa.Scale(64, interpolation="cubic").augment_image(image) ])) print("random nearest/cubic") iaa.Scale(64, interpolation=["nearest", "cubic"]).show_grid([image], 8, 8)
def main(): image = ia.quokka(size=0.5) kps = [ia.KeypointsOnImage( [ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)], shape=(image.shape[0]*2, image.shape[1]*2) )] kps[0] = kps[0].on(image.shape) print("image shape:", image.shape) augs_many = [ iaa.PadToFixedSize(200, 200, name="pad-width200-height200"), iaa.PadToFixedSize(200, 322, name="pad-width200-height322"), iaa.PadToFixedSize(200, 400, name="pad-width200-height400"), iaa.PadToFixedSize(480, 200, name="pad-width480-height200"), iaa.PadToFixedSize(480, 322, name="pad-width480-height322"), # input size == output size iaa.PadToFixedSize(480, 400, name="pad-width480-height400"), iaa.PadToFixedSize(600, 200, name="pad-width600-height200"), iaa.PadToFixedSize(600, 322, name="pad-width600-height322"), iaa.PadToFixedSize(600, 400, name="pad-width600-height400"), iaa.CropToFixedSize(200, 200, name="crop-width200-height200"), iaa.CropToFixedSize(200, 322, name="crop-width200-height322"), iaa.CropToFixedSize(200, 400, name="crop-width200-height400"), iaa.CropToFixedSize(480, 200, name="crop-width480-height200"), iaa.CropToFixedSize(480, 322, name="crop-width480-height322"), # input size == output size iaa.CropToFixedSize(480, 400, name="crop-width480-height400"), iaa.CropToFixedSize(600, 200, name="crop-width600-height200"), iaa.CropToFixedSize(600, 322, name="crop-width600-height322"), iaa.CropToFixedSize(600, 400, name="crop-width600-height400"), iaa.Sequential([ iaa.PadToFixedSize(200, 200), iaa.CropToFixedSize(200, 200) ], name="pad-crop-width200-height200"), iaa.Sequential([ iaa.PadToFixedSize(400, 400), iaa.CropToFixedSize(400, 400) ], name="pad-crop-width400-height400"), iaa.Sequential([ iaa.PadToFixedSize(600, 600), iaa.CropToFixedSize(600, 600) ], name="pad-crop-width600-height600"), iaa.Sequential([ iaa.CropToFixedSize(200, 200), iaa.PadToFixedSize(200, 200) ], name="crop-pad-width200-height200"), iaa.Sequential([ iaa.CropToFixedSize(400, 400), iaa.PadToFixedSize(400, 400) ], name="crop-pad-width400-height400"), iaa.Sequential([ iaa.CropToFixedSize(600, 600), iaa.PadToFixedSize(600, 600) ], name="crop-pad-width600-height600"), ] print("original", image.shape) ia.imshow(kps[0].draw_on_image(image)) print("-----------------") print("Random aug per image") print("-----------------") for aug in augs_many: images_aug = [] for _ in range(36): aug_det = aug.to_deterministic() img_aug = aug_det.augment_image(image) kps_aug = aug_det.augment_keypoints(kps)[0] img_aug_kps = kps_aug.draw_on_image(img_aug) img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255) images_aug.append(img_aug_kps) print(aug.name) ia.imshow(ia.draw_grid(images_aug))