def chapter_augmenters_cutout():
aug = iaa.Cutout(nb_iterations=2)
run_and_save_augseq("arithmetic/cutout_nb_iterations_2.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.Cutout(nb_iterations=(1, 5), size=0.2, squared=False)
run_and_save_augseq("arithmetic/cutout_non_square.jpg",
aug,
[ia.quokka(size=(128, 170)) for _ in range(3 * 2)],
cols=3,
rows=2)
aug = iaa.Cutout(fill_mode="constant", cval=255)
run_and_save_augseq("arithmetic/cutout_cval_255.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.Cutout(fill_mode="constant", cval=(0, 255), fill_per_channel=0.5)
run_and_save_augseq("arithmetic/cutout_rgb.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.Cutout(fill_mode="gaussian", fill_per_channel=True)
run_and_save_augseq("arithmetic/cutout_gaussian.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def chapter_augmenters_coarsesaltandpepper():
fn_start = "arithmetic/coarsesaltandpepper"
aug = iaa.CoarseSaltAndPepper(0.05, size_percent=(0.01, 0.1))
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2,
quality=95)
aug = iaa.CoarseSaltAndPepper(0.05, size_px=(4, 16))
run_and_save_augseq(fn_start + "_pixels.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2,
quality=95)
aug = iaa.CoarseSaltAndPepper(0.05,
size_percent=(0.01, 0.1),
per_channel=True)
run_and_save_augseq(fn_start + "_per_channel.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2,
quality=95)
def chapter_augmenters_affine():
fn_start = "pillike/affine"
aug = iaa.pillike.Affine(scale={"x": (0.8, 1.2), "y": (0.5, 1.5)})
run_and_save_augseq(fn_start + "_scale.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.pillike.Affine(translate_px={
"x": 0,
"y": [-10, 10]
},
fillcolor=128)
run_and_save_augseq(fn_start + "_translate_fillcolor.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.pillike.Affine(rotate=(-20, 20), fillcolor=(0, 256))
run_and_save_augseq(fn_start + "_rotate_fillcolor.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def chapter_augmenters_uniformcolorquantization():
fn_start = "color/uniformcolorquantization"
aug = iaa.UniformColorQuantization()
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.UniformColorQuantization(n_colors=8)
run_and_save_augseq(fn_start + "_with_8_colors.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.UniformColorQuantization(n_colors=(4, 16))
run_and_save_augseq(fn_start + "_with_random_n_colors.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3,
seed=2)
aug = iaa.UniformColorQuantization(
from_colorspace=iaa.ChangeColorspace.BGR,
to_colorspace=[iaa.ChangeColorspace.RGB, iaa.ChangeColorspace.HSV])
quokka_bgr = cv2.cvtColor(ia.quokka(size=(128, 128)), cv2.COLOR_RGB2BGR)
run_and_save_augseq(fn_start + "_in_rgb_or_hsv.jpg",
aug, [quokka_bgr for _ in range(8)],
cols=4,
rows=2,
image_colorspace="BGR")
def chapter_augmenters_randaugment():
fn_start = "collections/randaugment"
aug = iaa.RandAugment(n=2, m=9)
run_and_save_augseq(fn_start + "_standard_case.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.RandAugment(m=30)
run_and_save_augseq(fn_start + "_strong_magnitude.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.RandAugment(m=(0, 9))
run_and_save_augseq(fn_start + "_random_magnitude.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.RandAugment(n=(0, 3))
run_and_save_augseq(fn_start + "_random_iterations.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
def _test_map_batches_both(self, call_async):
augseq = iaa.Noop()
mock_Pool = mock.MagicMock()
mock_Pool.return_value = mock_Pool
mock_Pool.map.return_value = "X"
mock_Pool.map_async.return_value = "X"
with mock.patch("multiprocessing.Pool", mock_Pool):
batches = [
ia.Batch(images=[ia.quokka()]),
ia.Batch(images=[ia.quokka() + 1])
]
with multicore.Pool(augseq, processes=1) as pool:
if call_async:
_ = pool.map_batches_async(batches)
else:
_ = pool.map_batches(batches)
if call_async:
to_check = mock_Pool.map_async
else:
to_check = mock_Pool.map
assert to_check.call_count == 1
# args, arg 0
assert to_check.call_args[0][0] == multicore._Pool_starworker
# args, arg 1 (batches with ids), tuple 0, entry 0 in tuple (=> batch id)
assert to_check.call_args[0][1][0][0] == 0
# args, arg 1 (batches with ids), tuple 0, entry 1 in tuple (=> batch)
assert np.array_equal(to_check.call_args[0][1][0][1].images_unaug,
batches[0].images_unaug)
# args, arg 1 (batches with ids), tuple 1, entry 0 in tuple (=> batch id)
assert to_check.call_args[0][1][1][0] == 1
# args, arg 1 (batches with ids), tuple 1, entry 1 in tuple (=> batch)
assert np.array_equal(to_check.call_args[0][1][1][1].images_unaug,
batches[1].images_unaug)
def chapter_augmenters_someof():
aug = iaa.SomeOf(2, [
iaa.Affine(rotate=45),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.Add(50, per_channel=True),
iaa.Sharpen(alpha=0.5)
])
run_and_save_augseq("meta/someof.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.SomeOf((0, None), [
iaa.Affine(rotate=45),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.Add(50, per_channel=True),
iaa.Sharpen(alpha=0.5)
])
run_and_save_augseq("meta/someof_0_to_none.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.SomeOf(2, [
iaa.Affine(rotate=45),
iaa.AdditiveGaussianNoise(scale=0.2 * 255),
iaa.Add(50, per_channel=True),
iaa.Sharpen(alpha=0.5)
],
random_order=True)
run_and_save_augseq("meta/someof_random_order.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def chapter_augmenters_directededgedetect():
aug = iaa.DirectedEdgeDetect(alpha=(0.0, 1.0), direction=(0.0, 1.0))
run_and_save_augseq("convolutional/directededgedetect.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
#alphas = [1/8*i for i in range(8)]
alphas = np.linspace(0, 1.0, num=8)
run_and_save_augseq(
"convolutional/directededgedetect_vary_alpha.jpg",
[iaa.DirectedEdgeDetect(alpha=alpha, direction=0)
for alpha in alphas], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1)
#strength = [0.5+(0.5/8)*i for i in range(8)]
directions = np.linspace(0.0, 1.0, num=8)
run_and_save_augseq(
"convolutional/directededgedetect_vary_direction.jpg", [
iaa.DirectedEdgeDetect(alpha=1.0, direction=direction)
for direction in directions
], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1)
def _test_map_batches_both(self, call_async):
for clazz in [Batch, UnnormalizedBatch]:
augseq = iaa.Noop()
mock_Pool = mock.MagicMock()
mock_Pool.return_value = mock_Pool
mock_Pool.map.return_value = "X"
mock_Pool.map_async.return_value = "X"
with mock.patch("multiprocessing.Pool", mock_Pool):
batches = [
clazz(images=[ia.quokka()]),
clazz(images=[ia.quokka()+1])
]
with multicore.Pool(augseq, processes=1) as pool:
if call_async:
_ = pool.map_batches_async(batches)
else:
_ = pool.map_batches(batches)
if call_async:
to_check = mock_Pool.map_async
else:
to_check = mock_Pool.map
assert to_check.call_count == 1
# args, arg 0
assert to_check.call_args[0][0] == multicore._Pool_starworker
# args, arg 1 (batches with ids), tuple 0, entry 0 in tuple (=> batch id)
assert to_check.call_args[0][1][0][0] == 0
# args, arg 1 (batches with ids), tuple 0, entry 1 in tuple (=> batch)
assert np.array_equal(to_check.call_args[0][1][0][1].images_unaug, batches[0].images_unaug)
# args, arg 1 (batches with ids), tuple 1, entry 0 in tuple (=> batch id)
assert to_check.call_args[0][1][1][0] == 1
# args, arg 1 (batches with ids), tuple 1, entry 1 in tuple (=> batch)
assert np.array_equal(to_check.call_args[0][1][1][1].images_unaug, batches[1].images_unaug)
def chapter_augmenters_superpixels():
aug = iaa.Superpixels(p_replace=0.5, n_segments=64)
run_and_save_augseq("segmentation/superpixels_50_64.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.Superpixels(p_replace=(0.1, 1.0), n_segments=(16, 128))
run_and_save_augseq("segmentation/superpixels.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
#ps = [1/8*i for i in range(8)]
ps = np.linspace(0, 1.0, num=8)
run_and_save_augseq(
"segmentation/superpixels_vary_p.jpg",
[iaa.Superpixels(p_replace=p, n_segments=64)
for p in ps], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1)
ns = [16 * i for i in range(1, 9)]
run_and_save_augseq(
"segmentation/superpixels_vary_n.jpg",
[iaa.Superpixels(p_replace=1.0, n_segments=n)
for n in ns], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1)
def chapter_augmenters_minpooling():
fn_start = "pooling/minpooling"
aug_cls = iaa.MinPooling
aug = aug_cls(2)
run_and_save_augseq(
fn_start + ".jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*1)], cols=4, rows=1)
aug = aug_cls(2, keep_size=False)
run_and_save_augseq(
fn_start + "_keep_size_false.jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*1)], cols=4, rows=1)
aug = aug_cls([2, 8])
run_and_save_augseq(
fn_start + "_choice.jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*2)], cols=4, rows=2)
aug = aug_cls((1, 7))
run_and_save_augseq(
fn_start + "_uniform.jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*2)], cols=4, rows=2)
aug = aug_cls(((1, 7), (1, 7)))
run_and_save_augseq(
fn_start + "_unsymmetric.jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*2)], cols=4, rows=2)
def chapter_augmenters_blendalphahorizontallineargradient():
fn_start = "blend/blendalphahorizontallineargradient"
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AddToHue((-100, 100)))
run_and_save_augseq(fn_start + "_hue.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.TotalDropout(1.0),
min_value=0.2,
max_value=0.8)
run_and_save_augseq(fn_start + "_total_dropout.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.BlendAlphaHorizontalLinearGradient(iaa.AveragePooling(11),
start_at=(0.0, 1.0),
end_at=(0.0, 1.0))
run_and_save_augseq(fn_start + "_pooling.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def chapter_augmenters_uniformcolorquantizationtonbits():
fn_start = "color/uniformcolorquantizationtonbits"
aug = iaa.UniformColorQuantizationToNBits()
run_and_save_augseq(fn_start + ".jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.UniformColorQuantizationToNBits(nb_bits=(2, 8))
run_and_save_augseq(fn_start + "_2_to_8.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3)
aug = iaa.UniformColorQuantizationToNBits(
from_colorspace=iaa.CSPACE_BGR,
to_colorspace=[iaa.CSPACE_RGB, iaa.CSPACE_HSV])
run_and_save_augseq(fn_start + "_with_random_n_colors.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 3)],
cols=4,
rows=3,
seed=2)
def chapter_augmenters_blendalphasimplexnoise():
fn_start = "blend/blendalphasimplexnoise"
aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0))
run_and_save_augseq(fn_start + ".jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0), upscale_method="nearest")
run_and_save_augseq(fn_start + "_nearest.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0), upscale_method="linear")
run_and_save_augseq(fn_start + "_linear.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.SimplexNoiseAlpha(iaa.EdgeDetect(1.0),
sigmoid_thresh=iap.Normal(10.0, 5.0))
run_and_save_augseq(fn_start + "_sigmoid_thresh_normal.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 2)],
cols=4,
rows=2)
def chapter_augmenters_cropandpad():
aug = iaa.CropAndPad(percent=(-0.25, 0.25))
run_and_save_augseq("cropandpad_percent.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.CropAndPad(percent=(0, 0.2),
pad_mode=["constant", "edge"],
pad_cval=(0, 128))
run_and_save_augseq("cropandpad_mode_cval.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
aug = iaa.CropAndPad(px=((0, 30), (0, 10), (0, 30), (0, 10)),
pad_mode=ia.ALL,
pad_cval=(0, 128))
run_and_save_augseq("cropandpad_pad_complex.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(32)],
cols=8,
rows=4)
aug = iaa.CropAndPad(px=(-10, 10), sample_independently=False)
run_and_save_augseq("cropandpad_correlated.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
def chapter_augmenters_histogramequalization():
fn_start = "contrast/histogramequalization"
aug = iaa.HistogramEqualization()
run_and_save_augseq(fn_start + ".jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 1)],
cols=4,
rows=1)
aug = iaa.Alpha((0.0, 1.0), iaa.HistogramEqualization())
run_and_save_augseq(fn_start + "_alpha.jpg",
aug,
[ia.quokka(size=(128, 128)) for _ in range(4 * 4)],
cols=4,
rows=4)
aug = iaa.HistogramEqualization(
from_colorspace=iaa.HistogramEqualization.BGR,
to_colorspace=iaa.HistogramEqualization.HSV)
quokka_bgr = cv2.cvtColor(ia.quokka(size=(128, 128)), cv2.COLOR_RGB2BGR)
run_and_save_augseq(fn_start + "_bgr_to_hsv.jpg",
aug, [quokka_bgr for _ in range(4 * 1)],
cols=4,
rows=1,
image_colorspace="RGB")
def chapter_augmenters_sharpen():
aug = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))
run_and_save_augseq("sharpen.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
#alphas = [1/8*i for i in range(8)]
alphas = np.linspace(0, 1.0, num=8)
run_and_save_augseq(
"sharpen_vary_alpha.jpg",
[iaa.Sharpen(alpha=alpha, lightness=1.0)
for alpha in alphas], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1,
quality=90)
#lightnesses = [1/8*i for i in range(8)]
lightnesses = np.linspace(0.75, 1.5, num=8)
run_and_save_augseq("sharpen_vary_lightness.jpg", [
iaa.Sharpen(alpha=1.0, lightness=lightness)
for lightness in lightnesses
], [ia.quokka(size=(64, 64)) for _ in range(8)],
cols=8,
rows=1,
quality=90)
def chapter_augmenters_padtofixedsize():
fn_start = "size/padtofixedsize"
aug_cls = iaa.PadToFixedSize
aug = aug_cls(width=100, height=100)
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(80, 80)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = aug_cls(width=100, height=100, position="center")
run_and_save_augseq(fn_start + "_center.jpg",
aug, [ia.quokka(size=(80, 80)) for _ in range(4 * 1)],
cols=4,
rows=1)
aug = aug_cls(width=100, height=100, pad_mode=ia.ALL)
run_and_save_augseq(fn_start + "_pad_mode.jpg",
aug, [ia.quokka(size=(80, 80)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.Sequential([
iaa.PadToFixedSize(width=100, height=100),
iaa.CropToFixedSize(width=100, height=100)
])
run_and_save_augseq(fn_start + "_with_croptofixedsize.jpg",
aug, [ia.quokka(size=(80, 120)) for _ in range(4 * 2)],
cols=4,
rows=2)
def chapter_augmenters_keepsizebyresize():
# TODO add example images for heatmaps, segmaps
fn_start = "size/keepsizebyresize"
aug = iaa.KeepSizeByResize(iaa.Crop((20, 40), keep_size=False))
run_and_save_augseq(fn_start + "_crop.jpg",
aug,
[ia.quokka(size=(120, 120)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.KeepSizeByResize(iaa.Crop((20, 40), keep_size=False),
interpolation="nearest")
run_and_save_augseq(fn_start + "_crop_nearest.jpg",
aug,
[ia.quokka(size=(120, 120)) for _ in range(4 * 2)],
cols=4,
rows=2)
aug = iaa.KeepSizeByResize(
iaa.Crop((20, 40), keep_size=False),
interpolation=["nearest", "cubic"],
interpolation_heatmaps=iaa.KeepSizeByResize.SAME_AS_IMAGES,
interpolation_segmaps=iaa.KeepSizeByResize.NO_RESIZE)
run_and_save_augseq(fn_start + "_various_augmentables.jpg",
aug,
[ia.quokka(size=(120, 120)) for _ in range(4 * 4)],
cols=4,
rows=4)
def chapter_augmenters_invert():
aug = iaa.Invert(0.5)
run_and_save_augseq("invert.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
aug = iaa.Invert(0.25, per_channel=0.5)
run_and_save_augseq("invert_per_channel.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
def chapter_augmenters_multiply():
aug = iaa.Multiply((0.5, 1.5))
run_and_save_augseq("multiply.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
aug = iaa.Multiply((0.5, 1.5), per_channel=0.5)
run_and_save_augseq("multiply_per_channel.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
def chapter_augmenters_add():
aug = iaa.Add((-40, 40))
run_and_save_augseq("arithmetic/add.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.Add((-40, 40), per_channel=0.5)
run_and_save_augseq("arithmetic/add_per_channel.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def chapter_augmenters_perspectivetransform():
fn_start = "geometric/perspectivetransform"
aug = iaa.PerspectiveTransform(scale=(0.01, 0.15))
run_and_save_augseq(
fn_start + ".jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*3)], cols=4, rows=3)
aug = iaa.PerspectiveTransform(scale=(0.01, 0.15), keep_size=False)
run_and_save_augseq(
fn_start + "_keep_size_false.jpg", aug,
[ia.quokka(size=(128, 128)) for _ in range(4*3)], cols=4, rows=3)
def chapter_augmenters_contrastnormalization():
aug = iaa.ContrastNormalization((0.5, 1.5))
run_and_save_augseq("contrastnormalization.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
aug = iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5)
run_and_save_augseq("contrastnormalization_per_channel.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(16)],
cols=8,
rows=2)
def chapter_augmenters_withchannels():
aug = iaa.WithChannels(0, iaa.Add((10, 100)))
run_and_save_augseq("meta/withchannels.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.WithChannels(0, iaa.Affine(rotate=(0, 45)))
run_and_save_augseq("meta/withchannels_affine.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def chapter_augmenters_dropout():
aug = iaa.Dropout(p=(0, 0.2))
run_and_save_augseq("arithmetic/dropout.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
aug = iaa.Dropout(p=(0, 0.2), per_channel=0.5)
run_and_save_augseq("arithmetic/dropout_per_channel.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(8)],
cols=4,
rows=2)
def chapter_augmenters_averageblur():
aug = iaa.AverageBlur(k=(2, 11))
run_and_save_augseq("blur/averageblur.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(16)],
cols=4,
rows=4)
aug = iaa.AverageBlur(k=((5, 11), (1, 3)))
run_and_save_augseq("blur/averageblur_mixed.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(16)],
cols=4,
rows=4)
def chapter_augmenters_motionblur():
fn_start = "blur/motionblur"
aug = iaa.MotionBlur(k=15)
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(16)],
cols=4,
rows=4)
aug = iaa.MotionBlur(k=15, angle=[-45, 45])
run_and_save_augseq(fn_start + "_angle.jpg",
aug, [ia.quokka(size=(128, 128)) for _ in range(16)],
cols=4,
rows=4)
def chapter_augmenters_channelshuffle():
fn_start = "meta/channelshuffle"
aug = iaa.ChannelShuffle(0.35)
run_and_save_augseq(fn_start + ".jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(8 * 3)],
cols=8,
rows=3)
aug = iaa.ChannelShuffle(0.35, channels=[0, 1])
run_and_save_augseq(fn_start + "_limited_channels.jpg",
aug, [ia.quokka(size=(64, 64)) for _ in range(8 * 3)],
cols=8,
rows=3)
def chapter_augmenters_addelementwise():
aug = iaa.AddElementwise((-40, 40))
run_and_save_augseq("addelementwise.jpg",
aug, [ia.quokka(size=(512, 512)) for _ in range(1)],
cols=1,
rows=1,
quality=90)
aug = iaa.AddElementwise((-40, 40), per_channel=0.5)
run_and_save_augseq("addelementwise_per_channel.jpg",
aug, [ia.quokka(size=(512, 512)) for _ in range(1)],
cols=1,
rows=1,
quality=90)
def _test_imap_batches_both(cls, call_unordered):
for clazz in [Batch, UnnormalizedBatch]:
batches = [
clazz(images=[ia.quokka()]),
clazz(images=[ia.quokka() + 1])
]
def _generate_batches():
for batch in batches:
yield batch
augseq = iaa.Identity()
mock_Pool = mock.MagicMock()
mock_Pool.return_value = mock_Pool
mock_Pool.imap.return_value = batches
mock_Pool.imap_unordered.return_value = batches
with mock.patch("multiprocessing.pool.Pool", mock_Pool):
with multicore.Pool(augseq, processes=1) as pool:
gen = _generate_batches()
if call_unordered:
_ = list(pool.imap_batches_unordered(gen))
else:
_ = list(pool.imap_batches(gen))
if call_unordered:
to_check = mock_Pool.imap_unordered
else:
to_check = mock_Pool.imap
assert to_check.call_count == 1
assert to_check.call_args[0][0] == multicore._Pool_starworker
# convert generator to list, make it subscriptable
arg_batches = list(to_check.call_args[0][1])
# args, arg 1 (batches with ids), tuple 0,
# entry 0 in tuple (=> batch id)
assert arg_batches[0][0] == 0
# tuple 0, entry 1 in tuple (=> batch)
assert np.array_equal(arg_batches[0][1].images_unaug,
batches[0].images_unaug)
# tuple 1, entry 0 in tuple (=> batch id)
assert arg_batches[1][0] == 1
# tuple 1, entry 1 in tuple (=> batch)
assert np.array_equal(arg_batches[1][1].images_unaug,
batches[1].images_unaug)
def main():
image = ia.quokka(0.5)
height, width = image.shape[0], image.shape[1]
center_x = width // 2
center_y = height // 2
r = int(min(image.shape[0], image.shape[1]) / 3)
cv2.namedWindow("aug", cv2.WINDOW_NORMAL)
cv2.imshow("aug", image[:, :, ::-1])
cv2.waitKey(TIME_PER_STEP)
for angle in cycle(np.arange(0, 360, DEG_PER_STEP)):
rad = np.deg2rad(angle-90)
point_x = int(center_x + r * np.cos(rad))
point_y = int(center_y + r * np.sin(rad))
aug = iaa.MotionBlur(k=35, angle=angle, direction=-1.0)
img_aug = aug.augment_image(image)
img_aug[
point_y-POINT_SIZE:point_y+POINT_SIZE+1,
point_x-POINT_SIZE:point_x+POINT_SIZE+1,
:] = np.array([0, 255, 0])
aug_inv = iaa.MotionBlur(k=35, angle=angle, direction=1.0)
img_aug_inv = aug_inv.augment_image(image)
img_aug_inv[
point_y - POINT_SIZE:point_y + POINT_SIZE + 1,
point_x - POINT_SIZE:point_x + POINT_SIZE + 1,
:] = np.array([0, 255, 0])
cv2.imshow("aug", np.hstack([img_aug[:, :, ::-1], img_aug_inv[:, :, ::-1]]))
cv2.waitKey(TIME_PER_STEP)
def main():
image = ia.quokka()
image_gray = np.average(image, axis=2).astype(np.uint8)
image_gray_3d = image_gray[:, :, np.newaxis]
ia.imshow(image)
ia.imshow(image / 255.0)
ia.imshow(image_gray)
ia.imshow(image_gray_3d)
def main():
image = ia.quokka(size=0.5)
print(image.shape)
kps = [
ia.KeypointsOnImage(
[
ia.Keypoint(x=123, y=102),
ia.Keypoint(x=182, y=98),
ia.Keypoint(x=155, y=134),
#ia.Keypoint(x=255, y=213),
#ia.Keypoint(x=375, y=205),
#ia.Keypoint(x=323, y=279),
#ia.Keypoint(x=265, y=223),
#ia.Keypoint(x=385, y=215),
#ia.Keypoint(x=333, y=289),
#ia.Keypoint(x=275, y=233),
#ia.Keypoint(x=395, y=225),
#ia.Keypoint(x=343, y=299),
ia.Keypoint(x=-20, y=20)
],
shape=(image.shape[0], image.shape[1])
)
]
#kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
#iaa.PiecewiseAffine(scale=0),
iaa.PiecewiseAffine(scale=0.05),
iaa.PiecewiseAffine(scale=0.1),
iaa.PiecewiseAffine(scale=0.2)
]
#print("original", image.shape)
misc.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
#img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
#print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
images_aug.append(img_aug_kps)
#misc.imshow(img_aug_kps)
print(aug.name)
misc.imshow(ia.draw_grid(images_aug))
def _test_imap_batches_both(self, call_unordered):
for clazz in [Batch, UnnormalizedBatch]:
batches = [clazz(images=[ia.quokka()]),
clazz(images=[ia.quokka()+1])]
def _generate_batches():
for batch in batches:
yield batch
augseq = iaa.Noop()
mock_Pool = mock.MagicMock()
mock_Pool.return_value = mock_Pool
mock_Pool.imap.return_value = batches
mock_Pool.imap_unordered.return_value = batches
with mock.patch("multiprocessing.Pool", mock_Pool):
with multicore.Pool(augseq, processes=1) as pool:
gen = _generate_batches()
if call_unordered:
_ = list(pool.imap_batches_unordered(gen))
else:
_ = list(pool.imap_batches(gen))
if call_unordered:
to_check = mock_Pool.imap_unordered
else:
to_check = mock_Pool.imap
assert to_check.call_count == 1
assert to_check.call_args[0][0] == multicore._Pool_starworker
arg_batches = list(to_check.call_args[0][1]) # convert generator to list, make it subscriptable
# args, arg 1 (batches with ids), tuple 0, entry 0 in tuple (=> batch id)
assert arg_batches[0][0] == 0
# tuple 0, entry 1 in tuple (=> batch)
assert np.array_equal(arg_batches[0][1].images_unaug, batches[0].images_unaug)
# tuple 1, entry 0 in tuple (=> batch id)
assert arg_batches[1][0] == 1
# tuple 1, entry 1 in tuple (=> batch)
assert np.array_equal(arg_batches[1][1].images_unaug, batches[1].images_unaug)
def main():
augs = [
("iaa.Rot90(-1, keep_size=False)", iaa.Rot90(-1, keep_size=False)),
("iaa.Rot90(0, keep_size=False)", iaa.Rot90(0, keep_size=False)),
("iaa.Rot90(1, keep_size=False)", iaa.Rot90(1, keep_size=False)),
("iaa.Rot90(2, keep_size=False)", iaa.Rot90(2, keep_size=False)),
("iaa.Rot90(3, keep_size=False)", iaa.Rot90(3, keep_size=False)),
("iaa.Rot90(4, keep_size=False)", iaa.Rot90(4, keep_size=False)),
("iaa.Rot90(-1, keep_size=True)", iaa.Rot90(-1, keep_size=True)),
("iaa.Rot90(0, keep_size=True)", iaa.Rot90(0, keep_size=True)),
("iaa.Rot90(1, keep_size=True)", iaa.Rot90(1, keep_size=True)),
("iaa.Rot90(2, keep_size=True)", iaa.Rot90(2, keep_size=True)),
("iaa.Rot90(3, keep_size=True)", iaa.Rot90(3, keep_size=True)),
("iaa.Rot90(4, keep_size=True)", iaa.Rot90(4, keep_size=True)),
("iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=False)),
("iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)", iaa.Rot90([0, 1, 2, 3, 4], keep_size=True)),
("iaa.Rot90((0, 4), keep_size=False)", iaa.Rot90((0, 4), keep_size=False)),
("iaa.Rot90((0, 4), keep_size=True)", iaa.Rot90((0, 4), keep_size=True)),
("iaa.Rot90((1, 3), keep_size=False)", iaa.Rot90((1, 3), keep_size=False)),
("iaa.Rot90((1, 3), keep_size=True)", iaa.Rot90((1, 3), keep_size=True))
]
image = ia.quokka(0.25)
print("--------")
print("Image + Keypoints")
print("--------")
kps = ia.quokka_keypoints(0.25)
for name, aug in augs:
print(name, "...")
aug_det = aug.to_deterministic()
images_aug = aug_det.augment_images([image] * 16)
kps_aug = aug_det.augment_keypoints([kps] * 16)
images_aug = [kps_aug_i.draw_on_image(image_aug_i, size=5)
for image_aug_i, kps_aug_i in zip(images_aug, kps_aug)]
ia.imshow(ia.draw_grid(images_aug))
print("--------")
print("Image + Heatmaps (low res)")
print("--------")
hms = ia.quokka_heatmap(0.10)
for name, aug in augs:
print(name, "...")
aug_det = aug.to_deterministic()
images_aug = aug_det.augment_images([image] * 16)
hms_aug = aug_det.augment_heatmaps([hms] * 16)
images_aug = [hms_aug_i.draw_on_image(image_aug_i)[0]
for image_aug_i, hms_aug_i in zip(images_aug, hms_aug)]
ia.imshow(ia.draw_grid(images_aug))
def main():
img = ia.quokka(0.5)
mul = 0.01
augs = [
("iaa.ImpulseNoise(p=0*mul)", iaa.ImpulseNoise(p=0*mul)),
("iaa.ImpulseNoise(p=1*mul)", iaa.ImpulseNoise(p=1*mul)),
("iaa.ImpulseNoise(p=2*mul)", iaa.ImpulseNoise(p=2*mul)),
("iaa.ImpulseNoise(p=3*mul)", iaa.ImpulseNoise(p=3*mul)),
("iaa.ImpulseNoise(p=(0*mul, 1*mul))", iaa.ImpulseNoise(p=(0*mul, 1*mul))),
("iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul])", iaa.ImpulseNoise(p=[0*mul, 1*mul, 2*mul]))
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def main():
img = ia.quokka(0.5)
augs = [
("iaa.AdditivePoissonNoise(0)", iaa.AdditivePoissonNoise(0)),
("iaa.AdditivePoissonNoise(10.0)", iaa.AdditivePoissonNoise(10.0)),
("iaa.AdditivePoissonNoise(20.0)", iaa.AdditivePoissonNoise(20.0)),
("iaa.AdditivePoissonNoise(50.0)", iaa.AdditivePoissonNoise(50.0)),
("iaa.AdditivePoissonNoise((10.0, 20))", iaa.AdditivePoissonNoise((10.0, 20))),
("iaa.AdditivePoissonNoise([10.0, 20.0, 50])", iaa.AdditivePoissonNoise([10.0, 20.0, 50])),
("iaa.AdditivePoissonNoise(20, per_channel=True)", iaa.AdditivePoissonNoise(50, per_channel=True)),
]
for descr, aug in augs:
print(descr)
imgs_aug = aug.augment_images([img] * 16)
ia.imshow(ia.draw_grid(imgs_aug))
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.PerspectiveTransform(scale=0.01, name="pt001", keep_size=True),
iaa.PerspectiveTransform(scale=0.1, name="pt01", keep_size=True),
iaa.PerspectiveTransform(scale=0.2, name="pt02", keep_size=True),
iaa.PerspectiveTransform(scale=0.3, name="pt03", keep_size=True),
iaa.PerspectiveTransform(scale=(0, 0.3), name="pt00to03", keep_size=True)
]
print("original", image.shape)
misc.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
#print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
images_aug.append(img_aug_kps)
#misc.imshow(img_aug_kps)
print(aug.name)
misc.imshow(ia.draw_grid(images_aug))
print("----------------")
print("6 channels")
print("----------------")
image6 = np.dstack([image, image])
image6_aug = augs[1].augment_image(image6)
misc.imshow(
np.hstack([image6_aug[..., 0:3], image6_aug[..., 3:6]])
)
def main():
augs = [
("0", iaa.JpegCompression(compression=0)),
("1", iaa.JpegCompression(compression=1)),
("25", iaa.JpegCompression(compression=25)),
("50", iaa.JpegCompression(compression=50)),
("75", iaa.JpegCompression(compression=75)),
("99", iaa.JpegCompression(compression=99)),
("100", iaa.JpegCompression(compression=100)),
("(0, 50)", iaa.JpegCompression(compression=(0, 50))),
("(50, 100)", iaa.JpegCompression(compression=(50, 100))),
("(0, 100)", iaa.JpegCompression(compression=(0, 100))),
]
image = ia.quokka(size=(256, 256), extract="square")
images = np.uint8([image] * (5*5))
for i, (name, aug) in enumerate(augs):
print(i, name)
images_aug = aug.augment_images(images)
ia.imshow(ia.draw_grid(images_aug, cols=5, rows=5))
def main():
image = ia.quokka(size=0.5)
print(image.shape)
kps = [
ia.KeypointsOnImage(
[
ia.Keypoint(x=123, y=102),
ia.Keypoint(x=182, y=98),
ia.Keypoint(x=155, y=134),
ia.Keypoint(x=-20, y=20)
],
shape=(image.shape[0], image.shape[1])
)
]
print("image shape:", image.shape)
augs = [
iaa.PiecewiseAffine(scale=0.05),
iaa.PiecewiseAffine(scale=0.1),
iaa.PiecewiseAffine(scale=0.2)
]
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs:
images_aug = []
for _ in range(16):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = keypoints_draw_on_image(kps_aug, img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def test_determinism():
reseed()
images = [
ia.quokka(size=(128, 128)),
ia.quokka(size=(64, 64)),
ia.imresize_single_image(skimage.data.astronaut(), (128, 256))
]
images.extend([ia.quokka(size=(16, 16))] * 20)
keypoints = [
ia.KeypointsOnImage([
ia.Keypoint(x=20, y=10), ia.Keypoint(x=5, y=5),
ia.Keypoint(x=10, y=43)], shape=(50, 60, 3))
] * 20
augs = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
# iaa.WithChannels([0], iaa.Add((-50, 50))),
# iaa.Noop(name="Noop-nochange"),
# iaa.Lambda(
# func_images=lambda images, random_state, parents, hooks: images,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: keypoints_on_images,
# name="Lambda-nochange"
# ),
# iaa.AssertLambda(
# func_images=lambda images, random_state, parents, hooks: True,
# func_keypoints=lambda keypoints_on_images, random_state, parents, hooks: True,
# name="AssertLambda-nochange"
# ),
# iaa.AssertShape(
# (None, None, None, 3),
# check_keypoints=False,
# name="AssertShape-nochange"
# ),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)),
# iaa.ChangeColorspace(to_colorspace="GRAY"),
iaa.Grayscale(alpha=(0.1, 1.0)),
iaa.GaussianBlur((0.1, 3.0)),
iaa.AverageBlur((3, 11)),
iaa.MedianBlur((3, 11)),
# iaa.Convolve(np.array([[0, 1, 0],
# [1, -4, 1],
# [0, 1, 0]])),
iaa.Sharpen(alpha=(0.1, 1.0), lightness=(0.8, 1.2)),
iaa.Emboss(alpha=(0.1, 1.0), strength=(0.8, 1.2)),
iaa.EdgeDetect(alpha=(0.1, 1.0)),
iaa.DirectedEdgeDetect(alpha=(0.1, 1.0), direction=(0.0, 1.0)),
iaa.Add((-50, 50)),
iaa.AddElementwise((-50, 50)),
iaa.AdditiveGaussianNoise(scale=(0.1, 1.0)),
iaa.Multiply((0.6, 1.4)),
iaa.MultiplyElementwise((0.6, 1.4)),
iaa.Dropout((0.3, 0.5)),
iaa.CoarseDropout((0.3, 0.5), size_percent=(0.05, 0.2)),
iaa.Invert(0.5),
iaa.ContrastNormalization((0.6, 1.4)),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=0.5)
]
augs_affect_geometry = [
iaa.Sequential([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.SomeOf(1, [iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.OneOf([iaa.Fliplr(0.5), iaa.Flipud(0.5)]),
iaa.Sometimes(0.5, iaa.Fliplr(1.0)),
iaa.Resize((0.5, 0.9)),
iaa.CropAndPad(px=(-50, 50)),
iaa.Pad(px=(1, 50)),
iaa.Crop(px=(1, 50)),
iaa.Fliplr(0.5),
iaa.Flipud(0.5),
iaa.Affine(scale=(0.7, 1.3), translate_percent=(-0.1, 0.1),
rotate=(-20, 20), shear=(-20, 20), order=ia.ALL,
mode=ia.ALL, cval=(0, 255)),
iaa.PiecewiseAffine(scale=(0.1, 0.3)),
iaa.ElasticTransformation(alpha=(5, 100), sigma=(3, 5))
]
for aug in augs:
aug_det = aug.to_deterministic()
images_aug1 = aug_det.augment_images(images)
images_aug2 = aug_det.augment_images(images)
aug_det = aug.to_deterministic()
images_aug3 = aug_det.augment_images(images)
images_aug4 = aug_det.augment_images(images)
assert array_equal_lists(images_aug1, images_aug2), \
"Images (1, 2) expected to be identical for %s" % (aug.name,)
assert array_equal_lists(images_aug3, images_aug4), \
"Images (3, 4) expected to be identical for %s" % (aug.name,)
assert not array_equal_lists(images_aug1, images_aug3), \
"Images (1, 3) expected to be different for %s" % (aug.name,)
for aug in augs_affect_geometry:
aug_det = aug.to_deterministic()
kps_aug1 = aug_det.augment_keypoints(keypoints)
kps_aug2 = aug_det.augment_keypoints(keypoints)
aug_det = aug.to_deterministic()
kps_aug3 = aug_det.augment_keypoints(keypoints)
kps_aug4 = aug_det.augment_keypoints(keypoints)
assert keypoints_equal(kps_aug1, kps_aug2), \
"Keypoints (1, 2) expected to be identical for %s" % (aug.name,)
assert keypoints_equal(kps_aug3, kps_aug4), \
"Keypoints (3, 4) expected to be identical for %s" % (aug.name,)
assert not keypoints_equal(kps_aug1, kps_aug3), \
"Keypoints (1, 3) expected to be different for %s" % (aug.name,)
import imgaug as ia
import imageio
import numpy as np
# Load an example image (uint8, 128x128x3).
image = ia.quokka(size=(128, 128), extract="square")
# Create an example mask (bool, 128x128).
# Here, we just randomly place a square on the image.
segmap = np.zeros((128, 128), dtype=bool)
segmap[28:71, 35:85] = True
segmap = ia.SegmentationMapOnImage(segmap, shape=image.shape)
# Draw three columns: (1) original image, (2) original image with mask on top, (3) only mask
cells = [
image,
segmap.draw_on_image(image),
segmap.draw(size=image.shape[:2])
]
# Convert cells to grid image and save.
grid_image = ia.draw_grid(cells, cols=3)
imageio.imwrite("example_segmaps_bool.jpg", grid_image)
import imgaug as ia
from imgaug import augmenters as iaa
import numpy as np
# This seed can be changed - random seed
ia.seed(1)
# Example batch of 100 images
images = np.array(
[ia.quokka(size=(64, 64)) for _ in range(100)],
dtype=np.uint8
)
# Create the transformer function by specifying the different augmentations
seq = iaa.Sequential([
# Horizontal Flips
iaa.Fliplr(0.5),
# Random Crops
iaa.Crop(percent=(0, 0.1)),
# Gaussian blur for 50% of the images
iaa.Sometimes(0.5,
iaa.GaussianBlur(sigma=(0, 0.5))
),
# Strengthen or weaken the contrast in each image.
iaa.ContrastNormalization((0.75, 1.5)),
# Add gaussian noise.
iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),
def main():
quokka = ia.quokka(size=0.5)
h, w = quokka.shape[0:2]
heatmap = np.zeros((h, w), dtype=np.float32)
heatmap[70:120, 90:150] = 0.1
heatmap[30:70, 50:65] = 0.5
heatmap[20:50, 55:85] = 1.0
heatmap[120:140, 0:20] = 0.75
heatmaps = ia.HeatmapsOnImage(heatmap[..., np.newaxis], quokka.shape)
print("Affine...")
aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128)
quokka_aug = aug.augment_image(quokka)
heatmaps_aug = aug.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("Affine with mode=edge...")
aug = iaa.Affine(translate_px={"x": 20}, mode="edge")
quokka_aug = aug.augment_image(quokka)
heatmaps_aug = aug.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("PiecewiseAffine...")
aug = iaa.PiecewiseAffine(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("PerspectiveTransform...")
aug = iaa.PerspectiveTransform(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("ElasticTransformation alpha=3, sig=0.5...")
aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("ElasticTransformation alpha=10, sig=3...")
aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CopAndPad mode=constant...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CopAndPad mode=constant + percent...")
aug = iaa.CropAndPad(percent=(-0.05, 0.05, 0.1, -0.1), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("CropAndPad mode=edge...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
print("Resize...")
aug = iaa.Resize(0.5, interpolation="nearest")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(ia.draw_grid([heatmaps_drawn[0], heatmaps_aug_drawn[0]], cols=2))
print("Alpha...")
aug = iaa.Alpha(0.7, iaa.Affine(rotate=20))
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
heatmaps_aug = aug_det.augment_heatmaps([heatmaps])[0]
heatmaps_drawn = heatmaps.draw_on_image(quokka)
heatmaps_aug_drawn = heatmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
heatmaps_drawn[0],
heatmaps_aug_drawn[0]
])
)
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.CropAndPad(px=50, name="pad-by-50px"),
iaa.CropAndPad(px=(10, 20, 30, 40), name="pad-by-10-20-30-40px"),
iaa.CropAndPad(percent=0.1, name="pad-by-01percent"),
iaa.CropAndPad(percent=(0.01, 0.02, 0.03, 0.04), name="pad-by-001-002-003-004percent"),
iaa.CropAndPad(px=-20, name="crop-by-20px"),
iaa.CropAndPad(px=(-10, -20, -30, -40), name="crop-by-10-20-30-40px"),
iaa.CropAndPad(percent=-0.1, name="crop-by-01percent"),
iaa.CropAndPad(percent=(-0.01, -0.02, -0.03, -0.04), name="crop-by-001-002-003-004percent")
]
augs_many = [
iaa.Crop(px=(0, 50), name="native-crop-0-to-50px"),
iaa.Crop(px=iap.DiscreteUniform(0, 50), name="native-crop-0-to-50px-iap"),
iaa.Pad(px=(0, 50), pad_mode="linear_ramp", pad_cval=(0, 255), name="native-pad-0-to-50px-pad-modes"),
iaa.CropAndPad(px=(0, 50), sample_independently=False, name="pad-by-0-to-50px-same"),
iaa.CropAndPad(px=(0, 50), name="pad-by-0-to-50px"),
iaa.CropAndPad(px=(0, 50), pad_mode=ia.ALL, pad_cval=(0, 255), name="pad-by-0-to-50px-random-pad-modes-cvals"),
iaa.CropAndPad(px=((0, 50), (0, 50), (0, 50), (0, 50)), name="pad-by-0-to-50px-each"),
iaa.CropAndPad(percent=(0, 0.1), sample_independently=False, name="pad-by-0-to-01percent-same"),
iaa.CropAndPad(percent=(0, 0.1), name="pad-by-0-to-01percent"),
iaa.CropAndPad(percent=(0, 0.1), pad_mode=ia.ALL, pad_cval=(0, 255),
name="pad-by-0-to-01percent-random-pad-modes-cvals"),
iaa.CropAndPad(percent=((0, 0.1), (0, 0.1), (0, 0.1), (0, 0.1)), name="pad-by-0-to-01percent-each"),
iaa.CropAndPad(px=(-50, 0), name="crop-by-50-to-0px"),
iaa.CropAndPad(px=((-50, 0), (-50, 0), (-50, 0), (-50, 0)), name="crop-by-50-to-0px-each"),
iaa.CropAndPad(percent=(-0.1, 0), name="crop-by-01-to-0percent"),
iaa.CropAndPad(percent=((-0.1, 0), (-0.1, 0), (-0.1, 0), (-0.1, 0)), name="crop-by-01-to-0percent-each"),
iaa.CropAndPad(px=(-50, 50), name="pad-and-crop-by-50px")
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Same aug per image")
print("-----------------")
for aug in augs:
img_aug = aug.augment_image(image)
kps_aug = aug.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
ia.imshow(img_aug_kps)
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(64):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def main():
quokka = ia.quokka(size=0.5)
h, w = quokka.shape[0:2]
c = 4
segmap = np.zeros((h, w, c), dtype=np.float32)
segmap[70:120, 90:150, 0] = 1.0
segmap[30:70, 50:65, 1] = 1.0
segmap[20:50, 55:85, 2] = 1.0
segmap[120:140, 0:20, 3] = 1.0
segmap = ia.SegmentationMapOnImage(segmap, quokka.shape)
print("Affine...")
aug = iaa.Affine(translate_px={"x": 20}, mode="constant", cval=128)
quokka_aug = aug.augment_image(quokka)
segmaps_aug = aug.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("Affine with mode=edge...")
aug = iaa.Affine(translate_px={"x": 20}, mode="edge")
quokka_aug = aug.augment_image(quokka)
segmaps_aug = aug.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("PiecewiseAffine...")
aug = iaa.PiecewiseAffine(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("PerspectiveTransform...")
aug = iaa.PerspectiveTransform(scale=0.04)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("ElasticTransformation alpha=3, sig=0.5...")
aug = iaa.ElasticTransformation(alpha=3.0, sigma=0.5)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("ElasticTransformation alpha=10, sig=3...")
aug = iaa.ElasticTransformation(alpha=10.0, sigma=3.0)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("CopAndPad mode=constant...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="constant", pad_cval=128)
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("CropAndPad mode=edge...")
aug = iaa.CropAndPad(px=(-10, 10, 15, -15), pad_mode="edge")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
print("Resize...")
aug = iaa.Resize(0.5, interpolation="nearest")
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(ia.draw_grid([segmaps_drawn, segmaps_aug_drawn], cols=2))
print("Alpha...")
aug = iaa.Alpha(0.7, iaa.Affine(rotate=20))
aug_det = aug.to_deterministic()
quokka_aug = aug_det.augment_image(quokka)
segmaps_aug = aug_det.augment_segmentation_maps([segmap])[0]
segmaps_drawn = segmap.draw_on_image(quokka)
segmaps_aug_drawn = segmaps_aug.draw_on_image(quokka_aug)
ia.imshow(
np.hstack([
segmaps_drawn,
segmaps_aug_drawn
])
)
def main():
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs_many = [
iaa.PadToFixedSize(200, 200, name="pad-width200-height200"),
iaa.PadToFixedSize(200, 322, name="pad-width200-height322"),
iaa.PadToFixedSize(200, 400, name="pad-width200-height400"),
iaa.PadToFixedSize(480, 200, name="pad-width480-height200"),
iaa.PadToFixedSize(480, 322, name="pad-width480-height322"), # input size == output size
iaa.PadToFixedSize(480, 400, name="pad-width480-height400"),
iaa.PadToFixedSize(600, 200, name="pad-width600-height200"),
iaa.PadToFixedSize(600, 322, name="pad-width600-height322"),
iaa.PadToFixedSize(600, 400, name="pad-width600-height400"),
iaa.CropToFixedSize(200, 200, name="crop-width200-height200"),
iaa.CropToFixedSize(200, 322, name="crop-width200-height322"),
iaa.CropToFixedSize(200, 400, name="crop-width200-height400"),
iaa.CropToFixedSize(480, 200, name="crop-width480-height200"),
iaa.CropToFixedSize(480, 322, name="crop-width480-height322"), # input size == output size
iaa.CropToFixedSize(480, 400, name="crop-width480-height400"),
iaa.CropToFixedSize(600, 200, name="crop-width600-height200"),
iaa.CropToFixedSize(600, 322, name="crop-width600-height322"),
iaa.CropToFixedSize(600, 400, name="crop-width600-height400"),
iaa.Sequential([
iaa.PadToFixedSize(200, 200),
iaa.CropToFixedSize(200, 200)
], name="pad-crop-width200-height200"),
iaa.Sequential([
iaa.PadToFixedSize(400, 400),
iaa.CropToFixedSize(400, 400)
], name="pad-crop-width400-height400"),
iaa.Sequential([
iaa.PadToFixedSize(600, 600),
iaa.CropToFixedSize(600, 600)
], name="pad-crop-width600-height600"),
iaa.Sequential([
iaa.CropToFixedSize(200, 200),
iaa.PadToFixedSize(200, 200)
], name="crop-pad-width200-height200"),
iaa.Sequential([
iaa.CropToFixedSize(400, 400),
iaa.PadToFixedSize(400, 400)
], name="crop-pad-width400-height400"),
iaa.Sequential([
iaa.CropToFixedSize(600, 600),
iaa.PadToFixedSize(600, 600)
], name="crop-pad-width600-height600"),
]
print("original", image.shape)
ia.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Random aug per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(36):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
img_aug_kps = np.pad(img_aug_kps, ((1, 1), (1, 1), (0, 0)), mode="constant", constant_values=255)
images_aug.append(img_aug_kps)
print(aug.name)
ia.imshow(ia.draw_grid(images_aug))
def main():
# test 2d image
misc.imshow(iaa.Scale(64).augment_image(data.camera()))
# test many images
images = [ia.quokka(size=0.5), ia.quokka(size=0.5)]
images_aug = iaa.Scale(64).augment_images(images)
misc.imshow(np.hstack(images_aug))
image = ia.quokka(size=0.5)
kps = [ia.KeypointsOnImage(
[ia.Keypoint(x=245, y=203), ia.Keypoint(x=365, y=195), ia.Keypoint(x=313, y=269)],
shape=(image.shape[0]*2, image.shape[1]*2)
)]
kps[0] = kps[0].on(image.shape)
print("image shape:", image.shape)
augs = [
iaa.Scale("keep", name="keep"),
iaa.Scale(32, name="i32"),
iaa.Scale(0.5, name="f05"),
iaa.Scale({"height": 32}, name="height32"),
iaa.Scale({"width": 32}, name="width32"),
iaa.Scale({"height": "keep", "width": 32}, name="keep-width32"),
iaa.Scale({"height": 32, "width": "keep"}, name="height32-keep"),
iaa.Scale({"height": "keep", "width": "keep"}, name="keep-keep"),
iaa.Scale({"height": 32, "width": 64}, name="height32width64"),
iaa.Scale({"height": 64, "width": "keep-aspect-ratio"}, name="height64width-kar"),
iaa.Scale({"height": "keep-aspect-ratio", "width": 64}, name="height-kar_width64")
]
augs_many = [
iaa.Scale((32, 128), name="tuple-32-128"),
iaa.Scale([32, 64, 128], name="list-32-64-128"),
iaa.Scale({"height": (32, 128), "width": "keep"}, name="height-32-64_width-keep"),
iaa.Scale({"height": (32, 128), "width": "keep-aspect-ratio"}, name="height-32-128_width-kar"),
iaa.Scale({"height": (32, 128), "width": (32, 128)}, name="height-32-128_width-32-128")
]
print("original", image.shape)
misc.imshow(kps[0].draw_on_image(image))
print("-----------------")
print("Same size per image")
print("-----------------")
for aug in augs:
img_aug = aug.augment_image(image)
kps_aug = aug.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
misc.imshow(img_aug_kps)
print("-----------------")
print("Random per image")
print("-----------------")
for aug in augs_many:
images_aug = []
for _ in range(64):
aug_det = aug.to_deterministic()
img_aug = aug_det.augment_image(image)
kps_aug = aug_det.augment_keypoints(kps)[0]
img_aug_kps = kps_aug.draw_on_image(img_aug)
#print(aug.name, img_aug_kps.shape, img_aug_kps.shape[1]/img_aug_kps.shape[0])
images_aug.append(img_aug_kps)
print(aug.name)
misc.imshow(ia.draw_grid(images_aug))
print("nearest/cv2.INTER_NEAREST/cubic")
misc.imshow(np.hstack([
iaa.Scale(64, interpolation="nearest").augment_image(image),
iaa.Scale(64, interpolation=cv2.INTER_NEAREST).augment_image(image),
iaa.Scale(64, interpolation="cubic").augment_image(image)
]))
print("random nearest/cubic")
iaa.Scale(64, interpolation=["nearest", "cubic"]).show_grid([image], 8, 8)
