def test__draw_samples__single_value_hysteresis(self):
seed = 1
nb_images = 1000
aug = iaa.Canny(
alpha=0.2,
hysteresis_thresholds=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
sobel_kernel_size=[3, 5, 7],
random_state=iarandom.RNG(seed))
example_image = np.zeros((5, 5, 3), dtype=np.uint8)
samples = aug._draw_samples([example_image] * nb_images,
random_state=iarandom.RNG(seed))
alpha_samples = samples[0]
hthresh_samples = samples[1]
sobel_samples = samples[2]
rss = iarandom.RNG(seed).duplicate(4)
alpha_expected = iap.Deterministic(0.2).draw_samples((nb_images, ),
rss[0])
hthresh_expected = iap.Choice([0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10]).draw_samples((nb_images, 2),
rss[1])
sobel_expected = iap.Choice([3, 5, 7]).draw_samples((nb_images, ),
rss[2])
invalid = hthresh_expected[:, 0] > hthresh_expected[:, 1]
assert np.any(invalid)
hthresh_expected[invalid, :] = hthresh_expected[invalid, :][:, [1, 0]]
assert hthresh_expected.shape == (nb_images, 2)
assert not np.any(hthresh_expected[:, 0] > hthresh_expected[:, 1])
assert np.allclose(alpha_samples, alpha_expected)
assert np.allclose(hthresh_samples, hthresh_expected)
assert np.allclose(sobel_samples, sobel_expected)
def someAug():
bg = iap.Uniform(16, 18)
#Creating a series of augmentations
shearXY = iaa.Sequential([
iaa.ShearY(iap.Uniform(-10, 10), cval=bg),
iaa.ShearX(iap.Uniform(-10, 10), cval=bg)
])
rotate = iaa.Rotate(rotate=iap.Choice([-30, -15, 15, 30],
p=[0.25, 0.25, 0.25, 0.25]),
cval=bg)
pwAff = iaa.PiecewiseAffine(scale=(0.01, 0.06), cval=bg)
affine = iaa.Affine(scale={
"x": iap.Uniform(1.1, 1.2),
"y": iap.Uniform(1.1, 1.2)
},
cval=bg)
noise = iaa.AdditiveGaussianNoise(loc=0, scale=(0, 0.025 * 255))
#Using SomeOf to randomly select some augmentations
someAug = iaa.SomeOf(iap.Choice([2, 3, 4], p=[1 / 3, 1 / 3, 1 / 3]),
[affine, shearXY, pwAff, rotate, noise],
random_order=True)
return someAug
def test__draw_samples__tuple_as_hysteresis(self):
seed = 1
nb_images = 10
aug = iaa.Canny(
alpha=0.2,
hysteresis_thresholds=([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
iap.DiscreteUniform(5, 100)),
sobel_kernel_size=[3, 5, 7],
random_state=iarandom.RNG(seed))
aug.alpha = remove_prefetching(aug.alpha)
aug.hysteresis_thresholds = (
remove_prefetching(aug.hysteresis_thresholds[0]),
remove_prefetching(aug.hysteresis_thresholds[1])
)
aug.sobel_kernel_size = remove_prefetching(aug.sobel_kernel_size)
example_image = np.zeros((5, 5, 3), dtype=np.uint8)
samples = aug._draw_samples([example_image] * nb_images,
random_state=iarandom.RNG(seed))
alpha_samples = samples[0]
hthresh_samples = samples[1]
sobel_samples = samples[2]
rss = iarandom.RNG(seed).duplicate(4)
alpha_expected = iap.Deterministic(0.2).draw_samples((nb_images,),
rss[0])
hthresh_expected = [None, None]
hthresh_expected[0] = iap.Choice(
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).draw_samples((nb_images,),
rss[1])
# TODO simplify this to rss[2].randint(5, 100+1)
# would currenlty be a bit more ugly, because DiscrUniform
# samples two values for a and b first from rss[2]
hthresh_expected[1] = iap.DiscreteUniform(5, 100).draw_samples(
(nb_images,), rss[2])
hthresh_expected = np.stack(hthresh_expected, axis=-1)
sobel_expected = iap.Choice([3, 5, 7]).draw_samples((nb_images,),
rss[3])
invalid = hthresh_expected[:, 0] > hthresh_expected[:, 1]
hthresh_expected[invalid, :] = hthresh_expected[invalid, :][:, [1, 0]]
assert hthresh_expected.shape == (nb_images, 2)
assert not np.any(hthresh_expected[:, 0] > hthresh_expected[:, 1])
assert np.allclose(alpha_samples, alpha_expected)
assert np.allclose(hthresh_samples, hthresh_expected)
assert np.allclose(sobel_samples, sobel_expected)
def test_alpha_1_lightness_is_stochastic_parameter(self):
aug = iaa.Sharpen(alpha=1.0, lightness=iap.Choice([1.0, 1.5]))
observed = aug.augment_image(self.base_img)
expected1 = self._compute_sharpened_base_img(1.0 * 1.0, self.m)
expected2 = self._compute_sharpened_base_img(1.0 * 1.5, self.m)
assert (np.allclose(observed, expected1)
or np.allclose(observed, expected2))
def example_unusual_distributions():
print("Example: Unusual Distributions")
from imgaug import augmenters as iaa
from imgaug import parameters as iap
images = np.random.randint(0, 255, (16, 128, 128, 3), dtype=np.uint8)
# Blur by a value sigma which is sampled from a uniform distribution
# of range 0.1 <= x < 3.0.
# The convenience shortcut for this is: iaa.GaussianBlur((0.1, 3.0))
blurer = iaa.GaussianBlur(iap.Uniform(0.1, 3.0))
images_aug = blurer.augment_images(images)
# Blur by a value sigma which is sampled from a normal distribution N(1.0, 0.1),
# i.e. sample a value that is usually around 1.0.
# Clip the resulting value so that it never gets below 0.1 or above 3.0.
blurer = iaa.GaussianBlur(iap.Clip(iap.Normal(1.0, 0.1), 0.1, 3.0))
images_aug = blurer.augment_images(images)
# Same again, but this time the mean of the normal distribution is not constant,
# but comes itself from a uniform distribution between 0.5 and 1.5.
blurer = iaa.GaussianBlur(
iap.Clip(iap.Normal(iap.Uniform(0.5, 1.5), 0.1), 0.1, 3.0))
images_aug = blurer.augment_images(images)
# Use for sigma one of exactly three allowed values: 0.5, 1.0 or 1.5.
blurer = iaa.GaussianBlur(iap.Choice([0.5, 1.0, 1.5]))
images_aug = blurer.augment_images(images)
# Sample sigma from a discrete uniform distribution of range 1 <= sigma <= 5,
# i.e. sigma will have any of the following values: 1, 2, 3, 4, 5.
blurer = iaa.GaussianBlur(iap.DiscreteUniform(1, 5))
images_aug = blurer.augment_images(images)
def test_p_replace_stochastic_parameter_n_segments_2(self):
aug = iaa.Superpixels(
p_replace=iap.Binomial(iap.Choice([0.0, 1.0])), n_segments=2)
observed = aug.augment_image(self.base_img)
assert (
np.allclose(observed, self.base_img)
or self._array_equals_tolerant(
observed, self.base_img_superpixels, 2)
)
def test_alpha_is_stochastic_parameter(self):
aug = iaa.Sharpen(alpha=iap.Choice([0.5, 1.0]), lightness=1)
observed = aug.augment_image(self.base_img)
expected1 = self._compute_sharpened_base_img(
0.5 * 1, 0.5 * self.m_noop + 0.5 * self.m)
expected2 = self._compute_sharpened_base_img(
1.0 * 1, 0.0 * self.m_noop + 1.0 * self.m)
assert (np.allclose(observed, expected1)
or np.allclose(observed, expected2))
def test___init___stochastic_parameters(self):
colorizer = iaa.RandomColorsBinaryImageColorizer(
color_true=iap.DiscreteUniform(0, 100),
color_false=iap.Choice([200, 201, 202]))
assert isinstance(colorizer.color_true, iap.DiscreteUniform)
assert isinstance(colorizer.color_false, iap.Choice)
assert colorizer.color_true.a.value == 0
assert colorizer.color_true.b.value == 100
assert colorizer.color_false.a[0] == 200
assert colorizer.color_false.a[1] == 201
assert colorizer.color_false.a[2] == 202
def test_alpha_stochastic_parameter_strength_1(self):
aug = iaa.Emboss(alpha=iap.Choice([0.5, 1.0]), strength=1)
observed = aug.augment_image(self.base_img)
expected1 = self._compute_embossed_base_img(self.base_img,
alpha=0.5,
strength=1)
expected2 = self._compute_embossed_base_img(self.base_img,
alpha=1.0,
strength=1)
assert (self._allclose(observed, expected1)
or self._allclose(observed, expected2))
def test_alpha_1_strength_stochastic_parameter(self):
aug = iaa.Emboss(alpha=1.0, strength=iap.Choice([1.0, 2.5]))
observed = aug.augment_image(self.base_img)
expected1 = self._compute_embossed_base_img(self.base_img,
alpha=1.0,
strength=1.0)
expected2 = self._compute_embossed_base_img(self.base_img,
alpha=1.0,
strength=2.5)
assert (self._allclose(observed, expected1)
or self._allclose(observed, expected2))
def test_images_p_is_stochastic_parameter(self):
aug = self.create_aug(p=iap.Choice([0, 1], p=[0.7, 0.3]))
seen = [0, 0]
for _ in sm.xrange(1000):
observed = aug.augment_image(self.image)
if np.array_equal(observed, self.image):
seen[0] += 1
elif np.array_equal(observed, self.image_flipped):
seen[1] += 1
else:
assert False
assert np.allclose(seen, [700, 300], rtol=0, atol=75)
def create_augmneter():
"""
Augmentator declaration.
Returns
-------
iaa.Sequential
imgaug-augmenter.
"""
def random_size_crop(src):
h, w, _ = src.shape
src_area = h * w
area = (0.15, 0.25)
ratio = (3.0 / 4.0, 4.0 / 3.0)
for _ in range(10):
target_area = random.uniform(area[0], area[1]) * src_area
new_ratio = random.uniform(*ratio)
new_w = int(round(np.sqrt(target_area * new_ratio)))
new_h = int(round(np.sqrt(target_area / new_ratio)))
if random.random() < 0.5:
new_h, new_w = new_w, new_h
if new_w <= w and new_h <= h:
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
return src[y0:(y0 + new_h), x0:(x0 + new_w)]
new_w = int(round(0.3 * w))
new_h = int(round(0.3 * h))
x0 = int((w - new_w) / 2)
y0 = int((h - new_h) / 2)
return src[y0:(y0 + new_h), x0:(x0 + new_w)]
def rand_crop(images, random_state, parents, hooks):
images[0] = random_size_crop(images[0])
return images
return iaa.Sequential(children=[
# iaa.Affine(
# rotate=(-25.0, 25.0),
# order=iap.Choice([0, 1, 3], p=[0.15, 0.80, 0.05]),
# mode="edge"),
iaa.OneOf(children=[
# iaa.Rot90((1, 3), keep_size=False),
# iaa.Grayscale(alpha=1.0),
# iaa.AddToHueAndSaturation((25, 255)),
# iaa.Lambda(func_images=rand_crop)
iaa.Affine(rotate=(85.0, 275.0),
order=iap.Choice([0, 1, 3], p=[0.15, 0.80, 0.05]),
mode="edge"),
])
])
def cpu_augment(self, imgs, boxes):
# for bx in boxes:
# self.assert_bboxes(bx)
ia_bb = []
for n in range(len(imgs)):
c_boxes = []
for i in boxes[n]:
try:
c_boxes.append(
ia.BoundingBox(x1=i[0], y1=i[1], x2=i[2], y2=i[3]))
except AssertionError:
print('Assertion Error: ', i)
ia_bb.append(ia.BoundingBoxesOnImage(c_boxes, shape=imgs[n].shape))
seq = iaa.Sequential([
iaa.Sometimes(0.5, iaa.AddElementwise((-20, 20), per_channel=1)),
iaa.Sometimes(0.5,
iaa.AdditiveGaussianNoise(scale=(0, 0.10 * 255))),
iaa.Sometimes(0.5, iaa.Multiply((0.75, 1.25), per_channel=1)),
iaa.Sometimes(0.5, iaa.MultiplyElementwise((0.75, 1.25))),
iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=(0.0, 1.0))),
iaa.Fliplr(0.5),
iaa.Sometimes(
0.95,
iaa.SomeOf(1, [
iaa.CoarseDropout(p=(0.10, 0.25),
size_percent=(0.25, 0.5)),
iaa.CoarseDropout(p=(0.0, 0.15), size_percent=(0.1, 0.25)),
iaa.Dropout(p=(0, 0.25)),
iaa.CoarseSaltAndPepper(p=(0, 0.25),
size_percent=(0.1, 0.2))
])),
iaa.Affine(scale=iap.Choice(
[iap.Uniform(0.4, 1), iap.Uniform(1, 3)]),
rotate=(-180, 180))
])
seq_det = seq.to_deterministic()
image_b_aug = seq_det.augment_images(imgs)
bbs_b_aug = seq_det.augment_bounding_boxes(ia_bb)
bbs_b_aug = [
b.remove_out_of_image().cut_out_of_image() for b in bbs_b_aug
]
return image_b_aug, [
np.array([self.bbox_r(j) for j in i.bounding_boxes])
for i in bbs_b_aug
]
def chapter_parameters_introduction():
ia.seed(1)
from imgaug import augmenters as iaa
from imgaug import parameters as iap
seq = iaa.Sequential([
iaa.GaussianBlur(sigma=iap.Uniform(0.0, 1.0)),
iaa.ContrastNormalization(
iap.Choice([1.0, 1.5, 3.0], p=[0.5, 0.3, 0.2])),
iaa.Affine(rotate=iap.Normal(0.0, 30),
translate_px=iap.RandomSign(iap.Poisson(3))),
iaa.AddElementwise(iap.Discretize(
(iap.Beta(0.5, 0.5) * 2 - 1.0) * 64)),
iaa.Multiply(iap.Positive(iap.Normal(0.0, 0.1)) + 1.0)
])
images = np.array([ia.quokka_square(size=(128, 128)) for i in range(16)])
images_aug = [seq.augment_image(images[i]) for i in range(len(images))]
save("parameters", "introduction.jpg", grid(images_aug, cols=4, rows=4))
def __init__(self):
super(ImgAugTransform, self).__init__()
from imgaug import augmenters as iaa
from imgaug import parameters as iap
self.seq = iaa.Sequential(children=[
iaa.Sequential(children=[
iaa.Affine(rotate=(-25, 25),
order=iap.Choice([0, 1, 3], p=[0.15, 0.80, 0.05]),
mode="edge",
name="Affine"),
iaa.Sequential(children=[
iaa.Sometimes(p=0.5,
then_list=iaa.AdditiveGaussianNoise(
loc=0,
scale=(0.0, 10.0),
per_channel=0.5,
name="AdditiveGaussianNoise")),
iaa.Sometimes(
p=0.1,
then_list=iaa.SaltAndPepper(
p=(
0,
0.01), per_channel=0.5, name="SaltAndPepper"))
],
random_order=True,
name="Noise"),
iaa.OneOf(children=[
iaa.Sometimes(p=0.05,
then_list=iaa.MedianBlur(k=3,
name="MedianBlur")),
iaa.Sometimes(p=0.05,
then_list=iaa.AverageBlur(
k=(2, 4), name="AverageBlur")),
iaa.Sometimes(p=0.5,
then_list=iaa.GaussianBlur(
sigma=(0.0, 2.0), name="GaussianBlur"))
],
name="Blur"),
],
random_order=True,
name="MainProcess")
])
def make_synthetic_prev_mask_complex_mask_augmenter(crop_size):
h, w = crop_size
return iaa.Sequential([
iaa.Sometimes(0.5, iaa.Lambda(func_segmentation_maps=choose_random_objects_mask_augmenter)),
iaa.Lambda(func_segmentation_maps=morph_close_mask_augmenter),
iaa.Sometimes(0.3,
# failed mask
iaa.OneOf([
iaa.TotalDropout(1.0), # fill image
iaa.Sequential([ # fail mask
iaa.OneOf([
iaa.Lambda(func_segmentation_maps=make_morph_operation_mask_augmenter(cv2.erode, min_coef=0.2, max_coef=0.5)),
iaa.Lambda(func_segmentation_maps=make_morph_operation_mask_augmenter(cv2.dilate, min_coef=0.2, max_coef=0.5)),
]),
iaa.Affine(translate_percent=iap.Choice([iap.Uniform(-0.5, -0.2), iap.Uniform(0.2, 0.5)]))
])
]),
# normal mask
iaa.Sequential([
iaa.Sometimes(0.1, iaa.OneOf([
iaa.Lambda(func_segmentation_maps=make_morph_operation_mask_augmenter(cv2.erode)), # smaller mask
iaa.Lambda(func_segmentation_maps=make_morph_operation_mask_augmenter(cv2.dilate)), # larger mask
])),
iaa.Sometimes(1.0, iaa.Affine(
scale=iap.Normal(loc=1, scale=0.02),
translate_percent=iap.Normal(loc=0, scale=0.03),
shear=iap.Normal(loc=0, scale=1),
backend='cv2'
)),
iaa.Sometimes(0.1,
iaa.ElasticTransformation(alpha=2000, sigma=50)
),
iaa.Sometimes(0.1,
iaa.PiecewiseAffine()
)
])
)
], random_order=False)
def stochastic():
return iaa.Sequential([
iaa.GaussianBlur(
sigma=iap.Uniform(0.0, 1.0)
),
iaa.ContrastNormalization(
iap.Choice(
[1.0, 1.5, 3.0],
p=[0.5, 0.3, 0.2]
)
),
iaa.Affine(
rotate=iap.Normal(0.0, 30),
translate_px=iap.RandomSign(iap.Poisson(3))
),
iaa.AddElementwise(
iap.Discretize(
(iap.Beta(0.5, 0.5) * 2 - 1.0) * 64
)
),
iaa.Multiply(
iap.Positive(iap.Normal(0.0, 0.1)) + 1.0
)
])
def chapter_parameters_continuous():
ia.seed(1)
# -----------------------
# Normal
# -----------------------
from imgaug import parameters as iap
params = [
iap.Normal(0, 1),
iap.Normal(5, 3),
iap.Normal(iap.Choice([-3, 3]), 1),
iap.Normal(iap.Uniform(-3, 3), 1)
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_normal.jpg", gridarr)
# -----------------------
# Laplace
# -----------------------
from imgaug import parameters as iap
params = [
iap.Laplace(0, 1),
iap.Laplace(5, 3),
iap.Laplace(iap.Choice([-3, 3]), 1),
iap.Laplace(iap.Uniform(-3, 3), 1)
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_laplace.jpg", gridarr)
# -----------------------
# ChiSquare
# -----------------------
from imgaug import parameters as iap
params = [
iap.ChiSquare(1),
iap.ChiSquare(3),
iap.ChiSquare(iap.Choice([1, 5])),
iap.RandomSign(iap.ChiSquare(3))
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_chisquare.jpg", gridarr)
# -----------------------
# Weibull
# -----------------------
from imgaug import parameters as iap
params = [
iap.Weibull(0.5),
iap.Weibull(1),
iap.Weibull(1.5),
iap.Weibull((0.5, 1.5))
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_weibull.jpg", gridarr)
# -----------------------
# Uniform
# -----------------------
from imgaug import parameters as iap
params = [
iap.Uniform(0, 1),
iap.Uniform(iap.Normal(-3, 1), iap.Normal(3, 1)),
iap.Uniform([-1, 0], 1),
iap.Uniform((-1, 0), 1)
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_uniform.jpg", gridarr)
# -----------------------
# Beta
# -----------------------
from imgaug import parameters as iap
params = [
iap.Beta(0.5, 0.5),
iap.Beta(2.0, 2.0),
iap.Beta(1.0, 0.5),
iap.Beta(0.5, 1.0)
]
gridarr = draw_distributions_grid(params)
save("parameters", "continuous_beta.jpg", gridarr)
def test_Sharpen():
reseed()
def _compute_sharpened_base_img(lightness, m):
base_img_sharpened = np.zeros((3, 3), dtype=np.float32)
k = 1
# note that cv2 uses reflection padding by default
base_img_sharpened[0, 0] = (m[1, 1] + lightness) / k * 10 + 4 * (
m[0, 0] / k) * 10 + 4 * (m[2, 2] / k) * 20
base_img_sharpened[0, 2] = base_img_sharpened[0, 0]
base_img_sharpened[2, 0] = base_img_sharpened[0, 0]
base_img_sharpened[2, 2] = base_img_sharpened[0, 0]
base_img_sharpened[0, 1] = (m[1, 1] + lightness) / k * 10 + 6 * (
m[0, 1] / k) * 10 + 2 * (m[2, 2] / k) * 20
base_img_sharpened[1, 0] = base_img_sharpened[0, 1]
base_img_sharpened[1, 2] = base_img_sharpened[0, 1]
base_img_sharpened[2, 1] = base_img_sharpened[0, 1]
base_img_sharpened[
1, 1] = (m[1, 1] + lightness) / k * 20 + 8 * (m[0, 1] / k) * 10
base_img_sharpened = np.clip(base_img_sharpened, 0,
255).astype(np.uint8)
return base_img_sharpened
base_img = [[10, 10, 10], [10, 20, 10], [10, 10, 10]]
base_img = np.uint8(base_img)
m = np.float32([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])
m_noop = np.float32([[0, 0, 0], [0, 1, 0], [0, 0, 0]])
base_img_sharpened = _compute_sharpened_base_img(1, m)
aug = iaa.Sharpen(alpha=0, lightness=1)
observed = aug.augment_image(base_img)
expected = base_img
assert np.allclose(observed, expected)
aug = iaa.Sharpen(alpha=1.0, lightness=1)
observed = aug.augment_image(base_img)
expected = base_img_sharpened
assert np.allclose(observed, expected)
aug = iaa.Sharpen(alpha=0.5, lightness=1)
observed = aug.augment_image(base_img)
expected = _compute_sharpened_base_img(0.5 * 1, 0.5 * m_noop + 0.5 * m)
assert np.allclose(observed, expected.astype(np.uint8))
aug = iaa.Sharpen(alpha=0.75, lightness=1)
observed = aug.augment_image(base_img)
expected = _compute_sharpened_base_img(0.75 * 1, 0.25 * m_noop + 0.75 * m)
assert np.allclose(observed, expected)
aug = iaa.Sharpen(alpha=iap.Choice([0.5, 1.0]), lightness=1)
observed = aug.augment_image(base_img)
expected1 = _compute_sharpened_base_img(0.5 * 1, m)
expected2 = _compute_sharpened_base_img(1.0 * 1, m)
assert np.allclose(observed, expected1) or np.allclose(observed, expected2)
got_exception = False
try:
_ = iaa.Sharpen(alpha="test", lightness=1)
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
aug = iaa.Sharpen(alpha=1.0, lightness=2)
observed = aug.augment_image(base_img)
expected = _compute_sharpened_base_img(1.0 * 2, m)
assert np.allclose(observed, expected)
aug = iaa.Sharpen(alpha=1.0, lightness=3)
observed = aug.augment_image(base_img)
expected = _compute_sharpened_base_img(1.0 * 3, m)
assert np.allclose(observed, expected)
aug = iaa.Sharpen(alpha=1.0, lightness=iap.Choice([1.0, 1.5]))
observed = aug.augment_image(base_img)
expected1 = _compute_sharpened_base_img(1.0 * 1.0, m)
expected2 = _compute_sharpened_base_img(1.0 * 1.5, m)
assert np.allclose(observed, expected1) or np.allclose(observed, expected2)
got_exception = False
try:
_ = iaa.Sharpen(alpha=1.0, lightness="test")
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
# this part doesnt really work so far due to nonlinearities resulting from clipping to uint8
"""
def chapter_parameters_special():
ia.seed(1)
# -----------------------
# Choice
# -----------------------
from imgaug import parameters as iap
params = [
iap.Choice([0, 1, 2]),
iap.Choice([0, 1, 2], p=[0.15, 0.5, 0.35]),
iap.Choice([iap.Normal(-3, 1), iap.Normal(3, 1)]),
iap.Choice([iap.Normal(-3, 1), iap.Poisson(3)])
]
gridarr = draw_distributions_grid(params)
save("parameters", "special_choice.jpg", gridarr)
# -----------------------
# Clip
# -----------------------
from imgaug import parameters as iap
params = [
iap.Clip(iap.Normal(0, 1), -2, 2),
iap.Clip(iap.Normal(0, 1), -2, None)
]
gridarr = draw_distributions_grid(params, rows=1)
save("parameters", "special_clip.jpg", gridarr)
# -----------------------
# Discretize
# -----------------------
from imgaug import parameters as iap
params = [
iap.Discretize(iap.Normal(0, 1)),
iap.Discretize(iap.ChiSquare(3))
]
gridarr = draw_distributions_grid(params, rows=1)
save("parameters", "special_discretize.jpg", gridarr)
# -----------------------
# Absolute
# -----------------------
from imgaug import parameters as iap
params = [iap.Absolute(iap.Normal(0, 1)), iap.Absolute(iap.Laplace(0, 1))]
gridarr = draw_distributions_grid(params, rows=1)
save("parameters", "special_absolute.jpg", gridarr)
# -----------------------
# RandomSign
# -----------------------
from imgaug import parameters as iap
params = [
iap.ChiSquare(3),
iap.RandomSign(iap.ChiSquare(3)),
iap.RandomSign(iap.ChiSquare(3), p_positive=0.75),
iap.RandomSign(iap.ChiSquare(3), p_positive=0.9)
]
gridarr = draw_distributions_grid(params)
save("parameters", "special_randomsign.jpg", gridarr)
# -----------------------
# ForceSign
# -----------------------
from imgaug import parameters as iap
params = [
iap.ForceSign(iap.Normal(0, 1), positive=True),
iap.ChiSquare(3) - 3.0,
iap.ForceSign(iap.ChiSquare(3) - 3.0, positive=True, mode="invert"),
iap.ForceSign(iap.ChiSquare(3) - 3.0, positive=True, mode="reroll")
]
gridarr = draw_distributions_grid(params)
save("parameters", "special_forcesign.jpg", gridarr)
def __init__(self):
super(ImgAugTransform, self).__init__()
from imgaug import augmenters as iaa
from imgaug import parameters as iap
self.seq = iaa.Sequential(children=[
iaa.Sequential(children=[
iaa.Sequential(children=[
iaa.OneOf(children=[
iaa.Sometimes(
p=0.95,
then_list=iaa.Affine(scale={
"x": (0.9, 1.1),
"y": (0.9, 1.1)
},
translate_percent={
"x": (-0.05, 0.05),
"y": (-0.05, 0.05)
},
rotate=(-30, 30),
shear=(-15, 15),
order=iap.Choice(
[0, 1, 3],
p=[0.15, 0.80, 0.05]),
mode="reflect",
name="Affine")),
iaa.Sometimes(p=0.05,
then_list=iaa.PerspectiveTransform(
scale=(0.01, 0.1)))
],
name="Blur"),
iaa.Sometimes(p=0.01,
then_list=iaa.PiecewiseAffine(
scale=(0.0, 0.01),
nb_rows=(4, 20),
nb_cols=(4, 20),
order=iap.Choice([0, 1, 3],
p=[0.15, 0.80, 0.05]),
mode="reflect",
name="PiecewiseAffine"))
],
random_order=True,
name="GeomTransform"),
iaa.Sequential(children=[
iaa.Sometimes(p=0.75,
then_list=iaa.Add(value=(-10, 10),
per_channel=0.5,
name="Brightness")),
iaa.Sometimes(p=0.05,
then_list=iaa.Emboss(alpha=(0.0, 0.5),
strength=(0.5, 1.2),
name="Emboss")),
iaa.Sometimes(p=0.1,
then_list=iaa.Sharpen(alpha=(0.0, 0.5),
lightness=(0.5, 1.2),
name="Sharpen")),
iaa.Sometimes(p=0.25,
then_list=iaa.ContrastNormalization(
alpha=(0.5, 1.5),
per_channel=0.5,
name="ContrastNormalization"))
],
random_order=True,
name="ColorTransform"),
iaa.Sequential(children=[
iaa.Sometimes(p=0.5,
then_list=iaa.AdditiveGaussianNoise(
loc=0,
scale=(0.0, 10.0),
per_channel=0.5,
name="AdditiveGaussianNoise")),
iaa.Sometimes(p=0.1,
then_list=iaa.SaltAndPepper(
p=(0, 0.001),
per_channel=0.5,
name="SaltAndPepper"))
],
random_order=True,
name="Noise"),
iaa.OneOf(children=[
iaa.Sometimes(p=0.05,
then_list=iaa.MedianBlur(k=3,
name="MedianBlur")),
iaa.Sometimes(p=0.05,
then_list=iaa.AverageBlur(
k=(2, 4), name="AverageBlur")),
iaa.Sometimes(p=0.5,
then_list=iaa.GaussianBlur(
sigma=(0.0, 2.0), name="GaussianBlur"))
],
name="Blur"),
],
random_order=True,
name="MainProcess")
])
def chapter_parameters_arithmetic():
ia.seed(1)
# -----------------------
# Add
# -----------------------
from imgaug import parameters as iap
params = [
iap.Uniform(0, 1) + 1, # identical to: Add(Uniform(0, 1), 1)
iap.Add(iap.Uniform(0, 1), iap.Choice([0, 1], p=[0.7, 0.3])),
iap.Normal(0, 1) + iap.Uniform(-5.5, -5) + iap.Uniform(5, 5.5),
iap.Normal(0, 1) + iap.Uniform(-7, 5) + iap.Poisson(3),
iap.Add(iap.Normal(-3, 1), iap.Normal(3, 1)),
iap.Add(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True)
]
gridarr = draw_distributions_grid(
params,
rows=2,
sample_sizes=[ # (iterations, samples per iteration)
(1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000),
(1, 100000), (1, 100000)
])
save("parameters", "arithmetic_add.jpg", gridarr)
# -----------------------
# Multiply
# -----------------------
from imgaug import parameters as iap
params = [
iap.Uniform(0, 1) * 2, # identical to: Multiply(Uniform(0, 1), 2)
iap.Multiply(iap.Uniform(0, 1), iap.Choice([0, 1], p=[0.7, 0.3])),
(iap.Normal(0, 1) * iap.Uniform(-5.5, -5)) * iap.Uniform(5, 5.5),
(iap.Normal(0, 1) * iap.Uniform(-7, 5)) * iap.Poisson(3),
iap.Multiply(iap.Normal(-3, 1), iap.Normal(3, 1)),
iap.Multiply(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True)
]
gridarr = draw_distributions_grid(
params,
rows=2,
sample_sizes=[ # (iterations, samples per iteration)
(1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000),
(1, 100000), (1, 100000)
])
save("parameters", "arithmetic_multiply.jpg", gridarr)
# -----------------------
# Divide
# -----------------------
from imgaug import parameters as iap
params = [
iap.Uniform(0, 1) / 2, # identical to: Divide(Uniform(0, 1), 2)
iap.Divide(iap.Uniform(0, 1), iap.Choice([0, 2], p=[0.7, 0.3])),
(iap.Normal(0, 1) / iap.Uniform(-5.5, -5)) / iap.Uniform(5, 5.5),
(iap.Normal(0, 1) * iap.Uniform(-7, 5)) / iap.Poisson(3),
iap.Divide(iap.Normal(-3, 1), iap.Normal(3, 1)),
iap.Divide(iap.Normal(-3, 1), iap.Normal(3, 1), elementwise=True)
]
gridarr = draw_distributions_grid(
params,
rows=2,
sample_sizes=[ # (iterations, samples per iteration)
(1000, 1000), (1000, 1000), (1000, 1000), (1000, 1000),
(1, 100000), (1, 100000)
])
save("parameters", "arithmetic_divide.jpg", gridarr)
# -----------------------
# Power
# -----------------------
from imgaug import parameters as iap
params = [
iap.Uniform(0, 1)**2, # identical to: Power(Uniform(0, 1), 2)
iap.Clip(iap.Uniform(-1, 1)**iap.Normal(0, 1), -4, 4)
]
gridarr = draw_distributions_grid(params, rows=1)
save("parameters", "arithmetic_power.jpg", gridarr)
def black_and_white_aug():
alpha_seconds = iaa.OneOf([
iaa.Affine(rotate=(-3, 3)),
iaa.Affine(translate_percent={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(scale={
"x": (0.95, 1.05),
"y": (0.95, 1.05)
}),
iaa.Affine(shear=(-2, 2)),
iaa.CoarseDropout(p=0.1, size_percent=(0.08, 0.02)),
])
first_set = iaa.OneOf([
iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True),
iaa.EdgeDetect((0.1, 1)),
])
second_set = iaa.OneOf([
iaa.AddToHueAndSaturation((-40, 40)),
iaa.ContrastNormalization((0.5, 2.0), per_channel=True)
])
color_aug = iaa.Sequential(
[
# Original Image Domain ==================================================
# Geometric Rigid
iaa.Fliplr(0.5),
iaa.OneOf([
iaa.Noop(),
iaa.Affine(rotate=90),
iaa.Affine(rotate=180),
iaa.Affine(rotate=270),
]),
iaa.OneOf([
iaa.Noop(),
iaa.Crop(percent=(0, 0.1)), # Random Crops
iaa.PerspectiveTransform(scale=(0.05, 0.15)),
]),
# Affine
sometimes(
iaa.PiecewiseAffine(
scale=(0.01, 0.07), nb_rows=(3, 6), nb_cols=(3, 6))),
fewtimes(
iaa.Affine(scale={
"x": (0.8, 1.2),
"y": (0.8, 1.2)
},
translate_percent={
"x": (-0.2, 0.2),
"y": (-0.2, 0.2)
},
rotate=(-45, 45),
shear=(-16, 16),
order=[0, 1],
cval=0)),
# Transformations outside Image domain ==============================================
# COLOR, CONTRAST, HUE
iaa.Invert(0.5, name='Invert'),
fewtimes(iaa.Add((-10, 10), per_channel=0.5, name='Add')),
fewtimes(
iaa.AddToHueAndSaturation(
(-40, 40), per_channel=0.5, name='AddToHueAndSaturation')),
# Intensity / contrast
fewtimes(
iaa.ContrastNormalization(
(0.8, 1.1), name='ContrastNormalization')),
# Add to hue and saturation
fewtimes(
iaa.Multiply(
(0.5, 1.5), per_channel=0.5, name='HueAndSaturation')),
# Noise ===========================================================================
fewtimes(
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.15 * 255),
per_channel=0.5,
name='AdditiveGaussianNoise')),
fewtimes(
iaa.Alpha(factor=(0.5, 1),
first=iaa.ContrastNormalization(
(0.5, 2.0), per_channel=True),
second=alpha_seconds,
per_channel=0.5,
name='AlphaNoise'), ),
fewtimes(
iaa.SimplexNoiseAlpha(first=first_set,
second=second_set,
per_channel=0.5,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='SimplexNoiseAlpha'), ),
fewtimes(
iaa.FrequencyNoiseAlpha(first=first_set,
second=second_set,
per_channel=0.5,
aggregation_method="max",
sigmoid=False,
upscale_method='cubic',
size_px_max=(2, 12),
name='FrequencyNoiseAlpha'), ),
# Blur
fewtimes(
iaa.OneOf([
iaa.GaussianBlur((0, 3.0)),
iaa.AverageBlur(k=(2, 7)),
iaa.MedianBlur(k=(3, 11)),
iaa.BilateralBlur(d=(3, 10),
sigma_color=(10, 250),
sigma_space=(10, 250))
],
name='Blur')),
# Regularization ======================================================================
unlikely(
iaa.OneOf([
iaa.Dropout((0.01, 0.1), per_channel=0.5, name='Dropout'),
iaa.CoarseDropout((0.03, 0.15),
size_percent=(0.02, 0.05),
per_channel=0.5,
name='CoarseDropout'),
], )),
],
random_order=True)
seq = iaa.Sequential(
[
iaa.Sequential(
[
# Texture
rarely(
iaa.Superpixels(p_replace=(0.3, 1.0),
n_segments=(500, 1000),
name='Superpixels')),
rarely(
iaa.Sharpen(alpha=(0, 0.5),
lightness=(0.75, 1.0),
name='Sharpen')),
rarely(
iaa.Emboss(
alpha=(0, 1.0), strength=(0, 1.0), name='Emboss')),
rarely(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.5)),
iaa.DirectedEdgeDetect(alpha=(0, 0.5),
direction=(0.0, 1.0)),
],
name='EdgeDetect')),
rarely(
iaa.ElasticTransformation(
alpha=(0.5, 3.5),
sigma=0.25,
name='ElasticTransformation')),
],
random_order=True),
color_aug,
iaa.Grayscale(alpha=1.0, name='Grayscale')
],
random_order=False)
def activator_masks(images, augmenter, parents, default):
if 'Unnamed' not in augmenter.name:
return False
else:
return default
hooks_masks = ia.HooksImages(activator=activator_masks)
return seq, hooks_masks
def test_Alpha():
reseed()
base_img = np.zeros((3, 3, 1), dtype=np.uint8)
heatmaps_arr = np.float32([[0.0, 0.0, 1.0], [0.0, 0.0, 1.0],
[0.0, 1.0, 1.0]])
heatmaps_arr_r1 = np.float32([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0],
[0.0, 0.0, 1.0]])
heatmaps_arr_l1 = np.float32([[0.0, 1.0, 0.0], [0.0, 1.0, 0.0],
[1.0, 1.0, 0.0]])
heatmaps = ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))
aug = iaa.Alpha(1, iaa.Add(10), iaa.Add(20))
observed = aug.augment_image(base_img)
expected = np.round(base_img + 10).astype(np.uint8)
assert np.allclose(observed, expected)
for per_channel in [False, True]:
aug = iaa.Alpha(1,
iaa.Affine(translate_px={"x": 1}),
iaa.Affine(translate_px={"x": -1}),
per_channel=per_channel)
observed = aug.augment_heatmaps([heatmaps])[0]
assert observed.shape == heatmaps.shape
assert 0 - 1e-6 < heatmaps.min_value < 0 + 1e-6
assert 1 - 1e-6 < heatmaps.max_value < 1 + 1e-6
assert np.allclose(observed.get_arr(), heatmaps_arr_r1)
aug = iaa.Alpha(0, iaa.Add(10), iaa.Add(20))
observed = aug.augment_image(base_img)
expected = np.round(base_img + 20).astype(np.uint8)
assert np.allclose(observed, expected)
for per_channel in [False, True]:
aug = iaa.Alpha(0,
iaa.Affine(translate_px={"x": 1}),
iaa.Affine(translate_px={"x": -1}),
per_channel=per_channel)
observed = aug.augment_heatmaps([heatmaps])[0]
assert observed.shape == heatmaps.shape
assert 0 - 1e-6 < heatmaps.min_value < 0 + 1e-6
assert 1 - 1e-6 < heatmaps.max_value < 1 + 1e-6
assert np.allclose(observed.get_arr(), heatmaps_arr_l1)
aug = iaa.Alpha(0.75, iaa.Add(10), iaa.Add(20))
observed = aug.augment_image(base_img)
expected = np.round(base_img + 0.75 * 10 + 0.25 * 20).astype(np.uint8)
assert np.allclose(observed, expected)
aug = iaa.Alpha(0.75, None, iaa.Add(20))
observed = aug.augment_image(base_img + 10)
expected = np.round(base_img + 0.75 * 10 + 0.25 * (10 + 20)).astype(
np.uint8)
assert np.allclose(observed, expected)
aug = iaa.Alpha(0.75, iaa.Add(10), None)
observed = aug.augment_image(base_img + 10)
expected = np.round(base_img + 0.75 * (10 + 10) + 0.25 * 10).astype(
np.uint8)
assert np.allclose(observed, expected)
base_img = np.zeros((1, 2, 1), dtype=np.uint8)
nb_iterations = 1000
aug = iaa.Alpha((0.0, 1.0), iaa.Add(10), iaa.Add(110))
values = []
for _ in sm.xrange(nb_iterations):
observed = aug.augment_image(base_img)
observed_val = np.round(np.average(observed)) - 10
values.append(observed_val / 100)
nb_bins = 5
hist, _ = np.histogram(values,
bins=nb_bins,
range=(0.0, 1.0),
density=False)
density_expected = 1.0 / nb_bins
density_tolerance = 0.05
for nb_samples in hist:
density = nb_samples / nb_iterations
assert density_expected - density_tolerance < density < density_expected + density_tolerance
# bad datatype for factor
got_exception = False
try:
_ = iaa.Alpha(False, iaa.Add(10), None)
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
# per_channel
aug = iaa.Alpha(1.0,
iaa.Add((0, 100), per_channel=True),
None,
per_channel=True)
observed = aug.augment_image(np.zeros((1, 1, 1000), dtype=np.uint8))
uq = np.unique(observed)
assert len(uq) > 1
assert np.max(observed) > 80
assert np.min(observed) < 20
aug = iaa.Alpha((0.0, 1.0), iaa.Add(100), None, per_channel=True)
observed = aug.augment_image(np.zeros((1, 1, 1000), dtype=np.uint8))
uq = np.unique(observed)
assert len(uq) > 1
assert np.max(observed) > 80
assert np.min(observed) < 20
aug = iaa.Alpha((0.0, 1.0), iaa.Add(100), iaa.Add(0), per_channel=0.5)
seen = [0, 0]
for _ in sm.xrange(200):
observed = aug.augment_image(np.zeros((1, 1, 100), dtype=np.uint8))
uq = np.unique(observed)
if len(uq) == 1:
seen[0] += 1
elif len(uq) > 1:
seen[1] += 1
else:
assert False
assert 100 - 50 < seen[0] < 100 + 50
assert 100 - 50 < seen[1] < 100 + 50
# bad datatype for per_channel
got_exception = False
try:
_ = iaa.Alpha(0.5, iaa.Add(10), None, per_channel="test")
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
# propagating
aug = iaa.Alpha(0.5, iaa.Add(100), iaa.Add(50), name="AlphaTest")
def propagator(images, augmenter, parents, default):
if "Alpha" in augmenter.name:
return False
else:
return default
hooks = ia.HooksImages(propagator=propagator)
image = np.zeros((10, 10, 3), dtype=np.uint8) + 1
observed = aug.augment_image(image, hooks=hooks)
assert np.array_equal(observed, image)
# -----
# keypoints
# -----
kps = [ia.Keypoint(x=5, y=10), ia.Keypoint(x=6, y=11)]
kpsoi = ia.KeypointsOnImage(kps, shape=(20, 20, 3))
aug = iaa.Alpha(1.0, iaa.Noop(), iaa.Affine(translate_px={"x": 1}))
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.deepcopy()
assert keypoints_equal([observed], [expected])
aug = iaa.Alpha(0.501, iaa.Noop(), iaa.Affine(translate_px={"x": 1}))
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.deepcopy()
assert keypoints_equal([observed], [expected])
aug = iaa.Alpha(0.0, iaa.Noop(), iaa.Affine(translate_px={"x": 1}))
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.shift(x=1)
assert keypoints_equal([observed], [expected])
aug = iaa.Alpha(0.499, iaa.Noop(), iaa.Affine(translate_px={"x": 1}))
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.shift(x=1)
assert keypoints_equal([observed], [expected])
# per_channel
aug = iaa.Alpha(1.0,
iaa.Noop(),
iaa.Affine(translate_px={"x": 1}),
per_channel=True)
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.deepcopy()
assert keypoints_equal([observed], [expected])
aug = iaa.Alpha(0.0,
iaa.Noop(),
iaa.Affine(translate_px={"x": 1}),
per_channel=True)
observed = aug.augment_keypoints([kpsoi])[0]
expected = kpsoi.shift(x=1)
assert keypoints_equal([observed], [expected])
aug = iaa.Alpha(iap.Choice([0.49, 0.51]),
iaa.Noop(),
iaa.Affine(translate_px={"x": 1}),
per_channel=True)
expected_same = kpsoi.deepcopy()
expected_shifted = kpsoi.shift(x=1)
seen = [0, 0]
for _ in sm.xrange(200):
observed = aug.augment_keypoints([kpsoi])[0]
if keypoints_equal([observed], [expected_same]):
seen[0] += 1
elif keypoints_equal([observed], [expected_shifted]):
seen[1] += 1
else:
assert False
assert 100 - 50 < seen[0] < 100 + 50
assert 100 - 50 < seen[1] < 100 + 50
# propagating
aug = iaa.Alpha(0.0,
iaa.Affine(translate_px={"x": 1}),
iaa.Affine(translate_px={"y": 1}),
name="AlphaTest")
def propagator(kpsoi_to_aug, augmenter, parents, default):
if "Alpha" in augmenter.name:
return False
else:
return default
hooks = ia.HooksKeypoints(propagator=propagator)
observed = aug.augment_keypoints([kpsoi], hooks=hooks)[0]
assert keypoints_equal([observed], [kpsoi])
# -----
# get_parameters()
# -----
first = iaa.Noop()
second = iaa.Sequential([iaa.Add(1)])
aug = iaa.Alpha(0.65, first, second, per_channel=1)
params = aug.get_parameters()
assert isinstance(params[0], iap.Deterministic)
assert isinstance(params[1], iap.Deterministic)
assert 0.65 - 1e-6 < params[0].value < 0.65 + 1e-6
assert params[1].value == 1
# -----
# get_children_lists()
# -----
first = iaa.Noop()
second = iaa.Sequential([iaa.Add(1)])
aug = iaa.Alpha(0.65, first, second, per_channel=1)
children_lsts = aug.get_children_lists()
assert len(children_lsts) == 2
assert ia.is_iterable([lst for lst in children_lsts])
assert first in children_lsts[0]
assert second == children_lsts[1]
def data_aug(img, bboxs=None, keypoints=None):
'''
:param img: 需要进行数据增强的图像
:param bboxs: list, [ [x1, y1, x2, y2], ..., [xn1, yn1, xn2, yn2] ]
:param keypoints: 关键点, COCO format or Ai-challenger format, list of list, [ [num_joints x 3], [num_joints x 3], ..., ]
:return:
'''
is_flip = [random.randint(0, 1), random.randint(0, 1)]
seq = iaa.Sequential([
iaa.Multiply((0.7, 1.5)),
iaa.Grayscale(iap.Choice(a=[0, 1], p=[0.8, 0.2]),
from_colorspace='BGR'),
iaa.Fliplr(is_flip[0]),
iaa.Flipud(is_flip[1]),
iaa.Affine(rotate=(-15, 15), scale=(0.8, 1.2), mode='constant'),
])
seq_det = seq.to_deterministic()
bbs = None
kps = None
if bboxs is not None:
assert type(bboxs) == type([])
bbs = ia.BoundingBoxesOnImage([], shape=img.shape)
for box in bboxs:
bbs.bounding_boxes.append(
ia.BoundingBox(x1=box[0], y1=box[1], x2=box[2], y2=box[3]))
if keypoints is not None:
kps = ia.KeypointsOnImage([], shape=img.shape)
assert type(keypoints) == type([])
for single_person_keypoints in keypoints:
for i in range(14):
joint = single_person_keypoints[i * 3:i * 3 + 3]
kps.keypoints.append(ia.Keypoint(x=joint[0], y=joint[1]))
img_aug = seq_det.augment_image(img)
if bbs is not None:
bbs_aug = seq_det.augment_bounding_boxes(bbs)
bboxs = []
for i in range(len(bbs_aug.bounding_boxes)):
box_aug = bbs_aug.bounding_boxes[i]
box = [box_aug.x1, box_aug.y1, box_aug.x2, box_aug.y2]
bboxs.append(box)
if kps is not None:
kps_aug = seq_det.augment_keypoints(kps)
kps_ori = copy.copy(keypoints)
kps_ori = np.reshape(np.asarray(kps_ori), newshape=(-1, 14, 3))
joint_nums = 14
keypoints = []
for i in range(len(kps_aug.keypoints)):
point = kps_aug.keypoints[i]
keypoints.append([point.x, point.y, 1])
# single_keypoints.append([point.x, point.y, 1])
# if len(single_keypoints) == joint_nums:
# keypoints.append(single_keypoints)
# single_keypoints = []
keypoints = np.reshape(np.asarray(keypoints), newshape=(-1, 14, 3))
# keep ori keypoint visiable attribute
for i in range(kps_ori.shape[0]):
for joint in range(kps_ori.shape[1]):
keypoints[i][joint][2] = kps_ori[i][joint][2]
# if flip, change keypoint order (left <-> right)
# ai-format: [ 0-right_shoulder, 1-right_elbow, 2-right_wrist,
# 3-left_shoulder, 4-left_elbow, 5-left_wrist,
# 6-right_hip, 7-right_knee, 8-right_ankle,
# 9-left_hip, 10-left_knee, 11-left_ankle,
# 12-head, 13-neck ]
# coco-format: TODO add coco-foramt change index
change_index = [[0, 3], [1, 4], [2, 5], [6, 9], [7, 10], [8, 11]]
for flip in is_flip:
if flip:
for i in range(kps_ori.shape[0]):
for index in change_index:
right_point = copy.copy(keypoints[i][index[0]])
keypoints[i][index[0]] = keypoints[i][index[1]]
keypoints[i][index[1]] = right_point
keypoints = [
list(np.reshape(single_person_keypoints, (-1, )))
for single_person_keypoints in keypoints
]
# test
# if bbs is not None:
# img_before = bbs.draw_on_image(img, color=(0, 255, 0), thickness=2)
# img_after = bbs_aug.draw_on_image(img_aug, color=(0,0,255), thickness=2)
# cv2.imshow('box ori', img_before)
# cv2.imshow('box after', img_after)
# cv2.waitKey(0)
# if kps is not None:
# img_before = kps.draw_on_image(img, color=(0, 255, 0), size=5)
# img_after = kps_aug.draw_on_image(img_aug, color=(0, 0, 255), size=5)
# for i in range(kps_ori.shape[0]):
# for joint in range(kps_ori.shape[1]):
# point = kps_ori[i][joint]
# cv2.putText(img_before, str(point[2]), (int(point[0]), int(point[1])), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 250), 1)
# point = keypoints[i][joint]
# cv2.putText(img_after, str(point[2]), (int(point[0]), int(point[1])), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 250), 1)
# cv2.imshow('kps ori', img_before)
# cv2.imshow('kps after', img_after)
# cv2.waitKey(0)
return img_aug, bboxs, keypoints
def apply_transform_on_an_image(image, bbox=None):
# Sometimes(0.5, ...) applies the given augmenter in 50% of all cases,
# e.g. Sometimes(0.5, GaussianBlur(0.3)) would blur roughly every second
# image.
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential(
[
# iaa.Multiply((1.2, 1.5)), # change brightness, doesn't affect BBs
# 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=iap.Uniform(0.0, 1.0))
# ),
iaa.ContrastNormalization(
iap.Choice([1.0, 1.5, 3.0], p=[0.5, 0.3, 0.2])),
# 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.Multiply(iap.Positive(iap.Normal(0.0, 0.1)) + 1.0,
per_channel=0.2),
# Apply affine transformations to each image.
# - scale to 80-120% of image height/width (each axis independently)
# - translate by -20 to +20 relative to height/width (per axis)
# - rotate by -45 to +45 degrees
# - shear by -16 to +16 degrees
# - order: use nearest neighbour or bilinear interpolation (fast)
# - mode: use any available mode to fill newly created pixels
# see API or scikit-image for which modes are available
# - cval: if the mode is constant, then use a random brightness
# for the newly created pixels (e.g. sometimes black,
# sometimes white)
# 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)},
# # translate_percent=0.1,
# rotate=iap.Normal(-45, 45),
# shear=(-8, 8),
# order=[0, 1],
# cval=(0, 255),
# # translate_px=iap.RandomSign(iap.Poisson(3)),
# # translate_px=3,
# # mode=["constant", "edge"]
# mode=ia.ALL
# ),
# iaa.AddElementwise(
# iap.Discretize(
# (iap.Beta(0.5, 0.5) * 2 - 1.0) * 64
# )
# ),
#
# Execute 0 to 5 of the following (less important) augmenters per
# image. Don't execute all of them, as that would often be way too
# strong.
#
iaa.SomeOf(
(0, 5),
[
# Convert some images into their superpixel representation,
# sample between 20 and 200 superpixels per image, but do
# not replace all superpixels with their average, only
# some of them (p_replace).
# sometimes(
# iaa.Superpixels(
# p_replace=(0, 0.5),
# n_segments=(1, 4)
# )
# ),
# Blur each image with varying strength using
# gaussian blur (sigma between 0 and 3.0),
# average/uniform blur (kernel size between 2x2 and 7x7)
# median blur (kernel size between 3x3 and 11x11).
iaa.OneOf([
iaa.GaussianBlur((0, 0.3)),
iaa.AverageBlur(k=(1, 2)),
iaa.MedianBlur(k=(1, 3)),
]),
# iaa.OneOf([
# iaa.GaussianBlur((0, 3.0)),
# iaa.AverageBlur(k=(2, 7)),
# iaa.MedianBlur(k=(3, 11)),
# ]),
# 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, 0.01), lightness=(0, 0.01)),
# Same as sharpen, but for an embossing effect.
iaa.Emboss(alpha=(0, 0.01), strength=(0, 0.01)),
# Search in some images either for all edges or for
# directed edges. These edges are then marked in a black
# and white image and overlayed with the original image
# using an alpha of 0 to 0.7.
sometimes(
iaa.OneOf([
iaa.EdgeDetect(alpha=(0, 0.005)),
iaa.DirectedEdgeDetect(alpha=(0, 0.001),
direction=(0.0, 0.001)),
])),
# Add gaussian noise to some images.
# In 50% of these cases, the noise is randomly sampled per
# channel and pixel.
# In the other 50% of all cases it is sampled once per
# pixel (i.e. brightness change).
# iaa.AdditiveGaussianNoise(
# loc=0, scale=(0.0, 0.001 * 255), 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.
# iaa.OneOf([
# iaa.Dropout((0, 0.05), per_channel=0.5),
# iaa.CoarseDropout(
# (0, 0.01), size_percent=(0.1, 0.2),
# per_channel=0.2
# ),
# ]),
# Invert each image's channel with 5% probability.
# This sets each pixel value v to 255-v.
iaa.Invert(0.1, per_channel=True), # invert color channels
# Add a value of -10 to 10 to each pixel.
#iaa.Add((-40, 40), per_channel=0.5),
# Change brightness of images (50-150% of original value).
# iaa.Multiply((0.5, 1.5), per_channel=0.5),
# Improve or worsen the contrast of images.
# iaa.contrast.LinearContrast((0.5, 2.0), 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.
# iaa.Grayscale(alpha=(0.0, 1.0)),
# In some images move pixels locally around (with random
# strengths).
# sometimes(
# iaa.ElasticTransformation(alpha=(0.5, 1.5), sigma=0.25)
# ),
# In some images distort local areas with varying strength.
# sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05)))
],
# do all of the above augmentations in random order
random_order=True)
],
random_order=True)
# Augment BBs and images.
aug_image = seq(image=image)
return aug_image
def test_Emboss():
reseed()
base_img = [[10, 10, 10], [10, 20, 10], [10, 10, 15]]
base_img = np.uint8(base_img)
def _compute_embossed_base_img(img, alpha, strength):
img = np.copy(img)
base_img_embossed = np.zeros((3, 3), dtype=np.float32)
m = np.float32([[-1, 0, 0], [0, 1, 0], [0, 0, 1]])
strength_matrix = strength * np.float32([[-1, -1, 0], [-1, 0, 1],
[0, 1, 1]])
ms = m + strength_matrix
for i in range(base_img_embossed.shape[0]):
for j in range(base_img_embossed.shape[1]):
for u in range(ms.shape[0]):
for v in range(ms.shape[1]):
weight = ms[u, v]
inputs_i = abs(i + (u - (ms.shape[0] - 1) // 2))
inputs_j = abs(j + (v - (ms.shape[1] - 1) // 2))
if inputs_i >= img.shape[0]:
diff = inputs_i - (img.shape[0] - 1)
inputs_i = img.shape[0] - 1 - diff
if inputs_j >= img.shape[1]:
diff = inputs_j - (img.shape[1] - 1)
inputs_j = img.shape[1] - 1 - diff
inputs = img[inputs_i, inputs_j]
base_img_embossed[i, j] += inputs * weight
return np.clip((1 - alpha) * img + alpha * base_img_embossed, 0,
255).astype(np.uint8)
def _allclose(a, b):
return np.max(a.astype(np.float32) - b.astype(np.float32)) <= 2.1
aug = iaa.Emboss(alpha=0, strength=1)
observed = aug.augment_image(base_img)
expected = base_img
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=1.0, strength=1)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=1.0, strength=1)
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=0.5, strength=1)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=0.5, strength=1)
assert _allclose(observed, expected.astype(np.uint8))
aug = iaa.Emboss(alpha=0.75, strength=1)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=0.75, strength=1)
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=iap.Choice([0.5, 1.0]), strength=1)
observed = aug.augment_image(base_img)
expected1 = _compute_embossed_base_img(base_img, alpha=0.5, strength=1)
expected2 = _compute_embossed_base_img(base_img, alpha=1.0, strength=1)
assert _allclose(observed, expected1) or np.allclose(observed, expected2)
got_exception = False
try:
_ = iaa.Emboss(alpha="test", strength=1)
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
aug = iaa.Emboss(alpha=1.0, strength=2)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=1.0, strength=2)
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=1.0, strength=3)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=1.0, strength=3)
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=1.0, strength=6)
observed = aug.augment_image(base_img)
expected = _compute_embossed_base_img(base_img, alpha=1.0, strength=6)
assert _allclose(observed, expected)
aug = iaa.Emboss(alpha=1.0, strength=iap.Choice([1.0, 1.5]))
observed = aug.augment_image(base_img)
expected1 = _compute_embossed_base_img(base_img, alpha=1.0, strength=1.0)
expected2 = _compute_embossed_base_img(base_img, alpha=1.0, strength=1.5)
assert _allclose(observed, expected1) or np.allclose(observed, expected2)
got_exception = False
try:
_ = iaa.Emboss(alpha=1.0, strength="test")
except Exception as exc:
assert "Expected " in str(exc)
got_exception = True
assert got_exception
def transform(self, image: np.ndarray, target: str,
condition: int) -> Tuple[torch.Tensor, torch.Tensor, int]:
"""Transforms and normalizes the data. If in training mode the data is augmentated.
Args:
image (np.ndarray): Image to transform
target (str): Training target
condition (int): Condition
Returns:
Tuple[torch.Tensor, torch.Tensor, int]: Augmented image, target and condition
"""
# Resize
resize = iaa.Resize({"height": 224, "width": 224})
image = resize.augment_image(image)
# Random horizontal flipping and erase
if self.train:
if random.random() > 0.5:
# flip image
flip = iaa.HorizontalFlip(1.0)
image = flip.augment_image(image)
# flip class
if target == "a":
target = "d"
elif target == "d":
target = "a"
# flip condition
if condition == 2:
condition = 4
elif condition == 4:
condition = 2
#imgaug
seq = iaa.Sequential([
iaa.Sometimes(0.5, iaa.Affine(rotate=(-15, 15))),
iaa.Sometimes(0.3, iaa.EdgeDetect(alpha=(0.3, 0.8))),
iaa.Sometimes(0.5, iaa.MotionBlur(k=iap.Choice([3, 5, 7]))),
iaa.OneOf([
iaa.Dropout(p=(0, 0.3), per_channel=0.5),
iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.09))
]),
iaa.Sometimes(0.5, iaa.AllChannelsCLAHE(clip_limit=(1, 10)))
])
image = seq.augment_image(image)
# Transform to tensor
image = TF.to_tensor(image)
# Transform to one hot encoding
target = torch.tensor(self.target_dict[target])
#normalize image to fit pretrained vgg model
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
image = normalize(image)
return image, target, condition
def test_Fliplr():
reseed()
base_img = np.array([[0, 0, 1], [0, 0, 1], [0, 1, 1]], dtype=np.uint8)
base_img = base_img[:, :, np.newaxis]
base_img_flipped = np.array([[1, 0, 0], [1, 0, 0], [1, 1, 0]],
dtype=np.uint8)
base_img_flipped = base_img_flipped[:, :, np.newaxis]
images = np.array([base_img])
images_flipped = np.array([base_img_flipped])
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=0, y=0),
ia.Keypoint(x=1, y=1),
ia.Keypoint(x=2, y=2)
],
shape=base_img.shape)
]
keypoints_flipped = [
ia.KeypointsOnImage([
ia.Keypoint(x=2, y=0),
ia.Keypoint(x=1, y=1),
ia.Keypoint(x=0, y=2)
],
shape=base_img.shape)
]
# 0% chance of flip
aug = iaa.Fliplr(0)
aug_det = aug.to_deterministic()
for _ in sm.xrange(10):
observed = aug.augment_images(images)
expected = images
assert np.array_equal(observed, expected)
observed = aug_det.augment_images(images)
expected = images
assert np.array_equal(observed, expected)
observed = aug.augment_keypoints(keypoints)
expected = keypoints
assert keypoints_equal(observed, expected)
observed = aug_det.augment_keypoints(keypoints)
expected = keypoints
assert keypoints_equal(observed, expected)
# 0% chance of flip, heatmaps
aug = iaa.Fliplr(0)
heatmaps = ia.HeatmapsOnImage(np.float32([
[0, 0.5, 0.75],
[0, 0.5, 0.75],
[0.75, 0.75, 0.75],
]),
shape=(3, 3, 3))
observed = aug.augment_heatmaps([heatmaps])[0]
expected = heatmaps.get_arr()
assert observed.shape == heatmaps.shape
assert heatmaps.min_value - 1e-6 < observed.min_value < heatmaps.min_value + 1e-6
assert heatmaps.max_value - 1e-6 < observed.max_value < heatmaps.max_value + 1e-6
assert np.array_equal(observed.get_arr(), expected)
# 100% chance of flip
aug = iaa.Fliplr(1.0)
aug_det = aug.to_deterministic()
for _ in sm.xrange(10):
observed = aug.augment_images(images)
expected = images_flipped
assert np.array_equal(observed, expected)
observed = aug_det.augment_images(images)
expected = images_flipped
assert np.array_equal(observed, expected)
observed = aug.augment_keypoints(keypoints)
expected = keypoints_flipped
assert keypoints_equal(observed, expected)
observed = aug_det.augment_keypoints(keypoints)
expected = keypoints_flipped
assert keypoints_equal(observed, expected)
# 100% chance of flip, heatmaps
aug = iaa.Fliplr(1.0)
heatmaps = ia.HeatmapsOnImage(np.float32([
[0, 0.5, 0.75],
[0, 0.5, 0.75],
[0.75, 0.75, 0.75],
]),
shape=(3, 3, 3))
observed = aug.augment_heatmaps([heatmaps])[0]
expected = np.fliplr(heatmaps.get_arr())
assert observed.shape == heatmaps.shape
assert heatmaps.min_value - 1e-6 < observed.min_value < heatmaps.min_value + 1e-6
assert heatmaps.max_value - 1e-6 < observed.max_value < heatmaps.max_value + 1e-6
assert np.array_equal(observed.get_arr(), expected)
# 50% chance of flip
aug = iaa.Fliplr(0.5)
aug_det = aug.to_deterministic()
nb_iterations = 1000
nb_images_flipped = 0
nb_images_flipped_det = 0
nb_keypoints_flipped = 0
nb_keypoints_flipped_det = 0
for _ in sm.xrange(nb_iterations):
observed = aug.augment_images(images)
if np.array_equal(observed, images_flipped):
nb_images_flipped += 1
observed = aug_det.augment_images(images)
if np.array_equal(observed, images_flipped):
nb_images_flipped_det += 1
observed = aug.augment_keypoints(keypoints)
if keypoints_equal(observed, keypoints_flipped):
nb_keypoints_flipped += 1
observed = aug_det.augment_keypoints(keypoints)
if keypoints_equal(observed, keypoints_flipped):
nb_keypoints_flipped_det += 1
assert int(nb_iterations * 0.3) <= nb_images_flipped <= int(
nb_iterations * 0.7)
assert int(nb_iterations * 0.3) <= nb_keypoints_flipped <= int(
nb_iterations * 0.7)
assert nb_images_flipped_det in [0, nb_iterations]
assert nb_keypoints_flipped_det in [0, nb_iterations]
# 50% chance of flipped, multiple images, list as input
images_multi = [base_img, base_img]
aug = iaa.Fliplr(0.5)
aug_det = aug.to_deterministic()
nb_iterations = 1000
nb_flipped_by_pos = [0] * len(images_multi)
nb_flipped_by_pos_det = [0] * len(images_multi)
for _ in sm.xrange(nb_iterations):
observed = aug.augment_images(images_multi)
for i in sm.xrange(len(images_multi)):
if np.array_equal(observed[i], base_img_flipped):
nb_flipped_by_pos[i] += 1
observed = aug_det.augment_images(images_multi)
for i in sm.xrange(len(images_multi)):
if np.array_equal(observed[i], base_img_flipped):
nb_flipped_by_pos_det[i] += 1
for val in nb_flipped_by_pos:
assert int(nb_iterations * 0.3) <= val <= int(nb_iterations * 0.7)
for val in nb_flipped_by_pos_det:
assert val in [0, nb_iterations]
# test StochasticParameter as p
aug = iaa.Fliplr(p=iap.Choice([0, 1], p=[0.7, 0.3]))
seen = [0, 0]
for _ in sm.xrange(1000):
observed = aug.augment_image(base_img)
if np.array_equal(observed, base_img):
seen[0] += 1
elif np.array_equal(observed, base_img_flipped):
seen[1] += 1
else:
assert False
assert 700 - 75 < seen[0] < 700 + 75
assert 300 - 75 < seen[1] < 300 + 75
# test exceptions for wrong parameter types
got_exception = False
try:
_ = iaa.Fliplr(p="test")
except Exception:
got_exception = True
assert got_exception
# test get_parameters()
aug = iaa.Fliplr(p=0.5)
params = aug.get_parameters()
assert isinstance(params[0], iap.Binomial)
assert isinstance(params[0].p, iap.Deterministic)
assert 0.5 - 1e-4 < params[0].p.value < 0.5 + 1e-4
###################
# test other dtypes
###################
aug = iaa.Fliplr(1.0)
image = np.zeros((3, 3), dtype=bool)
image[0, 0] = True
expected = np.zeros((3, 3), dtype=bool)
expected[0, 2] = True
image_aug = aug.augment_image(image)
assert image_aug.dtype.type == image.dtype.type
assert np.all(image_aug == expected)
for dtype in [
np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int32,
np.int64
]:
min_value, center_value, max_value = iadt.get_value_range_of_dtype(
dtype)
value = max_value
image = np.zeros((3, 3), dtype=dtype)
image[0, 0] = value
expected = np.zeros((3, 3), dtype=dtype)
expected[0, 2] = value
image_aug = aug.augment_image(image)
assert image_aug.dtype.type == dtype
assert np.array_equal(image_aug, expected)
for dtype, value in zip([np.float16, np.float32, np.float64, np.float128],
[5000, 1000**2, 1000**3, 1000**4]):
atol = 1e-9 * max_value if dtype != np.float16 else 1e-3 * max_value
image = np.zeros((3, 3), dtype=dtype)
image[0, 0] = value
expected = np.zeros((3, 3), dtype=dtype)
expected[0, 2] = value
image_aug = aug.augment_image(image)
assert image_aug.dtype.type == dtype
assert np.allclose(image_aug, expected, atol=atol)
def __init__(self,
mean=(0.0, 0.0, 0.0, 0.0),
std=(1.0, 1.0, 1.0, 1.0),
crop_image_size=(224, 224)):
if isinstance(crop_image_size, int):
crop_image_size = (crop_image_size, crop_image_size)
self._mean = mean
self._std = std
self.crop_image_size = crop_image_size
self.seq = iaa.Sequential(
children=[
iaa.Sequential(
children=[
iaa.Fliplr(
p=0.5,
name="Fliplr"),
iaa.Flipud(
p=0.5,
name="Flipud"),
iaa.Sequential(
children=[
iaa.Affine(
scale={"x": (0.9, 1.1), "y": (0.9, 1.1)},
translate_percent={"x": (-0.05, 0.05), "y": (-0.05, 0.05)},
rotate=(-45, 45),
shear=(-16, 16),
order=iap.Choice([0, 1, 3], p=[0.15, 0.80, 0.05]),
mode="reflect",
name="Affine"),
iaa.Sometimes(
p=0.01,
then_list=iaa.PiecewiseAffine(
scale=(0.0, 0.01),
nb_rows=(4, 20),
nb_cols=(4, 20),
order=iap.Choice([0, 1, 3], p=[0.15, 0.80, 0.05]),
mode="reflect",
name="PiecewiseAffine"))],
random_order=True,
name="GeomTransform"),
iaa.Sequential(
children=[
iaa.Sometimes(
p=0.75,
then_list=iaa.Add(
value=(-10, 10),
per_channel=0.5,
name="Brightness")),
iaa.Sometimes(
p=0.05,
then_list=iaa.Emboss(
alpha=(0.0, 0.5),
strength=(0.5, 1.2),
name="Emboss")),
iaa.Sometimes(
p=0.1,
then_list=iaa.Sharpen(
alpha=(0.0, 0.5),
lightness=(0.5, 1.2),
name="Sharpen")),
iaa.Sometimes(
p=0.25,
then_list=iaa.ContrastNormalization(
alpha=(0.5, 1.5),
per_channel=0.5,
name="ContrastNormalization"))
],
random_order=True,
name="ColorTransform"),
iaa.Sequential(
children=[
iaa.Sometimes(
p=0.5,
then_list=iaa.AdditiveGaussianNoise(
loc=0,
scale=(0.0, 10.0),
per_channel=0.5,
name="AdditiveGaussianNoise")),
iaa.Sometimes(
p=0.1,
then_list=iaa.SaltAndPepper(
p=(0, 0.001),
per_channel=0.5,
name="SaltAndPepper"))],
random_order=True,
name="Noise"),
iaa.OneOf(
children=[
iaa.Sometimes(
p=0.05,
then_list=iaa.MedianBlur(
k=3,
name="MedianBlur")),
iaa.Sometimes(
p=0.05,
then_list=iaa.AverageBlur(
k=(2, 4),
name="AverageBlur")),
iaa.Sometimes(
p=0.5,
then_list=iaa.GaussianBlur(
sigma=(0.0, 2.0),
name="GaussianBlur"))],
name="Blur"),
],
random_order=True,
name="MainProcess")])
