def chapter_alpha_masks_introduction():
# -----------------------------------------
# example introduction
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(2)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seqs = [
iaa.BlendAlpha((0.0, 1.0),
foreground=iaa.MedianBlur(11),
per_channel=True),
iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
per_channel=False),
iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.5, 2.0)),
per_channel=0.5),
iaa.BlendAlphaFrequencyNoise(foreground=iaa.Affine(rotate=(-10, 10),
translate_px={
"x": (-4, 4),
"y": (-4, 4)
}),
background=iaa.AddToHueAndSaturation(
(-40, 40)),
per_channel=0.5),
iaa.BlendAlphaSimplexNoise(foreground=iaa.BlendAlphaSimplexNoise(
foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.5, 2.0)),
per_channel=True),
background=iaa.BlendAlphaFrequencyNoise(
exponent=(-2.5, -1.0),
foreground=iaa.Affine(rotate=(-10, 10),
translate_px={
"x": (-4, 4),
"y": (-4, 4)
}),
background=iaa.AddToHueAndSaturation(
(-40, 40)),
per_channel=True),
per_channel=True,
aggregation_method="max",
sigmoid=False)
]
cells = []
for seq in seqs:
images_aug = seq(images=images)
cells.extend(images_aug)
# ------------
save("alpha", "introduction.jpg", grid(cells, cols=8, rows=5))
def get_preview(images, augmentationList):
"""
Accepts a list of images and augmentationList as input.
Provides a list of augmented images in that order as ouptut.
"""
augmented = []
for image in images:
for augmentation in augmentationList:
aug_id = augmentation['id']
params = augmentation['params']
if (aug_id == 1):
image = iaa.SaltAndPepper(p=params[0],
per_channel=params[1])(image=image)
elif (aug_id == 2):
image = iaa.imgcorruptlike.GaussianNoise(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 3):
image = iaa.Rain(speed=(params[0], params[1]),
drop_size=(params[2], params[3]))(image=image)
elif (aug_id == 4):
image = iaa.imgcorruptlike.Fog(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 5):
image = iaa.imgcorruptlike.Snow(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 6):
image = iaa.imgcorruptlike.Spatter(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 7):
image = iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(1))(image=image)
elif (aug_id == 8):
image = iaa.Rotate(rotate=(params[0], params[1]))(image=image)
elif (aug_id == 9):
image = iaa.Affine()(image=image) #to be implemented
elif (aug_id == 10):
image = iaa.MotionBlur(k=params[0],
angle=(params[1],
params[2]))(image=image)
elif (aug_id == 11):
image = iaa.imgcorruptlike.ZoomBlur(
severity=(params[0], params[1]))(image=image)
elif (aug_id == 12):
image = iaa.AddToBrightness()(image=image) #to be implemented
elif (aug_id == 13):
image = iaa.ChangeColorTemperature(
kelvin=(params[0], params[1]))(image=image)
elif (aug_id == 14):
image = iaa.SigmoidContrast()(image=image) #to be implemented
elif (aug_id == 15):
image = iaa.Cutout(nb_iterations=(params[0], params[1]),
size=params[2],
squared=params[3])(image=image)
else:
print("Not implemented")
augmented.append(image)
return augmented
def __init__(self, folders_train, folders_val, num_classes):
'''
All paths to the images to train and validate.
Inputs
---------
folders_train : list
A list of folders where are the dataset to train.
folders_val : list
A list of folders where are the dataset to validation.
num_classes : int
Number of classes
'''
self.num_classes = num_classes
# map paths and split dataset
self.path_train = []
self.path_test = []
for path in folders_train:
self.path_train.extend(glob(os.path.join(path, '*_image.jpg')))
for path in folders_val:
self.path_test.extend(glob(os.path.join(path, '*_image.jpg')))
print(
f'Total train: {len(self.path_train)}, Total val: {len(self.path_test)}'
)
# options for augmentation
self.aug = iaa.SomeOf((0, 3), [
iaa.Affine(rotate=(-10, 10),
scale={
"x": (0.5, 1.2),
"y": (0.5, 1.2)
}),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0),
sigmoid_thresh=iap.Normal(10.0, 5.0)),
iaa.Add(50, per_channel=True),
iaa.WithChannels(0, iaa.Add((10, 100))),
iaa.Sharpen(alpha=0.2),
iaa.Fliplr(),
iaa.Flipud()
])
def _load_augmentation_aug_all():
""" Load image augmentation model """
def sometimes(aug):
return iaa.Sometimes(0.5, aug)
return iaa.Sequential(
[
# apply the following augmenters to most images
iaa.Fliplr(0.5), # horizontally flip 50% of all images
iaa.Flipud(0.2), # vertically flip 20% of all images
# crop images by -5% to 10% of their height/width
sometimes(
iaa.CropAndPad(percent=(-0.05, 0.1),
pad_mode='constant',
pad_cval=(0, 255))),
sometimes(
iaa.Affine(
# scale images to 80-120% of their size, individually per axis
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
# translate by -20 to +20 percent (per axis)
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-45, 45), # rotate by -45 to +45 degrees
shear=(-16, 16), # shear by -16 to +16 degrees
# use nearest neighbour or bilinear interpolation (fast)
order=[0, 1],
# if mode is constant, use a cval between 0 and 255
cval=(0, 255),
# use any of scikit-image's warping modes
# (see 2nd image from the top for examples)
mode='constant')),
# 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),
[
# convert images into their superpixel representation
sometimes(
iaa.Superpixels(p_replace=(0, 1.0),
n_segments=(20, 200))),
iaa.OneOf([
# blur images with a sigma between 0 and 3.0
iaa.GaussianBlur((0, 3.0)),
# blur image using local means with kernel sizes
# between 2 and 7
iaa.AverageBlur(k=(2, 7)),
# blur image using local medians with kernel sizes
# between 2 and 7
iaa.MedianBlur(k=(3, 11)),
]),
iaa.Sharpen(alpha=(0, 1.0),
lightness=(0.75, 1.5)), # sharpen images
iaa.Emboss(alpha=(0, 1.0),
strength=(0, 2.0)), # emboss images
# search either for all edges or for directed edges,
# blend the result with the original image using a blobby mask
iaa.BlendAlphaSimplexNoise(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0.5, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.5, 1.0),
direction=(0.0, 1.0)),
])),
# add gaussian noise to images
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=0.5),
iaa.OneOf([
# randomly remove up to 10% of the pixels
iaa.Dropout((0.01, 0.1), per_channel=0.5),
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.2),
]),
# invert color channels
iaa.Invert(0.05, per_channel=True),
# change brightness of images (by -10 to 10 of original value)
iaa.Add((-10, 10), per_channel=0.5),
# change hue and saturation
iaa.AddToHueAndSaturation((-20, 20)),
# either change the brightness of the whole image (sometimes
# per channel) or change the brightness of subareas
iaa.OneOf([
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.BlendAlphaFrequencyNoise(
exponent=(-4, 0),
foreground=iaa.Multiply(
(0.5, 1.5), per_channel=True),
background=iaa.contrast.LinearContrast((0.5, 2.0)))
]),
# improve or worsen the contrast
iaa.contrast.LinearContrast((0.5, 2.0), per_channel=0.5),
iaa.Grayscale(alpha=(0.0, 1.0)),
# move pixels locally around (with random strengths)
sometimes(
iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)
),
# sometimes move parts of the image around
sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))),
sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))
],
random_order=True)
],
random_order=True)
def test_dtype_preservation():
reseed()
size = (4, 16, 16, 3)
images = [
np.random.uniform(0, 255, size).astype(np.uint8),
np.random.uniform(0, 65535, size).astype(np.uint16),
np.random.uniform(0, 4294967295, size).astype(np.uint32),
np.random.uniform(-128, 127, size).astype(np.int16),
np.random.uniform(-32768, 32767, size).astype(np.int32),
np.random.uniform(0.0, 1.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float16),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float32),
np.random.uniform(-1000.0, 1000.0, size).astype(np.float64)
]
default_dtypes = set([arr.dtype for arr in images])
# Some dtypes are here removed per augmenter, because the respective
# augmenter does not support them. This test currently only checks whether
# dtypes are preserved from in- to output for all dtypes that are supported
# per augmenter.
# dtypes are here removed via list comprehension instead of
# `default_dtypes - set([dtype])`, because the latter one simply never
# removed the dtype(s) for some reason
def _not_dts(dts):
return [dt for dt in default_dtypes if dt not in dts]
augs = [
(iaa.Add((-5, 5), name="Add"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.AddElementwise((-5, 5), name="AddElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.AdditiveGaussianNoise(0.01*255, name="AdditiveGaussianNoise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Multiply((0.95, 1.05), name="Multiply"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Dropout(0.01, name="Dropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Invert(0.01, per_channel=True, name="Invert"),
default_dtypes),
(iaa.GaussianBlur(sigma=(0.95, 1.05), name="GaussianBlur"),
_not_dts([np.float16])),
(iaa.AverageBlur((3, 5), name="AverageBlur"),
_not_dts([np.uint32, np.int32, np.float16])),
(iaa.MedianBlur((3, 5), name="MedianBlur"),
_not_dts([np.uint32, np.int32, np.float16, np.float64])),
(iaa.BilateralBlur((3, 5), name="BilateralBlur"),
_not_dts([np.uint16, np.uint32, np.int16, np.int32, np.float16,
np.float64])),
(iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.DirectedEdgeDetect(alpha=(0.0, 0.1), direction=0,
name="DirectedEdgeDetect"),
_not_dts([np.uint32, np.int32, np.float16, np.uint32])),
(iaa.Fliplr(0.5, name="Fliplr"), default_dtypes),
(iaa.Flipud(0.5, name="Flipud"), default_dtypes),
(iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(rotate=(-20, 20), name="Affine-rotate"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(shear=(-20, 20), name="Affine-shear"),
_not_dts([np.uint32, np.int32])),
(iaa.Affine(scale=(0.9, 1.1), name="Affine-scale"),
_not_dts([np.uint32, np.int32])),
(iaa.PiecewiseAffine(scale=(0.001, 0.005), name="PiecewiseAffine"),
default_dtypes),
(iaa.ElasticTransformation(alpha=(0.1, 0.2), sigma=(0.1, 0.2),
name="ElasticTransformation"),
_not_dts([np.float16])),
(iaa.Sequential([iaa.Identity(), iaa.Identity()],
name="SequentialNoop"),
default_dtypes),
(iaa.SomeOf(1, [iaa.Identity(), iaa.Identity()], name="SomeOfNoop"),
default_dtypes),
(iaa.OneOf([iaa.Identity(), iaa.Identity()], name="OneOfNoop"),
default_dtypes),
(iaa.Sometimes(0.5, iaa.Identity(), name="SometimesNoop"),
default_dtypes),
(iaa.Sequential([iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))],
name="Sequential"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.SomeOf(1,
[iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))],
name="SomeOf"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.OneOf([iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))],
name="OneOf"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Sometimes(0.5, iaa.Add((-5, 5)), name="Sometimes"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Identity(name="Identity"), default_dtypes),
(iaa.BlendAlpha((0.0, 0.1), iaa.Identity(), name="BlendAlphaIdentity"),
_not_dts([np.float64])), # float64 requires float128 support
(iaa.BlendAlphaElementwise((0.0, 0.1), iaa.Identity(),
name="BlendAlphaElementwiseIdentity"),
_not_dts([np.float64])), # float64 requires float128 support
(iaa.BlendAlphaSimplexNoise(iaa.Identity(),
name="BlendAlphaSimplexNoiseIdentity"),
_not_dts([np.float64])), # float64 requires float128 support
(iaa.BlendAlphaFrequencyNoise(exponent=(-2, 2),
foreground=iaa.Identity(),
name="BlendAlphaFrequencyNoiseIdentity"),
_not_dts([np.float64])),
(iaa.BlendAlpha((0.0, 0.1), iaa.Add(10), name="BlendAlpha"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.BlendAlphaElementwise((0.0, 0.1), iaa.Add(10),
name="BlendAlphaElementwise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.BlendAlphaSimplexNoise(iaa.Add(10), name="BlendAlphaSimplexNoise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.BlendAlphaFrequencyNoise(exponent=(-2, 2),
foreground=iaa.Add(10),
name="BlendAlphaFrequencyNoise"),
_not_dts([np.uint32, np.int32, np.float64])),
(iaa.Superpixels(p_replace=0.01, n_segments=64),
_not_dts([np.float16, np.float32, np.float64])),
(iaa.Resize({"height": 4, "width": 4}, name="Resize"),
_not_dts([np.uint16, np.uint32, np.int16, np.int32, np.float32,
np.float16, np.float64])),
(iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
_not_dts([np.uint16, np.uint32, np.int16, np.int32, np.float32,
np.float16, np.float64])),
(iaa.Pad(px=(0, 10), name="Pad"),
_not_dts([np.uint16, np.uint32, np.int16, np.int32, np.float32,
np.float16, np.float64])),
(iaa.Crop(px=(0, 10), name="Crop"),
_not_dts([np.uint16, np.uint32, np.int16, np.int32, np.float32,
np.float16, np.float64]))
]
for (aug, allowed_dtypes) in augs:
for images_i in images:
if images_i.dtype in allowed_dtypes:
images_aug = aug.augment_images(images_i)
assert images_aug.dtype == images_i.dtype
def test_unusual_channel_numbers():
reseed()
images = [
(0, create_random_images((4, 16, 16))),
(1, create_random_images((4, 16, 16, 1))),
(2, create_random_images((4, 16, 16, 2))),
(4, create_random_images((4, 16, 16, 4))),
(5, create_random_images((4, 16, 16, 5))),
(10, create_random_images((4, 16, 16, 10))),
(20, create_random_images((4, 16, 16, 20)))
]
augs = [
iaa.Add((-5, 5), name="Add"),
iaa.AddElementwise((-5, 5), name="AddElementwise"),
iaa.AdditiveGaussianNoise(0.01*255, name="AdditiveGaussianNoise"),
iaa.Multiply((0.95, 1.05), name="Multiply"),
iaa.Dropout(0.01, name="Dropout"),
iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
iaa.Invert(0.01, per_channel=True, name="Invert"),
iaa.GaussianBlur(sigma=(0.95, 1.05), name="GaussianBlur"),
iaa.AverageBlur((3, 5), name="AverageBlur"),
iaa.MedianBlur((3, 5), name="MedianBlur"),
iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.0, 0.1), direction=0,
name="DirectedEdgeDetect"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
iaa.Affine(rotate=(-20, 20), name="Affine-rotate"),
iaa.Affine(shear=(-20, 20), name="Affine-shear"),
iaa.Affine(scale=(0.9, 1.1), name="Affine-scale"),
iaa.PiecewiseAffine(scale=(0.001, 0.005), name="PiecewiseAffine"),
iaa.PerspectiveTransform(scale=(0.01, 0.10),
name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.1, 0.2), sigma=(0.1, 0.2),
name="ElasticTransformation"),
iaa.Sequential([iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))]),
iaa.SomeOf(1, [iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))]),
iaa.OneOf([iaa.Add((-5, 5)), iaa.AddElementwise((-5, 5))]),
iaa.Sometimes(0.5, iaa.Add((-5, 5)), name="Sometimes"),
iaa.Identity(name="Noop"),
iaa.BlendAlpha((0.0, 0.1), iaa.Add(10), name="BlendAlpha"),
iaa.BlendAlphaElementwise((0.0, 0.1), iaa.Add(10),
name="BlendAlphaElementwise"),
iaa.BlendAlphaSimplexNoise(iaa.Add(10), name="BlendAlphaSimplexNoise"),
iaa.BlendAlphaFrequencyNoise(exponent=(-2, 2),
foreground=iaa.Add(10),
name="BlendAlphaSimplexNoise"),
iaa.Superpixels(p_replace=0.01, n_segments=64),
iaa.Resize({"height": 4, "width": 4}, name="Resize"),
iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
iaa.Pad(px=(0, 10), name="Pad"),
iaa.Crop(px=(0, 10), name="Crop")
]
for aug in augs:
for (nb_channels, images_c) in images:
if aug.name != "Resize":
images_aug = aug.augment_images(images_c)
assert images_aug.shape == images_c.shape
image_aug = aug.augment_image(images_c[0])
assert image_aug.shape == images_c[0].shape
else:
images_aug = aug.augment_images(images_c)
image_aug = aug.augment_image(images_c[0])
if images_c.ndim == 3:
assert images_aug.shape == (4, 4, 4)
assert image_aug.shape == (4, 4)
else:
assert images_aug.shape == (4, 4, 4, images_c.shape[3])
assert image_aug.shape == (4, 4, images_c.shape[3])
def test_many_augmenters(self):
keypoints = []
for y in sm.xrange(40//5):
for x in sm.xrange(60//5):
keypoints.append(ia.Keypoint(y=y*5, x=x*5))
keypoints_oi = ia.KeypointsOnImage(keypoints, shape=(40, 60, 3))
keypoints_oi_empty = ia.KeypointsOnImage([], shape=(40, 60, 3))
augs = [
iaa.Add((-5, 5), name="Add"),
iaa.AddElementwise((-5, 5), name="AddElementwise"),
iaa.AdditiveGaussianNoise(0.01*255, name="AdditiveGaussianNoise"),
iaa.Multiply((0.95, 1.05), name="Multiply"),
iaa.Dropout(0.01, name="Dropout"),
iaa.CoarseDropout(0.01, size_px=6, name="CoarseDropout"),
iaa.Invert(0.01, per_channel=True, name="Invert"),
iaa.GaussianBlur(sigma=(0.95, 1.05), name="GaussianBlur"),
iaa.AverageBlur((3, 5), name="AverageBlur"),
iaa.MedianBlur((3, 5), name="MedianBlur"),
iaa.Sharpen((0.0, 0.1), lightness=(1.0, 1.2), name="Sharpen"),
iaa.Emboss(alpha=(0.0, 0.1), strength=(0.5, 1.5), name="Emboss"),
iaa.EdgeDetect(alpha=(0.0, 0.1), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.0, 0.1), direction=0,
name="DirectedEdgeDetect"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Affine(translate_px=(-5, 5), name="Affine-translate-px"),
iaa.Affine(translate_percent=(-0.05, 0.05),
name="Affine-translate-percent"),
iaa.Affine(rotate=(-20, 20), name="Affine-rotate"),
iaa.Affine(shear=(-20, 20), name="Affine-shear"),
iaa.Affine(scale=(0.9, 1.1), name="Affine-scale"),
iaa.PiecewiseAffine(scale=(0.001, 0.005), name="PiecewiseAffine"),
iaa.ElasticTransformation(alpha=(0.1, 0.2), sigma=(0.1, 0.2),
name="ElasticTransformation"),
iaa.BlendAlpha((0.0, 0.1), iaa.Add(10), name="BlendAlpha"),
iaa.BlendAlphaElementwise((0.0, 0.1), iaa.Add(10),
name="BlendAlphaElementwise"),
iaa.BlendAlphaSimplexNoise(iaa.Add(10), name="BlendAlphaSimplexNoise"),
iaa.BlendAlphaFrequencyNoise(exponent=(-2, 2), foreground=iaa.Add(10),
name="BlendAlphaSimplexNoise"),
iaa.Superpixels(p_replace=0.01, n_segments=64),
iaa.Resize(0.5, name="Resize"),
iaa.CropAndPad(px=(-10, 10), name="CropAndPad"),
iaa.Pad(px=(0, 10), name="Pad"),
iaa.Crop(px=(0, 10), name="Crop")
]
for aug in augs:
dss = []
for i in sm.xrange(10):
aug_det = aug.to_deterministic()
kp_fully_empty_aug = aug_det.augment_keypoints([])
assert kp_fully_empty_aug == []
kp_first_empty_aug = aug_det.augment_keypoints(keypoints_oi_empty)
assert len(kp_first_empty_aug.keypoints) == 0
kp_image = keypoints_oi.to_keypoint_image(size=5)
with assertWarns(self, iaa.SuspiciousSingleImageShapeWarning):
kp_image_aug = aug_det.augment_image(kp_image)
kp_image_aug_rev = ia.KeypointsOnImage.from_keypoint_image(
kp_image_aug,
if_not_found_coords={"x": -9999, "y": -9999},
nb_channels=1
)
kp_aug = aug_det.augment_keypoints([keypoints_oi])[0]
ds = []
assert len(kp_image_aug_rev.keypoints) == len(kp_aug.keypoints), (
"Lost keypoints for '%s' (%d vs expected %d)" % (
aug.name,
len(kp_aug.keypoints),
len(kp_image_aug_rev.keypoints))
)
gen = zip(kp_aug.keypoints, kp_image_aug_rev.keypoints)
for kp_pred, kp_pred_img in gen:
kp_pred_lost = (kp_pred.x == -9999 and kp_pred.y == -9999)
kp_pred_img_lost = (kp_pred_img.x == -9999
and kp_pred_img.y == -9999)
if not kp_pred_lost and not kp_pred_img_lost:
d = np.sqrt((kp_pred.x - kp_pred_img.x) ** 2
+ (kp_pred.y - kp_pred_img.y) ** 2)
ds.append(d)
dss.extend(ds)
if len(ds) == 0:
print("[INFO] No valid keypoints found for '%s' "
"in test_keypoint_augmentation()" % (str(aug),))
assert np.average(dss) < 5.0, \
"Average distance too high (%.2f, with ds: %s)" \
% (np.average(dss), str(dss))
3.0)), # blur images with a sigma between 0 and 3.0
iaa.AverageBlur(
k=(2, 7)
), # blur image using local means with kernel sizes between 2 and 7
iaa.MedianBlur(
k=(3, 11)
), # blur image using local medians with kernel sizes between 2 and 7
]),
iaa.Sharpen(alpha=(0, 1.0),
lightness=(0.75, 1.5)), # sharpen images
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)), # emboss images
# search either for all edges or for directed edges,
# blend the result with the original image using a blobby mask
iaa.BlendAlphaSimplexNoise(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0.5, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.5, 1.0),
direction=(0.0, 1.0)),
])),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255),
per_channel=0.5), # add gaussian noise to images
iaa.OneOf([
iaa.Dropout((0.01, 0.1), per_channel=0.5
), # randomly remove up to 10% of the pixels
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.2),
]),
iaa.Invert(0.05, per_channel=True), # invert color channels
iaa.Add(
(-10, 10), per_channel=0.5
def __init__(self, rgb_mean, randomImg, insize):
sometimes = lambda aug: iaa.Sometimes(0.7, aug)
self.rand_img_dir = randomImg
self.rgb_mean = rgb_mean
self.inp_dim = insize
#
self.randomImgList = glob.glob( randomImg + '*.jpg')
self.aug = iaa.Sequential([
sometimes(iaa.Affine(
scale={"x": (0.8, 1.2), "y": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis
translate_percent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)}, # translate by -20 to +20 percent (per axis)
rotate=(-25, 25), # rotate by -45 to +45 degrees
shear=(-6, 6), # shear by -16 to +16 degrees
order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)
cval=(0, 255), # if mode is constant, use a cval between 0 and 255
mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)
)),
iaa.OneOf([
iaa.Fliplr(0.5),
iaa.GaussianBlur(
sigma=iap.Uniform(0.0, 1.0)
),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.BlendAlphaSimplexNoise(
foreground=iaa.EdgeDetect(1.0),
background=iaa.LinearContrast((0.1, .8)),
per_channel=True
),
background=iaa.BlendAlphaFrequencyNoise(
exponent=(-.5, -.1),
foreground=iaa.Affine(
rotate=(-10, 10),
translate_px={"x": (-1, 1), "y": (-1, 1)}
),
# background=iaa.AddToHueAndSaturation((-4, 4)),
# per_channel=True
),
per_channel=True,
aggregation_method="max",
sigmoid=False
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Sharpen(1.0, lightness=2),
background=iaa.CoarseDropout(p=0.1, size_px=8)
),
iaa.BlendAlpha(
factor=(0.2, 0.8),
foreground=iaa.Affine(rotate=(-5, 5)),
per_channel=True
),
iaa.MotionBlur(k=15, angle=[-5, 5]),
iaa.BlendAlphaCheckerboard(nb_rows=2, nb_cols=(1, 4),
foreground=iaa.AddToHue((-10, 10))),
iaa.BlendAlphaElementwise((0, 1.0), iaa.AddToHue(10)),
iaa.BilateralBlur(
d=(3, 10), sigma_color=(1, 5), sigma_space=(1, 5)),
iaa.AdditiveGaussianNoise(scale=0.02 * 255),
iaa.AddElementwise((-5, 5), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=0.01 * 255),
iaa.AdditivePoissonNoise(20),
iaa.Cutout(fill_mode="gaussian", fill_per_channel=True),
iaa.CoarseDropout(0.02, size_percent=0.1),
iaa.SaltAndPepper(0.1, per_channel=True),
iaa.JpegCompression(compression=(70, 99)),
iaa.ImpulseNoise(0.02),
iaa.Dropout(p=(0, 0.04)),
iaa.Sharpen(alpha=0.1),
]) # oneof
])
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.Identity(name="Identity"),
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.Cutout(nb_iterations=1, name="Cutout-fill_constant"),
iaa.Dropout((0.01, 0.05), name="Dropout"),
iaa.CoarseDropout((0.01, 0.05), size_percent=(0.01, 0.1), name="CoarseDropout"),
iaa.Dropout2d(0.1, name="Dropout2d"),
iaa.TotalDropout(0.1, name="TotalDropout"),
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_artistic = [
iaa.Cartoon(name="Cartoon")
]
augmenters_blend = [
iaa.BlendAlpha((0.01, 0.99), iaa.Identity(), name="Alpha"),
iaa.BlendAlphaElementwise((0.01, 0.99), iaa.Identity(), name="AlphaElementwise"),
iaa.BlendAlphaSimplexNoise(iaa.Identity(), name="SimplexNoiseAlpha"),
iaa.BlendAlphaFrequencyNoise((-2.0, 2.0), iaa.Identity(), name="FrequencyNoiseAlpha"),
iaa.BlendAlphaSomeColors(iaa.Identity(), name="BlendAlphaSomeColors"),
iaa.BlendAlphaHorizontalLinearGradient(iaa.Identity(), name="BlendAlphaHorizontalLinearGradient"),
iaa.BlendAlphaVerticalLinearGradient(iaa.Identity(), name="BlendAlphaVerticalLinearGradient"),
iaa.BlendAlphaRegularGrid(nb_rows=(2, 8), nb_cols=(2, 8), foreground=iaa.Identity(), name="BlendAlphaRegularGrid"),
iaa.BlendAlphaCheckerboard(nb_rows=(2, 8), nb_cols=(2, 8), foreground=iaa.Identity(), name="BlendAlphaCheckerboard"),
# TODO BlendAlphaSegMapClassId
# TODO BlendAlphaBoundingBoxes
]
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"),
iaa.MeanShiftBlur(spatial_radius=(5.0, 40.0), color_radius=(5.0, 40.0),
name="MeanShiftBlur")
]
augmenters_collections = [
iaa.RandAugment(n=2, m=(6, 12), name="RandAugment")
]
augmenters_color = [
# InColorspace (deprecated)
iaa.WithColorspace(to_colorspace="HSV", children=iaa.Noop(), name="WithColorspace"),
iaa.WithBrightnessChannels(iaa.Identity(), name="WithBrightnessChannels"),
iaa.MultiplyAndAddToBrightness(mul=(0.7, 1.3), add=(-30, 30), name="MultiplyAndAddToBrightness"),
iaa.MultiplyBrightness((0.7, 1.3), name="MultiplyBrightness"),
iaa.AddToBrightness((-30, 30), name="AddToBrightness"),
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.RemoveSaturation((0.01, 0.99), name="RemoveSaturation"),
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"),
iaa.UniformColorQuantizationToNBits((1, 7), name="UniformQuantizationToNBits"),
iaa.Posterize((1, 7), name="Posterize")
]
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"),
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"),
iaa.WithPolarWarping(iaa.Identity(), name="WithPolarWarping"),
iaa.Jigsaw(nb_rows=(3, 8), nb_cols=(3, 8), max_steps=1, name="Jigsaw")
]
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_imgcorruptlike = [
iaa.imgcorruptlike.GaussianNoise(severity=(1, 5), name="imgcorruptlike.GaussianNoise"),
iaa.imgcorruptlike.ShotNoise(severity=(1, 5), name="imgcorruptlike.ShotNoise"),
iaa.imgcorruptlike.ImpulseNoise(severity=(1, 5), name="imgcorruptlike.ImpulseNoise"),
iaa.imgcorruptlike.SpeckleNoise(severity=(1, 5), name="imgcorruptlike.SpeckleNoise"),
iaa.imgcorruptlike.GaussianBlur(severity=(1, 5), name="imgcorruptlike.GaussianBlur"),
iaa.imgcorruptlike.GlassBlur(severity=(1, 5), name="imgcorruptlike.GlassBlur"),
iaa.imgcorruptlike.DefocusBlur(severity=(1, 5), name="imgcorruptlike.DefocusBlur"),
iaa.imgcorruptlike.MotionBlur(severity=(1, 5), name="imgcorruptlike.MotionBlur"),
iaa.imgcorruptlike.ZoomBlur(severity=(1, 5), name="imgcorruptlike.ZoomBlur"),
iaa.imgcorruptlike.Fog(severity=(1, 5), name="imgcorruptlike.Fog"),
iaa.imgcorruptlike.Frost(severity=(1, 5), name="imgcorruptlike.Frost"),
iaa.imgcorruptlike.Snow(severity=(1, 5), name="imgcorruptlike.Snow"),
iaa.imgcorruptlike.Spatter(severity=(1, 5), name="imgcorruptlike.Spatter"),
iaa.imgcorruptlike.Contrast(severity=(1, 5), name="imgcorruptlike.Contrast"),
iaa.imgcorruptlike.Brightness(severity=(1, 5), name="imgcorruptlike.Brightness"),
iaa.imgcorruptlike.Saturate(severity=(1, 5), name="imgcorruptlike.Saturate"),
iaa.imgcorruptlike.JpegCompression(severity=(1, 5), name="imgcorruptlike.JpegCompression"),
iaa.imgcorruptlike.Pixelate(severity=(1, 5), name="imgcorruptlike.Pixelate"),
iaa.imgcorruptlike.ElasticTransform(severity=(1, 5), name="imgcorruptlike.ElasticTransform")
]
augmenters_pillike = [
iaa.pillike.Solarize(p=1.0, threshold=(32, 128), name="pillike.Solarize"),
iaa.pillike.Posterize((1, 7), name="pillike.Posterize"),
iaa.pillike.Equalize(name="pillike.Equalize"),
iaa.pillike.Autocontrast(name="pillike.Autocontrast"),
iaa.pillike.EnhanceColor((0.0, 3.0), name="pillike.EnhanceColor"),
iaa.pillike.EnhanceContrast((0.0, 3.0), name="pillike.EnhanceContrast"),
iaa.pillike.EnhanceBrightness((0.0, 3.0), name="pillike.EnhanceBrightness"),
iaa.pillike.EnhanceSharpness((0.0, 3.0), name="pillike.EnhanceSharpness"),
iaa.pillike.FilterBlur(name="pillike.FilterBlur"),
iaa.pillike.FilterSmooth(name="pillike.FilterSmooth"),
iaa.pillike.FilterSmoothMore(name="pillike.FilterSmoothMore"),
iaa.pillike.FilterEdgeEnhance(name="pillike.FilterEdgeEnhance"),
iaa.pillike.FilterEdgeEnhanceMore(name="pillike.FilterEdgeEnhanceMore"),
iaa.pillike.FilterFindEdges(name="pillike.FilterFindEdges"),
iaa.pillike.FilterContour(name="pillike.FilterContour"),
iaa.pillike.FilterEmboss(name="pillike.FilterEmboss"),
iaa.pillike.FilterSharpen(name="pillike.FilterSharpen"),
iaa.pillike.FilterDetail(name="pillike.FilterDetail"),
iaa.pillike.Affine(scale=(0.9, 1.1),
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)},
rotate=(-10, 10),
shear=(-10, 10),
fillcolor=(0, 255),
name="pillike.Affine"),
]
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"),
iaa.Rain(name="Rain"),
iaa.RainLayer(density=(0.03, 0.14),
density_uniformity=(0.8, 1.0),
drop_size=(0.01, 0.02),
drop_size_uniformity=(0.2, 0.5),
angle=(-15, 15),
speed=(0.04, 0.20),
blur_sigma_fraction=(0.001, 0.001),
name="RainLayer")
]
augmenters = (
augmenters_meta
+ augmenters_arithmetic
+ augmenters_artistic
+ augmenters_blend
+ augmenters_blur
+ augmenters_collections
+ augmenters_color
+ augmenters_contrast
+ augmenters_convolutional
+ augmenters_edges
+ augmenters_flip
+ augmenters_geometric
+ augmenters_pooling
+ augmenters_imgcorruptlike
+ augmenters_pillike
+ 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
iaa.GammaContrast((0.5, 2.0), per_channel=True),
iaa.Affine(rotate=(-15, 15)),
iaa.Affine(translate_percent={"x": -0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(translate_percent={"y": -0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(translate_percent={"x": +0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.Affine(translate_percent={"y": +0.20}, mode=ia.ALL, cval=(0, 255)),
iaa.BlendAlpha(
(0.0, 1.0),
iaa.Affine(rotate=(-20, 20)),
per_channel=0.5),
iaa.BlendAlpha([0.25, 0.75], iaa.MedianBlur(13)),
iaa.BlendAlphaElementwise(
(0.0, 1.0),
foreground=iaa.Add(100),
background=iaa.Multiply(0.2)),
iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0)),
iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(1.0),
upscale_method="nearest"),
iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(1.0),
upscale_method="linear"),
iaa.BlendAlphaSomeColors(iaa.TotalDropout(1.0)),
iaa.BlendAlphaSomeColors(
iaa.AveragePooling(7), alpha=[0.0, 1.0], smoothness=0.0),
iaa.FastSnowyLandscape(
lightness_threshold=140,
lightness_multiplier=2.5),
iaa.Clouds(),
iaa.Fog(),
iaa.Rain(speed=(0.1, 0.3)),
iaa.InvertMaskGen(0.5, iaa.VerticalLinearGradientMaskGen()),
iaa.Clouds()
)
aug26 = iaa.BlendAlphaElementwise(
(0.0, 0.5),
iaa.Affine(rotate=(-0, 0)),
per_channel=0.5)
aug27 = iaa.BlendAlphaElementwise(
(0.0, 0.2),
foreground=iaa.Add(20),
background=iaa.Multiply(0.4))
aug28 = iaa.BlendAlphaElementwise([0.25, 0.75], iaa.MedianBlur(13))
aug29 = iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(0.6))
aug30 = iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(0.2),
upscale_method="nearest")
aug31 = iaa.Cutout(fill_mode="constant", cval=(0, 255),
fill_per_channel=0.5)
# aug32 = iaa.BlendAlphaHorizontalLinearGradient(
# iaa.TotalDropout(0.3),
# min_value=0.1, max_value=0.3)
# aug33 = iaa.BlendAlphaHorizontalLinearGradient(
# iaa.AveragePooling(3),
# start_at=(0.0, 0.2), end_at=(0.0, 0.2))
# aug34 = iaa.BlendAlphaVerticalLinearGradient(
# iaa.TotalDropout(0.6),
def chapter_alpha_masks_simplex():
# -----------------------------------------
# example 1 (basic)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_simplex_example_basic.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# example 1 (per_channel)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
per_channel=True)
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_simplex_example_per_channel.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# noise masks
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks.jpg", grid(masks, cols=16,
rows=1))
# -----------------------------------------
# noise masks, upscale=nearest
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.SimplexNoiseAlpha(first=iaa.Multiply(iap.Choice([0.5, 1.5]),
per_channel=True),
upscale_method="nearest")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks_nearest.jpg",
grid(masks, cols=16, rows=1))
# -----------------------------------------
# noise masks linear
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaSimplexNoise(foreground=iaa.Multiply(iap.Choice(
[0.5, 1.5]),
per_channel=True),
upscale_method="linear")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks_linear.jpg",
grid(masks, cols=16, rows=1))
def __init__(self, args):
if args.inference:
logger.info(
f"`args.inference` is set, so switching off all augmentations")
self.seq = self.shift_seq = None
return
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
logger.info(f"Pixelwise augmentation: {args.use_pixelwise_augs}")
logger.info(f"Affine scale augmentation: {args.use_affine_scale}")
logger.info(f"Affine shift augmentation: {args.use_affine_shift}")
total_augs = []
if args.use_pixelwise_augs:
pixelwise_augs = [
iaa.SomeOf(
(0, 5),
[
# sometimes(iaa.Superpixels(p_replace=(0, 0.25), n_segments=(150, 200))),
iaa.OneOf([
iaa.GaussianBlur(
(0, 1.0)
), # blur images with a sigma between 0 and 3.0
iaa.AverageBlur(k=(1, 3)),
# blur image using local means with kernel sizes between 2 and 7
iaa.MedianBlur(k=(1, 3)),
# blur image using local medians with kernel sizes between 2 and 7
]),
iaa.Sharpen(alpha=(0, 1.0),
lightness=(1.0, 1.5)), # sharpen images
iaa.Emboss(alpha=(0, 1.0),
strength=(0, 0.5)), # emboss images
# search either for all edges or for directed edges,
# blend the result with the original image using a blobby mask
iaa.BlendAlphaSimplexNoise(
iaa.EdgeDetect(alpha=(0.0, 0.15)), ),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 255), per_channel=False),
# 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.AddToSaturation(
(-20, 20)), # change hue and saturation
iaa.JpegCompression((70, 99)),
iaa.Multiply((0.5, 1.5), per_channel=False),
iaa.OneOf([
iaa.LinearContrast(
(0.75, 1.25), per_channel=False),
iaa.SigmoidContrast(cutoff=0.5, gain=(3.0, 11.0))
]),
sometimes(
iaa.ElasticTransformation(alpha=(0.5, 3.5),
sigma=0.15)),
# move pixels locally around (with random strengths)
],
random_order=True)
]
total_augs.extend(pixelwise_augs)
if args.use_affine_scale:
affine_augs_scale = [
sometimes(
iaa.Affine(
scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
# scale images to 80-120% of their size, individually per axis
order=[1], # use bilinear interpolation (fast)
mode=["reflect"]))
]
total_augs.extend(affine_augs_scale)
if args.use_affine_shift:
affine_augs_shift = [
sometimes(
iaa.Affine(
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
order=[1], # use bilinear interpolation (fast)
mode=["reflect"]))
]
else:
affine_augs_shift = []
self.shift_seq = iaa.Sequential(affine_augs_shift)
self.seq = iaa.Sequential(total_augs, random_order=True)
def get_aug(self):
#sometimes_bg = lambda aug: iaa.Sometimes(0.3, aug)
sometimes_contrast = lambda aug: iaa.Sometimes(0.3, aug)
sometimes_noise = lambda aug: iaa.Sometimes(0.6, aug)
sometimes_blur = lambda aug: iaa.Sometimes(0.6, aug)
sometimes_degrade_quality = lambda aug: iaa.Sometimes(0.9, aug)
sometimes_blend = lambda aug: iaa.Sometimes(0.2, aug)
seq = iaa.Sequential(
[
# crop some of the images by 0-30% of their height/width
# Execute 0 to 4 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, 4),
# [
# change the background color of some of the images chosing any one technique
# sometimes_bg(iaa.OneOf([
# iaa.AddToHueAndSaturation((-60, 60)),
# iaa.Multiply((0.6, 1), per_channel=True),
# ])),
#change the contrast of the input images chosing any one technique
sometimes_contrast(iaa.OneOf([
iaa.LinearContrast((0.5,1.5)),
iaa.SigmoidContrast(gain=(3, 5), cutoff=(0.4, 0.6)),
iaa.CLAHE(tile_grid_size_px=(3, 21)),
iaa.GammaContrast((0.5,1.0))
])),
#add noise to the input images chosing any one technique
sometimes_noise(iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(3,8)),
iaa.CoarseDropout((0.001,0.01), size_percent=0.5),
iaa.AdditiveLaplaceNoise(scale=(3,10)),
iaa.CoarsePepper((0.001,0.01), size_percent=(0.5)),
iaa.AdditivePoissonNoise(lam=(3.0,10.0)),
iaa.Pepper((0.001,0.01)),
iaa.Snowflakes(),
iaa.Dropout(0.01,0.01),
])),
#add blurring techniques to the input image
sometimes_blur(iaa.OneOf([
iaa.AverageBlur(k=(3)),
iaa.GaussianBlur(sigma=(1.0)),
])),
# add techniques to degrade the iamge quality
sometimes_degrade_quality(iaa.OneOf([
iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
iaa.Sharpen(alpha=(0.5), lightness=(0.75,1.5)),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([1.5]), per_channel=False)
)
])),
# blend some patterns in the background
sometimes_blend(iaa.OneOf([
iaa.BlendAlpha(
factor=(0.6,0.8),
foreground=iaa.Sharpen(1.0, lightness=1),
background=iaa.CoarseDropout(p=0.1, size_px=np.random.randint(30))),
iaa.BlendAlphaFrequencyNoise(exponent=(-4),
foreground=iaa.Multiply(iap.Choice([0.5]), per_channel=False)
),
iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5]), per_channel=True)
)
])),
])
return seq
## Artistic
elif augmentation == 'cartoon':
transform = iaa.Cartoon(blur_ksize=3, segmentation_size=1.0,
saturation=2.0, edge_prevalence=1.0)
transformed_image = transform(image=image)
## Blend
elif augmentation == 'blend_alpha':
transform = iaa.BlendAlpha(0.5, iaa.Grayscale(1.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_simplex_noise':
transform = iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_some_colors':
transform = iaa.BlendAlphaSomeColors(iaa.Grayscale(1.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_regular_grid':
transform = iaa.BlendAlphaRegularGrid(nb_rows=(4, 6), nb_cols=(1, 4),
foreground=iaa.Multiply(0.0))
transformed_image = transform(image=image)
elif augmentation == 'blend_alpha_mask':
transform = iaa.BlendAlphaMask(iaa.InvertMaskGen(0.5,
iaa.VerticalLinearGradientMaskGen()),
iaa.Clouds())
