def preprocess(image, mode='plain', d_theta=0):
"""
Combine all preprocess functions into one
"""
if mode == 'random_rotate_and_shift':
angle = 30
dx = 32
dy = 16
d_theta = round(np.random.random() * angle * 2 - angle)
d_x = np.random.random() * dx * 2 - dx
d_y = np.random.random() * dy * 2 - dy
y, x = image.shape[:2]
translation_matrix = np.float32([[1, 0, d_x], [0, 1, d_y]])
from PIL import Image
image = Image.fromarray(image)
image = image.rotate(d_theta)
image = np.array(image)
image = cv2.warpAffine(image, translation_matrix, (x, y))
elif mode == 'exact_rotate':
from PIL import Image
image = Image.fromarray(image)
image = image.rotate(d_theta)
image = np.array(image)
elif mode == 'rainy_foggy_automold':
import Automold as am
import Helpers as hp
if np.random.random() > 0.5:
image = am.add_rain(image, rain_type='heavy')
else:
image = am.add_fog(image)
elif mode == 'rainy_foggy_iaa':
from imgaug import augmenters as iaa
seq = iaa.Rain()
if np.random.random() > 0.5:
seq = iaa.Rain()
else:
seq = iaa.Fog()
image = seq(images=image)
# for i in range(len(image)):
# image[i] = crop(image[i])
# image[i] = resize(image[i])
# image[i] = rgb2yuv(image[i])
# image[i] = image[i][np.newaxis, :, :, :]
# image = np.concatenate(image, axis=0)
image = crop(image)
image = resize(image)
image = rgb2yuv(image)
return image
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 chapter_augmenters_rain():
fn_start = "weather/rain"
image = LANDSCAPE_IMAGE
aug = iaa.Rain(speed=(0.1, 0.3))
run_and_save_augseq(
fn_start + ".jpg", aug,
[image for _ in range(4*2)], cols=4, rows=2)
def main():
augs = [
iaa.Rain(speed=(0.1, 0.3)),
iaa.Rain(),
iaa.Rain(drop_size=(0.1, 0.2))
]
image = imageio.imread(
("https://upload.wikimedia.org/wikipedia/commons/8/89/"
"Kukle%2CCzech_Republic..jpg"),
format="jpg")
for aug, size in zip(augs, [0.1, 0.2, 1.0]):
image_rs = ia.imresize_single_image(image, size, "cubic")
print(image_rs.shape)
images_aug = aug.augment_images([image_rs] * 64)
ia.imshow(ia.draw_grid(images_aug))
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 test_zero_sized_axes(self):
shapes = [(0, 0, 3), (0, 1, 3), (1, 0, 3)]
for shape in shapes:
with self.subTest(shape=shape):
image = np.zeros(shape, dtype=np.uint8)
aug = iaa.Rain()
image_aug = aug(image=image)
assert image_aug.dtype.name == "uint8"
assert image_aug.shape == shape
def generate_rain():
ia.seed(2)
image = imageio.imread(
os.path.join(INPUT_IMAGES_DIR, "Pahalgam_Valley.jpg"))
image = iaa.Resize({
"width": 256,
"height": "keep-aspect-ratio"
})(image=image)
images_aug = [image]
images_aug.extend(iaa.Rain()(images=[image] * (2 * 8 - 1)))
_save("rain.jpg", ia.draw_grid(images_aug, cols=4, rows=4))
def train(model):
"""Train the model."""
# Training dataset.
dataset_train = CharacterDataset()
dataset_train.load_characters("train")
dataset_train.prepare()
# Validation dataset
dataset_val = CharacterDataset()
dataset_val.load_characters("val")
dataset_val.prepare()
#Augmentation
aug = iaa.SomeOf(2, [
iaa.AdditiveGaussianNoise(scale=(0, 0.10 * 255)),
iaa.MotionBlur(),
iaa.GaussianBlur(sigma=(0.0, 2.0)),
iaa.RemoveSaturation(mul=(0, 0.5)),
iaa.GammaContrast(),
iaa.Rotate(rotate=(-45, 45)),
iaa.PerspectiveTransform(scale=(0.01, 0.15)),
iaa.JpegCompression(compression=(0, 75)),
iaa.imgcorruptlike.Spatter(severity=(1, 4)),
iaa.Rain(speed=(0.1, 0.3)),
iaa.Fog()
])
custom_callbacks = [
ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=5,
verbose=1),
EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1)
]
# *** This training schedule is an example. Update to your needs ***
# Since we're using a very small dataset, and starting from
# COCO trained weights, we don't need to train too long. Also,
# no need to train all layers, just the heads should do it.
print("Training network heads")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=100,
layers='heads',
augmentation=aug,
custom_callbacks=custom_callbacks)
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)
imgs_aug = iaa.Rain()(images=[img] * 5)
assert 5 < np.average(imgs_aug) < 200
assert np.max(imgs_aug) > 70
for img_aug in imgs_aug:
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)) > 10 * img.shape[1]
assert np.sum(np.abs(grad_y)) > 10 * 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)))
elif augmentation == 'relative_regular_grid_voronoi':
transform = iaa.RelativeRegularGridVoronoi(0.1, 0.25)
transformed_image = transform(image=image)
## Weather
elif augmentation == 'fog':
transform = iaa.imgcorruptlike.Fog(severity=2)
transformed_image = transform(image=image)
elif augmentation == 'random_rain':
transform = RandomRain(always_apply=True)
transformed_image = transform(image=image)['image']
elif augmentation == 'rain':
transform = iaa.Rain(speed=(0.1, 0.3))
transformed_image = transform(image=image)
elif augmentation == 'snow':
transform = iaa.imgcorruptlike.Snow(severity=2)
transformed_image = transform(image=image)
elif augmentation == 'snow_flakes':
transform = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05))
transformed_image = transform(image=image)
elif augmentation == 'frost':
transform = iaa.imgcorruptlike.Frost(severity=1)
transformed_image = transform(image=image)
elif augmentation == 'clouds':
def test_pickleable(self):
aug = iaa.Rain(random_state=1)
runtest_pickleable_uint8_img(aug, iterations=3, shape=(20, 20, 3))
iaa.AllChannelsHistogramEqualization(),
iaa.GammaContrast((0.5, 1.5), per_channel=True),
iaa.GammaContrast((0.5, 1.5)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
iaa.HistogramEqualization(),
iaa.Sharpen(alpha=0.5)
]),
iaa.OneOf([
iaa.AveragePooling([2, 3]),
iaa.MaxPooling(([2, 3], [2, 3])),
]),
iaa.OneOf([
iaa.Clouds(),
iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)),
iaa.Rain(speed=(0.1, 0.3))
])
],
random_order=True)
def get_color_augmentation(augment_prob):
return iaa.Sometimes(augment_prob, aug_transform).augment_image
class SegCompose(object):
def __init__(self, augmenters):
super().__init__()
self.augmenters = augmenters
def __call__(self, image, label):
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
def augument(self, image, bbox_list):
seq = iaa.Sequential([
# 变形
iaa.Sometimes(
0.6,
[
iaa.OneOf([
iaa.Affine(shear={
'x': (-1.5, 1.5),
'y': (-1.5, 1.5)
},
mode="edge"), # 仿射变化程度，单位像素
iaa.Rotate(rotate=(-1, 1), mode="edge"), # 旋转,单位度
])
]),
# 扭曲
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.PiecewiseAffine(
scale=(0, 0.02), nb_rows=2, nb_cols=2), # 局部仿射
iaa.ElasticTransformation( # distort扭曲变形
alpha=(0, 3), # 扭曲程度
sigma=(0.8, 1), # 扭曲后的平滑程度
mode="nearest"),
]),
]),
# 模糊
iaa.Sometimes(
0.5,
[
iaa.OneOf([
iaa.GaussianBlur(sigma=(0, 0.7)),
iaa.AverageBlur(k=(1, 3)),
iaa.MedianBlur(k=(1, 3)),
iaa.BilateralBlur(
d=(1, 5),
sigma_color=(10, 200),
sigma_space=(10, 200)), # 既噪音又模糊，叫双边,
iaa.MotionBlur(k=(3, 5)),
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.Sometimes(0.3, [
iaa.OneOf([
iaa.Sharpen(),
iaa.GammaContrast(),
iaa.SigmoidContrast()
])
]),
# 噪音
iaa.Sometimes(0.3, [
iaa.OneOf([
iaa.AdditiveGaussianNoise(scale=(1, 5)),
iaa.AdditiveLaplaceNoise(scale=(1, 5)),
iaa.AdditivePoissonNoise(lam=(1, 5)),
iaa.Salt((0, 0.02)),
iaa.Pepper((0, 0.02))
])
]),
# 剪切
iaa.Sometimes(
0.8,
[
iaa.OneOf([
iaa.Crop((0, 2)), # 切边, (0到10个像素采样)
])
]),
])
assert bbox_list is None or type(bbox_list) == list
if bbox_list is None or len(bbox_list) == 0:
polys = None
else:
polys = [ia.Polygon(pos) for pos in bbox_list]
polys = ia.PolygonsOnImage(polys, shape=image.shape)
# 处理部分或者整体出了图像的范围的多边形，参考：https://imgaug.readthedocs.io/en/latest/source/examples_bounding_boxes.html
polys = polys.remove_out_of_image().clip_out_of_image()
images_aug, polygons_aug = seq(images=[image], polygons=polys)
image = images_aug[0]
if polygons_aug is None:
polys = None
else:
polys = []
for p in polygons_aug.polygons:
polys.append(p.coords)
polys = np.array(polys, np.int32).tolist() # (N,2)
return image, polys
def aug4(self, img):
seq = iaa.Sequential([iaa.Rain(speed=(0))])
img_au = seq(image=img)
return img_au
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
