def chapter_augmenters_blendalphasomecolors():
fn_start = "blend/blendalphasomecolors"
image = imageio.imread(
os.path.join(DOCS_IMAGES_BASE_PATH, "input_images",
"1280px-Vincent_Van_Gogh_-_Wheatfield_with_Crows.jpg"))
# ca. 15% of original size
image = ia.imresize_single_image(image, (92, 192))
aug = iaa.BlendAlphaSomeColors(iaa.Grayscale(1.0))
run_and_save_augseq(fn_start + "_grayscale.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.TotalDropout(1.0))
run_and_save_augseq(fn_start + "_total_dropout.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.MultiplySaturation(0.5),
iaa.MultiplySaturation(1.5))
run_and_save_augseq(fn_start + "_saturation.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
alpha=[0.0, 1.0],
smoothness=0.0)
run_and_save_augseq(fn_start + "_pooling.jpg",
aug, [image for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
nb_bins=2,
smoothness=0.0)
run_and_save_augseq(fn_start + "_pooling_2_bins.jpg",
aug, [image for _ in range(4 * 4)],
cols=4,
rows=4)
aug = iaa.BlendAlphaSomeColors(iaa.AveragePooling(7),
from_colorspace="BGR")
run_and_save_augseq(fn_start + "_pooling_bgr.jpg",
aug, [image[:, :, ::-1] for _ in range(4 * 2)],
cols=4,
rows=2,
image_colorspace=iaa.CSPACE_BGR)
def main():
image = ia.quokka_square((128, 128))
images_aug = []
for mul in np.linspace(0.0, 2.0, 10):
aug = iaa.MultiplyHueAndSaturation(mul)
image_aug = aug.augment_image(image)
images_aug.append(image_aug)
for mul_hue in np.linspace(0.0, 5.0, 10):
aug = iaa.MultiplyHueAndSaturation(mul_hue=mul_hue)
image_aug = aug.augment_image(image)
images_aug.append(image_aug)
for mul_saturation in np.linspace(0.0, 5.0, 10):
aug = iaa.MultiplyHueAndSaturation(mul_saturation=mul_saturation)
image_aug = aug.augment_image(image)
images_aug.append(image_aug)
ia.imshow(ia.draw_grid(images_aug, rows=3))
images_aug = []
images_aug.extend(iaa.MultiplyHue().augment_images([image] * 10))
images_aug.extend(iaa.MultiplySaturation().augment_images([image] * 10))
ia.imshow(ia.draw_grid(images_aug, rows=2))
def chapter_augmenters_multiplysaturation():
fn_start = "color/multiplysaturation"
aug = iaa.MultiplySaturation((0.5, 1.5))
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def __call__(self, *args, **kwargs) -> typing.Tuple[np.ndarray, typing.List[Polygon]]:
if self.is_training:
resize = iaa.Resize(size=dict(longer_side=self.long_sizes,
width='keep-aspect-ratio'))
rotate = iaa.Rotate(rotate=self.angles, fit_output=True)
resize_height = iaa.Resize(size=dict(height=self.height_ratios,
width='keep'))
crop = iaa.CropToFixedSize(width=self.cropped_size[0], height=self.cropped_size[1])
fix_resize = iaa.Resize(size=self.output_size)
# blur = iaa.GaussianBlur()
# blur = iaa.Sometimes(p=self.blur_prob,
# then_list=blur)
brightness = iaa.MultiplyBrightness((0.5, 1.5))
brightness = iaa.Sometimes(self.color_jitter_prob, then_list=brightness)
saturation = iaa.MultiplySaturation((0.5, 1.5))
saturation = iaa.Sometimes(self.color_jitter_prob, then_list=saturation)
contrast = iaa.LinearContrast(0.5)
contrast = iaa.Sometimes(self.color_jitter_prob, then_list=contrast)
hue = iaa.MultiplyHue()
hue = iaa.Sometimes(self.color_jitter_prob, then_list=hue)
augs = [resize,
rotate,
resize_height,
crop,
fix_resize,
brightness,
saturation,
contrast,
hue]
ia = iaa.Sequential(augs)
else:
fix_resize = iaa.Resize(size=self.output_size)
ia = iaa.Sequential([fix_resize])
image = args[0]
polygons = args[1]
polygon_list = []
for i in range(polygons.shape[0]):
polygon_list.append(Polygon(polygons[i].tolist()))
polygons_on_image = PolygonsOnImage(polygon_list, shape=image.shape)
image_aug, polygons_aug = ia(image=image, polygons=polygons_on_image)
return image_aug, polygons_aug.polygons
def get_augmenter():
seq = iaa.Sequential([
iaa.Sometimes(0.05, iaa.GaussianBlur((0.0, 1.3))),
iaa.Sometimes(0.05, iaa.AdditiveGaussianNoise(scale=(0.0, 0.05 * 255))),
iaa.Sometimes(0.05, iaa.Dropout((0.0, 0.1))),
iaa.Sometimes(0.10, iaa.Add((-0.05 * 255, 0.05 * 255), True)),
iaa.Sometimes(0.20, iaa.Add((0.25, 2.5), True)),
iaa.Sometimes(0.05, iaa.contrast.LinearContrast((0.5, 1.5))),
iaa.Sometimes(0.05, iaa.MultiplySaturation((0.0, 1.0))),
])
return seq.augment_image
def __init__(self):
self.transform = iaa.Sequential(
[
iaa.Sometimes(
0.5,
iaa.SomeOf((1, 2), [
iaa.Fliplr(1.0),
iaa.Flipud(1.0),
])),
iaa.OneOf([
iaa.Sometimes(
0.3,
[
iaa.OneOf([
iaa.Multiply((0.7, 1.2)),
iaa.MultiplyElementwise((0.7, 1.2)),
]),
iaa.OneOf([
iaa.MultiplySaturation((5.0, 10.0)), # good
iaa.MultiplyHue((1.5, 3.0)),
iaa.LinearContrast((0.8, 2.0)),
iaa.AllChannelsHistogramEqualization(),
]),
]),
iaa.Sometimes(0.3, [
iaa.SomeOf((1, 2), [
iaa.pillike.EnhanceColor((1.1, 1.6)),
iaa.pillike.EnhanceSharpness((0.7, 1.6)),
iaa.pillike.Autocontrast(cutoff=(4, 8)),
iaa.MultiplySaturation((1.2, 5.1)),
])
])
]),
iaa.Sometimes(0.3, [
iaa.Dropout(p=(0.01, 0.09)),
iaa.GaussianBlur((0.4, 1.5)),
]),
],
random_order=True # apply the augmentations in random order
)
def test_returns_correct_class(self):
# this test is practically identical to
# TestMultiplyToHueAndSaturation
# .test_returns_correct_objects__mul_saturation
aug = iaa.MultiplySaturation((0.9, 1.1))
assert isinstance(aug, iaa.WithHueAndSaturation)
assert isinstance(aug.children, iaa.Sequential)
assert len(aug.children) == 1
assert isinstance(aug.children[0], iaa.WithChannels)
assert aug.children[0].channels == [1]
assert len(aug.children[0].children) == 1
assert isinstance(aug.children[0].children[0], iaa.Multiply)
assert isinstance(aug.children[0].children[0].mul, iap.Uniform)
assert np.isclose(aug.children[0].children[0].mul.a.value, 0.9)
assert np.isclose(aug.children[0].children[0].mul.b.value, 1.1)
def __init__(self, dataset: Dataset, cfg):
self._dataset = dataset
self.input_shape = cfg.AUGMENT.INPUT_SHAPE
self.zoom_in = cfg.AUGMENT.ZOOM_IN
self.min_scale = cfg.AUGMENT.MIN_SCALE
self.max_scale = cfg.AUGMENT.MAX_SCALE
self.max_try_times = cfg.AUGMENT.MAX_TRY_TIMES
self.flip = cfg.AUGMENT.FLIP
self.aspect_ratio = cfg.AUGMENT.ASPECT_RATIO
self.translate_percent = cfg.AUGMENT.TRANSLATE_PRESENT
self.rotate = cfg.AUGMENT.ROTATE
self.shear = cfg.AUGMENT.SHEAR
self.perspective_transform = cfg.AUGMENT.PERSPECTIVE_TRANSFORM
self.brightness = cfg.AUGMENT.BRIGHTNESS
self.hue = cfg.AUGMENT.HUE
self.saturation = cfg.AUGMENT.SATURATION
self.augment_background = cfg.AUGMENT.BACKGROUND
if self.augment_background:
self.backgrounds = [
os.path.join('../../data/background', item)
for item in os.listdir('../../data/background')
]
self.seq = iaa.Sequential([
iaa.Fliplr(self.flip),
iaa.Affine(scale={
"x": self.aspect_ratio,
"y": self.aspect_ratio
},
translate_percent={
"x": self.translate_percent,
"y": self.translate_percent
},
rotate=self.rotate,
shear=self.shear,
order=[0, 1],
cval=(0, 255)),
iaa.PerspectiveTransform(scale=self.perspective_transform),
iaa.MultiplyBrightness(self.brightness),
iaa.MultiplySaturation(self.saturation),
iaa.MultiplyHue(self.hue)
])
def _load_augmentation_aug_non_geometric():
return iaa.Sequential([
iaa.Sometimes(0.3, iaa.Multiply((0.5, 1.5), per_channel=0.5)),
iaa.Sometimes(0.2, iaa.JpegCompression(compression=(70, 99))),
iaa.Sometimes(0.2, iaa.GaussianBlur(sigma=(0, 3.0))),
iaa.Sometimes(0.2, iaa.MotionBlur(k=15, angle=[-45, 45])),
iaa.Sometimes(0.2, iaa.MultiplyHue((0.5, 1.5))),
iaa.Sometimes(0.2, iaa.MultiplySaturation((0.5, 1.5))),
iaa.Sometimes(
0.34, iaa.MultiplyHueAndSaturation((0.5, 1.5), per_channel=True)),
iaa.Sometimes(0.34, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(0.2, iaa.ChangeColorTemperature((1100, 10000))),
iaa.Sometimes(0.1, iaa.GammaContrast((0.5, 2.0))),
iaa.Sometimes(0.2, iaa.SigmoidContrast(gain=(3, 10),
cutoff=(0.4, 0.6))),
iaa.Sometimes(0.1, iaa.CLAHE()),
iaa.Sometimes(0.1, iaa.HistogramEqualization()),
iaa.Sometimes(0.2, iaa.LinearContrast((0.5, 2.0), per_channel=0.5)),
iaa.Sometimes(0.1, iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)))
])
desiredMultiple = 1
#PREVIEW N AMOUNT OF BOUNDING BOXES ON AUGMENTED IMAGES#
viewNBoundingBoxes = 0
#SAVE AUGMENTED IMAGES WITH BOUNDING BOX TO FILEPATH#
filepathSaveFolder = script_dir + "/augmented/"
filepath_img = filepathSaveFolder + batchName + "%d.jpg"
filepath_txt = filepathSaveFolder + batchName + "%d.txt"
#DESIRED AUGMENTATION#
seq = iaa.Sequential(
[
#iaa.AddToHue((-255,255)), # change their color
iaa.MultiplySaturation((0.1, 0.7)), #calm down color
#iaa.ElasticTransformation(alpha=20, sigma=4), # water-like effect (smaller sigma = smaller "waves")
#iaa.PiecewiseAffine(scale=(0.01,0.05)), #sometimes moves pieces of image around (RAM-heavy)
#iaa.LogContrast((0.5,1.0),True), #overlay color
#iaa.MotionBlur(20,(0,288),1,0), #motion blur for realism
#iaa.BlendAlpha((0.0, 1.0),
#iaa.MedianBlur(11), per_channel=True), #alpha-blending with median blur
iaa.PerspectiveTransform(scale=(0.1, 0.1)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=True), #noise
#iaa.CoarseDropout(p=0.1, size_percent=0.005), #blocks removed from image
iaa.Affine(
rotate=(-5, 5)
) #rotate #PROBLEM WITH BOUNDING BOXES MOSTLY CAUSED BY THIS
],
random_order=True)
import random
import colorsys
import numpy as np
import cv2
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug.augmentables import Keypoint, KeypointsOnImage
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
KPT_AUGS = [
iaa.LinearContrast((0.95, 1.05), per_channel=0.25),
iaa.Add((-10, 10), per_channel=False),
iaa.GammaContrast((0.95, 1.05)),
iaa.GaussianBlur(sigma=(0.0, 0.6)),
iaa.MultiplySaturation((0.95, 1.05)),
iaa.AddToHueAndSaturation((-255, 255)),
iaa.ChangeColorTemperature((1000, 20000)),
iaa.AdditiveGaussianNoise(scale=(0, 0.0125 * 255)),
iaa.flip.Flipud(0.5),
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.25, 0.25),
"y": (-0.2, 0.2)
}, # translate by -20 to +20 percent (per axis)
rotate=(-30, 30), # rotate by -45 to +45 degrees
def da_policy(image, label):
img_size = 224
#image = sample[0]
policy = np.random.randint(4)
#policy = 2
if policy == 0:
p = np.random.random()
if p <= 0.6:
aug = iaa.TranslateX(px=(-60, 60), cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.8:
aug = iaa.HistogramEqualization()
image = aug(image=image)
elif policy == 1:
p = np.random.random()
if p <= 0.2:
aug = iaa.TranslateY(px=(int(-0.18 * img_size),
int(0.18 * img_size)),
cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.8:
square_size = np.random.randint(48)
aug = iaa.Cutout(nb_iterations=1,
size=square_size / img_size,
squared=True)
image = aug(image=image)
elif policy == 2:
p = np.random.random()
if p <= 1:
aug = iaa.ShearY(shear=(int(-0.06 * img_size),
int(0.06 * img_size)),
order=1,
cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 0.6:
aug = iaa.TranslateX(px=(-60, 60), cval=128)
image = aug(image=image)
elif policy == 3:
p = np.random.random()
if p <= 0.6:
aug = iaa.Rotate(rotate=(-30, 30), order=1, cval=128)
image = aug(image=image)
p = np.random.random()
if p <= 1:
aug = iaa.MultiplySaturation((0.54, 1.54))
image = aug(image=image)
#Para EFFICIENTNET NO es necesario NORMALIZAR
return (tf.cast(image, tf.float32), tf.cast(label, tf.int64))
gaussian_noise = iaa.AdditiveGaussianNoise(10, 20)
noise_image = gaussian_noise.augment_image(img)
flip_hr = iaa.Fliplr(p=1.0)
flip_hr_image = flip_hr.augment_image(img)
contrast = iaa.GammaContrast(gamma=2.0)
contrast_image = contrast.augment_image(img)
aug = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6))
sigmoid_image = aug.augment_image(img)
aug = iaa.LogContrast(gain=(0.6, 1.4))
log_image = aug.augment_image(img)
aug = iaa.MultiplySaturation((0.5, 1.5))
channel = aug.augment_image(img)
aug = iaa.Rotate((-5, 5))
rotate1 = aug.augment_image(img)
aug = iaa.ShearX((-20, 20))
shear = aug.augment_image(img)
aug = iaa.PerspectiveTransform(scale=(0.01, 0.15))
perspec = aug.augment_image(img)
cv2.imshow("3", perspec)
cv2.waitKey(0)
aaa
rotate = iaa.Affine(rotate=(-50, 30))
elif augmentation == 'zoom_blur':
transform = iaa.imgcorruptlike.ZoomBlur(severity=2)
transformed_image = transform(image=image)
## Color
elif augmentation == 'multiply_hue':
transform = iaa.MultiplyHue((0.5, 1.5))
transformed_image = transform(image=image)
elif augmentation == 'addto_hue':
transform = iaa.AddToHue((-100, 100))
transformed_image = transform(image=image)
elif augmentation == 'multiply_saturation':
transform = iaa.MultiplySaturation((0.5, 1.5))
transformed_image = transform(image=image)
elif augmentation == 'addto_saturation':
transform = iaa.AddToSaturation((-100, 100))
transformed_image = transform(image=image)
elif augmentation == 'saturate':
transform = iaa.imgcorruptlike.Saturate(severity=5)
transformed_image = transform(image=image)
elif augmentation == 'remove_saturation':
transform = iaa.RemoveSaturation()
transformed_image = transform(image=image)
elif augmentation == 'multiply_hue_and_saturation':
def __init__(self,
data_root,
image_shape=(256, 256),
isTrain=True,
silence=False):
self.silence = silence
self.data_root = data_root
self.is_train = isTrain
self.image_shape = (image_shape[0], image_shape[1])
if isTrain:
fg_set_file_path = os.path.join(data_root, 'fg_train_set.txt')
bg_set_file_path = os.path.join(data_root, 'bg_train_set.txt')
else:
fg_set_file_path = os.path.join(data_root, 'fg_val_set.txt')
bg_set_file_path = os.path.join(data_root, 'bg_val_set.txt')
fg_file = open(fg_set_file_path, 'r')
bg_file = open(bg_set_file_path, 'r')
self.fg_list = []
self.bg_list = []
self.alpha_list = []
for line in fg_file:
line = line.strip()
fg_path, alpha_path = line.split(' ')
self.fg_list.append(fg_path)
self.alpha_list.append(alpha_path)
for line in bg_file:
bg_path = line.strip()
self.bg_list.append(bg_path)
self.num_fg = len(self.fg_list)
self.num_bg = len(self.bg_list)
if not isTrain:
assert self.num_fg == self.num_bg, "len(fg_list) must equal to len(bg_list) in eval mode. {}!={}".format(
len(self.fg_list), len(self.bg_list))
sometimes = lambda aug: iaa.Sometimes(0.3, aug)
# apply to fg, bg
self.color_aug = iaa.Sequential([
iaa.MultiplyHueAndSaturation(mul=iap.TruncatedNormal(
1.0, 0.2, 0.5, 1.5)), # mean, std, low, high
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.2, 0.5, 1.5)),
iaa.AddToHue(value=iap.TruncatedNormal(0.0, 0.1 * 100, -0.2 *
255, 0.2 * 255))
])
# apply to compose
self.compose_shape_aug = iaa.Sequential([
iaa.Fliplr(0.5),
# iaa.OneOf([
# iaa.Resize({"height":480, "width": "keep-aspect-ratio"}),
# iaa.Resize({"height":640, "width": "keep-aspect-ratio"}),
# # iaa.Resize({"height": 800, "width": "keep-aspect-ratio"})
# ]),
# iaa.Resize(size=(512, 512)),
iaa.OneOf([
# iaa.CropToFixedSize(width=256, height=256),
iaa.CropToFixedSize(width=384, height=384),
iaa.CropToFixedSize(width=480, height=480),
iaa.CropToFixedSize(width=512, height=512),
iaa.CropToFixedSize(width=640, height=640),
iaa.CropToFixedSize(width=800, height=800)
]),
sometimes(
iaa.PadToFixedSize(width=512,
height=512,
pad_mode="constant",
pad_cval=0)), # TODO:
iaa.Resize({
"height": self.image_shape[0],
"width": self.image_shape[1]
})
])
self.fg_simple_aug = iaa.Sequential([iaa.Fliplr(0.5)])
self.bg_aug = iaa.Sequential([
iaa.CropToFixedSize(width=self.image_shape[1],
height=self.image_shape[0]),
# iaa.OneOf([
# # iaa.CropToFixedSize(width=256, height=256),
# iaa.CropToFixedSize(width=384, height=384),
# iaa.CropToFixedSize(width=self.image_shape[1], height=self.image_shape[0]),
# iaa.CropToFixedSize(width=480, height=480),
# iaa.CropToFixedSize(width=512, height=512),
# # iaa.CropToFixedSize(width=640, height=640),
# ]),
iaa.Resize({
"height": self.image_shape[0],
"width": self.image_shape[1]
}),
iaa.GammaContrast(gamma=iap.TruncatedNormal(1.0, 0.3, 0.5, 1.5)),
iaa.MultiplySaturation(
mul=iap.TruncatedNormal(1.0, 0.3, 0.5, 1.5)),
# iaa.GaussianBlur(sigma=(0.0, 1.5)),
iaa.Fliplr(0.5),
])
self.scale_down = iaa.Sequential([
iaa.Resize(0.8),
iaa.PadToFixedSize(width=self.image_shape[1],
height=self.image_shape[0],
pad_mode='constant',
pad_cval=0)
])
transforms = iaa.Sequential(
[
iaa.Sometimes(0.5,
iaa.SomeOf((1, 2), [
iaa.Fliplr(1.0),
iaa.Flipud(1.0),
])),
iaa.OneOf([
iaa.Sometimes(0.4, [
iaa.OneOf([
iaa.Multiply((0.7, 1.1)),
iaa.MultiplyElementwise((0.7, 1.1)),
]),
iaa.OneOf([
iaa.MultiplySaturation((0.6, 1.5)),
iaa.MultiplyHue((0.6, 1.1)),
iaa.LinearContrast((0.8, 1.6)),
iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6)),
]),
]),
iaa.Sometimes(0.5, [
iaa.SomeOf((1, 2), [
iaa.pillike.EnhanceColor((0.8, 1.2)),
iaa.pillike.EnhanceSharpness((0.7, 1.6)),
iaa.pillike.Autocontrast(cutoff=(2, 5)),
])
])
]),
iaa.Sometimes(0.5, [
iaa.Dropout(p=(0.01, 0.05)),
def __init__(self):
self.seq = iaa.Sequential(
[
iaa.Fliplr(0.5),
iaa.Sometimes(0.5, iaa.Crop(percent=(0, 0.1))),
iaa.Sometimes(0.5, iaa.Affine(
rotate=(-20, 20), # 旋转±20度
# shear=(-16, 16), # 剪切变换±16度，矩形变平行四边形
# order=[0, 1], # 使用最近邻插值 或 双线性插值
cval=0, # 填充值
mode=ia.ALL # 定义填充图像外区域的方法
)),
# 使用0~3个方法进行图像增强
iaa.SomeOf((0, 3),
[
iaa.Sometimes(0.8, iaa.OneOf([
iaa.GaussianBlur((0, 2.0)), # 高斯模糊
iaa.AverageBlur(k=(1, 5)), # 平均模糊，磨砂
])),
# 要么运动，要么美颜
iaa.Sometimes(0.8, iaa.OneOf([
iaa.MotionBlur(k=(3, 11)), # 运动模糊
iaa.BilateralBlur(d=(1, 5),
sigma_color=(10, 250),
sigma_space=(10, 250)), # 双边滤波，美颜
])),
# 模仿雪花
iaa.Sometimes(0.8, iaa.OneOf([
iaa.SaltAndPepper(p=(0., 0.03)),
iaa.AdditiveGaussianNoise(loc=0, scale=(0., 0.05 * 255), per_channel=False)
])),
# 对比度
iaa.Sometimes(0.8, iaa.LinearContrast((0.6, 1.4), per_channel=0.5)),
# 锐化
iaa.Sometimes(0.8, iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5))),
# 整体亮度
iaa.Sometimes(0.8, iaa.OneOf([
# 加性调整
iaa.AddToBrightness((-30, 30)),
# 线性调整
iaa.MultiplyBrightness((0.5, 1.5)),
# 加性 & 线性
iaa.MultiplyAndAddToBrightness(mul=(0.5, 1.5), add=(-30, 30)),
])),
# 饱和度
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToSaturation((-75, 75)),
iaa.MultiplySaturation((0., 3.)),
])),
# 色相
iaa.Sometimes(0.8, iaa.OneOf([
iaa.AddToHue((-255, 255)),
iaa.MultiplyHue((-3.0, 3.0)),
])),
# 云雾
# iaa.Sometimes(0.3, iaa.Clouds()),
# 卡通化
# iaa.Sometimes(0.01, iaa.Cartoon()),
],
random_order=True
)
],
random_order=True
)
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
def data_augmentation(img, bounding_boxes, labels):
"""
Enhance the data with imgaug
Largely inspired by https://imgaug.readthedocs.io/en/latest/source/examples_bounding_boxes.html
:param img: single image
:param bounding_boxes: the list of bounding boxes
:return:
"""
bbs = BoundingBoxesOnImage([
BoundingBox(
x1=bbox[0], y1=bbox[1], x2=bbox[2], y2=bbox[3], label=label)
for bbox, label in zip(bounding_boxes, labels)
],
shape=img.shape)
seq = iaa.Sequential(
[
# Blur each image with varying strength using
# gaussian blur (sigma between 0 and 3.0),
iaa.GaussianBlur((0, 3.0)),
# 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.AdditiveGaussianNoise(
loc=0, scale=(0.0, 0.05 * 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.Sometimes(p=0.5,
then_list=iaa.Multiply((0.8, 1.2), per_channel=0.2)),
# Increase saturation
iaa.Sometimes(p=0.5,
then_list=iaa.MultiplySaturation(mul=(0.5, 1.5))),
# Strengthen or weaken the contrast in each image.
iaa.Sometimes(
p=0.5,
then_list=iaa.LinearContrast((0.75, 1.5)),
),
iaa.HistogramEqualization(),
# horizontal flips
iaa.Fliplr(0.5),
# random crops
iaa.Crop(percent=(0, 0.1)),
# Apply affine transformations to each image.
# Scale/zoom them, translate/move them, rotate them and shear them.
iaa.Sometimes(
p=0.5,
then_list=iaa.Affine(rotate=(-15, 15), ),
)
],
random_order=True)
seq_det = seq.to_deterministic()
# Augment BBs and images.
image_aug, bbs_aug = seq_det(image=img, bounding_boxes=bbs)
bbs_aug = bbs_aug.clip_out_of_image()
bboxes_aug = list()
height, width, _ = image_aug.shape
for i in range(len(bbs_aug.bounding_boxes)):
bboxes_aug.append([
bbs_aug.bounding_boxes[i].label, bbs_aug.bounding_boxes[i].x1,
bbs_aug.bounding_boxes[i].y1, bbs_aug.bounding_boxes[i].x2,
bbs_aug.bounding_boxes[i].y2
])
return image_aug, np.array(bboxes_aug, dtype=np.float32)
