def get_seq(flag_normal, flag_affine, flag_noise, flag_snow, flag_cloud, flag_fog, flag_snowflakes, flag_rain, flag_dropout): if flag_normal: seq_list = [ iaa.SomeOf((1, 2), [ iaa.LinearContrast((0.5, 2.0), per_channel=0.5), iaa.Grayscale(alpha=(0.0, 1.0)), iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), ]) ] else: seq_list = [] if flag_affine: seq_list.append( iaa.Sometimes( 0.7, iaa.Affine(scale={ "x": (0.8, 1.2), "y": (0.8, 1.2) }, translate_percent={ "x": (-0.2, 0.2), "y": (-0.2, 0.2) }, rotate=(-25, 25), shear=(-8, 8)))) if flag_noise: seq_list.append( iaa.OneOf([ iaa.GaussianBlur((0, 3.0)), iaa.AverageBlur(k=(2, 7)), iaa.MedianBlur(k=(3, 11)), ])) if flag_snow: seq_list.append( iaa.FastSnowyLandscape(lightness_threshold=(100, 255), lightness_multiplier=(1.0, 4.0))) elif flag_cloud: seq_list.append(iaa.Clouds()) elif flag_fog: seq_list.append(iaa.Fog()) elif flag_snowflakes: seq_list.append( iaa.Snowflakes(flake_size=(0.2, 0.7), speed=(0.007, 0.03))) elif flag_rain: seq_list.append(iaa.Rain()) if flag_dropout: seq_list.append( iaa.OneOf([ 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), ])) return iaa.Sequential(seq_list, random_order=True)
def augment(img, steering_angle): # Flip - odbicie lustrzane if random.random() > 0.5: img = img[:, ::-1, :] steering_angle = -steering_angle #blur - rozmazanie blurer = iaa.GaussianBlur(iap.Uniform(0.1, 1.0)) img = blurer.augment_image(img) #shuffle ColorShuffle = iaa.ChannelShuffle(p=0.7) img = ColorShuffle.augment_image(img) #SuperPixels superpixel = iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200)) img = superpixel.augment_image(img) #Fog Clouds = iaa.Clouds() img = Clouds.augment_image(img) #Snowflakes # Snowflakes = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)) # img = Snowflakes.augment_image(img) #Translate tx = random.randint(-20,20) translater = iaa.Affine(translate_px = {"x":tx}, mode = 'edge') img = translater.augment_image(img) steering_angle += tx*0.02 return img, steering_angle
def chapter_augmenters_clouds(): fn_start = "weather/clouds" image = LANDSCAPE_IMAGE aug = iaa.Clouds() run_and_save_augseq( fn_start + ".jpg", aug, [image for _ in range(4*2)], cols=4, rows=2)
def test_very_roughly(self): img = np.zeros((100, 100, 3), dtype=np.uint8) img_aug = iaa.Clouds().augment_image(img) assert 50 < np.average(img_aug) < 255 assert np.max(img_aug) > 100 img_aug_f32 = img_aug.astype(np.float32) grad_x = img_aug_f32[:, 1:] - img_aug_f32[:, :-1] grad_y = img_aug_f32[1:, :] - img_aug_f32[:-1, :] assert np.sum(np.abs(grad_x)) > 1 * img.shape[1] assert np.sum(np.abs(grad_y)) > 1 * img.shape[0]
def chapter_augmenters_blendalphamask(): fn_start = "blend/blendalphamask" aug = iaa.BlendAlphaMask( iaa.InvertMaskGen(0.5, iaa.VerticalLinearGradientMaskGen()), iaa.Sequential( [iaa.Clouds(), iaa.WithChannels([1, 2], iaa.Multiply(0.5))])) run_and_save_augseq(fn_start + ".jpg", aug, [ia.quokka(size=(128, 128)) for _ in range(4 * 2)], cols=4, rows=2)
def test_zero_sized_axes(self): shapes = [(0, 0), (0, 1), (1, 0), (0, 1, 0), (1, 0, 0), (0, 1, 1), (1, 0, 1)] for shape in shapes: with self.subTest(shape=shape): image = np.zeros(shape, dtype=np.uint8) aug = iaa.Clouds() image_aug = aug(image=image) assert image_aug.dtype.name == "uint8" assert image_aug.shape == shape
def test_unusual_channel_numbers(self): shapes = [(1, 1, 4), (1, 1, 5), (1, 1, 512), (1, 1, 513)] for shape in shapes: with self.subTest(shape=shape): image = np.zeros(shape, dtype=np.uint8) aug = iaa.Clouds() image_aug = aug(image=image) assert np.any(image_aug > 0) assert image_aug.dtype.name == "uint8" assert image_aug.shape == shape
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.Clouds()", iaa.Clouds())] for descr, aug in augs: print(descr) images_aug = aug.augment_images([image] * 64) ia.imshow(ia.draw_grid(images_aug))
def test_Fog(): # rough test as fairly hard to test more detailed reseed() img = np.zeros((100, 100, 3), dtype=np.uint8) img_aug = iaa.Clouds().augment_image(img) assert 50 < np.average(img_aug) < 255 assert np.max(img_aug) > 100 grad_x = img_aug[:, 1:].astype(np.float32) - img_aug[:, :-1].astype(np.float32) grad_y = img_aug[1:, :].astype(np.float32) - img_aug[:-1, :].astype(np.float32) assert np.sum(np.abs(grad_x)) > 1 * img.shape[1] assert np.sum(np.abs(grad_y)) > 1 * img.shape[0]
def _test_very_roughly(cls, nb_channels): if nb_channels is None: img = np.zeros((100, 100), dtype=np.uint8) else: img = np.zeros((100, 100, nb_channels), dtype=np.uint8) img_aug = iaa.Clouds().augment_image(img) assert 20 < np.average(img_aug) < 250 assert np.max(img_aug) > 150 img_aug_f32 = img_aug.astype(np.float32) grad_x = img_aug_f32[:, 1:] - img_aug_f32[:, :-1] grad_y = img_aug_f32[1:, :] - img_aug_f32[:-1, :] assert np.sum(np.abs(grad_x)) > 5 * img.shape[1] assert np.sum(np.abs(grad_y)) > 5 * img.shape[0]
def do_all_aug(image): do_aug(image, iaa.Noop(name="origin")) do_aug(image, iaa.Crop((0, 10))) # 切边 do_aug(image, iaa.GaussianBlur((0, 3))) do_aug(image, iaa.AverageBlur(1, 7)) do_aug(image, iaa.MedianBlur(1, 7)) do_aug(image, iaa.Sharpen()) do_aug(image, iaa.BilateralBlur()) # 既噪音又模糊,叫双边 do_aug(image, iaa.MotionBlur()) do_aug(image, iaa.MeanShiftBlur()) do_aug(image, iaa.GammaContrast()) do_aug(image, iaa.SigmoidContrast()) do_aug(image, iaa.Affine(shear={ 'x': (-10, 10), 'y': (-10, 10) }, mode="edge")) # shear:x轴往左右偏离的像素书,(a,b)是a,b间随机值,[a,b]是二选一 do_aug(image, iaa.Affine(shear={ 'x': (-10, 10), 'y': (-10, 10) }, mode="edge")) # shear:x轴往左右偏离的像素书,(a,b)是a,b间随机值,[a,b]是二选一 do_aug(image, iaa.Rotate(rotate=(-10, 10), mode="edge")) do_aug(image, iaa.PiecewiseAffine()) # 局部点变形 do_aug(image, iaa.Fog()) do_aug(image, iaa.Clouds()) do_aug(image, iaa.Snowflakes(flake_size=(0.1, 0.2), density=(0.005, 0.025))) do_aug( image, iaa.Rain( nb_iterations=1, drop_size=(0.05, 0.1), speed=(0.04, 0.08), )) do_aug( image, iaa.ElasticTransformation(alpha=(0.0, 20.0), sigma=(3.0, 5.0), mode="nearest")) do_aug(image, iaa.AdditiveGaussianNoise(scale=(0, 10))) do_aug(image, iaa.AdditiveLaplaceNoise(scale=(0, 10))) do_aug(image, iaa.AdditivePoissonNoise(lam=(0, 10))) do_aug(image, iaa.Salt((0, 0.02))) do_aug(image, iaa.Pepper((0, 0.02)))
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 augment_image(self,img): # gaussian noise if self.aug_rate > np.random.rand(): gaussian_noise = iaa.AdditiveGaussianNoise(0.01,np.random.rand()*30) img = gaussian_noise.augment_image(img) # Elastic Transformation (low sigma) if self.aug_rate> np.random.rand(): et_low = iaa.ElasticTransformation(alpha=np.random.rand(), sigma=0.2) img = et_low.augment_image(img) # Elastic Transformation (High Sigma) if self.aug_rate> np.random.rand(): et_high = iaa.ElasticTransformation(alpha=np.random.rand()*40.0, sigma=10.0) img = et_high.augment_image(img) # Clouds if self.aug_rate> np.random.rand(): clouds = iaa.Clouds() img = clouds.augment_image(img) img = img-np.min(img) mulfactor = 255/np.max(img) img = img*mulfactor img = img.astype(np.uint8) return img
def chapter_augmenters_blendalphaverticallineargradient(): fn_start = "blend/blendalphaverticallineargradient" aug = iaa.BlendAlphaVerticalLinearGradient(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.BlendAlphaVerticalLinearGradient(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.BlendAlphaVerticalLinearGradient(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) aug = iaa.BlendAlphaVerticalLinearGradient(iaa.Clouds(), start_at=(0.15, 0.35), end_at=0.0) run_and_save_augseq(fn_start + "_clouds.jpg", aug, [ia.quokka(size=(128, 128)) for _ in range(4 * 2)], cols=4, rows=2)
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)), # iaa.WithChannels(0, iaa.Affine(rotate=(0, 0))), iaa.ChannelShuffle(0.35), iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB", children=iaa.WithChannels(0, iaa.Add((0, 50)))), # iaa.WithHueAndSaturation([ iaa.WithChannels(0, iaa.Add((-30, 10))), iaa.WithChannels( 1, [iaa.Multiply((0.5, 1.5)), iaa.LinearContrast((0.75, 1.25))])
def __init__(self): self.aug = iaa.Sequential([ # iaa.Resize(32), iaa.Clouds() ])
def cloudsaug(img): images = np.expand_dims(img, axis=0) aug = iaa.Clouds() images_aug = aug(images=images) img_aug = np.squeeze(images_aug) return img_aug
def test_pickleable(self): aug = iaa.Clouds(random_state=1) runtest_pickleable_uint8_img(aug, iterations=3, shape=(20, 20, 3))
[iaa.AdditiveGaussianNoise(scale=0.1 * 255, per_channel=True)]) seq_AdditiveLaplaceNoise = iaa.Sequential( [iaa.AdditiveLaplaceNoise(scale=0.1 * 255)]) seq_ALN_per_channel = iaa.Sequential( [iaa.AdditiveLaplaceNoise(scale=0.1 * 255, per_channel=True)]) seq_Rot90 = iaa.Sequential([iaa.Rot90(1)]) seq_GammaContrast = iaa.Sequential([iaa.GammaContrast((0.5, 1.5))]) seq_GammaContrast_per_channel = iaa.Sequential( [iaa.GammaContrast((0.5, 1.5), per_channel=True)]) seq_MotionBlur = iaa.Sequential([iaa.MotionBlur(k=15, angle=[-180, 180])]) seq_Fliplr = iaa.Sequential([iaa.Fliplr(1.0)]) seq_Flipud = iaa.Sequential([iaa.Flipud(1.0)]) seq_AddToHueAndSaturation = iaa.Sequential( [iaa.AddToHueAndSaturation((-50, 50), per_channel=True)]) seq_Multiply = iaa.Sequential([iaa.Multiply((0.5, 1.5))]) seq_Clouds = iaa.Sequential([iaa.Clouds()]) #lists containing the augmented images, named like each corresponding sequence from above AdditiveGaussianNoise = seq_AdditiveGaussianNoise.augment_images(images) AGN_per_channel = seq_AGN_per_channel.augment_images(images) AdditiveLaplaceNoise = seq_AdditiveLaplaceNoise.augment_images(images) ALN_per_channel = seq_ALN_per_channel.augment_images(images) Rot90 = seq_Rot90.augment_images(images) GammaContrast = seq_GammaContrast.augment_images(images) GammaContrast_per_channel = seq_GammaContrast_per_channel.augment_images( images) MotionBlur = seq_MotionBlur.augment_images(images) Fliplr = seq_Fliplr.augment_images(images) Flipud = seq_Flipud.augment_images(images) AddToHueAndSaturation = seq_AddToHueAndSaturation.augment_images(images) Multiply = seq_Multiply.augment_images(images)
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()) transformed_image = transform(image=image) elif augmentation == 'blend_alpha_elementwise': transform = iaa.BlendAlphaElementwise(0.5, iaa.Grayscale(1.0)) transformed_image = transform(image=image) elif augmentation == 'blend_alpha_vlg': transform = iaa.BlendAlphaVerticalLinearGradient( iaa.AddToHue((-100, 100))) transformed_image = transform(image=image) elif augmentation == 'blend_alpha_hlg': transform = iaa.BlendAlphaHorizontalLinearGradient( iaa.AddToHue((-100, 100))) transformed_image = transform(image=image)
# these point around via affine transformations. This leads to local distortions. # Distort images locally by moving points around, each with a distance v (percent relative to image size), # where v is sampled per point from N(0, z) z is sampled per image from the range lo to hi: "Piecewise_Affine": lambda lo, hi: iaa.PiecewiseAffine(scale=(lo, hi)), # Augmenter to transform images by moving pixels locally around using displacement fields. # Distort images locally by moving individual pixels around following a distortions field with # strength sigma_lo to sigma_hi. The strength of the movement is sampled per pixel from the range # alpha_lo to alpha_hi: "Elastic_Transformation": lambda alpha_lo, alpha_hi, sigma_lo, sigma_hi: iaa.ElasticTransformation(alpha=(alpha_lo, alpha_hi), sigma=(sigma_lo, sigma_hi)), # Weather augmenters are computationally expensive and will not work effectively on certain data sets # Augmenter to draw clouds in images. "Clouds": iaa.Clouds(), # Augmenter to draw fog in images. "Fog": iaa.Fog(), # Augmenter to add falling snowflakes to images. "Snowflakes": iaa.Snowflakes(), # Replaces percent of all pixels in an image by either x or y "Replace_Element_Wise": lambda percent, x, y: iaa.ReplaceElementwise(percent, [x, y]), # Adds laplace noise (somewhere between gaussian and salt and peeper noise) to an image, sampled once per pixel # from a laplace distribution Laplace(0, s), where s is sampled per image and varies between lo and hi*255 for # percent of all images (sampled once for all channels) and sampled three (RGB) times (channel-wise) # for the rest from the same laplace distribution: "Additive_Laplace_Noise": lambda lo, hi, percent:
def transform(aug_type, magnitude, X): if aug_type == "crop": X_aug = iaa.Crop(px=(0, int(magnitude * 32))).augment_images(X) elif aug_type == "gaussian-blur": X_aug = iaa.GaussianBlur(sigma=(0, magnitude * 25.0)).augment_images(X) elif aug_type == "rotate": X_aug = iaa.Affine(rotate=(-180 * magnitude, 180 * magnitude)).augment_images(X) elif aug_type == "shear": X_aug = iaa.Affine(shear=(-90 * magnitude, 90 * magnitude)).augment_images(X) elif aug_type == "translate-x": X_aug = iaa.Affine( translate_percent={"x": (-magnitude, magnitude), "y": (0, 0)} ).augment_images(X) elif aug_type == "translate-y": X_aug = iaa.Affine( translate_percent={"x": (0, 0), "y": (-magnitude, magnitude)} ).augment_images(X) elif aug_type == "horizontal-flip": X_aug = iaa.Fliplr(magnitude).augment_images(X) elif aug_type == "vertical-flip": X_aug = iaa.Flipud(magnitude).augment_images(X) elif aug_type == "sharpen": X_aug = iaa.Sharpen( alpha=(0, 1.0), lightness=(0.50, 5 * magnitude) ).augment_images(X) elif aug_type == "emboss": X_aug = iaa.Emboss( alpha=(0, 1.0), strength=(0.0, 20.0 * magnitude) ).augment_images(X) elif aug_type == "additive-gaussian-noise": X_aug = iaa.AdditiveGaussianNoise( loc=0, scale=(0.0, magnitude * 255), per_channel=0.5 ).augment_images(X) elif aug_type == "dropout": X_aug = iaa.Dropout( (0.01, max(0.011, magnitude)), per_channel=0.5 ).augment_images( X ) # Dropout first argument should be smaller than second one elif aug_type == "coarse-dropout": X_aug = iaa.CoarseDropout( (0.03, 0.15), size_percent=(0.30, np.log10(magnitude * 3)), per_channel=0.2 ).augment_images(X) elif aug_type == "gamma-contrast": X_norm = normalize(X) X_aug_norm = iaa.GammaContrast(magnitude * 1.75).augment_images( X_norm ) # needs 0-1 values X_aug = denormalize(X_aug_norm) elif aug_type == "brighten": X_aug = iaa.Add( (int(-40 * magnitude), int(40 * magnitude)), per_channel=0.5 ).augment_images( X ) # brighten elif aug_type == "invert": X_aug = iaa.Invert(1.0).augment_images(X) # magnitude not used elif aug_type == "fog": X_aug = iaa.Fog().augment_images(X) # magnitude not used elif aug_type == "clouds": X_aug = iaa.Clouds().augment_images(X) # magnitude not used elif aug_type == "histogram-equalize": X_aug = iaa.AllChannelsHistogramEqualization().augment_images( X ) # magnitude not used elif aug_type == "super-pixels": # deprecated X_norm = normalize(X) X_norm2 = (X_norm * 2) - 1 X_aug_norm2 = iaa.Superpixels( p_replace=(0, magnitude), n_segments=(100, 100) ).augment_images(X_norm2) X_aug_norm = (X_aug_norm2 + 1) / 2 X_aug = denormalize(X_aug_norm) elif aug_type == "perspective-transform": X_norm = normalize(X) X_aug_norm = iaa.PerspectiveTransform( scale=(0.01, max(0.02, magnitude)) ).augment_images( X_norm ) # first scale param must be larger np.clip(X_aug_norm, 0.0, 1.0, out=X_aug_norm) X_aug = denormalize(X_aug_norm) elif aug_type == "elastic-transform": # deprecated X_norm = normalize(X) X_norm2 = (X_norm * 2) - 1 X_aug_norm2 = iaa.ElasticTransformation( alpha=(0.0, max(0.5, magnitude * 300)), sigma=5.0 ).augment_images(X_norm2) X_aug_norm = (X_aug_norm2 + 1) / 2 X_aug = denormalize(X_aug_norm) elif aug_type == "add-to-hue-and-saturation": X_aug = iaa.AddToHueAndSaturation( (int(-45 * magnitude), int(45 * magnitude)) ).augment_images(X) elif aug_type == "coarse-salt-pepper": X_aug = iaa.CoarseSaltAndPepper(p=0.2, size_percent=magnitude).augment_images(X) elif aug_type == "grayscale": X_aug = iaa.Grayscale(alpha=(0.0, magnitude)).augment_images(X) else: raise ValueError return X_aug
def get_augmentation(params): """ copy from https://github.com/barisozmen/deepaugment :param params: :return: """ padding_value = params['PaddingValue'] output_size = params['OutputSize'] scale_params = params['Scale'] if 'disable' in scale_params: random_scale_fn = partial(random_scale, output_size=output_size) else: min_scale = scale_params['min_scale'] max_scale = scale_params['max_scale'] random_scale_fn = partial(random_scale, output_size=output_size, min_scale=min_scale, max_scale=max_scale) rot_params = params['Rotation'] if 'disable' in rot_params: max_rot_angle = None else: max_rot_angle = rot_params['max_angle'] crop_params = params['Crop'] if 'disable' in crop_params: crop_x_ratio = None crop_y_ratio = None else: crop_x_ratio, crop_y_ratio = crop_params['crop_x'], crop_params[ 'crop_y'] random_rotate_crop_fn = partial(random_rotate_crop, output_size=output_size, max_angle=max_rot_angle, crop_x_ratio=crop_x_ratio, crop_y_ratio=crop_y_ratio, padding_value=padding_value) augmentation = [] for aug_type, aug_parameters in params.items(): if aug_type in [ 'Scale', 'Rotation', 'Crop', 'OutputSize', 'PaddingValue' ] or 'disable' in aug_parameters: continue elif aug_type == "Shear": angle = aug_parameters['angle'] augmentation.append( iaa.Affine(shear=(-90 * angle, 90 * angle), cval=padding_value[0])) elif aug_type == "HorizontalFlip": augmentation.append(iaa.Fliplr(aug_parameters['probability'])) elif aug_type == "VerticalFlip": augmentation.append(iaa.Flipud(aug_parameters['probability'])) elif aug_type == "gaussian-blur": augmentation.append(iaa.GaussianBlur(sigma=(0, magnitude * 25.0))) elif aug_type == "Brighten": magnitude = aug_parameters['magnitude'] augmentation.append(iaa.Multiply( (1 - magnitude, 1.0 + magnitude))) # brighten elif aug_type == "GammaContrast": magnitude = aug_parameters['magnitude'] augmentation.append( iaa.GammaContrast((1 - magnitude, 1.0 + magnitude))) elif aug_type == "Sharpen": max_alpha = aug_parameters['max_alpha'] max_lightness = aug_parameters['max_lightness'] augmentation.append( iaa.Sharpen(alpha=(0, max_alpha), lightness=(0.50, max_lightness))) elif aug_type == "Emboss": max_alpha = aug_parameters['max_alpha'] max_strength = aug_parameters['max_strength'] augmentation.append( iaa.Emboss(alpha=(0, max_alpha), strength=(0.0, max_strength))) elif aug_type == "MotionBlur": min_kernel_size = aug_parameters['min_kernel_size'] interval = aug_parameters['interval'] max_angle = aug_parameters['max_angle'] augmentation.append( iaa.Emboss(k=(int(min_kernel_size), int(min_kernel_size + interval)), angle=(0.0, max_angle))) elif aug_type == "fog" and aug_parameters: augmentation.append(iaa.Fog()) # magnitude not used elif aug_type == "clouds" and aug_parameters: augmentation.append(iaa.Clouds()) # magnitude not used elif aug_type == "ElasticTransformation": max_alpha = aug_parameters['max_alpha'] sigma = aug_parameters['sigma'] augmentation.append( iaa.ElasticTransformation(alpha=(0.0, max_alpha), sigma=sigma)) elif aug_type == "SaltAndPepper": probability = aug_parameters['probability'] per_channel_prob = aug_parameters['per_channel'] augmentation.append( iaa.SaltAndPepper(probability, per_channel=per_channel_prob)) elif aug_type == "CoarseSaltAndPepper": probability = aug_parameters['probability'] size_percent = aug_parameters['size_percent '] augmentation.append( iaa.CoarseSaltAndPepper(probability, size_percent=size_percent)) elif aug_type == "Dropout": max_probability = aug_parameters['max_probability'] per_channel_prob = aug_parameters['per_channel_prob '] augmentation.append( iaa.Dropout((0.01, max_probability), per_channel=per_channel_prob)) elif aug_type == "CoarseDropout": max_probability = aug_parameters['max_probability'] size_percent = aug_parameters['size_percent'] augmentation.append( iaa.CoarseDropout((0.03, max_probability), size_percent=size_percent)) elif aug_type == "GrayScale": max_alpha = aug_parameters['max_alpha'] augmentation.append(iaa.Grayscale(alpha=(0., max_alpha))) else: raise ValueError if len(augmentation) > 0: iaa_aug = iaa.Sequential(augmentation) else: iaa_aug = None def preprocessing(image, mask): image, mask = random_scale_fn(image, mask) if iaa_aug is not None: image, segmap = iaa_aug(image=image, segmentation_maps=SegmentationMapOnImage( mask, shape=mask.shape, nb_classes=19)) mask = segmap.get_arr_int() image, mask = random_rotate_crop_fn(image, mask) return image, mask return preprocessing
def do_random(image, pos_list): # 1.先任选5种影响位置的效果之一做位置变换 seq = iaa.Sequential([ iaa.Sometimes( 0.5, [ iaa.Crop((0, 10)), # 切边, (0到10个像素采样) ]), iaa.Sometimes( 0.5, [ iaa.Affine(shear={ 'x': (-10, 10), 'y': (-10, 10) }, mode="edge"), iaa.Rotate(rotate=(-10, 10), mode="edge"), # 旋转 ]), iaa.Sometimes( 0.5, [ iaa.PiecewiseAffine(), # 局部仿射 iaa.ElasticTransformation( # distort扭曲变形 alpha=(0.0, 20.0), sigma=(3.0, 5.0), mode="nearest"), ]), # 18种位置不变的效果 iaa.SomeOf( (1, 3), [ iaa.GaussianBlur(), iaa.AverageBlur(), iaa.MedianBlur(), iaa.Sharpen(), iaa.BilateralBlur(), # 既噪音又模糊,叫双边, iaa.MotionBlur(), iaa.MeanShiftBlur(), iaa.GammaContrast(), iaa.SigmoidContrast(), iaa.Fog(), iaa.Clouds(), iaa.Snowflakes(flake_size=(0.1, 0.2), density=(0.005, 0.025)), iaa.Rain(nb_iterations=1, drop_size=(0.05, 0.1), speed=(0.04, 0.08)), iaa.AdditiveGaussianNoise(scale=(0, 10)), iaa.AdditiveLaplaceNoise(scale=(0, 10)), iaa.AdditivePoissonNoise(lam=(0, 10)), iaa.Salt((0, 0.02)), iaa.Pepper((0, 0.02)) ]) ]) polys = [ia.Polygon(pos) for pos in pos_list] polygons = ia.PolygonsOnImage(polys, shape=image.shape) images_aug, polygons_aug = seq(images=[image], polygons=polygons) image = images_aug[0] image = polygons_aug.draw_on_image(image, size=2) new_polys = [] for p in polygons_aug.polygons: new_polys.append(p.coords) polys = np.array(new_polys, np.int32).tolist() return image, polys
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
print("{} annotations and images have been transformed!!".format( count)) sometimes = lambda aug: iaa.Sometimes(0.9, aug) seq = iaa.SomeOf( (1, 2), [ sometimes( iaa.BlendAlphaFrequencyNoise(foreground=iaa.EdgeDetect(0.75), upscale_method="nearest")), sometimes( iaa.BlendAlphaMask( iaa.InvertMaskGen(0.5, iaa.VerticalLinearGradientMaskGen()), iaa.Sequential([iaa.Clouds(), iaa.WithChannels([1, 2])]))), sometimes( iaa.BlendAlphaCheckerboard( nb_rows=2, nb_cols=(1, 4), foreground=iaa.AddToHue( (-80, 80)))), #important augmenter sometimes( iaa.BlendAlphaVerticalLinearGradient(iaa.AveragePooling(10), start_at=(0.0, 1.0), end_at=(0.0, 1.0))), sometimes( iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0), upscale_method="linear")) ])
#data_dir = "/disk2/datasets/faces_dataset/" labels_dir = "/disk2/datasets/faces_dataset/labels.pickle" SPLITTER = ":" widgets = [ progressbar.ETA(), " | ", progressbar.Percentage(), " ", progressbar.Bar() ] sometimes = lambda aug: iaa.Sometimes(0.5, aug) seq = iaa.Sequential([ #iaa.Affine(rotate=(45,45), fit_output=True), #iaa.Crop(px=(1, 16), keep_size=False), sometimes(iaa.Clouds()), ##iaa.WithChannels((0,1,2), iaa.MultiplyHue((0.2,1.3))), #sometimes(iaa.WithChannels((0,1,2), iaa.imgcorruptlike.GaussianNoise(severity=(1,3)))), #iaa.WithChannels((0,1,2), iaa.MultiplyHue((0.5,1.5))), #iaa.WithChannels((0,1,2), iaa.MultiplyHue((0.5,1.5))), #iaa.MultiplyHue((0.5, 1.5)), #iaa.BlendAlphaVerticalLinearGradient( # iaa.AveragePooling(11), # start_at=(0.0, 1.0), end_at=(0.0, 1.0)), #iaa.SomeOf #sometimes(iaa.Pad(((1,50), (1,50), (1,50), (1,50)), keep_size=False)), iaa.GaussianBlur((0, 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 #sometimes(iaa.Sharpen(alpha=(0.5, 1.0), lightness=(0.75, 1.5))), # sharpen images
class AugmentationScheme: # Dictionary containing all possible augmentation functions Augmentations = { # Convert images to HSV, then increase each pixel's Hue (H), Saturation (S) or Value/lightness (V) [0, 1, 2] # value by an amount in between lo and hi: "HSV": lambda channel, lo, hi: iaa.WithColorspace( to_colorspace="HSV", from_colorspace="RGB", children=iaa.WithChannels(channel, iaa.Add((lo, hi)))), # The augmenter first transforms images to HSV color space, then adds random values (lo to hi) # to the H and S channels and afterwards converts back to RGB. # (independently per channel and the same value for all pixels within that channel) "Add_To_Hue_And_Saturation": lambda lo, hi: iaa.AddToHueAndSaturation((lo, hi), per_channel=True), # Increase each pixel’s channel-value (redness/greenness/blueness) [0, 1, 2] by value in between lo and hi: "Increase_Channel": lambda channel, lo, hi: iaa.WithChannels(channel, iaa.Add((lo, hi))), # Rotate each image’s channel [R=0, G=1, B=2] by value in between lo and hi degrees: "Rotate_Channel": lambda channel, lo, hi: iaa.WithChannels(channel, iaa.Affine(rotate=(lo, hi))), # Augmenter that never changes input images (“no operation”). "No_Operation": iaa.Noop(), # Pads images, i.e. adds columns/rows to them. Pads image by value in between lo and hi # percent relative to its original size (only accepts positive values in range[0, 1]): # If s_i is false, The value will be sampled once per image and used for all sides # (i.e. all sides gain/lose the same number of rows/columns) # NOTE: automatically resizes images back to their original size after it has augmented them. "Pad_Percent": lambda lo, hi, s_i: iaa.Pad( percent=(lo, hi), keep_size=True, sample_independently=s_i), # Pads images by a number of pixels between lo and hi # If s_i is false, The value will be sampled once per image and used for all sides # (i.e. all sides gain/lose the same number of rows/columns) "Pad_Pixels": lambda lo, hi, s_i: iaa.Pad( px=(lo, hi), keep_size=True, sample_independently=s_i), # Crops/cuts away pixels at the sides of the image. # Crops images by value in between lo and hi (only accepts positive values in range[0, 1]): # If s_i is false, The value will be sampled once per image and used for all sides # (i.e. all sides gain/lose the same number of rows/columns) # NOTE: automatically resizes images back to their original size after it has augmented them. "Crop_Percent": lambda lo, hi, s_i: iaa.Crop( percent=(lo, hi), keep_size=True, sample_independently=s_i), # Crops images by a number of pixels between lo and hi # If s_i is false, The value will be sampled once per image and used for all sides # (i.e. all sides gain/lose the same number of rows/columns) "Crop_Pixels": lambda lo, hi, s_i: iaa.Crop( px=(lo, hi), keep_size=True, sample_independently=s_i), # Flip/mirror percent (i.e 0.5) of the input images horizontally # The default probability is 0, so to flip all images, percent=1 "Flip_lr": iaa.Fliplr(1), # Flip/mirror percent (i.e 0.5) of the input images vertically # The default probability is 0, so to flip all images, percent=1 "Flip_ud": iaa.Flipud(1), # Completely or partially transform images to their superpixel representation. # Generate s_pix_lo to s_pix_hi superpixels per image. Replace each superpixel with a probability between # prob_lo and prob_hi with range[0, 1] (sampled once per image) by its average pixel color. "Superpixels": lambda prob_lo, prob_hi, s_pix_lo, s_pix_hi: iaa.Superpixels( p_replace=(prob_lo, prob_hi), n_segments=(s_pix_lo, s_pix_hi)), # Change images to grayscale and overlay them with the original image by varying strengths, # effectively removing alpha_lo to alpha_hi of the color: "Grayscale": lambda alpha_lo, alpha_hi: iaa.Grayscale(alpha=(alpha_lo, alpha_hi)), # Blur each image with a gaussian kernel with a sigma between sigma_lo and sigma_hi: "Gaussian_Blur": lambda sigma_lo, sigma_hi: iaa.GaussianBlur(sigma=(sigma_lo, sigma_hi) ), # Blur each image using a mean over neighbourhoods that have random sizes, # which can vary between h_lo and h_hi in height and w_lo and w_hi in width: "Average_Blur": lambda h_lo, h_hi, w_lo, w_hi: iaa.AverageBlur(k=((h_lo, h_hi), (w_lo, w_hi))), # Blur each image using a median over neighbourhoods that have a random size between lo x lo and hi x hi: "Median_Blur": lambda lo, hi: iaa.MedianBlur(k=(lo, hi)), # Sharpen an image, then overlay the results with the original using an alpha between alpha_lo and alpha_hi: "Sharpen": lambda alpha_lo, alpha_hi, lightness_lo, lightness_hi: iaa. Sharpen(alpha=(alpha_lo, alpha_hi), lightness=(lightness_lo, lightness_hi)), # Emboss an image, then overlay the results with the original using an alpha between alpha_lo and alpha_hi: "Emboss": lambda alpha_lo, alpha_hi, strength_lo, strength_hi: iaa.Emboss( alpha=(alpha_lo, alpha_hi), strength=(strength_lo, strength_hi)), # Detect edges in images, turning them into black and white images and # then overlay these with the original images using random alphas between alpha_lo and alpha_hi: "Detect_Edges": lambda alpha_lo, alpha_hi: iaa.EdgeDetect(alpha=(alpha_lo, alpha_hi)), # Detect edges having random directions between dir_lo and dir_hi (i.e (0.0, 1.0) = 0 to 360 degrees) in # images, turning the images into black and white versions and then overlay these with the original images # using random alphas between alpha_lo and alpha_hi: "Directed_edge_Detect": lambda alpha_lo, alpha_hi, dir_lo, dir_hi: iaa.DirectedEdgeDetect( alpha=(alpha_lo, alpha_hi), direction=(dir_lo, dir_hi)), # Add random values between lo and hi to images. In percent of all images the values differ per channel # (3 sampled value). In the rest of the images the value is the same for all channels: "Add": lambda lo, hi, percent: iaa.Add((lo, hi), per_channel=percent), # Adds random values between lo and hi to images, with each value being sampled per pixel. # In percent of all images the values differ per channel (3 sampled value). In the rest of the images # the value is the same for all channels: "Add_Element_Wise": lambda lo, hi, percent: iaa.AddElementwise( (lo, hi), per_channel=percent), # Add gaussian noise (aka white noise) to an image, sampled once per pixel from a normal # distribution N(0, s), where s is sampled per image and varies between lo and hi*255 for percent of all # images (sampled once for all channels) and sampled three (RGB) times (channel-wise) # for the rest from the same normal distribution: "Additive_Gaussian_Noise": lambda lo, hi, percent: iaa.AdditiveGaussianNoise(scale=(lo, hi), per_channel=percent), # Multiply in percent of all images each pixel with random values between lo and hi and multiply # the pixels in the rest of the images channel-wise, # i.e. sample one multiplier independently per channel and pixel: "Multiply": lambda lo, hi, percent: iaa.Multiply((lo, hi), per_channel=percent), # Multiply values of pixels with possibly different values for neighbouring pixels, # making each pixel darker or brighter. Multiply each pixel with a random value between lo and hi: "Multiply_Element_Wise": lambda lo, hi, percent: iaa.MultiplyElementwise( (0.5, 1.5), per_channel=0.5), # Augmenter that sets a certain fraction of pixels in images to zero. # Sample per image a value p from the range lo<=p<=hi and then drop p percent of all pixels in the image # (i.e. convert them to black pixels), but do this independently per channel in percent of all images "Dropout": lambda lo, hi, percent: iaa.Dropout(p=(lo, hi), per_channel=percent), # Augmenter that sets rectangular areas within images to zero. # Drop d_lo to d_hi percent of all pixels by converting them to black pixels, # but do that on a lower-resolution version of the image that has s_lo to s_hi percent of the original size, # Also do this in percent of all images channel-wise, so that only the information of some # channels is set to 0 while others remain untouched: "Coarse_Dropout": lambda d_lo, d_hi, s_lo, s_hi, percent: iaa.CoarseDropout( (d_lo, d_hi), size_percent=(s_hi, s_hi), per_channel=percent), # Augmenter that inverts all values in images, i.e. sets a pixel from value v to 255-v. # For c_percent of all images, invert all pixels in these images channel-wise with probability=i_percent # (per image). In the rest of the images, invert i_percent of all channels: "Invert": lambda i_percent, c_percent: iaa.Invert(i_percent, per_channel=c_percent), # Augmenter that changes the contrast of images. # Normalize contrast by a factor of lo to hi, sampled randomly per image # and for percent of all images also independently per channel: "Contrast_Normalisation": lambda lo, hi, percent: iaa.ContrastNormalization( (lo, hi), per_channel=percent), # Scale images to a value of lo to hi percent of their original size but do this independently per axis: "Scale": lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(scale={ "x": (x_lo, x_hi), "y": (y_lo, y_hi) }), # Translate images by lo to hi percent on x-axis and y-axis independently: "Translate_Percent": lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(translate_percent={ "x": (x_lo, x_hi), "y": (y_lo, y_hi) }), # Translate images by lo to hi pixels on x-axis and y-axis independently: "Translate_Pixels": lambda x_lo, x_hi, y_lo, y_hi: iaa.Affine(translate_px={ "x": (x_lo, x_hi), "y": (y_lo, y_hi) }), # Rotate images by lo to hi degrees: "Rotate": lambda lo, hi: iaa.Affine(rotate=(lo, hi)), # Shear images by lo to hi degrees: "Shear": lambda lo, hi: iaa.Affine(shear=(lo, hi)), # Augmenter that places a regular grid of points on an image and randomly moves the neighbourhood of # these point around via affine transformations. This leads to local distortions. # Distort images locally by moving points around, each with a distance v (percent relative to image size), # where v is sampled per point from N(0, z) z is sampled per image from the range lo to hi: "Piecewise_Affine": lambda lo, hi: iaa.PiecewiseAffine(scale=(lo, hi)), # Augmenter to transform images by moving pixels locally around using displacement fields. # Distort images locally by moving individual pixels around following a distortions field with # strength sigma_lo to sigma_hi. The strength of the movement is sampled per pixel from the range # alpha_lo to alpha_hi: "Elastic_Transformation": lambda alpha_lo, alpha_hi, sigma_lo, sigma_hi: iaa. ElasticTransformation(alpha=(alpha_lo, alpha_hi), sigma=(sigma_lo, sigma_hi)), # Weather augmenters are computationally expensive and will not work effectively on certain data sets # Augmenter to draw clouds in images. "Clouds": iaa.Clouds(), # Augmenter to draw fog in images. "Fog": iaa.Fog(), # Augmenter to add falling snowflakes to images. "Snowflakes": iaa.Snowflakes(), # Replaces percent of all pixels in an image by either x or y "Replace_Element_Wise": lambda percent, x, y: iaa.ReplaceElementwise(percent, [x, y]), # Adds laplace noise (somewhere between gaussian and salt and peeper noise) to an image, sampled once per pixel # from a laplace distribution Laplace(0, s), where s is sampled per image and varies between lo and hi*255 for # percent of all images (sampled once for all channels) and sampled three (RGB) times (channel-wise) # for the rest from the same laplace distribution: "Additive_Laplace_Noise": lambda lo, hi, percent: iaa.AdditiveLaplaceNoise(scale=(lo, hi), per_channel=percent), # Adds poisson noise (similar to gaussian but different distribution) to an image, sampled once per pixel from # a poisson distribution Poisson(s), where s is sampled per image and varies between lo and hi for percent of # all images (sampled once for all channels) and sampled three (RGB) times (channel-wise) # for the rest from the same poisson distribution: "Additive_Poisson_Noise": lambda lo, hi, percent: iaa.AdditivePoissonNoise(lam=(lo, hi), per_channel=percent), # Adds salt and pepper noise to an image, i.e. some white-ish and black-ish pixels. # Replaces percent of all pixels with salt and pepper noise "Salt_And_Pepper": lambda percent: iaa.SaltAndPepper(percent), # Adds coarse salt and pepper noise to image, i.e. rectangles that contain noisy white-ish and black-ish pixels # Replaces percent of all pixels with salt/pepper in an image that has lo to hi percent of the input image size, # then upscales the results to the input image size, leading to large rectangular areas being replaced. "Coarse_Salt_And_Pepper": lambda percent, lo, hi: iaa.CoarseSaltAndPepper(percent, size_percent=(lo, hi)), # Adds salt noise to an image, i.e white-ish pixels # Replaces percent of all pixels with salt noise "Salt": lambda percent: iaa.Salt(percent), # Adds coarse salt noise to image, i.e. rectangles that contain noisy white-ish pixels # Replaces percent of all pixels with salt in an image that has lo to hi percent of the input image size, # then upscales the results to the input image size, leading to large rectangular areas being replaced. "Coarse_Salt": lambda percent, lo, hi: iaa.CoarseSalt(percent, size_percent=(lo, hi)), # Adds Pepper noise to an image, i.e Black-ish pixels # Replaces percent of all pixels with Pepper noise "Pepper": lambda percent: iaa.Pepper(percent), # Adds coarse pepper noise to image, i.e. rectangles that contain noisy black-ish pixels # Replaces percent of all pixels with salt in an image that has lo to hi percent of the input image size, # then upscales the results to the input image size, leading to large rectangular areas being replaced. "Coarse_Pepper": lambda percent, lo, hi: iaa.CoarsePepper(percent, size_percent=(lo, hi)), # In an alpha blending, two images are naively mixed. E.g. Let A be the foreground image, B be the background # image and a is the alpha value. Each pixel intensity is then computed as a * A_ij + (1-a) * B_ij. # Images passed in must be a numpy array of type (height, width, channel) "Blend_Alpha": lambda image_fg, image_bg, alpha: iaa.blend_alpha( image_fg, image_bg, alpha), # Blur/Denoise an image using a bilateral filter. # Bilateral filters blur homogeneous and textured areas, while trying to preserve edges. # Blurs all images using a bilateral filter with max distance d_lo to d_hi with ranges for sigma_colour # and sigma space being define by sc_lo/sc_hi and ss_lo/ss_hi "Bilateral_Blur": lambda d_lo, d_hi, sc_lo, sc_hi, ss_lo, ss_hi: iaa.BilateralBlur( d=(d_lo, d_hi), sigma_color=(sc_lo, sc_hi), sigma_space=(ss_lo, ss_hi)), # Augmenter that sharpens images and overlays the result with the original image. # Create a motion blur augmenter with kernel size of (kernel x kernel) and a blur angle of either x or y degrees # (randomly picked per image). "Motion_Blur": lambda kernel, x, y: iaa.MotionBlur(k=kernel, angle=[x, y]), # Augmenter to apply standard histogram equalization to images (similar to CLAHE) "Histogram_Equalization": iaa.HistogramEqualization(), # Augmenter to perform standard histogram equalization on images, applied to all channels of each input image "All_Channels_Histogram_Equalization": iaa.AllChannelsHistogramEqualization(), # Contrast Limited Adaptive Histogram Equalization (CLAHE). This augmenter applies CLAHE to images, a form of # histogram equalization that normalizes within local image patches. # Creates a CLAHE augmenter with clip limit uniformly sampled from [cl_lo..cl_hi], i.e. 1 is rather low contrast # and 50 is rather high contrast. Kernel sizes of SxS, where S is uniformly sampled from [t_lo..t_hi]. # Sampling happens once per image. (Note: more parameters are available for further specification) "CLAHE": lambda cl_lo, cl_hi, t_lo, t_hi: iaa.CLAHE( clip_limit=(cl_lo, cl_hi), tile_grid_size_px=(t_lo, t_hi)), # Contrast Limited Adaptive Histogram Equalization (refer above), applied to all channels of the input images. # CLAHE performs histogram equalization within image patches, i.e. over local neighbourhoods "All_Channels_CLAHE": lambda cl_lo, cl_hi, t_lo, t_hi: iaa.AllChannelsCLAHE( clip_limit=(cl_lo, cl_hi), tile_grid_size_px=(t_lo, t_hi)), # Augmenter that changes the contrast of images using a unique formula (using gamma). # Multiplier for gamma function is between lo and hi,, sampled randomly per image (higher values darken image) # For percent of all images values are sampled independently per channel. "Gamma_Contrast": lambda lo, hi, percent: iaa.GammaContrast( (lo, hi), per_channel=percent), # Augmenter that changes the contrast of images using a unique formula (linear). # Multiplier for linear function is between lo and hi, sampled randomly per image # For percent of all images values are sampled independently per channel. "Linear_Contrast": lambda lo, hi, percent: iaa.LinearContrast( (lo, hi), per_channel=percent), # Augmenter that changes the contrast of images using a unique formula (using log). # Multiplier for log function is between lo and hi, sampled randomly per image. # For percent of all images values are sampled independently per channel. # Values around 1.0 lead to a contrast-adjusted images. Values above 1.0 quickly lead to partially broken # images due to exceeding the datatype’s value range. "Log_Contrast": lambda lo, hi, percent: iaa.LogContrast((lo, hi), per_channel=percent), # Augmenter that changes the contrast of images using a unique formula (sigmoid). # Multiplier for sigmoid function is between lo and hi, sampled randomly per image. c_lo and c_hi decide the # cutoff value that shifts the sigmoid function in horizontal direction (Higher values mean that the switch # from dark to light pixels happens later, i.e. the pixels will remain darker). # For percent of all images values are sampled independently per channel: "Sigmoid_Contrast": lambda lo, hi, c_lo, c_hi, percent: iaa.SigmoidContrast( (lo, hi), (c_lo, c_hi), per_channel=percent), # Augmenter that calls a custom (lambda) function for each batch of input image. # Extracts Canny Edges from images (refer to description in CO) # Good default values for min and max are 100 and 200 'Custom_Canny_Edges': lambda min_val, max_val: iaa.Lambda(func_images=CO.Edges( min_value=min_val, max_value=max_val)), } # AugmentationScheme objects require images and labels. # 'augs' is a list that contains all data augmentations in the scheme def __init__(self): self.augs = [iaa.Flipud(1)] def __call__(self, image): image = np.array(image) aug_scheme = iaa.Sometimes( 0.5, iaa.SomeOf(random.randrange(1, len(self.augs) + 1), self.augs, random_order=True)) aug_img = self.aug_scheme.augment_image(image) # fixes negative strides aug_img = aug_img[..., ::1] - np.zeros_like(aug_img) return aug_img