def __init__(self, **config):
from numpy.random import uniform
from numpy.random import randint
## old photometric
self.aug = iaa.Sequential([
# iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0, 3.0))),
# iaa.Sometimes(0.25,
# iaa.OneOf([iaa.Dropout(p=(0, 0.1)),
# iaa.CoarseDropout(0.1, size_percent=0.5)])),
# iaa.Sometimes(0.25,
# iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05), per_channel=0.5),
# )
])
if config['photometric']['enable']:
params = config['photometric']['params']
aug_all = []
# if params.get('random_brightness', False):
# change = params['random_brightness']['max_abs_change']
# aug = iaa.Add((-change, change))
# # aug_all.append(aug)
# aug_all.append(aug)
# if params.get('random_contrast', False):
# change = params['random_contrast']['strength_range']
# aug = iaa.LinearContrast((change[0], change[1]))
# aug_all.append(aug)
# if params.get('additive_gaussian_noise', False):
# change = params['additive_gaussian_noise']['stddev_range']
# aug = iaa.AdditiveGaussianNoise(scale=(change[0], change[1]))
# aug_all.append(aug)
if params.get('additive_speckle_noise', False):
change = params['additive_speckle_noise']['prob_range']
aug = iaa.ImpulseNoise(p=(change[0], change[1]))
aug_all.append(aug)
# if params.get('motion_blur', False):
# change = params['motion_blur']['max_kernel_size']
# if change > 3:
# change = randint(3, change)
# elif change == 3:
# aug = iaa.Sometimes(0.5, iaa.MotionBlur(change))
# aug_all.append(aug)
# if params.get('GaussianBlur', False):
# change = params['GaussianBlur']['sigma']
# aug = iaa.GaussianBlur(sigma=(change))
# aug_all.append(aug)
self.aug = iaa.Sequential(aug_all)
else:
self.aug = iaa.Sequential([
iaa.Noop(),
])
def imgaugRGB(img):
print(img.shape)
seq = iaa.Sequential(
[
# blur
iaa.SomeOf((0, 2), [
iaa.GaussianBlur((0.0, 2.0)),
iaa.AverageBlur(k=(3, 7)),
iaa.MedianBlur(k=(3, 7)),
iaa.BilateralBlur(d=(1, 7)),
iaa.MotionBlur(k=(3, 7))
]),
#color
iaa.SomeOf(
(0, 2),
[
#iaa.WithColorspace(),
iaa.AddToHueAndSaturation((-20, 20)),
#iaa.ChangeColorspace(to_colorspace[], alpha=0.5),
iaa.Grayscale(alpha=(0.0, 0.2))
]),
#brightness
iaa.OneOf([
iaa.Sequential([
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5)
]),
iaa.Add((-10, 10), per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.FrequencyNoiseAlpha(exponent=(-4, 0),
first=iaa.Multiply(
(0.5, 1.5), per_channel=0.5),
second=iaa.ContrastNormalization(
(0.5, 2.0), per_channel=0.5))
]),
#contrast
iaa.SomeOf((0, 2), [
iaa.GammaContrast((0.5, 1.5), per_channel=0.5),
iaa.SigmoidContrast(
gain=(0, 10), cutoff=(0.25, 0.75), per_channel=0.5),
iaa.LogContrast(gain=(0.75, 1), per_channel=0.5),
iaa.LinearContrast(alpha=(0.7, 1.3), per_channel=0.5)
]),
#arithmetic
iaa.SomeOf((0, 3), [
iaa.AdditiveGaussianNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditiveLaplaceNoise(scale=(0, 0.05), per_channel=0.5),
iaa.AdditivePoissonNoise(lam=(0, 8), per_channel=0.5),
iaa.Dropout(p=(0, 0.05), per_channel=0.5),
iaa.ImpulseNoise(p=(0, 0.05)),
iaa.SaltAndPepper(p=(0, 0.05)),
iaa.Salt(p=(0, 0.05)),
iaa.Pepper(p=(0, 0.05))
]),
#iaa.Sometimes(p=0.5, iaa.JpegCompression((0, 30)), None),
],
random_order=True)
return seq.augment_image(img)
def chapter_augmenters_impulsenoise():
fn_start = "arithmetic/impulsenoise"
aug = iaa.ImpulseNoise(0.1)
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2,
quality=95)
def main():
img = ia.data.quokka(0.5)
mul = 0.01
augs = [("iaa.ImpulseNoise(p=0*mul)", iaa.ImpulseNoise(p=0 * mul)),
("iaa.ImpulseNoise(p=1*mul)", iaa.ImpulseNoise(p=1 * mul)),
("iaa.ImpulseNoise(p=2*mul)", iaa.ImpulseNoise(p=2 * mul)),
("iaa.ImpulseNoise(p=3*mul)", iaa.ImpulseNoise(p=3 * mul)),
("iaa.ImpulseNoise(p=(0*mul, 1*mul))",
iaa.ImpulseNoise(p=(0 * mul, 1 * mul))),
("iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul])",
iaa.ImpulseNoise(p=[0 * mul, 1 * mul, 2 * mul]))]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def __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.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
# defining our sequence of augmentation we want to apply
augmenters = [
iaa.GaussianBlur(sigma=(1.0, 3.0)), # blur images with a sigma of 0 to 2.0
iaa.MotionBlur((3, 5)), # blur image
iaa.AdditiveGaussianNoise(
scale=(0, 0.05 * 255)
), # Add gaussian noise to an image, sampled once per pixel from a normal distribution N(0, 0.05*255)
iaa.AdditiveLaplaceNoise(scale=(0, 0.05 * 255)),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.Multiply(
(0.5,
1.5)), # Multiply each image with a random value between 0.5 and 1.5:
iaa.Dropout(
p=(0.05, 0.15)
), # Sample per image a value p from the range 0.05<=p<=0.15 and then drop p percent of all pixels in the image (i.e. convert them to black pixels):
iaa.ImpulseNoise(p=(0.03, 0.06)),
iaa.Salt(p=(0.03, 0.05)),
iaa.Add((-30, 30)), # adding random value to pixels
iaa.SigmoidContrast(6.1, 0.5),
iaa.PerspectiveTransform(scale=0.02),
iaa.PerspectiveTransform(scale=0.01),
iaa.PerspectiveTransform(scale=0.015),
iaa.PerspectiveTransform(scale=0.012),
iaa.PiecewiseAffine(scale=0.015),
iaa.PiecewiseAffine(scale=0.005),
iaa.PiecewiseAffine(scale=0.01),
iaa.Crop(px=(10, 15), keep_size=True),
iaa.Crop(px=(10, 15))
]
aug1 = iaa.Add((-20, 20)) aug2 = iaa.AddElementwise((-20, 20), per_channel=0.5) aug3 = aug = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)) aug4 = iaa.AdditiveLaplaceNoise(scale=(0, 0.2*255)) aug5 = iaa.AdditivePoissonNoise(scale) aug6 = iaa.Multiply((0.5, 1.5), per_channel=0.5) aug7 = iaa.Cutout(nb_iterations=2, size=0.05) aug8 = iaa.Cutout(fill_mode="constant", size=0.05, cval=255) aug9 = iaa.Cutout(fill_mode="gaussian", fill_per_channel=True, size=0.05) aug10 = iaa.Dropout(p=(0, 0.05)) aug11 = iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.2)) aug12 = iaa.Dropout2d(p=0.05, nb_keep_channels=0) aug13 = iaa.ImpulseNoise(0.1) aug14 = iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.6)) aug15 = iaa.CoarsePepper(0.05, size_percent=(0.01, 0.2)) # aug16 = iaa.Invert(0.25, per_channel=0.4) # aug17 = iaa.Invert(0.1) # aug18 = iaa.Solarize(0.05, threshold=(32, 128)) # aug19 = iaa.JpegCompression(compression=(95, 99)) aug20 = iaa.GaussianBlur(sigma=(0.0, 3.0)) # blur aug21 = iaa.AverageBlur(k=((1, 5), (1, 3))) aug22 = iaa.MotionBlur(k=3) # aug23 = iaa.BlendAlpha( # (0.0, 0.5), # iaa.Affine(rotate=(0, 0)), # per_channel=0.5)
def __init__(self, configuration):
"""
Initialized the configuration prameters
Arguments:
configuration: file pointer
The hitif configuration file
"""
import configparser
config = configparser.ConfigParser()
config.read(configuration)
#Parse the augmentation parameters
aug_prms = config['augmentation']
self.CLAHE = eval(aug_prms['AllChannelsCLAHE'])
self.Saturation = eval(aug_prms['Saturation'])
self.impulse_noise = eval(aug_prms['ImpulseNoise'])
self.gaussian_blur = eval(aug_prms['GaussianBlur'])
self.poisson = eval(aug_prms['AdditivePoissonNoise'])
self.median = eval(aug_prms['MedianBlur'])
self.flip = float(aug_prms["flip"])
self.rotate = eval(aug_prms["rotate"])
self.gamma = eval(aug_prms["GammaContrast"])
self.gaussian_noise = eval(aug_prms["AdditiveGaussianNoise"])
self.dropout = eval(aug_prms["Dropout"])
self.salt_peper = eval(aug_prms["SaltAndPepper"])
from imgaug import augmenters as iaa
import imgaug as ia
import numpy as np
seed = np.random.randint(0, 2**31 - 1)
ia.seed(seed)
self.augmenters = {}
augmenters = self.augmenters
#Affine augmentation
augmenters["fliplr"] = iaa.Fliplr(self.flip)
augmenters["flipud"] = iaa.Flipud(self.flip)
augmenters["rotate"] = iaa.Affine(rotate=[self.rotate[0],\
self.rotate[1],\
self.rotate[2]])
#Contrast augmentation
#augmenters["CLAHE"] = iaa.AllChannelsCLAHE(self.CLAHE)
augmenters["CLAHE"] = iaa.CLAHE(self.CLAHE)
#augmenters["CLAHE"] = iaa.AllChannelsCLAHE(self.CLAHE[0], self.CLAHE[1], self.CLAHE[2],self.CLAHE[3])
augmenters["gamma"] = iaa.GammaContrast(self.gamma, True)
#augmenters['saturation'] = iaa.Lambda(func_images=self.saturate_images, func_heatmaps=self.func_heatmaps, func_keypoints=self.func_keypoints)
augmenters['Saturation'] = iaa.Saturation(self.Saturation)
#Blur augmenters
augmenters["median_blur"] = iaa.MedianBlur(self.median)
augmenters["gaussian_blur"] = iaa.GaussianBlur(self.gaussian_blur)
#Noise augmenters
augmenters["impulse_noise"] = iaa.ImpulseNoise(self.impulse_noise)
augmenters["poisson_noise"] = iaa.AdditivePoissonNoise(self.poisson)
augmenters["gaussian_noise"] = iaa.AdditiveGaussianNoise(
scale=self.gaussian_noise)
augmenters["dropout"] = iaa.Dropout(self.dropout)
from xmlParser import Parser
import glob
import numpy as np
import tensorflow as tf
from matplotlib import pyplot as plt
path= 'Image A*/train/*.xml'
import cv2
seq = iaa.Sequential([
iaa.Fliplr(p=0),# basically this is original one
iaa.Sometimes(0.05,(iaa.Crop(px=(22, 45),keep_size=True))), # crop images from each side by 0 to 16px (randomly chosen)
iaa.Sometimes(0.5,(iaa.Fliplr(1))), # horizontally flip 50% of the images
iaa.Sometimes(0.02,iaa.GaussianBlur(sigma=(5, 7.0))), # blur images with a sigma of 0 to 3.0
iaa.Sometimes(0.02 ,iaa.ImpulseNoise(p=(0.6,1))),
iaa.Sometimes(0.02 ,iaa.EdgeDetect(alpha=(0.09,1))),
#iaa.AddToBrightness(add=(100,124)),
iaa.Sometimes(0.02 ,iaa.Canny(alpha=(0.8,0.9))),
iaa.Sometimes(0.5 ,iaa.Grayscale(alpha=1.00)),
iaa.Sometimes(0.5 ,iaa.ChannelShuffle(p=1)),
#iaa.Sometimes(0.02 ,(iaa.geometric.Affine( scale=2,rotate=22,order=1))),
iaa.Sometimes(0.5 ,iaa.Cartoon(blur_ksize=(11,13))),
iaa.Sometimes(0.02 ,iaa.CenterCropToAspectRatio(1)),
iaa.Sometimes(0.02 ,iaa.CenterCropToFixedSize(100,100)),
iaa.Sometimes(0.12 ,iaa.ChangeColorTemperature(kelvin=(2222,3333))),
#iaa.segmentation(),
iaa.Sometimes(0.12 ,iaa.CLAHE(clip_limit=(4,8))),
iaa.Sometimes(0.8 ,iaa.Rotate(rotate=(-90,90),order=1))
])
def __init__(self, image_root, data_list, is_train, transform=None):
super(CLDC_Dataset, self).__init__()
self.image_root = image_root
self.data_list = data_list
self.is_train = is_train
self.transform = transform
self.image_list = []
self.label_list = []
for data in self.data_list:
self.image_list.append(data[0])
self.label_list.append(data[1])
self.seq = iaa.SomeOf(
(3, 11),
{
# self.seq = iaa.SomeOf((0, 5), {
# iaa.Fliplr(0.5),
iaa.Flipud(0.5),
# iaa.Crop(percent=(0, 0.1)),
# Small gaussian blur with random sigma between 0 and 0.5.
# But we only blur about 50% of all images.
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0, 0.5))),
# Strengthen or weaken the contrast in each image.
iaa.ContrastNormalization((0.75, 1.5)),
# 先将图片从RGB变换到HSV,然后将H值增加10,然后再变换回RGB
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((10, 50)))),
iaa.AverageBlur(k=((2, 5), (1, 3))),
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect((0.0, 0.2)),
second=iaa.ContrastNormalization(
(0.5, 2.0)),
per_channel=True),
# Add gaussian noise.
# For 50% of all images, we sample the noise once per pixel.
# For the other 50% of all images, we sample the noise per pixel AND
# channel. This can change the color (not only brightness) of the
# pixels.
iaa.ImpulseNoise(p=0.02),
iaa.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.02 * 255), per_channel=0.5),
# Make some images brighter and some darker.
# In 20% of all cases, we sample the multiplier once per channel,
# which can end up changing the color of the images.
iaa.Multiply((0.8, 1.2), per_channel=0.2),
iaa.PerspectiveTransform(scale=0.06),
# # 图像扭曲
# iaa.PiecewiseAffine(scale=(0.01, 0.05)),
# Apply affine transformations to each image.
# Scale/zoom them, translate/move them, rotate them and shear them.
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=(-45, 45),
shear=(-8, 8))
},
random_order=True)
aug_dict = {
'AdditiveGaussianNoise':
iaa.AdditiveGaussianNoise(loc=0, scale=0.05 * 255, per_channel=False),
'AdditiveGaussianNoise_pc':
iaa.AdditiveGaussianNoise(loc=0, scale=0.05 * 255, per_channel=True),
'AdditiveLaplaceNoise':
iaa.AdditiveLaplaceNoise(loc=0, scale=0.05 * 255, per_channel=False),
'AdditiveLaplaceNoise_pc':
iaa.AdditiveLaplaceNoise(loc=0, scale=0.05 * 255, per_channel=True),
'AdditivePoissonNoise':
iaa.AdditivePoissonNoise(lam=16.00, per_channel=False),
'AdditivePoissonNoise_pc':
iaa.AdditivePoissonNoise(lam=16.00, per_channel=True),
'ImpulseNoise':
iaa.ImpulseNoise(p=0.05),
'SaltAndPepper':
iaa.SaltAndPepper(p=0.05),
'GaussianBlur':
iaa.GaussianBlur(sigma=0.50),
'AverageBlur':
iaa.AverageBlur(k=3),
'AddToHueAndSaturation_p':
iaa.AddToHueAndSaturation(value=25),
'AddToHueAndSaturation_n':
iaa.AddToHueAndSaturation(value=-25),
'Grayscale':
iaa.Grayscale(alpha=1.0),
'GammaContrast':
iaa.GammaContrast(gamma=0.5, per_channel=False),
'GammaContrast_pc':
def merge_bg(self, img, label, bg_dir):
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
# merge bg
random_bg = np.random.choice([0, 1, 2])
list_sample_bg = glob.glob(bg_dir+'/*.jpg') + glob.glob(bg_dir+'/*/*.jpg') + glob.glob(bg_dir+'/*/*/*.jpg') + glob.glob(bg_dir+'/*/*/*/*.jpg')
# 0: original
# 1: list_sample_bg
# 2: pure bg
if random_bg == 1:
bg_path = np.random.choice(list_sample_bg)
bg = cv2.imread(bg_path, cv2.IMREAD_COLOR)
bg = cv2.resize(bg, (self.input_size, self.input_size), interpolation=cv2.INTER_LINEAR)
# bg = bg.astype(np.float32) # [:, :, ::-1] # RGB to BGR!!!
elif random_bg == 2:
# Generate Bg
bg = np.random.randint(255, size=3)
bg = bg.reshape(1,1,3)
bg = np.repeat(bg, self.input_size, axis=0)
bg = np.repeat(bg, self.input_size, axis=1)
bg = bg.astype(np.uint8)
# Augmentation
bg_seq = iaa.Sequential(
[
# execute 0 to 5 of the following (less important) augmenters per image
# don't execute all of them, as that would often be way too strong
iaa.SomeOf((1, 6),
[
sometimes(iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200))), # convert images into their superpixel representation
iaa.OneOf([
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
]),
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.SimplexNoiseAlpha(iaa.OneOf([
iaa.EdgeDetect(alpha=(0.5, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.5, 1.0), direction=(0.0, 1.0)),
])),
iaa.OneOf([
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5), # add gaussian noise to images
iaa.AdditiveLaplaceNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),
iaa.AdditivePoissonNoise(lam=(0.0, 4.0), per_channel=0.5)
]),
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.2), size_percent=(0.02, 0.05), per_channel=0.2),
]),
iaa.Invert(0.1, per_channel=True), # invert color channels
iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation
# 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.FrequencyNoiseAlpha(
exponent=(-4, 0),
first=iaa.Multiply((0.5, 1.5), per_channel=True),
second=iaa.ContrastNormalization((0.5, 2.0))
)
]),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5), # improve or worsen the contrast
sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)), # move pixels locally around (with random strengths)
iaa.Add((-25, 25), per_channel=0.5), # change brightness of images (by -10 to 10 of original value)
iaa.OneOf([
iaa.ImpulseNoise((0.01, 0.1)),
iaa.SaltAndPepper((0.01, 0.1), per_channel=0.2),
]),
iaa.JpegCompression(),
],
random_order=True
),
iaa.OneOf([
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
iaa.JpegCompression(),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),
]),
],
random_order=False
)
bg = bg_seq.augment_image(bg)
if random_bg >= 1:
bg = torch.as_tensor(bg.astype(np.float32))
bg = torch.transpose(torch.transpose(bg, 1, 2), 0, 1)
img = img * label + bg * (1 - label)
return img
# Bacon
from imgaug import augmenters as iaa
from matplotlib import pyplot as plt
import numpy as np
from PIL import Image
img=plt.imread('bird.jpg')
seq = iaa.Sequential([
iaa.Fliplr(p=0),# basically this is original one
iaa.Crop(px=(22, 45),keep_size=False), # crop images from each side by 0 to 16px (randomly chosen)
iaa.Fliplr(1), # horizontally flip 50% of the images
iaa.GaussianBlur(sigma=(5, 7.0)), # blur images with a sigma of 0 to 3.0
iaa.ImpulseNoise(p=(0.6,1)),
iaa.EdgeDetect(alpha=(0.9,1)),
#iaa.AddToBrightness(add=(100,124)),
iaa.Canny(alpha=(0.8,0.9)),
iaa.Grayscale(alpha=1.00),
iaa.ChannelShuffle(p=1),
iaa.geometric.Affine( scale=2,rotate=22, backend='cv2'),
iaa.Cartoon(blur_ksize=(11,13)),
iaa.CenterCropToAspectRatio(1),
iaa.CenterCropToFixedSize(100,100),
iaa.ChangeColorTemperature(kelvin=(2222,3333)),
#iaa.segmentation(),
iaa.CLAHE(clip_limit=(4,8)),
iaa.Rotate(rotate=(-30,90))
])
transformed_image = transform(image=image)
elif augmentation == 'coarse_pepper':
transform = iaa.CoarsePepper(0.05, size_percent=(0.01, 0.1))
transformed_image = transform(image=image)
elif augmentation == 'salt_and_papper':
transform = iaa.SaltAndPepper(0.1)
transformed_image = transform(image=image)
elif augmentation == 'coarse_salt_and_papper':
transform = iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1))
transformed_image = transform(image=image)
elif augmentation == 'impulse_noise':
transform = iaa.ImpulseNoise(0.1)
transformed_image = transform(image=image)
elif augmentation == 'replace_elementwise':
transform = iaa.ReplaceElementwise(0.1, [0, 255])
transformed_image = transform(image=image)
elif augmentation == 'cutout':
transform = iaa.Cutout(nb_iterations=5)
transformed_image = transform(image=image)
elif augmentation == 'solarize':
transform = Solarize(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'invert_img':
