def __call__(self, images):
nb_images = len(images) # 120 x 3 x H x W
seeds = ia.current_random_state().randint(0, 10**6, (nb_images, ))
rs_image = ia.new_random_state(seeds[0])
samples = self.p.draw_samples((nb_images, ), random_state=rs_image)
samples_true_index = np.where(samples == 1)[0]
samples_false_index = np.where(samples == 0)[0]
# Check for the zero case , related to pytorch isuee of not accepting zero size array
if samples_true_index.size > 0:
samples_true_index = torch.cuda.LongTensor(samples_true_index)
images_to_transform = torch.index_select(images, 0,
samples_true_index)
if samples_false_index.size > 0:
# images_not_to_transform = torch.index_select(images, 0, torch.cuda.LongTensor(
# samples_false_index))
transformed_imgs = self.transform(images_to_transform)
images = images.index_copy_(0, samples_true_index,
transformed_imgs)
return images
# return torch.cat((self.transform(images_to_transform), images_not_to_transform), 0)
else:
return self.transform(images)
else:
return images
def _augment_keypoints(self, keypoints_on_images, random_state, parents,
hooks):
result = []
nb_images = len(keypoints_on_images)
seeds = random_state.randint(0, 10**6, (nb_images, ))
for i, keypoints_on_image in enumerate(keypoints_on_images):
seed = seeds[i]
h, w = keypoints_on_image.shape[0:2]
crop_h, crop_w = self.size[0:2]
random_state = ia.new_random_state(seed)
which = self.choice.draw_sample(random_state=random_state)
if which == 0:
shifted = keypoints_on_image
elif which == 1:
shifted = keypoints_on_image.shift(x=-crop_w)
elif which == 2:
shifted = keypoints_on_image.shift(y=-crop_h)
elif which == 3:
shifted = keypoints_on_image.shift(x=-crop_w, y=-crop_h)
else:
i = int(round((h - crop_h) / 2.))
j = int(round((w - crop_w) / 2.))
shifted = keypoints_on_image.shift(x=-i, y=-j)
shifted.shape = (crop_h, crop_w)
result.append(shifted)
return result
def __call__(self, images):
# input_dtypes = copy_dtypes_for_restore(images, force_list=True)
result = images
nb_images = len(images)
# Generate new seeds con
seeds = ia.current_random_state().randint(0, 10**6, (nb_images, ))
rs_image = ia.new_random_state(seeds[0])
per_channel = self.per_channel.draw_sample(random_state=rs_image)
if per_channel == 1:
nb_channels = images.shape[1]
for c in range(nb_channels):
samples = self.value.draw_samples(
(nb_images, 1, 1, 1),
random_state=rs_image).astype(np.float32)
do_assert(samples.all() >= 0)
result[:, c:(c + 1),
...] = F.add(images[:, c:(c + 1), ...],
torch.cuda.FloatTensor(samples))
else:
samples = self.value.draw_samples(
(nb_images, 1, 1, 1), random_state=rs_image).astype(np.float32)
do_assert(samples.all() >= 0)
result = F.add(images, torch.cuda.FloatTensor(samples))
# image = meta.clip_augmented_image_(image, 0, 255) # TODO make value range more flexible
# image = meta.restore_augmented_image_dtype_(image, input_dtypes[i])
return result
def __call__(self, images):
result = images
nb_images = len(images)
# Generate new seeds con
seeds = ia.current_random_state().randint(0, 10**6, (nb_images, ))
rs_image = ia.new_random_state(seeds[0])
per_channel = self.per_channel.draw_sample(random_state=rs_image)
if per_channel == 1:
nb_channels = images.shape[1] #Considering (N C H W)
for c in range(nb_channels):
alphas = self.alpha.draw_samples(
(nb_images, 1, 1, 1),
random_state=rs_image).astype(np.float32)
do_assert(alphas.all() >= 0)
result[:, c:(c + 1),
...] = F.contrast(images[:, c:(c + 1), ...],
torch.cuda.FloatTensor(alphas))
else:
alphas = self.alpha.draw_samples(
(nb_images, 1, 1, 1), random_state=rs_image).astype(np.float32)
do_assert(alphas.all() >= 0)
#print(alphas)
result = F.contrast(images, torch.cuda.FloatTensor(alphas))
return result
def reseed(augmenter, deterministic=True):
augmenter.random_state = ia.new_random_state(get_seed())
if deterministic:
augmenter.deterministic = True
for lists in augmenter.get_children_lists():
for aug in lists:
aug = reseed(aug, deterministic=True)
return augmenter
def reseed(augmenter, deterministic=True):
augmenter.random_state = ia.new_random_state(get_seed())
if deterministic:
augmenter.deterministic = True
for lists in augmenter.get_children_lists():
for aug in lists:
aug = reseed(aug, deterministic=True)
return augmenter
def _draw_sample_point(self, box_w, box_h, img_w, img_h, seed):
x1 = math.ceil(box_w / 2)
y1 = math.ceil(box_h / 2)
x2 = math.floor(img_w - x1)
y2 = math.floor(img_h - y1)
random_state = ia.new_random_state(seed)
x = DiscreteUniform(x1, x2)
y = DiscreteUniform(y1, y2)
center_x = x.draw_sample(random_state=random_state)
center_y = y.draw_sample(random_state=random_state)
return center_x, center_y
def __call__(self, images):
# Convert to Grayscale direction
nb_images = len(images)
# Generate new seeds con
seeds = ia.current_random_state().randint(0, 10**6, (nb_images, ))
rs_image = ia.new_random_state(seeds[0])
samples = self.alpha.draw_samples(
(nb_images, 1, 1, 1), random_state=rs_image).astype(np.float32)
do_assert(samples.all() >= 0)
result = F.grayscale(images, torch.cuda.FloatTensor(samples))
return result
def __call__(self, images):
result = images
nb_images = len(images)
nb_channels, height, width = images[0].shape
seeds = ia.current_random_state().randint(0, 10**6, (nb_images, ))
rs_image = ia.new_random_state(seeds[0])
samples = self.sigma.draw_samples((nb_images, ), random_state=rs_image)
# note that while gaussian_filter can be applied to all channels
# at the same time, that should not be done here, because then
# the blurring would also happen across channels (e.g. red
# values might be mixed with blue values in RGB)
for c in range(nb_channels):
result[:, c:(c + 1), ...] = F.blur(result[:, c:(c + 1), ...],
samples)
return result
def _augment_images(self, images, random_state, parents, hooks):
result = images
nb_images = len(images)
seeds = random_state.randint(0, 10**6, (nb_images, ))
for i in ia.sm.xrange(nb_images):
image = images[i].astype(np.float32)
rs_image = ia.new_random_state(seeds[i])
per_channel = self.per_channel.draw_sample(random_state=rs_image)
if per_channel == 1:
nb_channels = image.shape[2]
samples = self.gamma_log2.draw_samples((nb_channels, ),
random_state=rs_image)
for c, sample in enumerate(samples):
image[..., c] = np.power(image[..., c] / 255.0, 2.0**
sample) * 255.0
# np.clip(image, 0, 255, out=image)
result[i] = image.astype(np.float32)
else:
sample = self.gamma_log2.draw_sample(random_state=rs_image)
image = np.power(image / 255.0, 2.0**sample) * 255.0
# np.clip(image, 0, 255, out=image)
result[i] = image.astype(np.float32)
return result
def _draw_samples_image(self, seed, height, width):
"""
height = 32
width = 32
h, w = shape = (30, 30)
random_state = np.random
"""
random_state = ia.new_random_state(seed)
h, w = self.shape
assert w <= width, '{} {}'.format(w, width)
assert h <= height, '{} {}'.format(h, height)
space_h = height - h
space_w = width - w
top = random_state.randint(0, space_h + 1)
bot = height - (space_h - top)
left = random_state.randint(0, space_w + 1)
right = width - (space_w - left)
sub = [top, bot, left, right]
return sub
def _draw_samples(self, nb_samples, random_state):
seed = random_state.randint(0, 10**6, 1)[0]
if isinstance(self.scale, tuple):
scale_samples = (
self.scale[0].draw_samples(
(nb_samples, ),
random_state=ia.new_random_state(seed + 10)),
self.scale[1].draw_samples(
(nb_samples, ),
random_state=ia.new_random_state(seed + 20)),
)
else:
scale_samples = self.scale.draw_samples(
(nb_samples, ), random_state=ia.new_random_state(seed + 30))
scale_samples = (scale_samples, scale_samples)
if isinstance(self.translate, tuple):
translate_samples = (
self.translate[0].draw_samples(
(nb_samples, ),
random_state=ia.new_random_state(seed + 40)),
self.translate[1].draw_samples(
(nb_samples, ),
random_state=ia.new_random_state(seed + 50)),
)
else:
translate_samples = self.translate.draw_samples(
(nb_samples, ), random_state=ia.new_random_state(seed + 60))
translate_samples = (translate_samples, translate_samples)
ia.do_assert(translate_samples[0].dtype in
[np.int32, np.int64, np.float32, np.float64])
ia.do_assert(translate_samples[1].dtype in
[np.int32, np.int64, np.float32, np.float64])
rotate_samples = self.rotate.draw_samples(
(nb_samples, ), random_state=ia.new_random_state(seed + 70))
return scale_samples, translate_samples, rotate_samples
def _augment_images(self, images, random_state, parents, hooks):
result = []
nb_images = len(images)
seeds = random_state.randint(0, 10**6, (nb_images, ))
for i in xrange(nb_images):
seed = seeds[i]
img = images[i]
h, w = img.shape[0:2]
crop_h, crop_w = self.size
if crop_w > w or crop_h > h:
raise ValueError(
"Requested crop size {} is bigger than input size {}".
format(self.size, (h, w)))
random_state = ia.new_random_state(seed)
which = self.choice.draw_sample(random_state=random_state)
if which == 0:
# top left
image_cr = img[0:crop_h, 0:crop_w]
elif which == 1:
# top right
image_cr = img[0:crop_h, (w - crop_w):w]
elif which == 2:
# bottom left
image_cr = img[(h - crop_h):h, 0:crop_w]
elif which == 3:
# bottom right
image_cr = img[(h - crop_h):h, (w - crop_w):w]
else:
# center
image_cr = self.center_crop(img, (crop_h, crop_w))
result.append(image_cr)
return result
def reseed(augmenter_sequence, deterministic=True):
for aug in augmenter_sequence:
aug.random_state = ia.new_random_state(get_seed())
if deterministic:
aug.deterministic = True
return augmenter_sequence
def test_MotionBlur():
reseed()
# simple scenario
aug = iaa.MotionBlur(k=3, angle=0, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 1.0 / 3, 0], [0, 1.0 / 3, 0], [0, 1.0 / 3, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# 90deg angle
aug = iaa.MotionBlur(k=3, angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0, 0], [1.0 / 3, 1.0 / 3, 1.0 / 3], [0, 0, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# 45deg angle
aug = iaa.MotionBlur(k=3, angle=45, direction=0.0, order=0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0, 1.0 / 3], [0, 1.0 / 3, 0], [1.0 / 3, 0, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# random angle
aug = iaa.MotionBlur(k=3, angle=[0, 90], direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([[0, 1.0 / 3, 0], [0, 1.0 / 3, 0], [0, 1.0 / 3, 0]])
expected2 = np.float32([
[0, 0, 0],
[1.0 / 3, 1.0 / 3, 1.0 / 3],
[0, 0, 0],
])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if np.allclose(matrix_channel, expected1):
nb_seen[0] += 1
elif np.allclose(matrix_channel, expected2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# 5x5
aug = iaa.MotionBlur(k=5, angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# random k
aug = iaa.MotionBlur(k=[3, 5], angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([
[0, 0, 0],
[1.0 / 3, 1.0 / 3, 1.0 / 3],
[0, 0, 0],
])
expected2 = np.float32([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if matrix_channel.shape == expected1.shape and np.allclose(
matrix_channel, expected1):
nb_seen[0] += 1
elif matrix_channel.shape == expected2.shape and np.allclose(
matrix_channel, expected2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# direction 1.0
aug = iaa.MotionBlur(k=3, angle=0, direction=1.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 1.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 0.0 / 1.5, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected, rtol=0, atol=1e-2)
# direction -1.0
aug = iaa.MotionBlur(k=3, angle=0, direction=-1.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 1.0 / 1.5, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected, rtol=0, atol=1e-2)
# random direction
aug = iaa.MotionBlur(k=3, angle=[0, 90], direction=[-1.0, 1.0])
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([[0, 1.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 0.0 / 1.5, 0]])
expected2 = np.float32([[0, 0.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 1.0 / 1.5, 0]])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if np.allclose(matrix_channel, expected1, rtol=0, atol=1e-2):
nb_seen[0] += 1
elif np.allclose(matrix_channel, expected2, rtol=0, atol=1e-2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# test of actual augmenter
img = np.zeros((7, 7, 3), dtype=np.uint8)
img[3 - 1:3 + 2, 3 - 1:3 + 2, :] = 255
aug = iaa.MotionBlur(k=3, angle=90, direction=0.0)
img_aug = aug.augment_image(img)
v1 = (255 * (1 / 3))
v2 = (255 * (1 / 3)) * 2
v3 = (255 * (1 / 3)) * 3
expected = np.float32([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, v1, v2, v3, v2, v1, 0],
[0, v1, v2, v3, v2, v1, 0],
[0, v1, v2, v3, v2, v1, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]).astype(np.uint8)
expected = np.tile(expected[..., np.newaxis], (1, 1, 3))
assert np.allclose(img_aug, expected)
def chapter_alpha_masks_iterative():
# -----------------------------------------
# IterativeNoiseAggregator varying number of iterations
# -----------------------------------------
import imgaug as ia
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
masks = []
iterations_all = [1, 2, 3, 4]
for iterations in iterations_all:
noise = iap.IterativeNoiseAggregator(other_param=iap.FrequencyNoise(
exponent=(-4.0, 4.0), upscale_method=["linear", "nearest"]),
iterations=iterations,
aggregation_method="max")
row = [
noise.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
row = np.hstack(row)
row = np.tile(row[:, :, np.newaxis], (1, 1, 3))
row = (row * 255).astype(np.uint8)
row = np.pad(row, ((0, 0), (50, 0), (0, 0)),
mode="constant",
constant_values=255)
row = ia.draw_text(row,
y=24,
x=2,
text="%d iter." % (iterations, ),
size=14,
color=[0, 0, 0])
masks.append(row)
# ------------
save("alpha", "iterative_vary_iterations.jpg",
grid(masks, cols=1, rows=len(iterations_all)))
# -----------------------------------------
# IterativeNoiseAggregator varying methods
# -----------------------------------------
import imgaug as ia
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
iterations_all = [1, 2, 3, 4, 5, 6]
methods = ["min", "avg", "max"]
cell_idx = 0
rows = []
for method_idx, method in enumerate(methods):
row = []
for iterations in iterations_all:
noise = iap.IterativeNoiseAggregator(
other_param=iap.FrequencyNoise(
exponent=-2.0,
size_px_max=32,
upscale_method=["linear", "nearest"]),
iterations=iterations,
aggregation_method=method)
cell = noise.draw_samples(
(64, 64),
random_state=ia.new_random_state(seed + 1 + method_idx))
cell = np.tile(cell[:, :, np.newaxis], (1, 1, 3))
cell = (cell * 255).astype(np.uint8)
if iterations == 1:
cell = np.pad(cell, ((0, 0), (40, 0), (0, 0)),
mode="constant",
constant_values=255)
cell = ia.draw_text(cell,
y=27,
x=2,
text="%s" % (method, ),
size=14,
color=[0, 0, 0])
if method_idx == 0:
cell = np.pad(cell, ((20, 0), (0, 0), (0, 0)),
mode="constant",
constant_values=255)
cell = ia.draw_text(cell,
y=0,
x=12 + 40 * (iterations == 1),
text="%d iter." % (iterations, ),
size=14,
color=[0, 0, 0])
cell = np.pad(cell, ((0, 1), (0, 1), (0, 0)),
mode="constant",
constant_values=255)
row.append(cell)
cell_idx += 1
rows.append(np.hstack(row))
gridarr = np.vstack(rows)
# ------------
save("alpha", "iterative_vary_methods.jpg", gridarr)
def chapter_alpha_masks_frequency():
# -----------------------------------------
# example 1 (basic)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
ia.seed(1)
# Example batch of images.
# The array has shape (8, 64, 64, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaFrequencyNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_frequency_example_basic.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# example 1 (per_channel)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaFrequencyNoise(foreground=iaa.EdgeDetect(1.0),
per_channel=True)
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_frequency_example_per_channel.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# noise masks
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaFrequencyNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = [np.tile(mask[:, :, np.newaxis], (1, 1, 3)) for mask in masks]
masks = [(mask * 255).astype(np.uint8) for mask in masks]
# ------------
save("alpha", "alpha_frequency_noise_masks.jpg", grid(masks,
cols=8,
rows=2))
# -----------------------------------------
# noise masks, varying exponent
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
masks = []
nb_rows = 4
exponents = np.linspace(-4.0, 4.0, 16)
for i, exponent in enumerate(exponents):
seq = iaa.BlendAlphaFrequencyNoise(exponent=exponent,
foreground=iaa.Multiply(
iap.Choice([0.5, 1.5]),
per_channel=True),
size_px_max=32,
upscale_method="linear",
iterations=1,
sigmoid=False)
group = []
for row in range(nb_rows):
mask = seq.factor.draw_samples(
(64, 64),
random_state=ia.new_random_state(seed + 1 + i * 10 + row))
mask = np.tile(mask[:, :, np.newaxis], (1, 1, 3))
mask = (mask * 255).astype(np.uint8)
if row == nb_rows - 1:
mask = np.pad(mask, ((0, 20), (0, 0), (0, 0)),
mode="constant",
constant_values=255)
mask = ia.draw_text(mask,
y=64 + 2,
x=6,
text="%.2f" % (exponent, ),
size=10,
color=[0, 0, 0])
group.append(mask)
masks.append(np.vstack(group))
# ------------
save("alpha", "alpha_frequency_noise_masks_exponents.jpg",
grid(masks, cols=16, rows=1))
# -----------------------------------------
# noise masks, upscale=nearest
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaFrequencyNoise(foreground=iaa.Multiply(
iap.Choice([0.5, 1.5]), per_channel=True),
upscale_method="nearest")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = [np.tile(mask[:, :, np.newaxis], (1, 1, 3)) for mask in masks]
masks = [(mask * 255).astype(np.uint8) for mask in masks]
# ------------
save("alpha", "alpha_frequency_noise_masks_nearest.jpg",
grid(masks, cols=8, rows=2))
# -----------------------------------------
# noise masks linear
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaFrequencyNoise(foreground=iaa.Multiply(
iap.Choice([0.5, 1.5]), per_channel=True),
upscale_method="linear")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = [np.tile(mask[:, :, np.newaxis], (1, 1, 3)) for mask in masks]
masks = [(mask * 255).astype(np.uint8) for mask in masks]
# ------------
save("alpha", "alpha_frequency_noise_masks_linear.jpg",
grid(masks, cols=8, rows=2))
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (128, 128))
# check if scipy and cv2 remap similarly
rs = ia.new_random_state(1)
aug_scipy = ElasticTransformationScipy(alpha=30,
sigma=3,
random_state=rs,
deterministic=True)
aug_cv2 = ElasticTransformationCv2(alpha=30,
sigma=3,
random_state=rs,
deterministic=True)
augs_scipy = aug_scipy.augment_images([image] * 8)
augs_cv2 = aug_cv2.augment_images([image] * 8)
ia.imshow(ia.draw_grid(augs_scipy + augs_cv2, rows=2))
print("alpha=vary, sigma=0.25")
augs = [
iaa.ElasticTransformation(alpha=alpha, sigma=0.25)
for alpha in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=1.0")
augs = [
iaa.ElasticTransformation(alpha=alpha, sigma=1.0)
for alpha in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=3.0")
augs = [
iaa.ElasticTransformation(alpha=alpha, sigma=3.0)
for alpha in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=5.0")
augs = [
iaa.ElasticTransformation(alpha=alpha, sigma=5.0)
for alpha in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=1.0, sigma=vary")
augs = [
iaa.ElasticTransformation(alpha=1.0, sigma=sigma)
for sigma in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=10.0, sigma=vary")
augs = [
iaa.ElasticTransformation(alpha=10.0, sigma=sigma)
for sigma in np.arange(0.0, 50.0, 0.1)
]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
kps = ia.KeypointsOnImage([
ia.Keypoint(x=1, y=1),
ia.Keypoint(x=50, y=24),
ia.Keypoint(x=42, y=96),
ia.Keypoint(x=88, y=106),
ia.Keypoint(x=88, y=53),
ia.Keypoint(x=0, y=0),
ia.Keypoint(x=128, y=128),
ia.Keypoint(x=-20, y=30),
ia.Keypoint(x=20, y=-30),
ia.Keypoint(x=-20, y=-30)
],
shape=image.shape)
images = []
params = [(0.0, 0.0), (0.2, 0.2), (2.0, 0.25), (0.25, 3.0), (2.0, 3.0),
(6.0, 3.0), (12.0, 3.0), (50.0, 5.0), (100.0, 5.0),
(100.0, 10.0)]
for (alpha, sigma) in params:
images_row = []
seqs_row = [
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=0,
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=128,
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=255,
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=0,
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=128,
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=255,
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=0,
order=3),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=128,
order=3),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="constant",
cval=255,
order=3),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="nearest",
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="nearest",
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="nearest",
order=2),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="nearest",
order=3),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="reflect",
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="reflect",
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="reflect",
order=2),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="reflect",
order=3),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="wrap",
order=0),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="wrap",
order=1),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="wrap",
order=2),
iaa.ElasticTransformation(alpha=alpha,
sigma=sigma,
mode="wrap",
order=3)
]
for seq in seqs_row:
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
image_aug_kp = np.copy(image_aug)
image_aug_kp = kps_aug.draw_on_image(image_aug_kp, size=3)
images_row.append(image_aug_kp)
images.append(np.hstack(images_row))
ia.imshow(np.vstack(images))
imageio.imwrite("elastic_transformations.jpg", np.vstack(images))
def chapter_alpha_masks_sigmoid():
# -----------------------------------------
# Sigmoid varying on/off
# -----------------------------------------
import imgaug as ia
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
masks = []
for activated in [False, True]:
noise = iap.Sigmoid.create_for_noise(other_param=iap.FrequencyNoise(
exponent=(-4.0, 4.0), upscale_method="linear"),
activated=activated)
row = [
noise.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
row = np.hstack(row)
row = np.tile(row[:, :, np.newaxis], (1, 1, 3))
row = (row * 255).astype(np.uint8)
row = np.pad(row, ((0, 0), (90, 0), (0, 0)),
mode="constant",
constant_values=255)
row = ia.draw_text(row,
y=17,
x=2,
text="activated=\n%s" % (activated, ),
size=14,
color=[0, 0, 0])
masks.append(row)
# ------------
save("alpha", "sigmoid_vary_activated.jpg", grid(masks, cols=1, rows=2))
# -----------------------------------------
# Sigmoid varying on/off
# -----------------------------------------
import imgaug as ia
from imgaug import parameters as iap
seed = 1
ia.seed(seed)
masks = []
nb_rows = 3
class ConstantNoise(iap.StochasticParameter):
def __init__(self, noise, seed):
super(ConstantNoise, self).__init__()
self.noise = noise
self.seed = seed
def _draw_samples(self, size, random_state):
return self.noise.draw_samples(size,
random_state=ia.new_random_state(
self.seed))
for rowidx in range(nb_rows):
row = []
for tidx, threshold in enumerate(np.linspace(-10.0, 10.0, 10)):
noise = iap.Sigmoid.create_for_noise(other_param=ConstantNoise(
iap.FrequencyNoise(exponent=(-4.0, 4.0),
upscale_method="linear"),
seed=seed + 100 + rowidx),
activated=True,
threshold=threshold)
cell = noise.draw_samples(
(64, 64), random_state=ia.new_random_state(seed + tidx))
cell = np.tile(cell[:, :, np.newaxis], (1, 1, 3))
cell = (cell * 255).astype(np.uint8)
if rowidx == 0:
cell = np.pad(cell, ((20, 0), (0, 0), (0, 0)),
mode="constant",
constant_values=255)
cell = ia.draw_text(cell,
y=2,
x=15,
text="%.1f" % (threshold, ),
size=14,
color=[0, 0, 0])
row.append(cell)
row = np.hstack(row)
masks.append(row)
gridarr = np.vstack(masks)
# ------------
save("alpha", "sigmoid_vary_threshold.jpg", gridarr)
def _augment_images(self, images, random_state, parents, hooks):
iadt.gate_dtypes(images,
allowed=[
"bool", "uint8", "uint16", "int8", "int16",
"float16", "float32", "float64"
],
disallowed=[
"uint32", "uint64", "uint128", "uint256", "int32",
"int64", "int128", "int256", "float96",
"float128", "float256"
],
augmenter=self)
seed = random_state.randint(0, 10**6, 1)[0]
for i, image in enumerate(images):
_height, _width, nb_channels = images[i].shape
input_dtype = image.dtype
if image.dtype.type in [np.bool_, np.float16]:
image = image.astype(np.float32, copy=False)
elif image.dtype.type == np.int8:
image = image.astype(np.int16, copy=False)
if self.matrix_type == "None":
matrices = [None] * nb_channels
elif self.matrix_type == "constant":
matrices = [self.matrix] * nb_channels
elif self.matrix_type == "function":
matrices = self.matrix(images[i], nb_channels,
ia.new_random_state(seed + i))
if ia.is_np_array(matrices) and matrices.ndim == 2:
matrices = np.tile(matrices[..., np.newaxis],
(1, 1, nb_channels))
ia.do_assert(
(isinstance(matrices, list)
and len(matrices) == nb_channels)
or (ia.is_np_array(matrices) and matrices.ndim == 3
and matrices.shape[2] == nb_channels),
"Callable provided to Convole must return either a list of 2D matrices (one per image channel) "
"or a 2D numpy array "
"or a 3D numpy array where the last dimension's size matches the number of image channels. "
"Got type %s." % (type(matrices), ))
if ia.is_np_array(matrices):
# Shape of matrices is currently (H, W, C), but in the loop below we need the
# first axis to be the channel index to unify handling of lists of arrays
# and arrays. So we move the channel axis here to the start.
matrices = matrices.transpose((2, 0, 1))
else:
raise Exception("Invalid matrix type")
image_aug = image
for channel in sm.xrange(nb_channels):
if matrices[channel] is not None:
# ndimage.convolve caused problems here
# cv2.filter2D() always returns same output dtype as input dtype
image_aug[...,
channel] = cv2.filter2D(image_aug[..., channel],
-1, matrices[channel])
if input_dtype == np.bool_:
image_aug = image_aug > 0.5
elif input_dtype in [np.int8, np.float16]:
image_aug = iadt.restore_dtypes_(image_aug, input_dtype)
images[i] = image_aug
return images
def test_MotionBlur():
reseed()
# simple scenario
aug = iaa.MotionBlur(k=3, angle=0, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 1.0 / 3, 0], [0, 1.0 / 3, 0], [0, 1.0 / 3, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# 90deg angle
aug = iaa.MotionBlur(k=3, angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0, 0], [1.0 / 3, 1.0 / 3, 1.0 / 3], [0, 0, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# 45deg angle
aug = iaa.MotionBlur(k=3, angle=45, direction=0.0, order=0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0, 1.0 / 3], [0, 1.0 / 3, 0], [1.0 / 3, 0, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# random angle
aug = iaa.MotionBlur(k=3, angle=[0, 90], direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([[0, 1.0 / 3, 0], [0, 1.0 / 3, 0], [0, 1.0 / 3, 0]])
expected2 = np.float32([
[0, 0, 0],
[1.0 / 3, 1.0 / 3, 1.0 / 3],
[0, 0, 0],
])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if np.allclose(matrix_channel, expected1):
nb_seen[0] += 1
elif np.allclose(matrix_channel, expected2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# 5x5
aug = iaa.MotionBlur(k=5, angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected)
# random k
aug = iaa.MotionBlur(k=[3, 5], angle=90, direction=0.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([
[0, 0, 0],
[1.0 / 3, 1.0 / 3, 1.0 / 3],
[0, 0, 0],
])
expected2 = np.float32([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5, 1.0 / 5],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if matrix_channel.shape == expected1.shape and np.allclose(
matrix_channel, expected1):
nb_seen[0] += 1
elif matrix_channel.shape == expected2.shape and np.allclose(
matrix_channel, expected2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# k with choice [a, b, c, ...] must error in case of non-discrete values
got_exception = False
try:
_ = iaa.MotionBlur(k=[3, 3.5, 4])
except Exception as exc:
assert "to only contain integer" in str(exc)
got_exception = True
assert got_exception
# no error in case of (a, b), checks for #215
aug = iaa.MotionBlur(k=(3, 7))
for _ in range(10):
_ = aug.augment_image(np.zeros((11, 11, 3), dtype=np.uint8))
# direction 1.0
aug = iaa.MotionBlur(k=3, angle=0, direction=1.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 1.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 0.0 / 1.5, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected, rtol=0, atol=1e-2)
# direction -1.0
aug = iaa.MotionBlur(k=3, angle=0, direction=-1.0)
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(10)
]
expected = np.float32([[0, 0.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 1.0 / 1.5, 0]])
for matrices_image in matrices:
for matrix_channel in matrices_image:
assert np.allclose(matrix_channel, expected, rtol=0, atol=1e-2)
# random direction
aug = iaa.MotionBlur(k=3, angle=[0, 90], direction=[-1.0, 1.0])
matrix_func = aug.matrix
matrices = [
matrix_func(np.zeros((128, 128, 3), dtype=np.uint8), 3,
ia.new_random_state(i)) for i in range(50)
]
expected1 = np.float32([[0, 1.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 0.0 / 1.5, 0]])
expected2 = np.float32([[0, 0.0 / 1.5, 0], [0, 0.5 / 1.5, 0],
[0, 1.0 / 1.5, 0]])
nb_seen = [0, 0]
for matrices_image in matrices:
assert np.allclose(matrices_image[0], matrices_image[1])
assert np.allclose(matrices_image[1], matrices_image[2])
for matrix_channel in matrices_image:
if np.allclose(matrix_channel, expected1, rtol=0, atol=1e-2):
nb_seen[0] += 1
elif np.allclose(matrix_channel, expected2, rtol=0, atol=1e-2):
nb_seen[1] += 1
assert nb_seen[0] > 0
assert nb_seen[1] > 0
# test of actual augmenter
img = np.zeros((7, 7, 3), dtype=np.uint8)
img[3 - 1:3 + 2, 3 - 1:3 + 2, :] = 255
aug = iaa.MotionBlur(k=3, angle=90, direction=0.0)
img_aug = aug.augment_image(img)
v1 = (255 * (1 / 3))
v2 = (255 * (1 / 3)) * 2
v3 = (255 * (1 / 3)) * 3
expected = np.float32([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, v1, v2, v3, v2, v1, 0],
[0, v1, v2, v3, v2, v1, 0],
[0, v1, v2, v3, v2, v1, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]).astype(np.uint8)
expected = np.tile(expected[..., np.newaxis], (1, 1, 3))
assert np.allclose(img_aug, expected)
def _draw_samples(self, size, random_state):
return self.noise.draw_samples(size,
random_state=ia.new_random_state(
self.seed))
def chapter_alpha_masks_simplex():
# -----------------------------------------
# example 1 (basic)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_simplex_example_basic.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# example 1 (per_channel)
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
ia.seed(1)
# Example batch of images.
# The array has shape (8, 128, 128, 3) and dtype uint8.
images = np.array([ia.quokka(size=(128, 128)) for _ in range(8)],
dtype=np.uint8)
seq = iaa.BlendAlphaSimplexNoise(foreground=iaa.EdgeDetect(1.0),
per_channel=True)
images_aug = seq(images=images)
# ------------
save("alpha", "alpha_simplex_example_per_channel.jpg",
grid(images_aug, cols=4, rows=2))
# -----------------------------------------
# noise masks
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaSimplexNoise(
foreground=iaa.Multiply(iap.Choice([0.5, 1.5]), per_channel=True))
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks.jpg", grid(masks, cols=16,
rows=1))
# -----------------------------------------
# noise masks, upscale=nearest
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.SimplexNoiseAlpha(first=iaa.Multiply(iap.Choice([0.5, 1.5]),
per_channel=True),
upscale_method="nearest")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks_nearest.jpg",
grid(masks, cols=16, rows=1))
# -----------------------------------------
# noise masks linear
# -----------------------------------------
import imgaug as ia
from imgaug import augmenters as iaa
seed = 1
ia.seed(seed)
seq = iaa.BlendAlphaSimplexNoise(foreground=iaa.Multiply(iap.Choice(
[0.5, 1.5]),
per_channel=True),
upscale_method="linear")
masks = [
seq.factor.draw_samples((64, 64),
random_state=ia.new_random_state(seed + 1 + i))
for i in range(16)
]
masks = np.hstack(masks)
masks = np.tile(masks[:, :, np.newaxis], (1, 1, 1, 3))
masks = (masks * 255).astype(np.uint8)
# ------------
save("alpha", "alpha_simplex_noise_masks_linear.jpg",
grid(masks, cols=16, rows=1))
def main():
image = data.astronaut()
image = ia.imresize_single_image(image, (128, 128))
# check if scipy and cv2 remap similarly
rs = ia.new_random_state(1)
aug_scipy = ElasticTransformationScipy(alpha=30, sigma=3, random_state=rs, deterministic=True)
aug_cv2 = ElasticTransformationCv2(alpha=30, sigma=3, random_state=rs, deterministic=True)
augs_scipy = aug_scipy.augment_images([image] * 8)
augs_cv2 = aug_cv2.augment_images([image] * 8)
ia.imshow(ia.draw_grid(augs_scipy + augs_cv2, rows=2))
print("alpha=vary, sigma=0.25")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=0.25) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=1.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=1.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=3.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=3.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=vary, sigma=5.0")
augs = [iaa.ElasticTransformation(alpha=alpha, sigma=5.0) for alpha in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=1.0, sigma=vary")
augs = [iaa.ElasticTransformation(alpha=1.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
print("alpha=10.0, sigma=vary")
augs = [iaa.ElasticTransformation(alpha=10.0, sigma=sigma) for sigma in np.arange(0.0, 50.0, 0.1)]
images_aug = [aug.augment_image(image) for aug in augs]
ia.imshow(ia.draw_grid(images_aug, cols=10))
kps = ia.KeypointsOnImage(
[ia.Keypoint(x=1, y=1),
ia.Keypoint(x=50, y=24), ia.Keypoint(x=42, y=96), ia.Keypoint(x=88, y=106), ia.Keypoint(x=88, y=53),
ia.Keypoint(x=0, y=0), ia.Keypoint(x=128, y=128), ia.Keypoint(x=-20, y=30), ia.Keypoint(x=20, y=-30),
ia.Keypoint(x=-20, y=-30)],
shape=image.shape
)
images = []
params = [
(0.0, 0.0),
(0.2, 0.2),
(2.0, 0.25),
(0.25, 3.0),
(2.0, 3.0),
(6.0, 3.0),
(12.0, 3.0),
(50.0, 5.0),
(100.0, 5.0),
(100.0, 10.0)
]
for (alpha, sigma) in params:
images_row = []
seqs_row = [
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=0, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=128, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="constant", cval=255, order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="nearest", order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="reflect", order=3),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=0),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=1),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=2),
iaa.ElasticTransformation(alpha=alpha, sigma=sigma, mode="wrap", order=3)
]
for seq in seqs_row:
seq_det = seq.to_deterministic()
image_aug = seq_det.augment_image(image)
kps_aug = seq_det.augment_keypoints([kps])[0]
image_aug_kp = np.copy(image_aug)
image_aug_kp = kps_aug.draw_on_image(image_aug_kp, size=3)
images_row.append(image_aug_kp)
images.append(np.hstack(images_row))
ia.imshow(np.vstack(images))
imageio.imwrite("elastic_transformations.jpg", np.vstack(images))
