def test___init__(self):
child = iaa.Noop()
aug = iaa.WithHueAndSaturation(child, from_colorspace="BGR")
assert isinstance(aug.children, list)
assert len(aug.children) == 1
assert aug.children[0] is child
assert aug.from_colorspace == "BGR"
aug = iaa.WithHueAndSaturation([child])
assert isinstance(aug.children, list)
assert len(aug.children) == 1
assert aug.children[0] is child
assert aug.from_colorspace == "RGB"
def main():
image = ia.quokka_square(size=(128, 128))
images = []
for i in range(15):
aug = iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add(i * 20)))
images.append(aug.augment_image(image))
for i in range(15):
aug = iaa.WithHueAndSaturation(iaa.WithChannels(1, iaa.Add(i * 20)))
images.append(aug.augment_image(image))
ia.imshow(ia.draw_grid(images, rows=2))
def test_get_children_lists(self):
child = iaa.Noop()
aug = iaa.WithHueAndSaturation(child)
children_lists = aug.get_children_lists()
assert len(children_lists) == 1
assert len(children_lists[0]) == 1
assert children_lists[0][0] is child
child = iaa.Noop()
aug = iaa.WithHueAndSaturation([child])
children_lists = aug.get_children_lists()
assert len(children_lists) == 1
assert len(children_lists[0]) == 1
assert children_lists[0][0] is child
def test_augment_images__hue(self):
def augment_images(images, random_state, parents, hooks):
assert images[0].dtype.name == "int16"
images = np.copy(images)
images[..., 0] += 10
return images
aug = iaa.WithHueAndSaturation(iaa.Lambda(func_images=augment_images))
# example image
image = np.arange(0, 255).reshape((1, 255, 1)).astype(np.uint8)
image = np.tile(image, (1, 1, 3))
image[..., 0] += 0
image[..., 1] += 1
image[..., 2] += 2
# compute expected output
image_hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
image_hsv = image_hsv.astype(np.int16)
image_hsv[..., 0] = ((image_hsv[..., 0].astype(np.float32) / 180) *
255).astype(np.int16)
image_hsv[..., 0] += 10
image_hsv[..., 0] = np.mod(image_hsv[..., 0], 255)
image_hsv[..., 0] = ((image_hsv[..., 0].astype(np.float32) / 255) *
180).astype(np.int16)
image_hsv = image_hsv.astype(np.uint8)
image_expected = cv2.cvtColor(image_hsv, cv2.COLOR_HSV2RGB)
assert not np.array_equal(image_expected, image)
# augment and verify
images_aug = aug.augment_images(np.stack([image, image], axis=0))
assert ia.is_np_array(images_aug)
for image_aug in images_aug:
assert image_aug.shape == (1, 255, 3)
assert np.array_equal(image_aug, image_expected)
def chapter_augmenters_withhueandsaturation():
fn_start = "color/withhueandsaturation"
aug = iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add((0, 50))))
run_and_save_augseq(fn_start + "_add_to_hue.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-30, 10))),
iaa.WithChannels(
1, [iaa.Multiply((0.5, 1.5)),
iaa.LinearContrast((0.75, 1.25))])
])
run_and_save_augseq(fn_start + "_modify_both.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def test__to_deterministic(self):
aug = iaa.WithHueAndSaturation([iaa.Noop()], from_colorspace="BGR")
aug_det = aug.to_deterministic()
assert not aug.deterministic # ensure copy
assert not aug.children[0].deterministic
assert aug_det.deterministic
assert isinstance(aug_det.children[0], iaa.Noop)
assert aug_det.children[0].deterministic
def test___str__(self):
child = iaa.Sequential([iaa.Noop(name="foo")])
aug = iaa.WithHueAndSaturation(child)
observed = aug.__str__()
expected = ("WithHueAndSaturation("
"from_colorspace=RGB, "
"name=UnnamedWithHueAndSaturation, "
"children=[%s], "
"deterministic=False"
")" % (child.__str__(), ))
assert observed == expected
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 __init__(self, sometimes_prob=0.5, someof_range=(0, 3)):
def sometimes(aug):
return iaa.Sometimes(sometimes_prob, aug)
# define the sequence of augmentation strageties
self._pipeline = sometimes(
iaa.SomeOf(
someof_range,
[
# converts to HSV
# alters Hue in range -50,50°
# multiplies saturation
# converts back
iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-50, 50))),
iaa.WithChannels(1, [
iaa.Multiply((0.5, 1.5)),
]),
]),
# Sharpen each image, overlay the result with the original
# image using an alpha between 0 (no sharpening) and 1
# (full sharpening effect).
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
# Improve or worsen the contrast of images.
iaa.LinearContrast((0.5, 1.5), per_channel=0.5),
# Either drop randomly 1 to 10% of all pixels (i.e. set
# them to black) or drop them on an image with 2-5% percent
# of the original size, leading to large dropped
# rectangles.
# otherwise apply gaussian blur
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),
# gaussian blur (sigma between 0 and 3.0),
iaa.GaussianBlur((0, 3.0)),
]),
# Add a value of -10 to 10 to each pixel.
iaa.Add((-10, 10), per_channel=0.5),
# Convert each image to grayscale and then overlay the
# result with the original with random alpha. I.e. remove
# colors with varying strengths.
sometimes(iaa.Grayscale(alpha=(0.0, 1.0))),
],
# do all of the above augmentations in random order
random_order=True))
def test_augment_images(self):
def do_return_images(images, parents, hooks):
assert images[0].dtype.name == "int16"
return images
aug_mock = mock.MagicMock(spec=meta.Augmenter)
aug_mock.augment_images.side_effect = do_return_images
aug = iaa.WithHueAndSaturation(aug_mock)
image = np.zeros((4, 4, 3), dtype=np.uint8)
image_aug = aug.augment_images([image])[0]
assert image_aug.dtype.name == "uint8"
assert np.array_equal(image_aug, image)
assert aug_mock.augment_images.call_count == 1
def test_augment_heatmaps(self):
from imgaug.augmentables.heatmaps import HeatmapsOnImage
def do_return_augmentables(heatmaps, parents, hooks):
return heatmaps
aug_mock = mock.MagicMock(spec=meta.Augmenter)
aug_mock.augment_heatmaps.side_effect = do_return_augmentables
hm = np.ones((8, 12, 1), dtype=np.float32)
hmoi = HeatmapsOnImage(hm, shape=(16, 24, 3))
aug = iaa.WithHueAndSaturation(aug_mock)
hmoi_aug = aug.augment_heatmaps(hmoi)
assert hmoi_aug.shape == (16, 24, 3)
assert hmoi_aug.arr_0to1.shape == (8, 12, 1)
assert aug_mock.augment_heatmaps.call_count == 1
def test_augment_keypoints(self):
from imgaug.augmentables.kps import Keypoint, KeypointsOnImage
def do_return_augmentables(keypoints_on_images, parents, hooks):
return keypoints_on_images
aug_mock = mock.MagicMock(spec=meta.Augmenter)
aug_mock.augment_keypoints.side_effect = do_return_augmentables
kpsoi = KeypointsOnImage.from_xy_array(np.float32([[0, 0], [5, 1]]),
shape=(16, 24, 3))
aug = iaa.WithHueAndSaturation(aug_mock)
kpsoi_aug = aug.augment_keypoints(kpsoi)
assert kpsoi_aug.shape == (16, 24, 3)
assert kpsoi.keypoints[0].x == 0
assert kpsoi.keypoints[0].y == 0
assert kpsoi.keypoints[1].x == 5
assert kpsoi.keypoints[1].y == 1
assert aug_mock.augment_keypoints.call_count == 1
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 show(image):
image = cv2.resize(image, (0, 0), fx=3, fy=3)
cv2.imshow("image", image)
cv2.moveWindow("image", 300, 0)
[
iaa.OneOf([
iaa.GaussianBlur((0, 0.3)),
]),
#iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
# iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),
# iaa.AdditiveGaussianNoise(
# loc=0, scale=(0.0, 0.02*255), per_channel=0.5
# ),
# iaa.Add((-15, 15), per_channel=0.5),
# iaa.Multiply((0.8, 1.2), per_channel=0.5),
# iaa.imgcorruptlike.Contrast(severity=1),
# iaa.imgcorruptlike.Brightness(severity=2),
iaa.ContrastNormalization((0.1, 1.5), per_channel=0.5),
iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-15, 15))),
iaa.WithChannels(1, iaa.Add((-20, 20))),
]),
iaa.GammaContrast((0.3, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-30, 70))),
iaa.ScaleX((0.5, 1.5)),
iaa.ScaleY((0.5, 1.5)),
iaa.ShearX((-10, 10)),
iaa.ShearY((-10, 10)),
],
random_order=True)
],
random_order=True)
def augment_pair(fg, label):
# print('Augment start')
def generate(self, dataset_type, scene_type):
now = datetime.datetime.now()
dt_folder = str(now.year) + str(now.month).zfill(2) + str(now.day).zfill(2)
image_save_dir = os.path.join(ROOT_DIR, self.config["image_save_dir"] + "/" + dt_folder)
for target_object in self.config["target_objects"]:
self.target_object = target_object
print(" Target Object is '" + self.target_object + "'")
self.obj_image_save_dir = os.path.join(image_save_dir, dataset_type + "/" + self.target_object + "/" + scene_type)
if not os.path.exists(self.obj_image_save_dir):
os.makedirs(self.obj_image_save_dir)
count = 0
dataset = {}
for camera_height in [1.4, 1.6, 1.8]:
for i in range(self.config["num_generated_images"]):
self.reset()
# print(" Step " + str(i))
self.load_mesh_urdf("plane", isEnv = True)
# self.load_mesh_urdf("bin", isEnv = True)
for j in range(self.num_objects):
self.load_mesh_urdf(self.target_object)
if scene_type == "clutter":
self.drop_objects(isLast = j == self.num_objects - 1)
if scene_type == "aligned":
self.align_objects(idx = i)
self.translate_objects(idx = i)
augment_param = iaa.WithHueAndSaturation([
iaa.WithChannels(0, iaa.Add((-5, 5))),
iaa.WithChannels(1, [
iaa.Multiply((0.8, 1.1)),
iaa.LinearContrast((0.8, 1.1))
])
])
light_color = (1.0 - 0.1) * np.random.rand(3) + 0.1
self.add_object()
self.add_light(light_color)
self.add_camera()
camera_nodes = self.scene.camera_nodes
self.scene.remove_node(next(iter(camera_nodes)))
camera_pose = np.eye(4)
camera_pose[2, 3] = camera_height
self.add_camera(camera_pose)
color, depth = self.rendering()
filename = str(count).zfill(4) + '.png'
cv2.imwrite(self.obj_image_save_dir + "/" + filename, cv2.cvtColor(color, cv2.COLOR_RGB2BGR))
dataset[filename] = {"filename": filename, "file_attributes":{}, "size":0}
# depth unit is [m]
np.save(self.obj_image_save_dir + "/" + str(count).zfill(4) + "_depth", depth)
regions = self.get_segmented_info(scene_type)
dataset[filename]["regions"] = regions
count +=1
with open(self.obj_image_save_dir + "/label.json", "w") as f:
json.dump(dataset, f)
def __iter__(self):
data = []
labels = []
if self.mode == 'train':
data = self.data_files
labels = self.label_files
elif self.mode == 'eval':
data = self.eval_files
labels = self.eval_labels
elif self.mode == 'test':
data = self.test_files
data_size = len(data)
if self.mode == 'test':
input_batch = torch.zeros([1, 3, self.input_height, self.input_width], dtype=torch.float32)
else:
input_batch = torch.zeros([self.batch_size, 3, self.input_height, self.input_width], dtype=torch.float32)
target_batch = torch.zeros([self.batch_size, 1, self.input_height, self.input_width], dtype=torch.float32)
if self.mode == 'test':
current = 0
while current < data_size:
data_image_orig = cv2.imread(data[current])
data_image_orig = cv2.resize(data_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST)
input_batch[0, :, :, :] = self.normalize(data_image_orig)
yield input_batch, data[current]
current += 1
else:
current = 0
while current < data_size:
count = 0
while count < self.batch_size and current < data_size:
# print(data[current])
# print(labels[current])
data_image_orig = cv2.imread(data[current])
label_image_orig = cv2.imread(labels[current], cv2.IMREAD_GRAYSCALE)
# Resizing
data_image_orig = cv2.resize(data_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST)
# To crop change to 572 and un comment next line
# To not crop 388 (check assignment chart again)
#label_image_orig = label_image_orig.resize((388,388))
label_image_orig = cv2.resize(label_image_orig, (self.input_width, self.input_height), interpolation=cv2.INTER_NEAREST)
_, label_image_orig = cv2.threshold(label_image_orig, 127, 255, cv2.THRESH_BINARY)
## AUGMENTATION ##
# img_size = np.shape(label_image_orig)
# segmap = np.zeros(img_size, dtype=np.uint8)
# segmap[:] = label_image_orig
# segmap = SegmentationMapOnImage(segmap, shape=img_size)
segmap = SegmentationMapsOnImage(label_image_orig, shape=np.shape(label_image_orig))
# Augementation pipeline
# pipeline = iaa.Sometimes(
# 0.7,
pipeline = iaa.OneOf([
iaa.Affine(scale=(0.5, 1.5)),
iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),
iaa.WithBrightnessChannels(iaa.Add((-50, 50))),
iaa.WithHueAndSaturation(iaa.WithChannels(0, iaa.Add((0, 50)))),
iaa.ChangeColorTemperature((1100, 10000)),
iaa.GammaContrast((0.5, 2.0))
])
# )
if random.random() > 0.3:
if random.random() > 0.4:
data_image_aug, label_image_aug = pipeline(image = data_image_orig, segmentation_maps=segmap)
label_image_aug = label_image_aug.get_arr()
else:
data_image_aug = self.warming_transform(data_image_orig)
label_image_aug = label_image_orig
else:
data_image_aug = data_image_orig
label_image_aug = label_image_orig
# data_image_aug = data_image_aug.transpose((2, 0, 1))
# label_image_aug = np.expand_dims(label_image_aug.get_arr(), axis=0).astype('uint8')
input_batch[count, :, :, :] = self.normalize(data_image_aug)
# label_image_aug = label_image_aug.get_arr() // 255
# label_image_aug = label_image_aug.astype('uint8')
# target_batch[count, :, :] = torch.from_numpy(label_image_aug).long()
label_image_aug = np.expand_dims(label_image_aug.astype(np.float32) / 255.0, axis=0)
target_batch[count, :, :, :] = torch.from_numpy(label_image_aug)
count += 1
current += 1
yield input_batch, target_batch
# min_value=0.2, max_value=0.8)
# aug35 = iaa.BlendAlphaVerticalLinearGradient(
# iaa.AveragePooling(9),
# start_at=(0.0, 0.4), end_at=(0.0, 0.4))
# aug36 = iaa.BlendAlpha(
# (0.0, 0.3),
# iaa.Affine(rotate=(0, 0)),
# per_channel=0.3)
aug38 = iaa.WithColorspace(
to_colorspace="HSV",
from_colorspace="RGB",
children=iaa.WithChannels(0,iaa.Add((0, 50))))
aug40 = iaa.WithHueAndSaturation(
iaa.WithChannels(0, iaa.Add((0, 50))))
aug41 = iaa.MultiplyHueAndSaturation((0.5, 1.9), per_channel=True)
aug42 = iaa.AddToHueAndSaturation((-50, 50), per_channel=True)
aug43 = iaa.AddToHue((-50, 50))
aug44 = iaa.AddToSaturation((-50, 50))
aug45 = iaa.Sequential([
iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
iaa.WithChannels(0, iaa.Add((50, 100))),
iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB")])
aug46 = iaa.Grayscale(alpha=(0.0, 1.0))
aug47 = iaa.ChangeColorTemperature((1100, 10000))
aug49 = iaa.UniformColorQuantization()
aug50 = iaa.UniformColorQuantizationToNBits()
aug51 = iaa.GammaContrast((0.5, 2.0), per_channel=True)
aug52 = iaa.SigmoidContrast(gain=(3, 10), cutoff=(0.4, 0.6), per_channel=True)
def test_get_parameters(self):
aug = iaa.WithHueAndSaturation([iaa.Noop()], from_colorspace="BGR")
assert aug.get_parameters()[0] == "BGR"
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
