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 chapter_augmenters_blendalphasomecolors():
fn_start = "blend/blendalphasomecolors"
image = imageio.imread(
os.path.join(DOCS_IMAGES_BASE_PATH, "input_images",
"1280px-Vincent_Van_Gogh_-_Wheatfield_with_Crows.jpg"))
# ca. 15% of original size
image = ia.imresize_single_image(image, (92, 192))
aug = iaa.BlendAlphaSomeColors(iaa.Grayscale(1.0))
run_and_save_augseq(fn_start + "_grayscale.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.TotalDropout(1.0))
run_and_save_augseq(fn_start + "_total_dropout.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.MultiplySaturation(0.5),
iaa.MultiplySaturation(1.5))
run_and_save_augseq(fn_start + "_saturation.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
alpha=[0.0, 1.0],
smoothness=0.0)
run_and_save_augseq(fn_start + "_pooling.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
nb_bins=2,
smoothness=0.0)
run_and_save_augseq(fn_start + "_pooling_2_bins.jpg",
aug, [image for _ in range(4 * 4)],
cols=4,
rows=4)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
from_colorspace="BGR")
run_and_save_augseq(fn_start + "_pooling_bgr.jpg",
aug, [image[:, :, ::-1] for _ in range(4 * 2)],
cols=4,
rows=2,
image_colorspace=iaa.CSPACE_BGR)
def test_augment_images__kernel_size_differs__requires_padding(self):
aug = iaa.AveragePooling(
(iap.Deterministic(3), iap.Deterministic(1)),
keep_size=False)
image = np.uint8([
[50-2, 50-1, 120-4, 120+4],
[50+1, 50+2, 120+2, 120-1]
])
image = np.tile(image[:, :, np.newaxis], (1, 1, 3))
expected = np.uint8([
[(50-2 + 50+1 + 50-2)/3,
(50-1 + 50+2 + 50-1)/3,
(120-4 + 120+2 + 120-4)/3,
(120+4 + 120-1 + 120+4)/3]
])
expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3))
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == (1, 4, 3)
assert np.all(diff <= 1)
def test_augment_images__kernel_size_is_two__full_100s(self):
aug = iaa.AveragePooling(2, keep_size=False)
image = np.full((6, 6, 3), 100, dtype=np.uint8)
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - 100)
assert image_aug.shape == (3, 3, 3)
assert np.all(diff <= 1)
def test___init___default_settings(self):
aug = iaa.AveragePooling(2)
assert len(aug.kernel_size) == 2
assert is_parameter_instance(aug.kernel_size[0], iap.Deterministic)
assert aug.kernel_size[0].value == 2
assert aug.kernel_size[1] is None
assert aug.keep_size is True
def chapter_augmenters_blendalphahorizontallineargradient():
fn_start = "blend/blendalphahorizontallineargradient"
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AddToHue((-100, 100)))
run_and_save_augseq(fn_start + "_hue.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.TotalDropout(1.0),
min_value=0.2,
max_value=0.8)
run_and_save_augseq(fn_start + "_total_dropout.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AveragePooling(11),
start_at=(0.0, 1.0),
end_at=(0.0, 1.0))
run_and_save_augseq(fn_start + "_pooling.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def rgbmore(self, im):
return_im = []
add_return_im = lambda im: return_im.extend(im)
grey = np.array(im.convert(mode='L'))
im = np.array(im)
rgb_grey = np.dstack((im, grey))
edge = iaa.EdgeDetect(alpha=1)(images=rgb_grey)
dir_edge = lambda d: iaa.DirectedEdgeDetect(alpha=1, direction=d)(images=
grey)
dir_edges = np.array(
[dir_edge(d) for d in np.linspace(0, 1, num=3, endpoint=False)])
dir_edges = np.transpose(dir_edges, (1, 2, 0))
canny = iaa.Canny(alpha=1.0,
hysteresis_thresholds=128,
sobel_kernel_size=4,
deterministic=True,
colorizer=iaa.RandomColorsBinaryImageColorizer(
color_true=255, color_false=0))(images=grey)
avg_pool = iaa.AveragePooling(2)(images=grey)
max_pool = iaa.MaxPooling(2)(images=grey)
min_pool = iaa.MinPooling(2)(images=grey)
add_return_im([im, grey])
add_return_im([edge, dir_edges, canny])
add_return_im([avg_pool, max_pool, min_pool])
return np.dstack(return_im)
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 chapter_augmenters_withpolarwarping():
fn_start = "geometric/withpolarwarping"
image = ia.quokka(size=(128, 128))
aug = iaa.WithPolarWarping(iaa.CropAndPad(percent=(-0.1, 0.1)))
run_and_save_augseq(
fn_start + "_cropandpad.jpg", aug,
[image for _ in range(4*1)], cols=4, rows=1)
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)}
)
)
run_and_save_augseq(
fn_start + "_affine.jpg", aug,
[image for _ in range(4*4)], cols=4, rows=4)
aug = iaa.WithPolarWarping(iaa.AveragePooling((2, 8)))
run_and_save_augseq(
fn_start + "_averagepooling.jpg", aug,
[image for _ in range(4*2)], cols=4, rows=2)
def img_aug(img_name, base_dir):
image = mpimg.imread(Path(base_dir, 'datasets', 'images', img_name))
ran = random.randint(1, 5)
if ran == 1:
aug = iaa.Sequential([
iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),
iaa.AddToHueAndSaturation((-60, 60)),
iaa.ElasticTransformation(alpha=90, sigma=9),
iaa.Cutout()
],
random_order=True)
image = aug(image=image)
elif ran == 2:
aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
nb_cols=2,
foreground=iaa.Multiply(0.0),
background=iaa.AveragePooling(8),
alpha=[0.0, 0.0, 1.0])
image = aug(image=image)
elif ran == 3:
image = tf.image.adjust_brightness(image, 0.4)
elif ran == 4:
image = tf.image.random_flip_left_right(image)
image = tf.image.rot90(image)
image = tf.image.random_flip_up_down(image)
elif ran == 5:
image = tf.image.central_crop(image, central_fraction=0.5)
return image
def test_get_parameters(self):
aug = iaa.AveragePooling(2)
params = aug.get_parameters()
assert len(params) == 2
assert len(params[0]) == 2
assert isinstance(params[0][0], iap.Deterministic)
assert params[0][0].value == 2
assert params[0][1] is None
def test___init___custom_settings(self):
aug = iaa.AveragePooling(((2, 4), (5, 6)), keep_size=False)
assert len(aug.kernel_size) == 2
assert is_parameter_instance(aug.kernel_size[0], iap.DiscreteUniform)
assert is_parameter_instance(aug.kernel_size[1], iap.DiscreteUniform)
assert aug.kernel_size[0].a.value == 2
assert aug.kernel_size[0].b.value == 4
assert aug.kernel_size[1].a.value == 5
assert aug.kernel_size[1].b.value == 6
assert aug.keep_size is False
def load_aug():
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
seq[0] = iaa.Sequential(
[
# execute 0 to 5 of the following (less important) augmenters per image
# don't execute all of them, as that would often be way too strong
iaa.SomeOf(
(0, 5),
[
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode=ia.ALL,
pad_cval=(0, 255)),
iaa.Crop(percent=0.25, keep_size=True),
iaa.OneOf([
iaa.GaussianBlur(
(0, 0.2
)), # blur images with a sigma between 0 and 2.0
iaa.AverageBlur(k=(2,
3)), # blur image using local means
iaa.MedianBlur(
k=(1, 3)), # blur image using local medians
]),
iaa.Sharpen(alpha=(0, 0.5),
lightness=(0.75, 1.5)), # sharpen images
iaa.Emboss(alpha=(0, 0.5),
strength=(0, 0.5)), # emboss images
# search either for all edges or for directed edges,
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255),
per_channel=0.5), # add gaussian noise to images
iaa.Add(
(-10, 10), per_channel=0.5
), # change brightness of images (by -10 to 10 of original value)
iaa.AddToHueAndSaturation(
(-10, 10)), # change hue and saturation
# either change the brightness of the whole image (sometimes
# per channel) or change the brightness of subareas
iaa.contrast.LinearContrast(
(0.5, 2.0),
per_channel=0.5), # improve or worsen the contrast
iaa.Grayscale(alpha=(0.0, 0.5)),
iaa.AdditiveLaplaceNoise(scale=0.05 * 255),
iaa.AdditivePoissonNoise(lam=2),
iaa.Multiply(mul=(0.5, 1.5)),
iaa.Dropout(p=(0.1, 0.2)),
iaa.CoarseDropout(p=0.1, size_percent=0.05),
iaa.MotionBlur(k=3),
iaa.LinearContrast(),
iaa.AveragePooling(2)
],
random_order=True)
],
random_order=True)
def main():
aug = iaa.BlendAlphaMask(
iaa.SegMapClassIdsMaskGen(1),
iaa.OneOf([iaa.TotalDropout(1.0),
iaa.AveragePooling(8)]))
aug2 = iaa.BlendAlphaSegMapClassIds(
1, iaa.OneOf([iaa.TotalDropout(1.0),
iaa.AveragePooling(8)]))
image = ia.quokka(0.25)
segmap = ia.quokka_segmentation_map(0.25)
images_aug, segmaps_aug = aug(images=[image] * 25,
segmentation_maps=[segmap] * 25)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
images_aug, segmaps_aug = aug2(images=[image] * 25,
segmentation_maps=[segmap] * 25)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def img_aug(image, method):
# image = mpimg.imread(
# Path(config.base_dir, 'datasets', 'images', img_path))
# print('original image')
# ia.imshow(image)
# sequential
if method == 'seq':
aug = iaa.Sequential([
iaa.CropAndPad(percent=(-0.2, 0.2), pad_mode="edge"),
iaa.AddToHueAndSaturation((-60, 60)),
iaa.ElasticTransformation(alpha=90, sigma=9),
iaa.Cutout(),
],
random_order=True)
image = aug(image=image)
# print("water-like")
# ia.imshow(image)
# blend alpha
elif method == 'ba':
aug = iaa.BlendAlphaVerticalLinearGradient(iaa.AveragePooling(11),
start_at=(0.0, 1.0),
end_at=(0.0, 1.0))
image = aug(image=image)
# print('blend alpha')
# ia.imshow(image)
# mosaic
elif method == 'ba_box':
aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
nb_cols=2,
foreground=iaa.Multiply(0.0),
background=iaa.AveragePooling(8),
alpha=[0.0, 0.0, 1.0])
image = aug(image=image)
# print('blend_alpha with boxes')
# ia.imshow(image)
return image
def test_augment_images__kernel_size_is_two__four_channels(self):
aug = iaa.AveragePooling(2, keep_size=False)
image = np.uint8([[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 1, 120 - 1]])
image = np.tile(image[:, :, np.newaxis], (1, 1, 4))
expected = np.uint8([[50, 120]])
expected = np.tile(expected[:, :, np.newaxis], (1, 1, 4))
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.shape == (1, 2, 4)
assert np.all(diff <= 1)
def get_seq_val():
sometimes = lambda aug: iaa.Sometimes(0.5, aug, random_state=STATE, )
seq_val = iaa.Sequential([
iaa.OneOf([
sometimes(iaa.GaussianBlur(sigma=(0.1, 1), random_state=STATE, )),
sometimes(iaa.AverageBlur(k=(3, 7))),
sometimes(iaa.MotionBlur(k=(3, 7))),
sometimes(iaa.AveragePooling((2, 8))),
sometimes(iaa.MaxPooling((2, 8))),
sometimes(iaa.MedianPooling((2, 8))),
sometimes(iaa.MinPooling((2, 8))),
]),
iaa.Multiply((0.8, 1.2)),
], random_order=True)
return seq_val
def test_augment_images__kernel_size_is_two__single_channel(self):
aug = iaa.AveragePooling(2, keep_size=False)
image = np.uint8([[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 1, 120 - 1]])
image = image[:, :, np.newaxis]
expected = np.uint8([[50, 120]])
expected = expected[:, :, np.newaxis]
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == (1, 2, 1)
assert np.all(diff <= 1)
def test_augment_images__kernel_size_is_two__non_contiguous(self):
aug = iaa.AveragePooling(2, keep_size=False)
image = np.array([[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 1, 120 - 1]],
dtype=np.uint8,
order="F")
assert image.flags["OWNDATA"]
assert not image.flags["C_CONTIGUOUS"]
expected = np.uint8([[50, 120]])
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == (1, 2)
assert np.all(diff <= 1)
def test_augment_images__kernel_size_differs(self):
aug = iaa.AveragePooling((iap.Deterministic(3), iap.Deterministic(2)),
keep_size=False)
image = np.uint8([
[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 2, 120 - 1],
[50 - 5, 50 + 5, 120 - 2, 120 + 1],
])
image = np.tile(image[:, :, np.newaxis], (1, 1, 3))
expected = np.uint8([[50, 120]])
expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3))
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.shape == (1, 2, 3)
assert np.all(diff <= 1)
def test_augment_images__kernel_size_is_two__view(self):
aug = iaa.AveragePooling(2, keep_size=False)
image = np.uint8([[50 - 2, 50 - 1, 120 - 4, 120 + 4],
[50 + 1, 50 + 2, 120 + 1, 120 - 1], [0, 0, 0, 0]])
image = np.tile(image[:, :, np.newaxis], (1, 1, 3))
image = image[:2, :, :]
assert not image.flags["OWNDATA"]
assert image.flags["C_CONTIGUOUS"]
expected = np.uint8([[50, 120]])
expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3))
image_aug = aug.augment_image(image)
diff = np.abs(image_aug.astype(np.int32) - expected)
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == (1, 2, 3)
assert np.all(diff <= 1)
def get_seq():
import imgaug.augmenters as iaa
sometimes = lambda aug: iaa.Sometimes(0.1, aug)
seq = iaa.Sequential(
[
sometimes(iaa.AdditiveGaussianNoise(scale=0.07 * 255)),
sometimes(iaa.GaussianBlur(sigma=(0, 3.0))),
sometimes(iaa.MedianBlur(k=(1, 5))),
sometimes(iaa.AverageBlur(k=((1, 5), (1, 3)))),
sometimes(iaa.AveragePooling([1, 5])),
sometimes(iaa.MaxPooling([1, 5])),
sometimes(iaa.MaxPooling([1, 5])),
sometimes(
iaa.CropAndPad(percent=(0, 0.2),
pad_mode=["constant", "edge"],
pad_cval=(0, 128))),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 64,
"width": 64
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 16,
"width": 16
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
],
random_order=True,
)
return seq
def get_augmenter():
sometimes = lambda aug: iaa.Sometimes(0.7, aug)
augmenter = iaa.Sequential([
sometimes(
iaa.OneOf([
iaa.GaussianBlur((0.8, 1.2)),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.AveragePooling([2, 2]),
iaa.Sharpen(alpha=(0.0, 0.5), lightness=(0.75, 2.0)),
iaa.AdditiveLaplaceNoise(scale=0.05 * 255, per_channel=True),
iaa.LinearContrast((0.5, 2.0), per_channel=True),
iaa.Clouds(),
iaa.Fog(),
iaa.PiecewiseAffine(scale=0.02),
iaa.Affine(scale={
"x": (0.8, 1),
"y": (0.8, 1)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
rotate=(-10, 10),
shear=(-5, 5),
order=[0, 1],
cval=(0, 255),
mode='constant'),
])),
sometimes(
iaa.OneOf([
iaa.Crop(px=(2, 6)),
iaa.CoarseDropout((0.0, 0.01), size_percent=(0.02, 0.1)),
])),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.08),
keep_size=False))
],
random_order=True)
return augmenter
def chapter_augmenters_blendalpharegulargrid():
fn_start = "blend/blendalpharegulargrid"
aug = iaa.BlendAlphaRegularGrid(nb_rows=(4, 6),
nb_cols=(1, 4),
foreground=iaa.Multiply(0.0))
run_and_save_augseq(fn_start + "_multiply.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaRegularGrid(nb_rows=2,
nb_cols=2,
foreground=iaa.Multiply(0.0),
background=iaa.AveragePooling(8),
alpha=[0.0, 0.0, 1.0])
run_and_save_augseq(fn_start + "_two_branches.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
def get_seq():
import imgaug.augmenters as iaa
sometimes = lambda aug: iaa.Sometimes(0.1, aug)
seq = iaa.Sequential(
[
sometimes(iaa.AdditiveGaussianNoise(scale=0.07 * 255)),
sometimes(iaa.GaussianBlur(sigma=(0, 3.0))),
sometimes(iaa.MedianBlur(k=(1, 5))),
sometimes(iaa.AverageBlur(k=((5, 11), (1, 3)))),
sometimes(iaa.AveragePooling([2, 8])),
sometimes(iaa.MaxPooling([2, 8])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 64,
"width": 64
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
sometimes(
iaa.Sequential([
iaa.Resize({
"height": 512,
"width": 512
}),
iaa.Resize({
"height": input_shape[0],
"width": input_shape[1]
}),
])),
],
random_order=True,
)
return seq
import numpy as np
import cv2
from imgaug import augmenters as iaa
path = 'idcard/'
sqe_list = [
iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add((-50, 50))),
iaa.WithChannels(1, iaa.Add((-50, 50))),
iaa.WithChannels(2, iaa.Add((-50, 50))),
iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB"),
iaa.Add((-80, 80), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.AverageBlur(k=((5), (1, 3))),
iaa.AveragePooling(2),
iaa.AddElementwise((-20, -5)),
iaa.AdditiveGaussianNoise(scale=(0, 0.05 * 255)),
iaa.JpegCompression(compression=(50, 99)),
iaa.MultiplyHueAndSaturation(mul_hue=(0.5, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-50, 50))),
iaa.WithBrightnessChannels(iaa.Add((-50, 50)),
to_colorspace=[iaa.CSPACE_Lab, iaa.CSPACE_HSV]),
iaa.MaxPooling(2),
iaa.MinPooling((1, 2)),
# iaa.Superpixels(p_replace=(0.1, 0.2), n_segments=(16, 128)),
iaa.Clouds(),
iaa.Fog(),
iaa.AdditiveGaussianNoise(scale=0.1 * 255, per_channel=True),
iaa.Dropout(p=(0, 0.2)),
def test_augment_images__kernel_size_is_one(self):
aug = iaa.AveragePooling(1)
image = np.arange(6 * 6 * 3).astype(np.uint8).reshape((6, 6, 3))
assert np.array_equal(aug.augment_image(image), image)
iaa.BilateralBlur(
d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)),
iaa.MotionBlur(k=(3, 9), angle=[-45, 45]),
iaa.MeanShiftBlur(spatial_radius=(5.0, 10.0),
color_radius=(5.0, 10.0)),
iaa.AllChannelsCLAHE(clip_limit=(1, 10)),
iaa.AllChannelsHistogramEqualization(),
iaa.GammaContrast((0.5, 1.5), per_channel=True),
iaa.GammaContrast((0.5, 1.5)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.HistogramEqualization(),
iaa.Sharpen(alpha=0.5)
]),
iaa.OneOf([
iaa.AveragePooling([2, 3]),
iaa.MaxPooling(([2, 3], [2, 3])),
]),
iaa.OneOf([
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
iaa.Rain(speed=(0.1, 0.3))
])
],
random_order=True)
def get_color_augmentation(augment_prob):
return iaa.Sometimes(augment_prob, aug_transform).augment_image
def create_augmenters(height, width, height_augmentable, width_augmentable,
only_augmenters):
def lambda_func_images(images, random_state, parents, hooks):
return images
def lambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return heatmaps
def lambda_func_keypoints(keypoints, random_state, parents, hooks):
return keypoints
def assertlambda_func_images(images, random_state, parents, hooks):
return True
def assertlambda_func_heatmaps(heatmaps, random_state, parents, hooks):
return True
def assertlambda_func_keypoints(keypoints, random_state, parents, hooks):
return True
augmenters_meta = [
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=False,
name="Sequential_2xNoop"),
iaa.Sequential([iaa.Noop(), iaa.Noop()],
random_order=True,
name="Sequential_2xNoop_random_order"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=False,
name="SomeOf_3xNoop"),
iaa.SomeOf((1, 3),
[iaa.Noop(), iaa.Noop(), iaa.Noop()],
random_order=True,
name="SomeOf_3xNoop_random_order"),
iaa.OneOf([iaa.Noop(), iaa.Noop(), iaa.Noop()], name="OneOf_3xNoop"),
iaa.Sometimes(0.5, iaa.Noop(), name="Sometimes_Noop"),
iaa.WithChannels([1, 2], iaa.Noop(), name="WithChannels_1_and_2_Noop"),
iaa.Noop(name="Noop"),
iaa.Lambda(func_images=lambda_func_images,
func_heatmaps=lambda_func_heatmaps,
func_keypoints=lambda_func_keypoints,
name="Lambda"),
iaa.AssertLambda(func_images=assertlambda_func_images,
func_heatmaps=assertlambda_func_heatmaps,
func_keypoints=assertlambda_func_keypoints,
name="AssertLambda"),
iaa.AssertShape((None, height_augmentable, width_augmentable, None),
name="AssertShape"),
iaa.ChannelShuffle(0.5, name="ChannelShuffle")
]
augmenters_arithmetic = [
iaa.Add((-10, 10), name="Add"),
iaa.AddElementwise((-10, 10), name="AddElementwise"),
#iaa.AddElementwise((-500, 500), name="AddElementwise"),
iaa.AdditiveGaussianNoise(scale=(5, 10), name="AdditiveGaussianNoise"),
iaa.AdditiveLaplaceNoise(scale=(5, 10), name="AdditiveLaplaceNoise"),
iaa.AdditivePoissonNoise(lam=(1, 5), name="AdditivePoissonNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseDropout"),
iaa.ReplaceElementwise((0.01, 0.05), (0, 255),
name="ReplaceElementwise"),
#iaa.ReplaceElementwise((0.95, 0.99), (0, 255), name="ReplaceElementwise"),
iaa.SaltAndPepper((0.01, 0.05), name="SaltAndPepper"),
iaa.ImpulseNoise((0.01, 0.05), name="ImpulseNoise"),
iaa.CoarseSaltAndPepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.Salt((0.01, 0.05), name="Salt"),
iaa.CoarseSalt((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarseSalt"),
iaa.Pepper((0.01, 0.05), name="Pepper"),
iaa.CoarsePepper((0.01, 0.05),
size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Invert(0.1, name="Invert"),
# ContrastNormalization
iaa.JpegCompression((50, 99), name="JpegCompression")
]
augmenters_blend = [
iaa.Alpha((0.01, 0.99), iaa.Noop(), name="Alpha"),
iaa.AlphaElementwise((0.01, 0.99), iaa.Noop(),
name="AlphaElementwise"),
iaa.SimplexNoiseAlpha(iaa.Noop(), name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha((-2.0, 2.0),
iaa.Noop(),
name="FrequencyNoiseAlpha")
]
augmenters_blur = [
iaa.GaussianBlur(sigma=(1.0, 5.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=(3, 11), name="BilateralBlur"),
iaa.MotionBlur(k=(3, 11), name="MotionBlur")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV",
children=iaa.Noop(),
name="WithColorspace"),
iaa.WithHueAndSaturation(children=iaa.Noop(),
name="WithHueAndSaturation"),
iaa.MultiplyHueAndSaturation((0.8, 1.2),
name="MultiplyHueAndSaturation"),
iaa.MultiplyHue((-1.0, 1.0), name="MultiplyHue"),
iaa.MultiplySaturation((0.8, 1.2), name="MultiplySaturation"),
iaa.AddToHueAndSaturation((-10, 10), name="AddToHueAndSaturation"),
iaa.AddToHue((-10, 10), name="AddToHue"),
iaa.AddToSaturation((-10, 10), name="AddToSaturation"),
iaa.ChangeColorspace(to_colorspace="HSV", name="ChangeColorspace"),
iaa.Grayscale((0.01, 0.99), name="Grayscale"),
iaa.KMeansColorQuantization((2, 16), name="KMeansColorQuantization"),
iaa.UniformColorQuantization((2, 16), name="UniformColorQuantization")
]
augmenters_contrast = [
iaa.GammaContrast(gamma=(0.5, 2.0), name="GammaContrast"),
iaa.SigmoidContrast(gain=(5, 20),
cutoff=(0.25, 0.75),
name="SigmoidContrast"),
iaa.LogContrast(gain=(0.7, 1.0), name="LogContrast"),
iaa.LinearContrast((0.5, 1.5), name="LinearContrast"),
iaa.AllChannelsCLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
name="AllChannelsCLAHE"),
iaa.CLAHE(clip_limit=(2, 10),
tile_grid_size_px=(3, 11),
to_colorspace="HSV",
name="CLAHE"),
iaa.AllChannelsHistogramEqualization(
name="AllChannelsHistogramEqualization"),
iaa.HistogramEqualization(to_colorspace="HSV",
name="HistogramEqualization"),
]
augmenters_convolutional = [
iaa.Convolve(np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]]),
name="Convolve_3x3"),
iaa.Sharpen(alpha=(0.01, 0.99), lightness=(0.5, 2), name="Sharpen"),
iaa.Emboss(alpha=(0.01, 0.99), strength=(0, 2), name="Emboss"),
iaa.EdgeDetect(alpha=(0.01, 0.99), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.01, 0.99), name="DirectedEdgeDetect")
]
augmenters_edges = [iaa.Canny(alpha=(0.01, 0.99), name="Canny")]
augmenters_flip = [
iaa.Fliplr(1.0, name="Fliplr"),
iaa.Flipud(1.0, name="Flipud")
]
augmenters_geometric = [
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=0,
mode="constant",
cval=(0, 255),
name="Affine_order_0_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
name="Affine_order_1_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=3,
mode="constant",
cval=(0, 255),
name="Affine_order_3_constant"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="edge",
cval=(0, 255),
name="Affine_order_1_edge"),
iaa.Affine(scale=(0.9, 1.1),
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-10, 10),
shear=(-10, 10),
order=1,
mode="constant",
cval=(0, 255),
backend="skimage",
name="Affine_order_1_constant_skimage"),
# TODO AffineCv2
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="constant",
name="PiecewiseAffine_4x4_order_1_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=0,
mode="constant",
name="PiecewiseAffine_4x4_order_0_constant"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=4,
nb_cols=4,
order=1,
mode="edge",
name="PiecewiseAffine_4x4_order_1_edge"),
iaa.PiecewiseAffine(scale=(0.01, 0.05),
nb_rows=8,
nb_cols=8,
order=1,
mode="constant",
name="PiecewiseAffine_8x8_order_1_constant"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=False,
name="PerspectiveTransform"),
iaa.PerspectiveTransform(scale=(0.01, 0.05),
keep_size=True,
name="PerspectiveTransform_keep_size"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=0,
mode="constant",
cval=0,
name="ElasticTransformation_order_0_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="constant",
cval=0,
name="ElasticTransformation_order_1_constant"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="nearest",
cval=0,
name="ElasticTransformation_order_1_nearest"),
iaa.ElasticTransformation(
alpha=(1, 10),
sigma=(0.5, 1.5),
order=1,
mode="reflect",
cval=0,
name="ElasticTransformation_order_1_reflect"),
iaa.Rot90((1, 3), keep_size=False, name="Rot90"),
iaa.Rot90((1, 3), keep_size=True, name="Rot90_keep_size")
]
augmenters_pooling = [
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=False,
name="AveragePooling"),
iaa.AveragePooling(kernel_size=(1, 16),
keep_size=True,
name="AveragePooling_keep_size"),
iaa.MaxPooling(kernel_size=(1, 16), keep_size=False,
name="MaxPooling"),
iaa.MaxPooling(kernel_size=(1, 16),
keep_size=True,
name="MaxPooling_keep_size"),
iaa.MinPooling(kernel_size=(1, 16), keep_size=False,
name="MinPooling"),
iaa.MinPooling(kernel_size=(1, 16),
keep_size=True,
name="MinPooling_keep_size"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=False,
name="MedianPooling"),
iaa.MedianPooling(kernel_size=(1, 16),
keep_size=True,
name="MedianPooling_keep_size")
]
augmenters_segmentation = [
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="cubic",
name="Superpixels_max_size_64_cubic"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=64,
interpolation="linear",
name="Superpixels_max_size_64_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=128,
interpolation="linear",
name="Superpixels_max_size_128_linear"),
iaa.Superpixels(p_replace=(0.05, 1.0),
n_segments=(10, 100),
max_size=224,
interpolation="linear",
name="Superpixels_max_size_224_linear"),
iaa.UniformVoronoi(n_points=(250, 1000), name="UniformVoronoi"),
iaa.RegularGridVoronoi(n_rows=(16, 31),
n_cols=(16, 31),
name="RegularGridVoronoi"),
iaa.RelativeRegularGridVoronoi(n_rows_frac=(0.07, 0.14),
n_cols_frac=(0.07, 0.14),
name="RelativeRegularGridVoronoi"),
]
augmenters_size = [
iaa.Resize((0.8, 1.2), interpolation="nearest", name="Resize_nearest"),
iaa.Resize((0.8, 1.2), interpolation="linear", name="Resize_linear"),
iaa.Resize((0.8, 1.2), interpolation="cubic", name="Resize_cubic"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="CropAndPad_edge"),
iaa.CropAndPad(percent=(-0.2, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="CropAndPad_keep_size"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
keep_size=False,
name="Pad"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="edge",
pad_cval=(0, 255),
keep_size=False,
name="Pad_edge"),
iaa.Pad(percent=(0.05, 0.2),
pad_mode="constant",
pad_cval=(0, 255),
name="Pad_keep_size"),
iaa.Crop(percent=(0.05, 0.2), keep_size=False, name="Crop"),
iaa.Crop(percent=(0.05, 0.2), name="Crop_keep_size"),
iaa.PadToFixedSize(width=width + 10,
height=height + 10,
pad_mode="constant",
pad_cval=(0, 255),
name="PadToFixedSize"),
iaa.CropToFixedSize(width=width - 10,
height=height - 10,
name="CropToFixedSize"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="nearest",
name="KeepSizeByResize_CropToFixedSize_nearest"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="linear",
name="KeepSizeByResize_CropToFixedSize_linear"),
iaa.KeepSizeByResize(iaa.CropToFixedSize(height=height - 10,
width=width - 10),
interpolation="cubic",
name="KeepSizeByResize_CropToFixedSize_cubic"),
]
augmenters_weather = [
iaa.FastSnowyLandscape(lightness_threshold=(100, 255),
lightness_multiplier=(1.0, 4.0),
name="FastSnowyLandscape"),
iaa.Clouds(name="Clouds"),
iaa.Fog(name="Fog"),
iaa.CloudLayer(intensity_mean=(196, 255),
intensity_freq_exponent=(-2.5, -2.0),
intensity_coarse_scale=10,
alpha_min=0,
alpha_multiplier=(0.25, 0.75),
alpha_size_px_max=(2, 8),
alpha_freq_exponent=(-2.5, -2.0),
sparsity=(0.8, 1.0),
density_multiplier=(0.5, 1.0),
name="CloudLayer"),
iaa.Snowflakes(name="Snowflakes"),
iaa.SnowflakesLayer(density=(0.005, 0.075),
density_uniformity=(0.3, 0.9),
flake_size=(0.2, 0.7),
flake_size_uniformity=(0.4, 0.8),
angle=(-30, 30),
speed=(0.007, 0.03),
blur_sigma_fraction=(0.0001, 0.001),
name="SnowflakesLayer")
]
augmenters = (augmenters_meta + augmenters_arithmetic + augmenters_blend +
augmenters_blur + augmenters_color + augmenters_contrast +
augmenters_convolutional + augmenters_edges +
augmenters_flip + augmenters_geometric + augmenters_pooling +
augmenters_segmentation + augmenters_size +
augmenters_weather)
if only_augmenters is not None:
augmenters_reduced = []
for augmenter in augmenters:
if any([
re.search(pattern, augmenter.name)
for pattern in only_augmenters
]):
augmenters_reduced.append(augmenter)
augmenters = augmenters_reduced
return augmenters
# https://imgaug.readthedocs.io/en/latest/source/overview_of_augmenters.html
# #Set up augmentations
seq = iaa.Sequential([
iaa.Sometimes(0.3,
iaa.OneOf([
iaa.MotionBlur(k=(5,10), angle=(60, 120)),
iaa.imgcorruptlike.DefocusBlur(severity=(1,2)),
# iaa.imgcorruptlike.ZoomBlur(severity=1),
iaa.GaussianBlur(sigma=(0.3, 0.5))
])
),
iaa.Sometimes(0.05,
iaa.AveragePooling(1)
),
# iaa.Sometimes(0.05,
# iaa.OneOf([
# iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.05)),
# iaa.Cutout(nb_iterations=(1, 3), size=(0.05, 0.15), fill_mode="constant", cval=(0, 255))
# ]),
# ),
iaa.Fliplr(0.5),
# iaa.Sometimes(0.1,
# iaa.Crop(percent=(0.05, 0.15))
# ),
