def _lane_argue(*, image, lane_src):
lines_tuple = [[(float(pt['x']), float(pt['y'])) for pt in line_spec] for line_spec in lane_src['Lines']]
lss = [ia_LineString(line_tuple_spec) for line_tuple_spec in lines_tuple]
lsoi = LineStringsOnImage(lss, shape=image.shape)
color_shift = iaa.OneOf([
iaa.GaussianBlur(sigma=(0.5, 1.5)),
iaa.LinearContrast((1.5, 1.5), per_channel=False),
iaa.Multiply((0.8, 1.2), per_channel=0.2),
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.1 * 255), per_channel=0.5),
iaa.WithColorspace(to_colorspace=iaa.CSPACE_HSV, from_colorspace=iaa.CSPACE_RGB,
children=iaa.WithChannels(0, iaa.Multiply((0.7, 1.3)))),
iaa.WithColorspace(to_colorspace=iaa.CSPACE_HSV, from_colorspace=iaa.CSPACE_RGB,
children=iaa.WithChannels(1, iaa.Multiply((0.1, 2)))),
iaa.WithColorspace(to_colorspace=iaa.CSPACE_HSV, from_colorspace=iaa.CSPACE_RGB,
children=iaa.WithChannels(2, iaa.Multiply((0.5, 1.5)))),
])
posion_shift = iaa.SomeOf(4, [
iaa.Fliplr(),
iaa.Crop(percent=([0, 0.2], [0, 0.15], [0, 0], [0, 0.15]), keep_size=True),
iaa.TranslateX(px=(-16, 16)),
iaa.ShearX(shear=(-15, 15)),
iaa.Rotate(rotate=(-15, 15))
])
aug = iaa.Sequential([
iaa.Sometimes(p=0.6, then_list=color_shift),
iaa.Sometimes(p=0.6, then_list=posion_shift)
], random_order=True)
batch = ia.Batch(images=[image], line_strings=[lsoi])
batch_aug = list(aug.augment_batches([batch]))[0] # augment_batches returns a generator
image_aug = batch_aug.images_aug[0]
lsoi_aug = batch_aug.line_strings_aug[0]
lane_aug = [[dict(x=kpt.x, y=kpt.y) for kpt in shapely_line.to_keypoints()] for shapely_line in lsoi_aug]
return image_aug, dict(Lines=lane_aug)
def transform(self, in_data):
augmenter = iaa.Sequential([
iaa.LinearContrast(alpha=(0.8, 1.2)),
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.Sequential([
# SV
iaa.WithChannels(
(1, 2),
iaa.Multiply(mul=(0.8, 1.2), per_channel=True),
),
# H
iaa.WithChannels(
(0, ),
iaa.Multiply(mul=(0.95, 1.05), per_channel=True),
),
]),
),
iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.KeepSizeByResize(children=iaa.Resize((0.25, 1.0))),
])
augmenter = augmenter.to_deterministic()
for index in self._indices:
in_data[index] = augmenter.augment_image(in_data[index])
def chapter_augmenters_withcolorspace():
aug = iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0, iaa.Add((10, 50))))
run_and_save_augseq("withcolorspace.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def generate_images(row):
path, width, height, xmin, ymin, xmax, ymax = row
image = cv2.imread(path)
bbs = ia.BoundingBoxesOnImage(
[ia.BoundingBox(x1=xmin, y1=ymin, x2=xmax, y2=ymax)],
shape=image.shape)
seq = iaa.Sequential([
iaa.Affine(scale=(0.4, 1.6)),
iaa.Crop(percent=(0, 0.2)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.AddToHueAndSaturation((-30, 30)),
iaa.Sometimes(0.5, iaa.Affine(rotate=(-45, 45)),
iaa.Affine(shear=(-16, 16))),
iaa.Sometimes(
0.2,
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0, iaa.Add(
(10, 50)))),
),
iaa.Multiply((0.8, 1.2), per_channel=0.2),
iaa.GaussianBlur(sigma=(0, 1.0))
])
new_rows = []
for i in range(0, AUGMENTATION_PER_IMAGE):
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
if not bbs_aug.bounding_boxes[0].is_fully_within_image(image.shape):
continue
# Another possibility is:
# bbs_aug = bbs_aug.remove_out_of_image().cut_out_of_image()
# if not bbs_aug.bounding_boxes:
# continue
after = bbs_aug.bounding_boxes[0]
if AUGMENTATION_DEBUG:
image_aug = bbs_aug.draw_on_image(image_aug,
thickness=2,
color=[0, 0, 255])
name, ftype = os.path.splitext(os.path.basename(path))
new_filename = "{}_aug_{}{}".format(name, i, ftype)
new_path = os.path.join(TRAIN_FOLDER, new_filename)
cv2.imwrite(new_path, cv2.resize(image_aug, (IMAGE_SIZE, IMAGE_SIZE)))
new_rows.append([
new_path, *scale_coordinates(width, height, after.x1, after.y1,
after.x2, after.y2)
])
return new_rows
def augment():
with open(CONFIG, "r") as file:
config = json.loads(file.read())
if config[ImageAugmentation.AUGMENT_DATA]:
matrix = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]])
return iaa.Sometimes(ImageAugmentation.AUG_PERCENTAGE, [
iaa.GaussianBlur(sigma=2.0),
iaa.Sequential([iaa.Affine(rotate=45),
iaa.Sharpen(alpha=1.0)]),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
0, iaa.Add((10, 50)))),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.Add(50, per_channel=True),
iaa.Sharpen(alpha=0.5),
iaa.WithChannels(0, iaa.Add((10, 100))),
iaa.WithChannels(0, iaa.Affine(rotate=(0, 45))),
iaa.Noop(),
iaa.Superpixels(p_replace=0.5, n_segments=64),
iaa.Superpixels(p_replace=(0.1, 1.0), n_segments=(16, 128)),
iaa.ChangeColorspace(from_colorspace="RGB",
to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add((50, 100))),
iaa.ChangeColorspace(from_colorspace="HSV",
to_colorspace="RGB"),
iaa.Grayscale(alpha=(0.0, 1.0)),
iaa.GaussianBlur(sigma=(0.0, 3.0)),
iaa.AverageBlur(k=(2, 11)),
iaa.AverageBlur(k=((5, 11), (1, 3))),
iaa.MedianBlur(k=(3, 11)),
iaa.Convolve(matrix=matrix),
iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0)),
iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5)),
iaa.EdgeDetect(alpha=(0.0, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.0, 1.0), direction=(0.0, 1.0)),
iaa.Add((-40, 40)),
iaa.Add((-40, 40), per_channel=0.5),
iaa.AddElementwise((-40, 40)),
iaa.AddElementwise((-40, 40), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=(0, 0.05 * 255)),
iaa.AdditiveGaussianNoise(scale=0.05 * 255),
iaa.AdditiveGaussianNoise(scale=0.05 * 255, per_channel=0.5),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.Dropout(p=(0, 0.2)),
iaa.Dropout(p=(0, 0.2), per_channel=0.5),
iaa.CoarseDropout(0.02, size_percent=0.5),
iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25)),
iaa.CoarseDropout(0.02, size_percent=0.15, per_channel=0.5),
iaa.Invert(0.25, per_channel=0.5),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.5, 1.5)),
iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5),
iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25)
])
else:
return None
def get_ill_seq(self):
light_change = 50
seq = iaa.Sequential([
# 全局调整，含有颜色空间调整
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.OneOf([
iaa.WithChannels(0, iaa.Add((-5, 5))),
iaa.WithChannels(1, iaa.Add((-20, 20))),
iaa.WithChannels(
2, iaa.Add((-light_change, light_change))),
])),
iaa.Grayscale((0.2, 0.6)),
iaa.ChannelShuffle(1),
iaa.Add((-light_change, light_change)),
iaa.Multiply((0.5, 1.5)),
])),
# # dropout阴影模仿，暂时不使用，转而使用了自定义的阴影模仿
# iaa.Sometimes(0.5, iaa.OneOf([
# iaa.Alpha((0.2, 0.7), iaa.CoarseDropout(p=0.2, size_percent=(0.02, 0.005)))
# ])),
# 椒盐噪声
iaa.Sometimes(
0.5,
iaa.OneOf(
[iaa.Alpha((0.2, 0.6), iaa.SaltAndPepper((0.01, 0.03)))])),
# 图像反转
iaa.Sometimes(0.5, iaa.OneOf([
iaa.Invert(1),
])),
# 对比度调整
iaa.Sometimes(0.5,
iaa.OneOf([
iaa.ContrastNormalization((0.5, 1.5)),
])),
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.AdditiveGaussianNoise(0, (3, 6)),
iaa.AdditivePoissonNoise((3, 6)),
iaa.JpegCompression((30, 60)),
iaa.GaussianBlur(sigma=1),
iaa.AverageBlur((1, 3)),
iaa.MedianBlur((1, 3)),
])),
])
return seq
def __call__(self, image, target):
if random.random() < self.prob:
aug_seq = iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
0, iaa.Add((10, 50)))),
iaa.Grayscale(alpha=(0.0, 1.0))
])
image = aug_seq.augment_image(np.array(image))
image = Image.fromarray(np.uint8(image))
return image, target
def _main_(args) :
number_of_data_augmentation = int(args.number_of_dataset_augmentation)
last_gen = int(args.number_of_the_last_dataset_augmentation)
aug = iaa.SomeOf(3, [
#FIRST GEN OF DATA AUGMENTATION
iaa.Affine(scale=(0.8, 1.2)),
iaa.Affine(rotate=(-30, 30)),
iaa.Affine(translate_percent={"x":(-0.2, 0.2),"y":(-0.2, 0.2)}),
iaa.Fliplr(1),
#SECOND GEN OF DATA AUGMENTATION
iaa.SaltAndPepper(0.1, per_channel=True),
iaa.Add((-40, 40), per_channel=0.5),
iaa.AdditiveGaussianNoise(scale=(0, 0.2*255)),
iaa.Multiply((0.5, 1.5), per_channel=0.5),
iaa.AverageBlur(k=((5, 11), (1, 3))),
iaa.WithColorspace(to_colorspace="HSV",from_colorspace="RGB",children=iaa.WithChannels(0,iaa.Add((0, 50)))),
iaa.AddToHueAndSaturation((-50, 50), per_channel=True),
#iaa.RandAugment(n=(0, 3)), # ==> DON'T WORK WITH BOUNDING BOX
#iaa.BlendAlphaCheckerboard(nb_rows=2, nb_cols=(1, 4),foreground=iaa.AddToHue((-100, 100))),
#iaa.BlendAlphaHorizontalLinearGradient(iaa.TotalDropout(1.0),min_value=0.2, max_value=0.8),
#iaa.BlendAlphaSimplexNoise(iaa.EdgeDetect(1.0)),
iaa.Solarize(0.5, threshold=(32, 128)),
iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add((0, 50))))
])
labels_df = xml_to_csv('vanilla_dataset_annot/')
labels_df.to_csv(('labels.csv'), index=None)
for i in range(number_of_data_augmentation):
prefix = "aug{}_".format(i+last_gen+1)
augmented_images_df = image_aug(labels_df, 'vanilla_dataset_img/', 'aug_images/', prefix, aug)
csv_to_xml(augmented_images_df, 'aug_images/')
# Concat resized_images_df and augmented_images_df together and save in a new all_labels.csv file
if(i==0):
all_labels_df = pd.concat([labels_df, augmented_images_df])
else:
all_labels_df = pd.concat([all_labels_df, augmented_images_df])
all_labels_df.to_csv('all_labels.csv', index=False)
del_unique_file()
# Lastly we can copy all our augmented images in the same folder as original resized images
for file in os.listdir('aug_images/'):
shutil.copy('aug_images/'+file, 'train_image_folder/'+file)
for file in os.listdir("aug_annot/"):
shutil.copy('aug_annot/'+file, 'train_annot_folder/'+file)
def imgaug_darken(images, base_save_path):
darken = iaa.WithColorspace(to_colorspace="HSV",
children=iaa.WithChannels(
2, iaa.Add((-60, -80))))
darken_imgs = darken.augment_images(images)
darken_path = '\\darken\\'
if not os.path.exists(base_save_path + darken_path):
os.mkdir(base_save_path + darken_path)
name_index = 0
for img in darken_imgs:
name_index += 1
imageio.imwrite(base_save_path + darken_path + 'img_aug_darken_' + time.strftime('%Y%m%d_%H',time.localtime()) \
+ '_' + str(name_index) + '.jpg', img)
def main():
image = data.astronaut()
print("image shape:", image.shape)
aug = iaa.WithColorspace(from_colorspace="RGB",
to_colorspace="HSV",
children=iaa.WithChannels(0, iaa.Add(50)))
aug_no_colorspace = iaa.WithChannels(0, iaa.Add(50))
img_show = np.hstack([
image,
aug.augment_image(image),
aug_no_colorspace.augment_image(image)
])
misc.imshow(img_show)
def __init__(self, list_path, img_size=416, augment=True):
with open(list_path, 'r') as file:
self.img_files = file.readlines()
self.label_files = [
path.replace('Images',
'Labels').replace('.png',
'.txt').replace('.jpg', '.txt')
for path in self.img_files
]
self.img_shape = (img_size, img_size)
self.max_objects = 50
# augment = True
# multiscale = False
# augmentHSV = True
# lrFlip = True
# udFlip = True
if augment:
self.augments = iaa.Sequential([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=[
iaa.WithChannels(1, iaa.Add((-50, 50))),
iaa.WithChannels(2, iaa.Add((-50, 50)))
]),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale={
"x": (0.90, 1.10),
"y": (0.90, 1.10)
},
translate_percent={
"x": (-0.1, 0.1),
"y": (-0.1, 0.1)
},
rotate=(-10, 10),
shear=(-16, 16),
order=[0, 1],
mode="constant",
cval=128),
])
else:
self.augments = iaa.Noop()
def get_simple_ill_seq(self):
light_change = 20
seq = iaa.Sequential([
# 全局调整，含有颜色空间调整
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.OneOf([
iaa.WithChannels(0, iaa.Add((-5, 5))),
iaa.WithChannels(1, iaa.Add((-20, 20))),
iaa.WithChannels(
2, iaa.Add((-light_change, light_change))),
])),
iaa.Grayscale((0.2, 0.6)),
iaa.Add((-light_change, light_change)),
iaa.Multiply((0.8, 1.2)),
])),
# 椒盐噪声
iaa.Sometimes(
0.5,
iaa.OneOf(
[iaa.Alpha((0.2, 0.6), iaa.SaltAndPepper((0.01, 0.03)))])),
# 对比度调整
iaa.Sometimes(0.5,
iaa.OneOf([
iaa.ContrastNormalization((0.8, 1.2)),
])),
iaa.Sometimes(
0.5,
iaa.OneOf([
iaa.AdditiveGaussianNoise(0, 1),
iaa.AdditivePoissonNoise(1),
iaa.JpegCompression((30, 60)),
iaa.GaussianBlur(sigma=1),
iaa.AverageBlur(1),
iaa.MedianBlur(1),
])),
])
return seq
def aug_mix(
image,
augmenters_param={
'Flip': 1,
'Colorspace': ((10, 50)),
'GaussianBlur': (0.0, 3.0),
'Dropout': ((0, 0.2), 0.5),
'Multiply': ((0.5, 1.5), 0.5),
'Crop': (-0.2, -0.1)
}):
images = np.zeros((15, image.shape[0], image.shape[1], image.shape[2]))
augmenters_param_ = {
'Flip': 0,
'Colorspace': 0,
'GaussianBlur': 0,
'Dropout': (0, 1),
}
i = 0
flag = []
for aug1 in augmenters_param:
for aug2 in [x for x in augmenters_param if x != aug1]:
if (aug2, aug1) in flag:
continue
flag.append((aug1, aug2))
augmenters_param_copy = copy.deepcopy(augmenters_param_)
augmenters_param_copy[aug1] = augmenters_param[aug1]
augmenters_param_copy[aug2] = augmenters_param[aug2]
seq = iaa.Sequential([
iaa.Fliplr(augmenters_param_copy['Flip']),
iaa.WithColorspace(
to_colorspace='HSV',
from_colorspace='RGB',
children=iaa.WithChannels(
0, iaa.Add(augmenters_param_copy['Colorspace']))),
iaa.GaussianBlur(sigma=augmenters_param_copy['GaussianBlur']),
iaa.Dropout(p=augmenters_param_copy['Dropout'][0],
per_channel=augmenters_param_copy['Dropout'][1])
])
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_images([image])[0]
images[i] = image_aug
i += 1
return images
def _iaa_image_fn(image):
aug = iaa.Sequential([
iaa.Sometimes(0.25, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(
0.25,
iaa.WithColorspace(to_colorspace='HSV',
from_colorspace='RGB',
children=[
iaa.WithChannels(0, iaa.Add((-10, 10))),
iaa.WithChannels(1, iaa.Add((-25, 25))),
iaa.WithChannels(2, iaa.Multiply(
(0.8, 1.1)))
])),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0.0, 3.0))),
iaa.Sometimes(0.25, iaa.AdditiveGaussianNoise(scale=(0, 0.025 * 255.)))
])
r = aug.augment_image(image.astype(np.uint8))
c = np.random.shuffle([0, 1, 2]) # shuffle
return r[..., c].astype(np.float32)
def augment_images(np_img_array, img_dir, img_list):
seq = iaa.Sequential(
[
iaa.Sometimes(
0.8,
iaa.CropAndPad(
percent=(0.1, 0.3),
pad_mode=["edge", "reflect"],
)),
iaa.Sometimes(
0.35,
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
0, iaa.Add((10, 50))))),
iaa.Sometimes(
0.35, iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5)),
iaa.Sometimes(0.35,
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.25))),
iaa.Sometimes(
0.35,
iaa.OneOf([
iaa.CoarseDropout((0.15, 0.2),
size_percent=(0.001, 0.02),
per_channel=0.1),
iaa.CoarseSaltAndPepper(
(0.15, 0.2), size_percent=(0.001, 0.02)),
#iaa.Superpixels(p_replace=(0.15, 0.2), n_segments=(128, 256))
]))
],
random_order=True)
images_aug = seq.augment_images(np_img_array)
for image, filepath in zip(images_aug, image_list):
global image_num
image_num += 1
im = Image.fromarray(image)
new_filename = split(filepath)[-1]
new_filename.replace(image_extension, '')
new_filename = new_filename + str(image_num) + image_extension
im.save(join(image_dir, new_filename))
def _augment_rgb(rgb):
augmenter = iaa.Sequential([
iaa.LinearContrast(alpha=(0.8, 1.2)),
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.Sequential([
# SV
iaa.WithChannels(
(1, 2),
iaa.Multiply(mul=(0.8, 1.2), per_channel=True),
),
# H
iaa.WithChannels(
(0, ),
iaa.Multiply(mul=(0.95, 1.05), per_channel=True),
),
]),
),
iaa.GaussianBlur(sigma=(0, 1.0)),
iaa.KeepSizeByResize(children=iaa.Resize((0.25, 1.0))),
])
return augmenter.augment_image(rgb)
def __init__(self,
base_data_path,
train,
transform,
id_name_path,
device,
little_train=False,
read_mode='jpeg4py',
input_size=224,
C=2048,
test_mode=False):
print('data init')
self.train = train
self.base_data_path = base_data_path
self.transform = transform
self.fnames = []
self.resize = input_size
self.little_train = little_train
self.id_name_path = id_name_path
self.C = C
self.read_mode = read_mode
self.device = device
self._test = test_mode
self.fnames = self.get_data_list(base_data_path)
self.num_samples = len(self.fnames)
self.get_id_map()
self.cls_path_map = self.get_cls_pathlist_map()
self.img_augsometimes = lambda aug: iaa.Sometimes(0.5, aug)
self.augmentation = iaa.Sequential(
[
# augment without change bboxes
self.img_augsometimes(
iaa.SomeOf(
(1, 4),
[
iaa.Dropout([0.05, 0.2
]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, .8)), # sharpen the image
# iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
# iaa.WithColorspace(to_colorspace="HSV", from_colorspace="RGB",
# children=iaa.WithChannels(2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
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))
],
random_order=True)),
iaa.Fliplr(.5),
iaa.Flipud(.25),
],
random_order=True)
ia.seed(1)
images = cv2.imread('dataset/train/id_00000002/02_1_front.jpg')
images = images.reshape((1, 256, 256, 3))
seq = iaa.Sequential(
[
# 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))
# ),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(2, iaa.Add(40))),
iaa.WithColorspace(to_colorspace="BGR",
from_colorspace="RGB",
children=iaa.WithChannels(1, iaa.Add(30))),
iaa.WithColorspace(to_colorspace="BGR",
from_colorspace="RGB",
children=iaa.WithChannels(0, iaa.Add(30))),
# Strengthen or weaken the contrast in each image.
#iaa.LinearContrast((0.75, 1.5)),
#iaa.Dropout2d(p=0.8),
iaa.Add((-40, 40), per_channel=0.5),
#iaa.Dropout(p=0.1),
from typing import List
import imgaug.augmenters as iaa
# Dictionary containing all possible augmentation functions
from src.genotype.cdn.genomes.da_genome import DAGenome
from src.phenotype.augmentations.custom_operations import CustomOperation as CO
from src.genotype.neat.connection import Connection
from src.genotype.neat.node import NodeType
Augmentations = {
# Convert images to HSV, then increase each pixel's Hue (H), Saturation (S) or Value/lightness (V) [0, 1, 2]
# value by an amount in between lo and hi:
"HSV": lambda channel, lo, hi: iaa.WithColorspace
(to_colorspace="HSV", from_colorspace="RGB", children=iaa.WithChannels(channel, iaa.Add((lo, hi)))),
# The augmenter first transforms images to HSV color space, then adds random values (lo to hi)
# to the H and S channels and afterwards converts back to RGB.
# (independently per channel and the same value for all pixels within that channel)
"Add_To_Hue_And_Saturation": lambda lo, hi: iaa.AddToHueAndSaturation((lo, hi), per_channel=True),
# Increase each pixel’s channel-value (redness/greenness/blueness) [0, 1, 2] by value in between lo and hi:
"Increase_Channel": lambda channel, lo, hi: iaa.WithChannels(channel, iaa.Add((lo, hi))),
# Rotate each image’s channel [R=0, G=1, B=2] by value in between lo and hi degrees:
"Rotate_Channel": lambda channel, lo, hi: iaa.WithChannels(channel, iaa.Affine(rotate=(lo, hi))),
# Augmenter that never changes input images (“no operation”).
"No_Operation": iaa.Noop(),
# Pads images, i.e. adds columns/rows to them. Pads image by value in between lo and hi
augmentation = iaa.SomeOf(
(0, None),
[
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(rotate=(-180, 180)),
iaa.Affine(translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
}),
iaa.CropAndPad(percent=(-0.25, 0.25)),
#iaa.Multiply((0.5, 1.5)),
#iaa.GaussianBlur(sigma=(0.0, 0.5)),
#iaa.AdditiveGaussianNoise(scale=(0, 0.15*255))
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
0, iaa.Multiply((0.5, 1.5)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Multiply((0.5, 1.5)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Multiply((0.5, 1.5)))),
iaa.WithChannels(0, iaa.Multiply((0.5, 1.5))),
iaa.WithChannels(1, iaa.Multiply((0.5, 1.5))),
iaa.WithChannels(2, iaa.Multiply((0.5, 1.5)))
])
'''
augmentation = iaa.SomeOf((0, 3), [
train_aug = iaa.SomeOf(
(1, 3),
[ # Random number between 0, 3
iaa.Fliplr(0.5), # Horizontal flips 0.01
# Random channel increase and rotation 0.03
iaa.Add((-5, 5)), # Overall Brightness 0.04
iaa.Multiply(
(0.95, 1.05),
per_channel=0.2), # Brightness multiplier per channel 0.05
iaa.Sharpen(
alpha=(0.1, 0.75),
lightness=(0.85,
1.15)), # Sharpness 0.05
iaa.WithColorspace(
to_colorspace='HSV',
from_colorspace=
'RGB', # Random HSV increase 0.09
children=iaa.WithChannels(0, iaa.Add((-30, 30)))),
iaa.WithColorspace(to_colorspace='HSV',
from_colorspace='RGB',
children=iaa.WithChannels(
1, iaa.Add((-30, 30)))),
iaa.WithColorspace(to_colorspace='HSV',
from_colorspace='RGB',
children=iaa.WithChannels(
2, iaa.Add((-30, 30)))),
iaa.AddElementwise(
(-10, 10)), # Per pixel addition 0.11
iaa.CoarseDropout((0.0, 0.02), size_percent=(
0.02, 0.25)), # Add large black squares 0.13
iaa.GaussianBlur(
def main():
parser = argparse.ArgumentParser(description="Check augmenters visually.")
parser.add_argument(
"--only",
default=None,
help=
"If this is set, then only the results of an augmenter with this name will be shown. "
"Optionally, comma-separated list.",
required=False)
args = parser.parse_args()
images = [
ia.quokka_square(size=(128, 128)),
ia.imresize_single_image(data.astronaut(), (128, 128))
]
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=50, y=40),
ia.Keypoint(x=70, y=38),
ia.Keypoint(x=62, y=52)
],
shape=images[0].shape),
ia.KeypointsOnImage([
ia.Keypoint(x=55, y=32),
ia.Keypoint(x=42, y=95),
ia.Keypoint(x=75, y=89)
],
shape=images[1].shape)
]
bounding_boxes = [
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[0].shape),
ia.BoundingBoxesOnImage([
ia.BoundingBox(x1=10, y1=10, x2=20, y2=20),
ia.BoundingBox(x1=40, y1=50, x2=70, y2=60)
],
shape=images[1].shape)
]
augmenters = [
iaa.Sequential([
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="Sequential"),
iaa.SomeOf(2,
children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="SomeOf"),
iaa.OneOf(children=[
iaa.CoarseDropout(p=0.5, size_percent=0.05),
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
iaa.Crop(percent=0.1)
],
name="OneOf"),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=0.1 * 255),
name="Sometimes"),
iaa.WithColorspace("HSV",
children=[iaa.Add(20)],
name="WithColorspace"),
iaa.WithChannels([0], children=[iaa.Add(20)], name="WithChannels"),
iaa.AddToHueAndSaturation((-20, 20),
per_channel=True,
name="AddToHueAndSaturation"),
iaa.Noop(name="Noop"),
iaa.Resize({
"width": 64,
"height": 64
}, name="Resize"),
iaa.CropAndPad(px=(-8, 8), name="CropAndPad-px"),
iaa.Pad(px=(0, 8), name="Pad-px"),
iaa.Crop(px=(0, 8), name="Crop-px"),
iaa.Crop(percent=(0, 0.1), name="Crop-percent"),
iaa.Fliplr(0.5, name="Fliplr"),
iaa.Flipud(0.5, name="Flipud"),
iaa.Superpixels(p_replace=0.75, n_segments=50, name="Superpixels"),
iaa.Grayscale(0.5, name="Grayscale0.5"),
iaa.Grayscale(1.0, name="Grayscale1.0"),
iaa.GaussianBlur((0, 3.0), name="GaussianBlur"),
iaa.AverageBlur(k=(3, 11), name="AverageBlur"),
iaa.MedianBlur(k=(3, 11), name="MedianBlur"),
iaa.BilateralBlur(d=10, name="BilateralBlur"),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0, 2.0), name="Sharpen"),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0, 2.0), name="Emboss"),
iaa.EdgeDetect(alpha=(0.1, 1.0), name="EdgeDetect"),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0),
direction=(0, 1.0),
name="DirectedEdgeDetect"),
iaa.Add((-50, 50), name="Add"),
iaa.Add((-50, 50), per_channel=True, name="AddPerChannel"),
iaa.AddElementwise((-50, 50), name="AddElementwise"),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.1 * 255),
name="AdditiveGaussianNoise"),
iaa.Multiply((0.5, 1.5), name="Multiply"),
iaa.Multiply((0.5, 1.5), per_channel=True, name="MultiplyPerChannel"),
iaa.MultiplyElementwise((0.5, 1.5), name="MultiplyElementwise"),
iaa.Dropout((0.0, 0.1), name="Dropout"),
iaa.CoarseDropout(p=0.05,
size_percent=(0.05, 0.5),
name="CoarseDropout"),
iaa.Invert(p=0.5, name="Invert"),
iaa.Invert(p=0.5, per_channel=True, name="InvertPerChannel"),
iaa.ContrastNormalization(alpha=(0.5, 2.0),
name="ContrastNormalization"),
iaa.SaltAndPepper(p=0.05, name="SaltAndPepper"),
iaa.Salt(p=0.05, name="Salt"),
iaa.Pepper(p=0.05, name="Pepper"),
iaa.CoarseSaltAndPepper(p=0.05,
size_percent=(0.01, 0.1),
name="CoarseSaltAndPepper"),
iaa.CoarseSalt(p=0.05, size_percent=(0.01, 0.1), name="CoarseSalt"),
iaa.CoarsePepper(p=0.05, size_percent=(0.01, 0.1),
name="CoarsePepper"),
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_px={
"x": (-16, 16),
"y": (-16, 16)
},
rotate=(-45, 45),
shear=(-16, 16),
order=ia.ALL,
cval=(0, 255),
mode=ia.ALL,
name="Affine"),
iaa.PiecewiseAffine(scale=0.03,
nb_rows=(2, 6),
nb_cols=(2, 6),
name="PiecewiseAffine"),
iaa.PerspectiveTransform(scale=0.1, name="PerspectiveTransform"),
iaa.ElasticTransformation(alpha=(0.5, 8.0),
sigma=1.0,
name="ElasticTransformation"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=False,
name="Alpha"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Add(100),
second=iaa.Dropout(0.5),
per_channel=True,
name="AlphaPerChannel"),
iaa.Alpha(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaAffine"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=False,
name="AlphaElementwise"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Add(50),
second=iaa.ContrastNormalization(2.0),
per_channel=True,
name="AlphaElementwisePerChannel"),
iaa.AlphaElementwise(factor=(0.0, 1.0),
first=iaa.Affine(rotate=(-45, 45)),
per_channel=True,
name="AlphaElementwiseAffine"),
iaa.SimplexNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="SimplexNoiseAlpha"),
iaa.FrequencyNoiseAlpha(first=iaa.EdgeDetect(1.0),
per_channel=False,
name="FrequencyNoiseAlpha")
]
augmenters.append(
iaa.Sequential([iaa.Sometimes(0.2, aug.copy()) for aug in augmenters],
name="Sequential"))
augmenters.append(
iaa.Sometimes(0.5, [aug.copy() for aug in augmenters],
name="Sometimes"))
for augmenter in augmenters:
if args.only is None or augmenter.name in [
v.strip() for v in args.only.split(",")
]:
print("Augmenter: %s" % (augmenter.name, ))
grid = []
for image, kps, bbs in zip(images, keypoints, bounding_boxes):
aug_det = augmenter.to_deterministic()
imgs_aug = aug_det.augment_images(
np.tile(image[np.newaxis, ...], (16, 1, 1, 1)))
kps_aug = aug_det.augment_keypoints([kps] * 16)
bbs_aug = aug_det.augment_bounding_boxes([bbs] * 16)
imgs_aug_drawn = [
kps_aug_one.draw_on_image(img_aug)
for img_aug, kps_aug_one in zip(imgs_aug, kps_aug)
]
imgs_aug_drawn = [
bbs_aug_one.draw_on_image(img_aug)
for img_aug, bbs_aug_one in zip(imgs_aug_drawn, bbs_aug)
]
grid.append(np.hstack(imgs_aug_drawn))
ia.imshow(np.vstack(grid))
def __init__(self,
list_file,
train,
transform,
device,
little_train=False,
S=7):
print('data init')
self.train = train
self.transform = transform
self.fnames = []
self.boxes = []
self.labels = []
self.S = S
self.B = 2
self.C = 20
self.device = device
self.augmentation = iaa.Sometimes(
0.5,
iaa.SomeOf(
(1, 6),
[
iaa.Dropout([0.05, 0.2]), # drop 5% or 20% of all pixels
iaa.Sharpen((0.1, 1.0)), # sharpen the image
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.OneOf([
iaa.GaussianBlur(sigma=(2., 3.5)),
iaa.AverageBlur(k=(2, 5)),
iaa.BilateralBlur(d=(7, 12),
sigma_color=(10, 250),
sigma_space=(10, 250)),
iaa.MedianBlur(k=(3, 7)),
]),
# iaa.Fliplr(1.0),
# iaa.Flipud(1.0),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0, 0.1 * 255)),
iaa.JpegCompression(compression=(80, 95)),
iaa.Multiply((0.5, 1.5)),
iaa.MultiplyElementwise((0.5, 1.5)),
iaa.ReplaceElementwise(0.05, [0, 255]),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
iaa.OneOf([
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
1, iaa.Add((-10, 50)))),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(
2, iaa.Add((-10, 50)))),
]),
],
random_order=True))
torch.manual_seed(23)
with open(list_file) as f:
lines = f.readlines()
if little_train:
lines = lines[:64]
for line in lines:
splited = line.strip().split()
self.fnames.append(splited[0])
self.num_samples = len(self.fnames)
iaa.MultiplyHueAndSaturation(mul_hue=(0.5, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-50, 50))),
iaa.WithBrightnessChannels(iaa.Add((-50, 50)),
to_colorspace=[iaa.CSPACE_Lab, iaa.CSPACE_HSV]),
iaa.MaxPooling(2),
iaa.MinPooling((1, 2)),
# iaa.Superpixels(p_replace=(0.1, 0.2), n_segments=(16, 128)),
iaa.Clouds(),
iaa.Fog(),
iaa.AdditiveGaussianNoise(scale=0.1 * 255, per_channel=True),
iaa.Dropout(p=(0, 0.2)),
# iaa.WithChannels(0, iaa.Affine(rotate=(0, 0))),
iaa.ChannelShuffle(0.35),
iaa.WithColorspace(to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0, iaa.Add((0, 50)))),
#
iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-30, 10))),
iaa.WithChannels(
1, [iaa.Multiply((0.5, 1.5)),
iaa.LinearContrast((0.75, 1.25))])
]),
#
# # iaa.Canny()
# iaa.FastSnowyLandscape(
# lightness_threshold=140,
# lightness_multiplier=2.5
# )
]
def attain_aug_source_img_data(self,
array_source_img,
length=None,
file_name=None):
# 111
seq11 = iaa.Sequential(
children=[
iaa.Crop(px=(5, 15)),
iaa.Fliplr(p=0.5),
# """仿射变换"""
iaa.Affine(
scale=0.95, # 缩放比列(越大缩的越多)
translate_percent=0.09, # 平移
rotate=(0, 360)),
# iaa.contrast.LinearContrast(alpha=0.95, per_channel=False)
],
random_order=True)
# 112
seq12 = iaa.Sequential(
children=[
iaa.Affine(
scale=(0.85, 1.3), # 缩放比列
translate_percent=0.05, # 平移
rotate=(10, 360),
),
],
random_order=True) # 调整亮度
# 113
seq13 = iaa.Sequential(
children=[
iaa.Flipud(p=0.5),
# iaa.contrast.LinearContrast(alpha=(0.8, 1.2), per_channel=True), # 改变图片的对比度(越高越亮)
iaa.Affine(rotate=(10, 360)),
],
random_order=True)
someof11 = iaa.SomeOf(
4,
[
iaa.Fliplr(0.6),
iaa.Sharpen(alpha=0.5, lightness=1),
# iaa.SigmoidContrast(gain=3.5, cutoff=(0.15, 0.35)),
iaa.Affine(rotate=(0, 360))
],
random_order=True)
# 211
someof12 = iaa.SomeOf(
2,
[
# iaa.ChangeColorTemperature(kelvin=(3000, 7500)), # 色温
iaa.Affine(rotate=(50, 360))
],
random_order=True)
# 212
someof13 = iaa.SomeOf(
2,
[
# iaa.ChangeColorTemperature(kelvin=(2000, 4500)),
iaa.Sharpen(alpha=0.7, lightness=1.5),
iaa.Affine(rotate=(10, 150))
],
random_order=True)
# 213
sometimes11 = iaa.Sometimes(0.5, iaa.GaussianBlur(0.05),
iaa.Fliplr(0.5))
# 颜色空间的变换
# 311
colorspace_change11 = iaa.WithColorspace(
to_colorspace=iaa.CSPACE_HSV,
from_colorspace=iaa.CSPACE_RGB,
children=[
iaa.WithChannels(2, iaa.Add((5, 10))),
iaa.Affine(rotate=(50, 360))
])
# 411
Channels_changes11 = iaa.WithChannels([2], iaa.Add(2))
# 511
linearcontrast11 = iaa.SomeOf(
4,
[
iaa.Fliplr(0.6),
iaa.Sharpen(alpha=0.5, lightness=1),
# iaa.SigmoidContrast(gain=2.5, cutoff=(0.15, 0.35)),
iaa.Affine(rotate=(0, 360))
],
random_order=True)
# 611
mltiply = iaa.Multiply(mul=1.4,
per_channel=False,
name=None,
deterministic=False,
random_state=None)
array_aug_img = []
aug_way_nums = 0
for img_order in range(length):
source_image = array_source_img[img_order]
image = cv2.cvtColor(source_image, cv2.COLOR_BGR2RGB)
# 策略调整入口
# 增强策略
# 策略一
aug_img_data111 = seq11.augment_image(image)
aug_img_data112 = seq12.augment_image(image)
aug_img_data113 = seq13.augment_image(image)
# 策略二
aug_img_data211 = someof11.augment_image(image)
aug_img_data212 = someof12.augment_image(image)
aug_img_data213 = someof13.augment_image(image)
# 策略三
aug_img_data311 = colorspace_change11.augment_image(image)
# 策略四
aug_img_data411 = Channels_changes11.augment_image(image)
# 策略五
aug_img_data511 = sometimes11.augment_image(image)
# 策略六
aug_img_data611 = mltiply.augment_image(image)
# 看下增强后数据的形状
# 恢复原始图片的图片的模式BGR
aug_way_array = []
aug_img_data111 = cv2.cvtColor(aug_img_data111, cv2.COLOR_RGB2BGR)
aug_img_data112 = cv2.cvtColor(aug_img_data112, cv2.COLOR_RGB2BGR)
aug_img_data113 = cv2.cvtColor(aug_img_data113, cv2.COLOR_RGB2BGR)
aug_img_data211 = cv2.cvtColor(aug_img_data211, cv2.COLOR_RGB2BGR)
aug_img_data212 = cv2.cvtColor(aug_img_data212, cv2.COLOR_RGB2BGR)
aug_img_data213 = cv2.cvtColor(aug_img_data213, cv2.COLOR_RGB2BGR)
aug_img_data311 = cv2.cvtColor(aug_img_data311, cv2.COLOR_RGB2BGR)
aug_img_data411 = cv2.cvtColor(aug_img_data411, cv2.COLOR_RGB2BGR)
aug_img_data511 = cv2.cvtColor(aug_img_data511, cv2.COLOR_RGB2BGR)
aug_img_data611 = cv2.cvtColor(aug_img_data611, cv2.COLOR_RGB2BGR)
aug_way_array.append(aug_img_data111)
aug_way_array.append(aug_img_data112)
aug_way_array.append(aug_img_data113)
aug_way_array.append(aug_img_data211)
aug_way_array.append(aug_img_data212)
aug_way_array.append(aug_img_data213)
aug_way_array.append(aug_img_data311)
aug_way_array.append(aug_img_data411)
aug_way_array.append(aug_img_data511)
aug_way_array.append(aug_img_data611)
# 直接改这里即可增加
array_aug_img.append(aug_img_data111)
array_aug_img.append(aug_img_data112)
array_aug_img.append(aug_img_data113)
array_aug_img.append(aug_img_data211)
array_aug_img.append(aug_img_data212)
# array_aug_img.append(aug_img_data213)
# array_aug_img.append(aug_img_data311)
array_aug_img.append(aug_img_data411)
array_aug_img.append(aug_img_data511)
# array_aug_img.append(aug_img_data611)
aug_way_nums = len(aug_way_array)
# ia.show_grid(array_aug_img[0:aug_way_nums], rows=None, cols=4)
print("第{0}个文件夹，共增强了{1}张图片".format(file_name, len(array_aug_img)))
length_aug = len(array_aug_img)
return array_aug_img, length_aug
def generate_train(self):
sample_weights = []
for sample_id in self.train_sample_ids:
area = self.images[sample_id].shape[0] * self.images[
sample_id].shape[1]
# scale = np.clip(self.expected_mask_size/self.median_mask_size[sample_id], 0.5, 2.0)
# use more of larger images but not proportionally to area, let's keep some variability as well
weight = area**0.5
if sample_id.startswith('extra_set14'):
weight *= 0.1
if 'synth' in sample_id:
weight *= 0.2
sample_weights.append(weight)
sample_weights = np.array(sample_weights)
sample_weights /= np.sum(sample_weights)
while True:
requests = []
for i in range(self.batch_size):
sample_id = np.random.choice(self.train_sample_ids,
p=sample_weights)
img = self.images[sample_id]
scale = 2**np.random.uniform(-1.1, 1.1)
scale *= config.IMG_SCALE
scale_x = 2**np.random.uniform(-0.3, 0.3)
scale_y = 2**np.random.uniform(-0.3, 0.3)
cfg = SampleCfg(sample_id=sample_id,
src_center_x=np.random.uniform(
CROP_SIZE // 2 - 32,
img.shape[1] - CROP_SIZE // 2 + 32),
src_center_y=np.random.uniform(
CROP_SIZE // 2 - 32,
img.shape[0] - CROP_SIZE // 2 + 32),
angle=np.random.uniform(-180, 180),
shear=np.random.uniform(-15, 15),
scale_x=scale * scale_x,
scale_y=scale * scale_y)
cfg.aug = iaa.Sequential([
# iaa.Invert(p=0.2),
iaa.Sometimes(0.25, iaa.Grayscale(alpha=(0.0, 1.0))),
iaa.Sometimes(
0.25,
iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=[
# iaa.WithChannels(0, iaa.Add((0, 255))),
iaa.WithChannels(0, iaa.Add((-10, 10))),
iaa.WithChannels(1, iaa.Add((-25, 25))),
iaa.WithChannels(2, iaa.Multiply((0.8, 1.1)))
])),
iaa.Sometimes(0.25, iaa.GaussianBlur(sigma=(0.0, 3.0))),
iaa.Sometimes(
0.25,
iaa.AdditiveGaussianNoise(scale=(0, 0.025 * 255))),
iaa.Sometimes(0.5, extra_augmentations.Gamma(-1.0, 1.0))
])
requests.append(cfg)
X = self.pool.map(self.generate_x, requests)
y = self.pool.map(self.generate_y, requests)
self.last_requests = requests
yield np.array(X), np.array(y)
def augment_object_data(object_data,
random_state=None,
fit_output=True,
aug_color=True,
aug_geo=True,
augmentations=None,
random_order=False,
scale=(0.5, 1.0)):
try:
iaa.Affine(fit_output=True)
except TypeError:
warnings.warn(
'Your imgaug does not support fit_output kwarg for'
'imgaug.augmenters.Affine. Please install via'
'\n\n\tpip install -e git+https://github.com/wkentaro/imgaug@affine_resize\n\n' # NOQA
'to enable it.')
fit_output = False
if random_state is None:
random_state = np.random.RandomState()
if augmentations is None:
st = lambda x: iaa.Sometimes(0.3, x) # NOQA
kwargs_affine = dict(
order=1, # order=0 for mask
cval=0,
scale=scale,
translate_px=(-16, 16),
rotate=(-180, 180),
shear=(-16, 16),
mode='constant',
)
if fit_output:
kwargs_affine['fit_output'] = fit_output
augmentations = [
st(
iaa.WithChannels([0, 1], iaa.Multiply([1, 1.5])
) if aug_color else iaa.Noop()),
st(
iaa.WithColorspace('HSV',
children=iaa.
WithChannels([1, 2], iaa.Multiply([0.5, 2]))
) if aug_color else iaa.Noop()),
st(
iaa.GaussianBlur(
sigma=[0.0, 1.0]) if aug_color else iaa.Noop()),
iaa.Sometimes(
0.8,
iaa.Affine(**kwargs_affine) if aug_geo else iaa.Noop()),
]
aug = iaa.Sequential(
augmentations,
random_order=random_order,
random_state=ia.copy_random_state(random_state),
)
def activator_imgs(images, augmenter, parents, default):
if isinstance(augmenter, iaa.Affine):
augmenter.order = Deterministic(1)
augmenter.cval = Deterministic(0)
return True
def activator_masks(images, augmenter, parents, default):
white_lists = (iaa.Affine, iaa.PerspectiveTransform, iaa.Sequential,
iaa.Sometimes)
if not isinstance(augmenter, white_lists):
return False
if isinstance(augmenter, iaa.Affine):
augmenter.order = Deterministic(0)
augmenter.cval = Deterministic(0)
return True
def activator_lbls(images, augmenter, parents, default):
white_lists = (iaa.Affine, iaa.PerspectiveTransform, iaa.Sequential,
iaa.Sometimes)
if not isinstance(augmenter, white_lists):
return False
if isinstance(augmenter, iaa.Affine):
augmenter.order = Deterministic(0)
augmenter.cval = Deterministic(-1)
return True
for objd in object_data:
aug = aug.to_deterministic()
objd['img'] = aug.augment_image(
objd['img'], hooks=ia.HooksImages(activator=activator_imgs))
if 'mask' in objd:
objd['mask'] = aug.augment_image(
objd['mask'], hooks=ia.HooksImages(activator=activator_masks))
if 'lbl' in objd:
objd['lbl'] = aug.augment_image(
objd['lbl'], hooks=ia.HooksImages(activator=activator_lbls))
if 'lbl_suc' in objd:
objd['lbl_suc'] = aug.augment_image(
objd['lbl_suc'],
hooks=ia.HooksImages(activator=activator_lbls))
if 'masks' in objd:
masks = []
for mask in objd['masks']:
mask = aug.augment_image(
mask,
hooks=ia.HooksImages(activator=activator_masks),
)
masks.append(mask)
masks = np.asarray(masks)
objd['masks'] = masks
del masks
if 'lbls' in objd:
lbls = []
for lbl in objd['lbls']:
lbl = aug.augment_image(
lbl,
hooks=ia.HooksImages(activator=activator_lbls),
)
lbls.append(lbl)
lbls = np.asarray(lbls)
objd['lbls'] = lbls
del lbls
yield objd
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.imresize_single_image(skimage.data.astronaut(), (128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10, vis=None, label=None), ia.Keypoint(x=5, y=5, vis=None, label=None),
ia.Keypoint(x=10, y=43, vis=None, label=None)], shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
# iaa.WithChannels([0], iaa.Add((-50, 50))),
# iaa.Noop(name="Noop-nochange"),
# iaa.Lambda(
# func_images=lambda images, random_state, parents, hooks: images,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: keypoints_on_images,
# name="Lambda-nochange"
# ),
# iaa.AssertLambda(
# func_images=lambda images, random_state, parents, hooks: True,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: True,
# name="AssertLambda-nochange"
# ),
# iaa.AssertShape(
# (None, None, None, 3),
# check_keypoints=False,
# name="AssertShape-nochange"
# ),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
# iaa.ChangeColorspace(to_colorspace="GRAY"),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
# iaa.Convolve(np.array([[0, 1, 0],
# [1, -4, 1],
# [0, 1, 0]])),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.6, 1.4)),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=0.5)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.quokka((128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10), ia.Keypoint(x=5, y=5),
ia.Keypoint(x=10, y=43)], shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=10.0)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
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
