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))
