aleju--imgaug/test/augmenters/test_meta.py

from __future__ import print_function, division, absolute_import

import os
import warnings
import sys
import itertools
import copy
from abc import ABCMeta, abstractmethod
# unittest only added in 3.4 self.subTest()
if sys.version_info[0] < 3 or sys.version_info[1] < 4:
    import unittest2 as unittest
else:
    import unittest
# unittest.mock is not available in 2.7 (though unittest2 might contain it?)
try:
    import unittest.mock as mock
except ImportError:
    import mock
try:
    import cPickle as pickle
except ImportError:
    import pickle

import numpy as np
import six
import six.moves as sm
import cv2
import PIL.Image
import imageio

import imgaug as ia
from imgaug import augmenters as iaa
from imgaug import parameters as iap
from imgaug import dtypes as iadt
from imgaug import random as iarandom
from imgaug.testutils import (create_random_images, create_random_keypoints,
                              array_equal_lists, keypoints_equal, reseed,
                              assert_cbaois_equal,
                              runtest_pickleable_uint8_img,
                              TemporaryDirectory, is_parameter_instance)
from imgaug.augmentables.heatmaps import HeatmapsOnImage
from imgaug.augmentables.segmaps import SegmentationMapsOnImage
from imgaug.augmentables.lines import LineString, LineStringsOnImage
from imgaug.augmentables.polys import _ConcavePolygonRecoverer
from imgaug.augmentables.batches import _BatchInAugmentation


IS_PY36_OR_HIGHER = (sys.version_info[0] == 3 and sys.version_info[1] >= 6)


class _InplaceDummyAugmenterImgsArray(iaa.meta.Augmenter):
    def __init__(self, addval):
        super(_InplaceDummyAugmenterImgsArray, self).__init__()
        self.addval = addval

    def _augment_batch_(self, batch, random_state, parents, hooks):
        batch.images += self.addval
        return batch

    def get_parameters(self):
        return []


class _InplaceDummyAugmenterImgsList(iaa.meta.Augmenter):
    def __init__(self, addval):
        super(_InplaceDummyAugmenterImgsList, self).__init__()
        self.addval = addval

    def _augment_batch_(self, batch, random_state, parents, hooks):
        assert len(batch.images) > 0
        for i in range(len(batch.images)):
            batch.images[i] += self.addval
        return batch

    def get_parameters(self):
        return []


class _InplaceDummyAugmenterSegMaps(iaa.meta.Augmenter):
    def __init__(self, addval):
        super(_InplaceDummyAugmenterSegMaps, self).__init__()
        self.addval = addval

    def _augment_batch_(self, batch, random_state, parents, hooks):
        assert len(batch.segmentation_maps) > 0
        for i in range(len(batch.segmentation_maps)):
            batch.segmentation_maps[i].arr += self.addval
        return batch

    def get_parameters(self):
        return []


class _InplaceDummyAugmenterKeypoints(iaa.meta.Augmenter):
    def __init__(self, x, y):
        super(_InplaceDummyAugmenterKeypoints, self).__init__()
        self.x = x
        self.y = y

    def _augment_batch_(self, batch, random_state, parents, hooks):
        assert len(batch.keypoints) > 0
        for i in range(len(batch.keypoints)):
            kpsoi = batch.keypoints[i]
            for j in range(len(kpsoi)):
                batch.keypoints[i].keypoints[j].x += self.x
                batch.keypoints[i].keypoints[j].y += self.y
        return batch

    def get_parameters(self):
        return []


class TestIdentity(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_images(self):
        aug = iaa.Identity()
        images = create_random_images((16, 70, 50, 3))

        observed = aug.augment_images(images)

        expected = images
        assert np.array_equal(observed, expected)

    def test_images_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        images = create_random_images((16, 70, 50, 3))

        observed = aug_det.augment_images(images)

        expected = images
        assert np.array_equal(observed, expected)

    def test_heatmaps(self):
        aug = iaa.Identity()
        heatmaps_arr = np.linspace(0.0, 1.0, 2*2, dtype="float32")\
            .reshape((2, 2, 1))
        heatmaps = ia.HeatmapsOnImage(heatmaps_arr, shape=(2, 2, 3))

        observed = aug.augment_heatmaps(heatmaps)

        assert np.allclose(observed.arr_0to1, heatmaps.arr_0to1)

    def test_heatmaps_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        heatmaps_arr = np.linspace(0.0, 1.0, 2*2, dtype="float32")\
            .reshape((2, 2, 1))
        heatmaps = ia.HeatmapsOnImage(heatmaps_arr, shape=(2, 2, 3))

        observed = aug_det.augment_heatmaps(heatmaps)

        assert np.allclose(observed.arr_0to1, heatmaps.arr_0to1)

    def test_segmentation_maps(self):
        aug = iaa.Identity()
        segmaps_arr = np.arange(2*2).reshape((2, 2, 1)).astype(np.int32)
        segmaps = SegmentationMapsOnImage(segmaps_arr, shape=(2, 2, 3))

        observed = aug.augment_segmentation_maps(segmaps)

        assert np.array_equal(observed.arr, segmaps.arr)

    def test_segmentation_maps_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        segmaps_arr = np.arange(2*2).reshape((2, 2, 1)).astype(np.int32)
        segmaps = SegmentationMapsOnImage(segmaps_arr, shape=(2, 2, 3))

        observed = aug_det.augment_segmentation_maps(segmaps)

        assert np.array_equal(observed.arr, segmaps.arr)

    def test_keypoints(self):
        aug = iaa.Identity()
        keypoints = create_random_keypoints((16, 70, 50, 3), 4)

        observed = aug.augment_keypoints(keypoints)

        assert_cbaois_equal(observed, keypoints)

    def test_keypoints_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        keypoints = create_random_keypoints((16, 70, 50, 3), 4)

        observed = aug_det.augment_keypoints(keypoints)

        assert_cbaois_equal(observed, keypoints)

    def test_polygons(self):
        aug = iaa.Identity()
        polygon = ia.Polygon([(10, 10), (30, 10), (30, 50), (10, 50)])
        psoi = ia.PolygonsOnImage([polygon], shape=(100, 75, 3))

        observed = aug.augment_polygons(psoi)

        assert_cbaois_equal(observed, psoi)

    def test_polygons_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        polygon = ia.Polygon([(10, 10), (30, 10), (30, 50), (10, 50)])
        psoi = ia.PolygonsOnImage([polygon], shape=(100, 75, 3))

        observed = aug_det.augment_polygons(psoi)

        assert_cbaois_equal(observed, psoi)

    def test_line_strings(self):
        aug = iaa.Identity()
        ls = LineString([(10, 10), (30, 10), (30, 50), (10, 50)])
        lsoi = LineStringsOnImage([ls], shape=(100, 75, 3))

        observed = aug.augment_line_strings(lsoi)

        assert_cbaois_equal(observed, lsoi)

    def test_line_strings_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        ls = LineString([(10, 10), (30, 10), (30, 50), (10, 50)])
        lsoi = LineStringsOnImage([ls], shape=(100, 75, 3))

        observed = aug_det.augment_line_strings(lsoi)

        assert_cbaois_equal(observed, lsoi)

    def test_bounding_boxes(self):
        aug = iaa.Identity()
        bbs = ia.BoundingBox(x1=10, y1=10, x2=30, y2=50)
        bbsoi = ia.BoundingBoxesOnImage([bbs], shape=(100, 75, 3))

        observed = aug.augment_bounding_boxes(bbsoi)

        assert_cbaois_equal(observed, bbsoi)

    def test_bounding_boxes_deterministic(self):
        aug_det = iaa.Identity().to_deterministic()
        bbs = ia.BoundingBox(x1=10, y1=10, x2=30, y2=50)
        bbsoi = ia.BoundingBoxesOnImage([bbs], shape=(100, 75, 3))

        observed = aug_det.augment_bounding_boxes(bbsoi)

        assert_cbaois_equal(observed, bbsoi)

    def test_keypoints_empty(self):
        aug = iaa.Identity()
        kpsoi = ia.KeypointsOnImage([], shape=(4, 5, 3))

        observed = aug.augment_keypoints(kpsoi)

        assert_cbaois_equal(observed, kpsoi)

    def test_polygons_empty(self):
        aug = iaa.Identity()
        psoi = ia.PolygonsOnImage([], shape=(4, 5, 3))

        observed = aug.augment_polygons(psoi)

        assert_cbaois_equal(observed, psoi)

    def test_line_strings_empty(self):
        aug = iaa.Identity()
        lsoi = ia.LineStringsOnImage([], shape=(4, 5, 3))

        observed = aug.augment_line_strings(lsoi)

        assert_cbaois_equal(observed, lsoi)

    def test_bounding_boxes_empty(self):
        aug = iaa.Identity()
        bbsoi = ia.BoundingBoxesOnImage([], shape=(4, 5, 3))

        observed = aug.augment_bounding_boxes(bbsoi)

        assert_cbaois_equal(observed, bbsoi)

    def test_get_parameters(self):
        assert iaa.Identity().get_parameters() == []

    def test_other_dtypes_bool(self):
        aug = iaa.Identity()
        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True

        image_aug = aug.augment_image(image)

        assert image_aug.dtype.type == image.dtype.type
        assert np.all(image_aug == image)

    def test_other_dtypes_uint_int(self):
        aug = iaa.Identity()

        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]

        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_float(self):
        aug = iaa.Identity()

        try:
            f128 = [np.dtype("float128").name]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == image)

    def test_pickleable(self):
        aug = iaa.Noop()
        runtest_pickleable_uint8_img(aug, iterations=2)


class TestNoop(unittest.TestCase):
    def setUp(self):
        reseed()

    def test___init__(self):
        aug = iaa.Noop()
        assert isinstance(aug, iaa.Identity)

    def test_images(self):
        image = np.mod(np.arange(10*10*3), 255)
        image = image.astype(np.uint8).reshape((10, 10, 3))

        image_aug = iaa.Noop()(image=image)

        assert np.array_equal(image, image_aug)


# TODO add tests for line strings
class TestLambda(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def base_img(self):
        base_img = np.array([[0, 0, 1],
                             [0, 0, 1],
                             [0, 1, 1]], dtype=np.uint8)
        base_img = base_img[:, :, np.newaxis]
        return base_img

    @property
    def heatmaps(self):
        heatmaps_arr = np.float32([[0.0, 0.0, 1.0],
                                   [0.0, 0.0, 1.0],
                                   [0.0, 1.0, 1.0]])
        heatmaps = ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))
        return heatmaps

    @property
    def heatmaps_aug(self):
        heatmaps_arr_aug = np.float32([[0.5, 0.0, 1.0],
                                       [0.0, 0.0, 1.0],
                                       [0.0, 1.0, 1.0]])
        heatmaps = ia.HeatmapsOnImage(heatmaps_arr_aug, shape=(3, 3, 3))
        return heatmaps

    @property
    def segmentation_maps(self):
        segmaps_arr = np.int32([[0, 0, 1],
                                [0, 0, 1],
                                [0, 1, 1]])
        segmaps = SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))
        return segmaps

    @property
    def segmentation_maps_aug(self):
        segmaps_arr_aug = np.int32([[1, 1, 2],
                                    [1, 1, 2],
                                    [1, 2, 2]])
        segmaps = SegmentationMapsOnImage(segmaps_arr_aug, shape=(3, 3, 3))
        return segmaps

    @property
    def keypoints(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1),
               ia.Keypoint(x=2, y=2)]
        kpsoi = [ia.KeypointsOnImage(kps, shape=(3, 3, 3))]
        return kpsoi

    @property
    def keypoints_aug(self):
        expected_kps = [ia.Keypoint(x=1, y=0), ia.Keypoint(x=2, y=1),
                        ia.Keypoint(x=0, y=2)]
        expected = [ia.KeypointsOnImage(expected_kps, shape=(3, 3, 3))]
        return expected

    @property
    def polygons(self):
        poly = ia.Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
        psois = [ia.PolygonsOnImage([poly], shape=(3, 3, 3))]
        return psois

    @property
    def polygons_aug(self):
        expected_poly = ia.Polygon([(1, 2), (3, 2), (3, 4), (1, 4)])
        expected_psoi = [ia.PolygonsOnImage([expected_poly], shape=(3, 3, 3))]
        return expected_psoi

    @property
    def lsoi(self):
        ls = ia.LineString([(0, 0), (2, 0), (2, 2), (0, 2)])
        lsois = [ia.LineStringsOnImage([ls], shape=(3, 3, 3))]
        return lsois

    @property
    def lsoi_aug(self):
        ls = ia.LineString([(1, 2), (3, 2), (3, 4), (1, 4)])
        lsois = [ia.LineStringsOnImage([ls], shape=(3, 3, 3))]
        return lsois

    @property
    def bbsoi(self):
        bb = ia.BoundingBox(x1=0, y1=1, x2=3, y2=4)
        bbsois = [ia.BoundingBoxesOnImage([bb], shape=(3, 3, 3))]
        return bbsois

    @property
    def bbsoi_aug(self):
        bb = ia.BoundingBox(x1=0+1, y1=1+2, x2=3+1, y2=4+2)
        bbsois = [ia.BoundingBoxesOnImage([bb], shape=(3, 3, 3))]
        return bbsois

    @classmethod
    def func_images(cls, images, random_state, parents, hooks):
        if isinstance(images, list):
            images = [image + 1 for image in images]
        else:
            images = images + 1
        return images

    @classmethod
    def func_heatmaps(cls, heatmaps, random_state, parents, hooks):
        heatmaps[0].arr_0to1[0, 0] += 0.5
        return heatmaps

    @classmethod
    def func_segmaps(cls, segmaps, random_state, parents, hooks):
        segmaps[0].arr += 1
        return segmaps

    @classmethod
    def func_keypoints(cls, keypoints_on_images, random_state, parents, hooks):
        for keypoints_on_image in keypoints_on_images:
            for kp in keypoints_on_image.keypoints:
                kp.x = (kp.x + 1) % 3
        return keypoints_on_images

    @classmethod
    def func_polygons(cls, polygons_on_images, random_state, parents, hooks):
        if len(polygons_on_images[0].polygons) == 0:
            return [ia.PolygonsOnImage([], shape=polygons_on_images[0].shape)]
        new_exterior = np.copy(polygons_on_images[0].polygons[0].exterior)
        new_exterior[:, 0] += 1
        new_exterior[:, 1] += 2
        return [
            ia.PolygonsOnImage([ia.Polygon(new_exterior)],
                               shape=polygons_on_images[0].shape)
        ]

    @classmethod
    def func_line_strings(cls, line_strings_on_images, random_state, parents,
                          hooks):
        if line_strings_on_images[0].empty:
            return [ia.LineStringsOnImage(
                [], shape=line_strings_on_images[0].shape)]
        new_coords = np.copy(line_strings_on_images[0].items[0].coords)
        new_coords[:, 0] += 1
        new_coords[:, 1] += 2
        return [
            ia.LineStringsOnImage(
                [ia.LineString(new_coords)],
                shape=line_strings_on_images[0].shape)
        ]

    @classmethod
    def func_bbs(cls, bounding_boxes_on_images, random_state, parents, hooks):
        if bounding_boxes_on_images[0].empty:
            return [
                ia.BoundingBoxesOnImage(
                    [], shape=bounding_boxes_on_images[0].shape)
            ]
        new_coords = np.copy(bounding_boxes_on_images[0].items[0].coords)
        new_coords[:, 0] += 1
        new_coords[:, 1] += 2
        return [
            ia.BoundingBoxesOnImage(
                [ia.BoundingBox(x1=new_coords[0][0], y1=new_coords[0][1],
                                x2=new_coords[1][0], y2=new_coords[1][1])],
                shape=bounding_boxes_on_images[0].shape)
        ]

    def test_images(self):
        image = self.base_img
        expected = image + 1
        aug = iaa.Lambda(func_images=self.func_images)

        for _ in sm.xrange(3):
            observed = aug.augment_image(image)

            assert np.array_equal(observed, expected)

    def test_images_deterministic(self):
        image = self.base_img
        expected = image + 1
        aug_det = iaa.Lambda(func_images=self.func_images).to_deterministic()

        for _ in sm.xrange(3):
            observed = aug_det.augment_image(image)

            assert np.array_equal(observed, expected)

    def test_images_list(self):
        image = self.base_img
        expected = [image + 1]
        aug = iaa.Lambda(func_images=self.func_images)

        observed = aug.augment_images([image])

        assert array_equal_lists(observed, expected)

    def test_images_list_deterministic(self):
        image = self.base_img
        expected = [image + 1]
        aug_det = iaa.Lambda(func_images=self.func_images).to_deterministic()

        observed = aug_det.augment_images([image])

        assert array_equal_lists(observed, expected)

    def test_heatmaps(self):
        heatmaps = self.heatmaps
        heatmaps_arr_aug = self.heatmaps_aug.get_arr()
        aug = iaa.Lambda(func_heatmaps=self.func_heatmaps)

        for _ in sm.xrange(3):
            observed = aug.augment_heatmaps(heatmaps)

            assert observed.shape == (3, 3, 3)
            assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
            assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
            assert np.allclose(observed.get_arr(), heatmaps_arr_aug)

    def test_heatmaps_deterministic(self):
        heatmaps = self.heatmaps
        heatmaps_arr_aug = self.heatmaps_aug.get_arr()
        aug_det = iaa.Lambda(func_heatmaps=self.func_heatmaps)\
            .to_deterministic()

        for _ in sm.xrange(3):
            observed = aug_det.augment_heatmaps(heatmaps)

            assert observed.shape == (3, 3, 3)
            assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
            assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
            assert np.allclose(observed.get_arr(), heatmaps_arr_aug)

    def test_segmentation_maps(self):
        segmaps = self.segmentation_maps
        segmaps_arr_aug = self.segmentation_maps_aug.get_arr()
        aug = iaa.Lambda(func_segmentation_maps=self.func_segmaps)

        for _ in sm.xrange(3):
            observed = aug.augment_segmentation_maps(segmaps)

            assert observed.shape == (3, 3, 3)
            assert np.array_equal(observed.get_arr(), segmaps_arr_aug)

    def test_segmentation_maps_deterministic(self):
        segmaps = self.segmentation_maps
        segmaps_arr_aug = self.segmentation_maps_aug.get_arr()
        aug_det = iaa.Lambda(func_segmentation_maps=self.func_segmaps)\
            .to_deterministic()

        for _ in sm.xrange(3):
            observed = aug_det.augment_segmentation_maps(segmaps)

            assert observed.shape == (3, 3, 3)
            assert np.array_equal(observed.get_arr(), segmaps_arr_aug)

    def test_keypoints(self):
        kpsoi = self.keypoints
        aug = iaa.Lambda(func_keypoints=self.func_keypoints)

        for _ in sm.xrange(3):
            observed = aug.augment_keypoints(kpsoi)

            expected = self.keypoints_aug
            assert_cbaois_equal(observed, expected)

    def test_keypoints_deterministic(self):
        kpsoi = self.keypoints
        aug = iaa.Lambda(func_keypoints=self.func_keypoints)
        aug = aug.to_deterministic()

        for _ in sm.xrange(3):
            observed = aug.augment_keypoints(kpsoi)

            expected = self.keypoints_aug
            assert_cbaois_equal(observed, expected)

    def test_polygons(self):
        psois = self.polygons
        aug = iaa.Lambda(func_polygons=self.func_polygons)

        for _ in sm.xrange(3):
            observed = aug.augment_polygons(psois)

            expected_psoi = self.polygons_aug
            assert_cbaois_equal(observed, expected_psoi)

    def test_polygons_deterministic(self):
        psois = self.polygons

        aug = iaa.Lambda(func_polygons=self.func_polygons)
        aug = aug.to_deterministic()

        for _ in sm.xrange(3):
            observed = aug.augment_polygons(psois)

            expected_psoi = self.polygons_aug
            assert_cbaois_equal(observed, expected_psoi)

    def test_line_strings(self):
        lsois = self.lsoi
        aug = iaa.Lambda(func_line_strings=self.func_line_strings)

        for _ in sm.xrange(3):
            observed = aug.augment_line_strings(lsois)

            expected_lsoi = self.lsoi_aug
            assert_cbaois_equal(observed, expected_lsoi)

    def test_line_strings_deterministic(self):
        lsois = self.lsoi

        aug = iaa.Lambda(func_line_strings=self.func_line_strings)
        aug = aug.to_deterministic()

        for _ in sm.xrange(3):
            observed = aug.augment_line_strings(lsois)

            expected_lsoi = self.lsoi_aug
            assert_cbaois_equal(observed, expected_lsoi)

    def test_bounding_boxes(self):
        bbsoi = self.bbsoi
        aug = iaa.Lambda(func_bounding_boxes=self.func_bbs)

        for _ in sm.xrange(3):
            observed = aug.augment_bounding_boxes(bbsoi)

            expected = self.bbsoi_aug
            assert_cbaois_equal(observed, expected)

    def test_bounding_boxes_deterministic(self):
        bbsoi = self.bbsoi
        aug = iaa.Lambda(func_bounding_boxes=self.func_bbs)
        aug = aug.to_deterministic()

        for _ in sm.xrange(3):
            observed = aug.augment_bounding_boxes(bbsoi)

            expected = self.bbsoi_aug
            assert_cbaois_equal(observed, expected)

    def test_bounding_boxes_x1_x2_coords_can_get_flipped(self):
        # Verify that if any augmented BB ends up with x1 > x2 that the
        # x-coordinates will be flipped to ensure that x1 is always below x2
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)
        ], shape=(10, 10, 3))

        def _func_bbs(bounding_boxes_on_images, random_state, parents, hooks):
            bounding_boxes_on_images[0].bounding_boxes[0].x1 += 10
            return bounding_boxes_on_images

        aug = iaa.Lambda(func_bounding_boxes=_func_bbs)

        for _ in sm.xrange(3):
            observed = aug.augment_bounding_boxes(bbsoi)

            assert np.allclose(
                observed.bounding_boxes[0].coords,
                [(2, 1), (0+10, 3)]
            )

    def test_bounding_boxes_y1_y2_coords_can_get_flipped(self):
        # Verify that if any augmented BB ends up with y1 > y2 that the
        # x-coordinates will be flipped to ensure that y1 is always below y2
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)
        ], shape=(10, 10, 3))

        def _func_bbs(bounding_boxes_on_images, random_state, parents, hooks):
            bounding_boxes_on_images[0].bounding_boxes[0].y1 += 10
            return bounding_boxes_on_images

        aug = iaa.Lambda(func_bounding_boxes=_func_bbs)

        for _ in sm.xrange(3):
            observed = aug.augment_bounding_boxes(bbsoi)

            assert np.allclose(
                observed.bounding_boxes[0].coords,
                [(0, 3), (2, 1+10)]
            )

    def test_keypoints_empty(self):
        kpsoi = ia.KeypointsOnImage([], shape=(1, 2, 3))
        aug = iaa.Lambda(func_keypoints=self.func_keypoints)

        observed = aug.augment_keypoints(kpsoi)

        assert_cbaois_equal(observed, kpsoi)

    def test_polygons_empty(self):
        psoi = ia.PolygonsOnImage([], shape=(1, 2, 3))
        aug = iaa.Lambda(func_polygons=self.func_polygons)

        observed = aug.augment_polygons(psoi)

        assert_cbaois_equal(observed, psoi)

    def test_line_strings_empty(self):
        lsoi = ia.LineStringsOnImage([], shape=(1, 2, 3))
        aug = iaa.Lambda(func_line_strings=self.func_line_strings)

        observed = aug.augment_line_strings(lsoi)

        assert_cbaois_equal(observed, lsoi)

    def test_bounding_boxes_empty(self):
        bbsoi = ia.BoundingBoxesOnImage([], shape=(1, 2, 3))
        aug = iaa.Lambda(func_bounding_boxes=self.func_bbs)

        observed = aug.augment_bounding_boxes(bbsoi)

        assert_cbaois_equal(observed, bbsoi)

    # TODO add tests when funcs are not set in Lambda

    def test_other_dtypes_bool(self):
        def func_images(images, random_state, parents, hooks):
            aug = iaa.Flipud(1.0)  # flipud is know to work with all dtypes
            return aug.augment_images(images)

        aug = iaa.Lambda(func_images=func_images)

        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True
        expected = np.zeros((3, 3), dtype=bool)
        expected[2, 0] = True

        image_aug = aug.augment_image(image)

        assert image_aug.dtype.name == "bool"
        assert np.all(image_aug == expected)

    def test_other_dtypes_uint_int(self):
        def func_images(images, random_state, parents, hooks):
            aug = iaa.Flipud(1.0)  # flipud is know to work with all dtypes
            return aug.augment_images(images)

        aug = iaa.Lambda(func_images=func_images)

        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]

        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = np.zeros((3, 3), dtype=dtype)
                expected[2, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, expected)

    def test_other_dtypes_float(self):
        def func_images(images, random_state, parents, hooks):
            aug = iaa.Flipud(1.0)  # flipud is know to work with all dtypes
            return aug.augment_images(images)

        aug = iaa.Lambda(func_images=func_images)

        try:
            f128 = [np.dtype("float128").name]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = np.zeros((3, 3), dtype=dtype)
                expected[2, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == expected)

    def test_pickleable(self):
        aug = iaa.Lambda(
            func_images=_lambda_pickleable_callback_images,
            seed=1)
        runtest_pickleable_uint8_img(aug)


def _lambda_pickleable_callback_images(images, random_state, parents, hooks):
    aug = iaa.Flipud(0.5, seed=random_state)
    return aug.augment_images(images)


class TestAssertLambda(unittest.TestCase):
    DTYPES_UINT = ["uint8", "uint16", "uint32", "uint64"]
    DTYPES_INT = ["int8", "int32", "int64"]
    DTYPES_FLOAT = (
        ["float16", "float32", "float64"]
        + (
            ["float128"] if hasattr(np, "float128") else []
        )
    )

    def setUp(self):
        reseed()

    @property
    def image(self):
        base_img = np.array([[0, 0, 1],
                             [0, 0, 1],
                             [0, 1, 1]], dtype=np.uint8)
        return np.atleast_3d(base_img)

    @property
    def images(self):
        return np.array([self.image])

    @property
    def heatmaps(self):
        heatmaps_arr = np.float32([[0.0, 0.0, 1.0],
                                   [0.0, 0.0, 1.0],
                                   [0.0, 1.0, 1.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))

    @property
    def segmaps(self):
        segmaps_arr = np.int32([[0, 0, 1],
                                [0, 0, 1],
                                [0, 1, 1]])
        return SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))

    @property
    def kpsoi(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1),
               ia.Keypoint(x=2, y=2)]
        return ia.KeypointsOnImage(kps, shape=self.image.shape)

    @property
    def psoi(self):
        polygons = [ia.Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image.shape)

    @property
    def lsoi(self):
        lss = [ia.LineString([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.LineStringsOnImage(lss, shape=self.image.shape)

    @property
    def bbsoi(self):
        bb = ia.BoundingBox(x1=0, y1=0, x2=2, y2=2)
        return ia.BoundingBoxesOnImage([bb], shape=self.image.shape)

    @property
    def aug_succeeds(self):
        def _func_images_succeeds(images, random_state, parents, hooks):
            return images[0][0, 0] == 0 and images[0][2, 2] == 1

        def _func_heatmaps_succeeds(heatmaps, random_state, parents, hooks):
            return heatmaps[0].arr_0to1[0, 0] < 0 + 1e-6

        def _func_segmaps_succeeds(segmaps, random_state, parents, hooks):
            return segmaps[0].arr[0, 0] == 0

        def _func_keypoints_succeeds(keypoints_on_images, random_state, parents,
                                    hooks):
            return (
                keypoints_on_images[0].keypoints[0].x == 0
                and keypoints_on_images[0].keypoints[2].x == 2
            )

        def _func_bounding_boxes_succeeds(bounding_boxes_on_images,
                                          random_state, parents, hooks):
            return (bounding_boxes_on_images[0].items[0].x1 == 0
                    and bounding_boxes_on_images[0].items[0].x2 == 2)

        def _func_polygons_succeeds(polygons_on_images, random_state, parents,
                                   hooks):
            return (polygons_on_images[0].polygons[0].exterior[0][0] == 0
                    and polygons_on_images[0].polygons[0].exterior[2][1] == 2)

        def _func_line_strings_succeeds(line_strings_on_image, random_state,
                                        parents, hooks):
            return (line_strings_on_image[0].items[0].coords[0][0] == 0
                    and line_strings_on_image[0].items[0].coords[2][1] == 2)

        return iaa.AssertLambda(
            func_images=_func_images_succeeds,
            func_heatmaps=_func_heatmaps_succeeds,
            func_segmentation_maps=_func_segmaps_succeeds,
            func_keypoints=_func_keypoints_succeeds,
            func_bounding_boxes=_func_bounding_boxes_succeeds,
            func_polygons=_func_polygons_succeeds,
            func_line_strings=_func_line_strings_succeeds)

    @property
    def aug_fails(self):
        def _func_images_fails(images, random_state, parents, hooks):
            return images[0][0, 0] == 1

        def _func_heatmaps_fails(heatmaps, random_state, parents, hooks):
            return heatmaps[0].arr_0to1[0, 0] > 0 + 1e-6

        def _func_segmaps_fails(segmaps, random_state, parents, hooks):
            return segmaps[0].arr[0, 0] == 1

        def _func_keypoints_fails(keypoints_on_images, random_state, parents,
                                  hooks):
            return keypoints_on_images[0].keypoints[0].x == 2

        def _func_bounding_boxes_fails(bounding_boxes_on_images, random_state,
                                       parents, hooks):
            return bounding_boxes_on_images[0].items[0].x1 == 2

        def _func_polygons_fails(polygons_on_images, random_state, parents,
                                 hooks):
            return polygons_on_images[0].polygons[0].exterior[0][0] == 2

        def _func_line_strings_fails(line_strings_on_images, random_state,
                                     parents, hooks):
            return line_strings_on_images[0].items[0].coords[0][0] == 2

        return iaa.AssertLambda(
            func_images=_func_images_fails,
            func_heatmaps=_func_heatmaps_fails,
            func_segmentation_maps=_func_segmaps_fails,
            func_keypoints=_func_keypoints_fails,
            func_bounding_boxes=_func_bounding_boxes_fails,
            func_polygons=_func_polygons_fails,
            func_line_strings=_func_line_strings_fails)

    def test_images_as_array_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_as_array_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_images(self.images)

    def test_images_as_array_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_as_array_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_images(self.images)

    def test_images_as_list_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_images([self.images[0]])
        expected = [self.images[0]]
        assert array_equal_lists(observed, expected)

    def test_images_as_list_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_images([self.images[0]])

    def test_images_as_list_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_images([self.images[0]])
        expected = [self.images[0]]
        assert array_equal_lists(observed, expected)

    def test_images_as_list_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_images([self.images[0]])

    def test_heatmaps_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 3, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_heatmaps(self.heatmaps)

    def test_heatmaps_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 3, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_heatmaps(self.heatmaps)

    def test_segmaps_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 3, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_segmaps_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_segmentation_maps(self.segmaps)

    def test_segmaps_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 3, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_segmaps_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_segmentation_maps(self.segmaps)

    def test_keypoints_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_keypoints(self.kpsoi)

    def test_keypoints_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_keypoints(self.kpsoi)

    def test_polygons_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_polygons(self.psoi)

    def test_polygons_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_polygons(self.psoi)

    def test_line_strings_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_line_strings(self.lsoi)

    def test_line_strings_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_line_strings(self.lsoi)

    def test_bounding_boxes_with_assert_that_succeeds(self):
        observed = self.aug_succeeds.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_assert_that_fails(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_bounding_boxes(self.bbsoi)

    def test_bounding_boxes_with_assert_that_succeeds__deterministic(self):
        aug_succeeds_det = self.aug_succeeds.to_deterministic()
        observed = aug_succeeds_det.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_assert_that_fails__deterministic(self):
        with self.assertRaises(AssertionError):
            _ = self.aug_fails.augment_bounding_boxes(self.bbsoi)

    def test_other_dtypes_bool__with_assert_that_succeeds(self):
        def func_images_succeeds(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 0], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_succeeds)

        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True
        image_aug = aug.augment_image(image)
        assert image_aug.dtype.name == image.dtype.name
        assert np.all(image_aug == image)

    def test_other_dtypes_uint_int__with_assert_that_succeeds(self):
        def func_images_succeeds(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 0], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_succeeds)

        dtypes = self.DTYPES_UINT + self.DTYPES_INT
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = 1
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_float__with_assert_that_succeeds(self):
        def func_images_succeeds(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 0], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_succeeds)

        dtypes = self.DTYPES_FLOAT
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = 1
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == image)

    def test_other_dtypes_bool__with_assert_that_fails(self):
        def func_images_fails(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 1], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_fails)

        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True
        with self.assertRaises(AssertionError):
            _ = aug.augment_image(image)

    def test_other_dtypes_uint_int__with_assert_that_fails(self):
        def func_images_fails(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 1], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_fails)

        dtypes = self.DTYPES_UINT + self.DTYPES_INT
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = 1
                with self.assertRaises(AssertionError):
                    _ = aug.augment_image(image)

    def test_other_dtypes_float__with_assert_that_fails(self):
        def func_images_fails(images, random_state, parents, hooks):
            return np.allclose(images[0][0, 1], 1, rtol=0, atol=1e-6)

        aug = iaa.AssertLambda(func_images=func_images_fails)

        dtypes = self.DTYPES_FLOAT
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = 1
                with self.assertRaises(AssertionError):
                    _ = aug.augment_image(image)

    def test_pickleable(self):
        aug = iaa.AssertLambda(
            func_images=_assertlambda_pickleable_callback_images,
            seed=1)
        runtest_pickleable_uint8_img(aug, iterations=2)


# in py3+, this could be a classmethod of TestAssertLambda,
# but in py2.7 such classmethods are not pickle-able and would cause an error
def _assertlambda_pickleable_callback_images(images, random_state,
                                             parents, hooks):
    return np.any(images[0] > 0)


class TestAssertShape(unittest.TestCase):
    DTYPES_UINT = ["uint8", "uint16", "uint32", "uint64"]
    DTYPES_INT = ["int8", "int32", "int64"]
    DTYPES_FLOAT = (
        ["float16", "float32", "float64"]
        + (
            ["float128"] if hasattr(np, "float128") else []
        )
    )

    def setUp(self):
        reseed()

    @property
    def image(self):
        base_img = np.array([[0, 0, 1, 0],
                             [0, 0, 1, 0],
                             [0, 1, 1, 0]], dtype=np.uint8)
        return np.atleast_3d(base_img)

    @property
    def images(self):
        return np.array([self.image])

    @property
    def heatmaps(self):
        heatmaps_arr = np.float32([[0.0, 0.0, 1.0, 0.0],
                                   [0.0, 0.0, 1.0, 0.0],
                                   [0.0, 1.0, 1.0, 0.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 4, 3))

    @property
    def segmaps(self):
        segmaps_arr = np.int32([[0, 0, 1, 0],
                                [0, 0, 1, 0],
                                [0, 1, 1, 0]])
        return SegmentationMapsOnImage(segmaps_arr, shape=(3, 4, 3))

    @property
    def kpsoi(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1),
               ia.Keypoint(x=2, y=2)]
        return ia.KeypointsOnImage(kps, shape=self.image.shape)

    @property
    def psoi(self):
        polygons = [ia.Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image.shape)

    @property
    def lsoi(self):
        lss = [ia.LineString([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.LineStringsOnImage(lss, shape=self.image.shape)

    @property
    def bbsoi(self):
        bb = ia.BoundingBox(x1=0, y1=0, x2=2, y2=2)
        return ia.BoundingBoxesOnImage([bb], shape=self.image.shape)

    @property
    def image_h4(self):
        base_img_h4 = np.array([[0, 0, 1, 0],
                                [0, 0, 1, 0],
                                [0, 1, 1, 0],
                                [1, 0, 1, 0]], dtype=np.uint8)
        return np.atleast_3d(base_img_h4)

    @property
    def images_h4(self):
        return np.array([self.image_h4])

    @property
    def heatmaps_h4(self):
        heatmaps_arr_h4 = np.float32([[0.0, 0.0, 1.0, 0.0],
                                      [0.0, 0.0, 1.0, 0.0],
                                      [0.0, 1.0, 1.0, 0.0],
                                      [1.0, 0.0, 1.0, 0.0]])
        return ia.HeatmapsOnImage(heatmaps_arr_h4, shape=(4, 4, 3))

    @property
    def segmaps_h4(self):
        segmaps_arr_h4 = np.int32([[0, 0, 1, 0],
                                   [0, 0, 1, 0],
                                   [0, 1, 1, 0],
                                   [1, 0, 1, 0]])
        return SegmentationMapsOnImage(segmaps_arr_h4, shape=(4, 4, 3))

    @property
    def kpsoi_h4(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1),
               ia.Keypoint(x=2, y=2)]
        return ia.KeypointsOnImage(kps, shape=self.image_h4.shape)

    @property
    def psoi_h4(self):
        polygons = [ia.Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image_h4.shape)

    @property
    def lsoi_h4(self):
        lss = [ia.LineString([(0, 0), (2, 0), (2, 2), (0, 2)])]
        return ia.LineStringsOnImage(lss, shape=self.image_h4.shape)

    @property
    def bbsoi_h4(self):
        bb = ia.BoundingBox(x1=0, y1=0, x2=2, y2=2)
        return ia.BoundingBoxesOnImage([bb], shape=self.image_h4.shape)

    @property
    def aug_exact_shape(self):
        return iaa.AssertShape((1, 3, 4, 1))

    @property
    def aug_none_in_shape(self):
        return iaa.AssertShape((None, 3, 4, 1))

    @property
    def aug_list_in_shape(self):
        return iaa.AssertShape((1, [1, 3, 5], 4, 1))

    @property
    def aug_tuple_in_shape(self):
        return iaa.AssertShape((1, (1, 4), 4, 1))

    def test_images_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_with_exact_shape__succeeds__list(self):
        aug = self.aug_exact_shape
        observed = aug.augment_images([self.images[0]])
        expected = [self.images[0]]
        assert array_equal_lists(observed, expected)

    def test_images_with_exact_shape__succeeds__deterministic__list(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_images([self.images[0]])
        expected = [self.images[0]]
        assert array_equal_lists(observed, expected)

    def test_heatmaps_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_segmaps_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_keypoints_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_polygons_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_line_strings_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_bounding_boxes_with_exact_shape__succeeds(self):
        aug = self.aug_exact_shape
        observed = aug.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_exact_shape__succeeds__deterministic(self):
        aug_det = self.aug_exact_shape.to_deterministic()
        observed = aug_det.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_images_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_images(self.images_h4)

    def test_heatmaps_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_heatmaps(self.heatmaps_h4)

    def test_keypoints_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_keypoints(self.kpsoi_h4)

    def test_polygons_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_polygons(self.psoi_h4)

    def test_line_strings_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_line_strings(self.lsoi_h4)

    def test_bounding_boxes_with_exact_shape__fails(self):
        aug = self.aug_exact_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_bounding_boxes(self.bbsoi_h4)

    def test_images_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_heatmaps_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_keypoints_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_polygons_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_line_strings_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_bounding_boxes_with_none_in_shape__succeeds(self):
        aug = self.aug_none_in_shape
        observed = aug.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_none_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_none_in_shape.to_deterministic()
        observed = aug_det.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_images_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_images(self.images_h4)

    def test_heatmaps_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_heatmaps(self.heatmaps_h4)

    def test_keypoints_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_keypoints(self.kpsoi_h4)

    def test_polygons_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_polygons(self.psoi_h4)

    def test_line_strings_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_line_strings(self.lsoi_h4)

    def test_bounding_boxes_with_none_in_shape__fails(self):
        aug = self.aug_none_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_bounding_boxes(self.bbsoi_h4)

    def test_images_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_heatmaps_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_segmaps_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.segmaps.get_arr())

    def test_keypoints_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_polygons_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_line_strings_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_bounding_boxes_with_list_in_shape__succeeds(self):
        aug = self.aug_list_in_shape
        observed = aug.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_list_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_list_in_shape.to_deterministic()
        observed = aug_det.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_images_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_images(self.images_h4)

    def test_heatmaps_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_heatmaps(self.heatmaps_h4)

    def test_segmaps_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_segmentation_maps(self.segmaps_h4)

    def test_keypoints_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_keypoints(self.kpsoi_h4)

    def test_polygons_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_polygons(self.psoi_h4)

    def test_line_strings_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_line_strings(self.lsoi_h4)

    def test_bounding_boxes_with_list_in_shape__fails(self):
        aug = self.aug_list_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_bounding_boxes(self.bbsoi_h4)

    def test_images_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_images_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_images(self.images)
        expected = self.images
        assert np.array_equal(observed, expected)

    def test_heatmaps_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_heatmaps_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_heatmaps(self.heatmaps)
        assert observed.shape == (3, 4, 3)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.allclose(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.heatmaps.get_arr())

    def test_segmaps_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_segmentation_maps(self.segmaps)
        assert observed.shape == (3, 4, 3)
        assert np.array_equal(observed.get_arr(), self.heatmaps.get_arr())

    def test_keypoints_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_keypoints_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_keypoints(self.kpsoi)
        assert_cbaois_equal(observed, self.kpsoi)

    def test_polygons_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_polygons_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_polygons(self.psoi)
        assert_cbaois_equal(observed, self.psoi)

    def test_line_strings_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_line_strings_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_line_strings(self.lsoi)
        assert_cbaois_equal(observed, self.lsoi)

    def test_bounding_boxes_with_tuple_in_shape__succeeds(self):
        aug = self.aug_tuple_in_shape
        observed = aug.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_bounding_boxes_with_tuple_in_shape__succeeds__deterministic(self):
        aug_det = self.aug_tuple_in_shape.to_deterministic()
        observed = aug_det.augment_bounding_boxes(self.bbsoi)
        assert_cbaois_equal(observed, self.bbsoi)

    def test_images_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_images(self.images_h4)

    def test_heatmaps_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_heatmaps(self.heatmaps_h4)

    def test_segmaps_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_segmentation_maps(self.segmaps_h4)

    def test_keypoints_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_keypoints(self.kpsoi_h4)

    def test_polygons_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_polygons(self.psoi_h4)

    def test_line_strings_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_line_strings(self.lsoi_h4)

    def test_bounding_boxes_with_tuple_in_shape__fails(self):
        aug = self.aug_tuple_in_shape
        with self.assertRaises(AssertionError):
            _ = aug.augment_bounding_boxes(self.bbsoi_h4)

    def test_fails_if_shape_contains_invalid_datatype(self):
        got_exception = False
        try:
            aug = iaa.AssertShape((1, False, 4, 1))
            _ = aug.augment_images(np.zeros((1, 2, 2, 1), dtype=np.uint8))
        except Exception as exc:
            assert "Invalid datatype " in str(exc)
            got_exception = True
        assert got_exception

    def test_other_dtypes_bool__succeeds(self):
        aug = iaa.AssertShape((None, 3, 3, 1))
        image = np.zeros((3, 3, 1), dtype=bool)
        image[0, 0, 0] = True

        image_aug = aug.augment_image(image)

        assert image_aug.dtype.type == image.dtype.type
        assert np.all(image_aug == image)

    def test_other_dtypes_uint_int__succeeds(self):
        aug = iaa.AssertShape((None, 3, 3, 1))
        for dtype in self.DTYPES_UINT + self.DTYPES_INT:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3, 1), dtype=dtype)
                image[0, 0, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_float__succeeds(self):
        aug = iaa.AssertShape((None, 3, 3, 1))
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for dtype, value in zip(self.DTYPES_FLOAT, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3, 1), dtype=dtype)
                image[0, 0, 0] = 1
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == image)

    def test_other_dtypes_bool__fails(self):
        aug = iaa.AssertShape((None, 3, 4, 1))
        image = np.zeros((3, 3, 1), dtype=bool)
        image[0, 0, 0] = True

        with self.assertRaises(AssertionError):
            _ = aug.augment_image(image)

    def test_other_dtypes_uint_int__fails(self):
        aug = iaa.AssertShape((None, 3, 4, 1))

        for dtype in self.DTYPES_UINT + self.DTYPES_INT:
            min_value, center_value, max_value = \
                iadt.get_value_range_of_dtype(dtype)
            value = max_value
            image = np.zeros((3, 3, 1), dtype=dtype)
            image[0, 0, 0] = value
            with self.assertRaises(AssertionError):
                _ = aug.augment_image(image)

    def test_other_dtypes_float__fails(self):
        aug = iaa.AssertShape((None, 3, 4, 1))
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for dtype, value in zip(self.DTYPES_FLOAT, values):
            image = np.zeros((3, 3, 1), dtype=dtype)
            image[0, 0, 0] = value
            with self.assertRaises(AssertionError):
                _ = aug.augment_image(image)

    def test_pickleable(self):
        aug = iaa.AssertShape(
            shape=(None, 15, 15, None), check_images=True,
            seed=1)
        runtest_pickleable_uint8_img(aug, iterations=2, shape=(15, 15, 1))


def test_clip_augmented_image_():
    warnings.resetwarnings()
    with warnings.catch_warnings(record=True) as caught_warnings:
        warnings.simplefilter("always")

        image = np.zeros((1, 3), dtype=np.uint8)
        image[0, 0] = 10
        image[0, 1] = 20
        image[0, 2] = 30
        image_clipped = iaa.clip_augmented_image_(image,
                                                  min_value=15, max_value=25)
        assert image_clipped[0, 0] == 15
        assert image_clipped[0, 1] == 20
        assert image_clipped[0, 2] == 25

    assert len(caught_warnings) >= 1
    assert "deprecated" in str(caught_warnings[-1].message)


def test_clip_augmented_image():
    warnings.resetwarnings()
    with warnings.catch_warnings(record=True) as caught_warnings:
        warnings.simplefilter("always")

        image = np.zeros((1, 3), dtype=np.uint8)
        image[0, 0] = 10
        image[0, 1] = 20
        image[0, 2] = 30
        image_clipped = iaa.clip_augmented_image(image,
                                                 min_value=15, max_value=25)
        assert image_clipped[0, 0] == 15
        assert image_clipped[0, 1] == 20
        assert image_clipped[0, 2] == 25

    assert len(caught_warnings) >= 1
    assert "deprecated" in str(caught_warnings[-1].message)


def test_clip_augmented_images_():
    warnings.resetwarnings()
    with warnings.catch_warnings(record=True) as caught_warnings:
        warnings.simplefilter("always")

        images = np.zeros((2, 1, 3), dtype=np.uint8)
        images[:, 0, 0] = 10
        images[:, 0, 1] = 20
        images[:, 0, 2] = 30
        imgs_clipped = iaa.clip_augmented_images_(images,
                                                  min_value=15, max_value=25)
        assert np.all(imgs_clipped[:, 0, 0] == 15)
        assert np.all(imgs_clipped[:, 0, 1] == 20)
        assert np.all(imgs_clipped[:, 0, 2] == 25)

        images = [np.zeros((1, 3), dtype=np.uint8) for _ in sm.xrange(2)]
        for i in sm.xrange(len(images)):
            images[i][0, 0] = 10
            images[i][0, 1] = 20
            images[i][0, 2] = 30
        imgs_clipped = iaa.clip_augmented_images_(images,
                                                  min_value=15, max_value=25)
        assert isinstance(imgs_clipped, list)
        assert np.all([imgs_clipped[i][0, 0] == 15
                       for i in sm.xrange(len(images))])
        assert np.all([imgs_clipped[i][0, 1] == 20
                       for i in sm.xrange(len(images))])
        assert np.all([imgs_clipped[i][0, 2] == 25
                       for i in sm.xrange(len(images))])

    assert len(caught_warnings) >= 1
    assert "deprecated" in str(caught_warnings[-1].message)


def test_clip_augmented_images():
    warnings.resetwarnings()
    with warnings.catch_warnings(record=True) as caught_warnings:
        warnings.simplefilter("always")

        images = np.zeros((2, 1, 3), dtype=np.uint8)
        images[:, 0, 0] = 10
        images[:, 0, 1] = 20
        images[:, 0, 2] = 30
        imgs_clipped = iaa.clip_augmented_images(images,
                                                 min_value=15, max_value=25)
        assert np.all(imgs_clipped[:, 0, 0] == 15)
        assert np.all(imgs_clipped[:, 0, 1] == 20)
        assert np.all(imgs_clipped[:, 0, 2] == 25)

        images = [np.zeros((1, 3), dtype=np.uint8) for _ in sm.xrange(2)]
        for i in sm.xrange(len(images)):
            images[i][0, 0] = 10
            images[i][0, 1] = 20
            images[i][0, 2] = 30
        imgs_clipped = iaa.clip_augmented_images(images,
                                                 min_value=15, max_value=25)
        assert isinstance(imgs_clipped, list)
        assert np.all([imgs_clipped[i][0, 0] == 15
                       for i in sm.xrange(len(images))])
        assert np.all([imgs_clipped[i][0, 1] == 20
                       for i in sm.xrange(len(images))])
        assert np.all([imgs_clipped[i][0, 2] ==
                       25 for i in sm.xrange(len(images))])

    assert len(caught_warnings) >= 1
    assert "deprecated" in str(caught_warnings[-1].message)


def test_reduce_to_nonempty():
    kpsois = [
        ia.KeypointsOnImage([ia.Keypoint(x=0, y=1)], shape=(4, 4, 3)),
        ia.KeypointsOnImage([ia.Keypoint(x=0, y=1), ia.Keypoint(x=1, y=0)],
                            shape=(4, 4, 3)),
        ia.KeypointsOnImage([], shape=(4, 4, 3)),
        ia.KeypointsOnImage([ia.Keypoint(x=2, y=2)], shape=(4, 4, 3)),
        ia.KeypointsOnImage([], shape=(4, 4, 3))
    ]

    kpsois_reduced, ids = iaa.reduce_to_nonempty(kpsois)
    assert kpsois_reduced == [kpsois[0], kpsois[1], kpsois[3]]
    assert ids == [0, 1, 3]

    kpsois = [
        ia.KeypointsOnImage([], shape=(4, 4, 3)),
        ia.KeypointsOnImage([], shape=(4, 4, 3))
    ]

    kpsois_reduced, ids = iaa.reduce_to_nonempty(kpsois)
    assert kpsois_reduced == []
    assert ids == []

    kpsois = [
        ia.KeypointsOnImage([ia.Keypoint(x=0, y=1)], shape=(4, 4, 3))
    ]

    kpsois_reduced, ids = iaa.reduce_to_nonempty(kpsois)
    assert kpsois_reduced == [kpsois[0]]
    assert ids == [0]

    kpsois = []

    kpsois_reduced, ids = iaa.reduce_to_nonempty(kpsois)
    assert kpsois_reduced == []
    assert ids == []


def test_invert_reduce_to_nonempty():
    kpsois = [
        ia.KeypointsOnImage([ia.Keypoint(x=0, y=1)], shape=(4, 4, 3)),
        ia.KeypointsOnImage([ia.Keypoint(x=0, y=1),
                             ia.Keypoint(x=1, y=0)], shape=(4, 4, 3)),
        ia.KeypointsOnImage([ia.Keypoint(x=2, y=2)], shape=(4, 4, 3)),
    ]

    kpsois_recovered = iaa.invert_reduce_to_nonempty(
        kpsois, [0, 1, 2], ["foo1", "foo2", "foo3"])
    assert kpsois_recovered == ["foo1", "foo2", "foo3"]

    kpsois_recovered = iaa.invert_reduce_to_nonempty(kpsois, [1], ["foo1"])
    assert np.all([
        isinstance(kpsoi, ia.KeypointsOnImage)
        for kpsoi
        in kpsois])  # assert original list not changed
    assert kpsois_recovered == [kpsois[0], "foo1", kpsois[2]]

    kpsois_recovered = iaa.invert_reduce_to_nonempty(kpsois, [], [])
    assert kpsois_recovered == [kpsois[0], kpsois[1], kpsois[2]]

    kpsois_recovered = iaa.invert_reduce_to_nonempty([], [], [])
    assert kpsois_recovered == []


class _DummyAugmenter(iaa.Augmenter):
    def _augment_images(self, images, random_state, parents, hooks):
        return images

    def get_parameters(self):
        return []


class _DummyAugmenterBBs(iaa.Augmenter):
    def _augment_images(self, images, random_state, parents, hooks):
        return images

    def _augment_bounding_boxes(self, bounding_boxes_on_images, random_state,
                                parents, hooks):
        return [bbsoi.shift(x=1)
                for bbsoi
                in bounding_boxes_on_images]

    def get_parameters(self):
        return []


# TODO remove _augment_heatmaps() and _augment_keypoints() here once they are
#      no longer abstract methods but default to noop
class _DummyAugmenterCallsParent(iaa.Augmenter):
    def _augment_images(self, images, random_state, parents, hooks):
        return super(_DummyAugmenterCallsParent, self)\
            ._augment_images(images, random_state, parents, hooks)

    def get_parameters(self):
        return super(_DummyAugmenterCallsParent, self)\
            .get_parameters()


def _same_rs(rs1, rs2):
    return rs1.equals(rs2)


# TODO the test in here do not check everything, but instead only the cases
#      that were not yet indirectly tested via other tests
class TestAugmenter(unittest.TestCase):
    def setUp(self):
        reseed()

    def test___init___global_rng(self):
        aug = _DummyAugmenter()
        assert not aug.deterministic
        assert aug.random_state.is_global_rng()

    def test___init___deterministic(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            aug = _DummyAugmenter(deterministic=True)
            assert aug.deterministic
            assert not aug.random_state.is_global_rng()

            assert len(caught_warnings) == 1
            assert (
                "is deprecated"
                in str(caught_warnings[-1].message))

    # old name for parameter `seed`
    def test___init___random_state_is_rng(self):
        rs = iarandom.RNG(123)
        aug = _DummyAugmenter(seed=rs)
        assert aug.random_state.generator is rs.generator

    # old name for parameter `seed`
    def test___init___random_state_is_seed(self):
        aug = _DummyAugmenter(seed=123)
        assert aug.random_state.equals(iarandom.RNG(123))

    def test___init___seed_is_random_state(self):
        rs = iarandom.RNG(123)
        aug = _DummyAugmenter(seed=rs)
        assert aug.random_state.generator is rs.generator

    def test___init___seed_is_seed(self):
        aug = _DummyAugmenter(seed=123)
        assert aug.random_state.equals(iarandom.RNG(123))

    def test_augment_images_called_probably_with_single_image(self):
        aug = _DummyAugmenter()
        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            _ = aug.augment_images(np.zeros((16, 32, 3), dtype=np.uint8))

        assert len(caught_warnings) == 1
        assert (
            "indicates that you provided a single image with shape (H, W, C)"
            in str(caught_warnings[-1].message)
        )

    def test_augment_images_array_in_list_out(self):
        self._test_augment_images_array_in_list_out_varying_channels(
            [3] * 20)

    def test_augment_images_array_in_list_out_single_channel(self):
        self._test_augment_images_array_in_list_out_varying_channels(
            [1] * 20)

    def test_augment_images_array_in_list_out_no_channels(self):
        self._test_augment_images_array_in_list_out_varying_channels(
            [None] * 20)

    def test_augment_images_array_in_list_out_varying_channels(self):
        self._test_augment_images_array_in_list_out_varying_channels(
            ["random"] * 20)

    @classmethod
    def _test_augment_images_array_in_list_out_varying_channels(cls,
                                                                nb_channels):
        assert len(nb_channels) == 20

        aug = iaa.Crop(((1, 8), (1, 8), (1, 8), (1, 8)), keep_size=False)
        seen = [0, 0]

        for nb_channels_i in nb_channels:
            if nb_channels_i == "random":
                channels = np.random.choice([None, 1, 3, 4, 9], size=(16,))

            elif nb_channels_i is None:
                channels = np.random.choice([None], size=(16,))
            else:
                channels = np.random.choice([nb_channels_i], size=(16,))

            images = [np.zeros((64, 64), dtype=np.uint8)
                      if c is None
                      else np.zeros((64, 64, c), dtype=np.uint8)
                      for c in channels]

            if nb_channels_i != "random":
                images = np.array(images)

            observed = aug.augment_images(images)

            if ia.is_np_array(observed):
                seen[0] += 1
            else:
                seen[1] += 1

            for image, c in zip(observed, channels):
                if c is None:
                    assert image.ndim == 2
                else:
                    assert image.ndim == 3
                    assert image.shape[2] == c
                assert 48 <= image.shape[0] <= 62
                assert 48 <= image.shape[1] <= 62

        assert seen[0] <= 3
        assert seen[1] >= 17

    def test_augment_images_with_2d_inputs(self):
        base_img1 = np.array([[0, 0, 1, 1],
                              [0, 0, 1, 1],
                              [0, 1, 1, 1]], dtype=np.uint8)
        base_img2 = np.array([[0, 0, 1, 1],
                              [0, 1, 1, 1],
                              [0, 1, 0, 0]], dtype=np.uint8)

        base_img1_flipped = np.array([[1, 1, 0, 0],
                                      [1, 1, 0, 0],
                                      [1, 1, 1, 0]], dtype=np.uint8)
        base_img2_flipped = np.array([[1, 1, 0, 0],
                                      [1, 1, 1, 0],
                                      [0, 0, 1, 0]], dtype=np.uint8)

        images = np.array([base_img1, base_img2])
        images_flipped = np.array([base_img1_flipped, base_img2_flipped])
        images_list = [base_img1, base_img2]
        images_flipped_list = [base_img1_flipped, base_img2_flipped]
        images_list2d3d = [base_img1, base_img2[:, :, np.newaxis]]
        images_flipped_list2d3d = [
            base_img1_flipped,
            base_img2_flipped[:, :, np.newaxis]]

        aug = iaa.Fliplr(1.0)
        noaug = iaa.Fliplr(0.0)

        # one numpy array as input
        observed = aug.augment_images(images)
        assert np.array_equal(observed, images_flipped)

        observed = noaug.augment_images(images)
        assert np.array_equal(observed, images)

        # list of 2d images
        observed = aug.augment_images(images_list)
        assert array_equal_lists(observed, images_flipped_list)

        observed = noaug.augment_images(images_list)
        assert array_equal_lists(observed, images_list)

        # list of images, one 2d and one 3d
        observed = aug.augment_images(images_list2d3d)
        assert array_equal_lists(observed, images_flipped_list2d3d)

        observed = noaug.augment_images(images_list2d3d)
        assert array_equal_lists(observed, images_list2d3d)

    def test_augment_keypoints_single_instance(self):
        kpsoi = ia.KeypointsOnImage([ia.Keypoint(10, 10)], shape=(32, 32, 3))
        aug = iaa.Affine(translate_px={"x": 1})

        kpsoi_aug = aug.augment_keypoints(kpsoi)

        assert len(kpsoi_aug.keypoints) == 1
        assert kpsoi_aug.keypoints[0].x == 11

    def test_augment_keypoints_single_instance_rot90(self):
        kps = [ia.Keypoint(x=1, y=2), ia.Keypoint(x=2, y=5),
               ia.Keypoint(x=3, y=3)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 10, 3))
        aug = iaa.Rot90(1, keep_size=False)

        kpsoi_aug = aug.augment_keypoints(kpsoi)

        # set offset to -1 if Rot90 uses int-based coordinate transformation
        kp_offset = 0
        assert np.allclose(kpsoi_aug.keypoints[0].x, 5 - 2 + kp_offset)
        assert np.allclose(kpsoi_aug.keypoints[0].y, 1)
        assert np.allclose(kpsoi_aug.keypoints[1].x, 5 - 5 + kp_offset)
        assert np.allclose(kpsoi_aug.keypoints[1].y, 2)
        assert np.allclose(kpsoi_aug.keypoints[2].x, 5 - 3 + kp_offset)
        assert np.allclose(kpsoi_aug.keypoints[2].y, 3)

    def test_augment_keypoints_many_instances_rot90(self):
        kps = [ia.Keypoint(x=1, y=2), ia.Keypoint(x=2, y=5),
               ia.Keypoint(x=3, y=3)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 10, 3))
        aug = iaa.Rot90(1, keep_size=False)

        kpsoi_aug = aug.augment_keypoints([kpsoi, kpsoi, kpsoi])

        # set offset to -1 if Rot90 uses int-based coordinate transformation
        kp_offset = 0
        for i in range(3):
            assert np.allclose(kpsoi_aug[i].keypoints[0].x, 5 - 2 + kp_offset)
            assert np.allclose(kpsoi_aug[i].keypoints[0].y, 1)
            assert np.allclose(kpsoi_aug[i].keypoints[1].x, 5 - 5 + kp_offset)
            assert np.allclose(kpsoi_aug[i].keypoints[1].y, 2)
            assert np.allclose(kpsoi_aug[i].keypoints[2].x, 5 - 3 + kp_offset)
            assert np.allclose(kpsoi_aug[i].keypoints[2].y, 3)

    def test_augment_keypoints_empty_instance(self):
        # test empty KeypointsOnImage objects
        kpsoi = ia.KeypointsOnImage([], shape=(32, 32, 3))
        aug = iaa.Affine(translate_px={"x": 1})

        kpsoi_aug = aug.augment_keypoints([kpsoi])

        assert len(kpsoi_aug) == 1
        assert len(kpsoi_aug[0].keypoints) == 0

    def test_augment_keypoints_mixed_filled_and_empty_instances(self):
        kpsoi1 = ia.KeypointsOnImage([], shape=(32, 32, 3))
        kpsoi2 = ia.KeypointsOnImage([ia.Keypoint(10, 10)], shape=(32, 32, 3))
        aug = iaa.Affine(translate_px={"x": 1})

        kpsoi_aug = aug.augment_keypoints([kpsoi1, kpsoi2])

        assert len(kpsoi_aug) == 2
        assert len(kpsoi_aug[0].keypoints) == 0
        assert len(kpsoi_aug[1].keypoints) == 1
        assert kpsoi_aug[1].keypoints[0].x == 11

    def test_augment_keypoints_aligned_despite_empty_instance(self):
        # Test if augmenting lists of KeypointsOnImage is still aligned with
        # image augmentation when one KeypointsOnImage instance is empty
        # (no keypoints)
        kpsoi_lst = [
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=1, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([], shape=(1, 8)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=1, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10)),
            ia.KeypointsOnImage([ia.Keypoint(x=0, y=0)], shape=(1, 10))
        ]
        image = np.zeros((1, 10), dtype=np.uint8)
        image[0, 0] = 255
        images = np.tile(image[np.newaxis, :, :], (len(kpsoi_lst), 1, 1))

        aug = iaa.Affine(translate_px={"x": (0, 8)}, order=0, mode="constant",
                         cval=0)

        for i in sm.xrange(10):
            for is_list in [False, True]:
                with self.subTest(i=i, is_list=is_list):
                    aug_det = aug.to_deterministic()
                    if is_list:
                        images_aug = aug_det.augment_images(list(images))
                    else:
                        images_aug = aug_det.augment_images(images)
                    kpsoi_lst_aug = aug_det.augment_keypoints(kpsoi_lst)

                    if is_list:
                        images_aug = np.array(images_aug, dtype=np.uint8)
                    translations_imgs = np.argmax(images_aug[:, 0, :], axis=1)
                    translations_kps = [
                        kpsoi.keypoints[0].x
                        if len(kpsoi.keypoints) > 0
                        else None
                        for kpsoi
                        in kpsoi_lst_aug]

                    assert len([kpresult
                                for kpresult
                                in translations_kps
                                if kpresult is None]) == 1
                    assert translations_kps[5] is None
                    translations_imgs = np.concatenate(
                        [translations_imgs[0:5], translations_imgs[6:]])
                    translations_kps = np.array(
                        translations_kps[0:5] + translations_kps[6:],
                        dtype=translations_imgs.dtype)
                    translations_kps[2] -= 1
                    translations_kps[8-1] -= 1
                    assert np.array_equal(translations_imgs, translations_kps)

    def test_augment_keypoints_aligned_despite_nongeometric_image_ops(self):
        # Verify for keypoints that adding augmentations that only
        # affect images doesn't lead to misalignments between image
        # and keypoint transformations
        augs = iaa.Sequential([
            iaa.Fliplr(0.5),
            iaa.AdditiveGaussianNoise(scale=(0.01, 0.1)),
            iaa.Affine(translate_px={"x": (-10, 10), "y": (-10, 10)},
                       order=0, mode="constant", cval=0),
            iaa.AddElementwise((0, 1)),
            iaa.Flipud(0.5)
        ], random_order=True)

        kps = [ia.Keypoint(x=15.5, y=12.5), ia.Keypoint(x=23.5, y=20.5),
               ia.Keypoint(x=61.5, y=36.5), ia.Keypoint(x=47.5, y=32.5)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(50, 80, 4))
        image = kpsoi.to_keypoint_image(size=1)
        images = np.tile(image[np.newaxis, ...], (20, 1, 1, 1))

        for _ in sm.xrange(50):
            images_aug, kpsois_aug = augs(images=images,
                                          keypoints=[kpsoi]*len(images))

            for image_aug, kpsoi_aug in zip(images_aug, kpsois_aug):
                kpsoi_recovered = ia.KeypointsOnImage.from_keypoint_image(
                    image_aug, nb_channels=4, threshold=100
                )

                for kp, kp_image in zip(kpsoi_aug.keypoints,
                                        kpsoi_recovered.keypoints):
                    distance = np.sqrt((kp.x - kp_image.x)**2
                                       + (kp.y - kp_image.y)**2)
                    assert distance <= 1

    def test_augment_bounding_boxes(self):
        aug = _DummyAugmenterBBs()
        bb = ia.BoundingBox(x1=1, y1=4, x2=2, y2=5)
        bbs = [bb]
        bbsois = [ia.BoundingBoxesOnImage(bbs, shape=(10, 10, 3))]
        bbsois_aug = aug.augment_bounding_boxes(bbsois)

        bb_aug = bbsois_aug[0].bounding_boxes[0]

        assert bb_aug.x1 == 1+1
        assert bb_aug.y1 == 4
        assert bb_aug.x2 == 2+1
        assert bb_aug.y2 == 5

    def test_augment_bounding_boxes_empty_bboi(self):
        aug = _DummyAugmenterBBs()
        bbsois = [ia.BoundingBoxesOnImage([], shape=(10, 10, 3))]

        bbsois_aug = aug.augment_bounding_boxes(bbsois)

        assert len(bbsois_aug) == 1
        assert bbsois_aug[0].bounding_boxes == []

    def test_augment_bounding_boxes_empty_list(self):
        aug = _DummyAugmenterBBs()

        bbsois_aug = aug.augment_bounding_boxes([])

        assert bbsois_aug == []

    def test_augment_bounding_boxes_single_instance(self):
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=1, x2=3, y1=4, y2=5),
            ia.BoundingBox(x1=2.5, x2=3, y1=0, y2=2)
        ], shape=(5, 10, 3))
        aug = iaa.Identity()

        bbsoi_aug = aug.augment_bounding_boxes(bbsoi)

        for bb_aug, bb in zip(bbsoi_aug.bounding_boxes, bbsoi.bounding_boxes):
            assert np.allclose(bb_aug.x1, bb.x1)
            assert np.allclose(bb_aug.x2, bb.x2)
            assert np.allclose(bb_aug.y1, bb.y1)
            assert np.allclose(bb_aug.y2, bb.y2)

    def test_augment_bounding_boxes_single_instance_rot90(self):
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=1, x2=3, y1=4, y2=5),
            ia.BoundingBox(x1=2.5, x2=3, y1=0, y2=2)
        ], shape=(5, 10, 3))
        aug = iaa.Rot90(1, keep_size=False)

        bbsoi_aug = aug.augment_bounding_boxes(bbsoi)

        # set offset to -1 if Rot90 uses int-based coordinate transformation
        kp_offset = 0
        # Note here that the new coordinates are minima/maxima of the BB, so
        # not as straight forward to compute the new coords as for keypoint
        # augmentation
        bb0 = bbsoi_aug.bounding_boxes[0]
        bb1 = bbsoi_aug.bounding_boxes[1]
        assert np.allclose(bb0.x1, 5 - 5 + kp_offset)
        assert np.allclose(bb0.x2, 5 - 4 + kp_offset)
        assert np.allclose(bb0.y1, 1)
        assert np.allclose(bb0.y2, 3)
        assert np.allclose(bb1.x1, 5 - 2 + kp_offset)
        assert np.allclose(bb1.x2, 5 - 0 + kp_offset)
        assert np.allclose(bb1.y1, 2.5)
        assert np.allclose(bb1.y2, 3)

    def test_augment_bounding_box_list_of_many_instances(self):
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=1, x2=3, y1=4, y2=5),
            ia.BoundingBox(x1=2.5, x2=3, y1=0, y2=2)
        ], shape=(5, 10, 3))
        aug = iaa.Rot90(1, keep_size=False)

        bbsoi_aug = aug.augment_bounding_boxes([bbsoi, bbsoi, bbsoi])

        # set offset to -1 if Rot90 uses int-based coordinate transformation
        kp_offset = 0
        for i in range(3):
            bb0 = bbsoi_aug[i].bounding_boxes[0]
            bb1 = bbsoi_aug[i].bounding_boxes[1]
            assert np.allclose(bb0.x1, 5 - 5 + kp_offset)
            assert np.allclose(bb0.x2, 5 - 4 + kp_offset)
            assert np.allclose(bb0.y1, 1)
            assert np.allclose(bb0.y2, 3)
            assert np.allclose(bb1.x1, 5 - 2 + kp_offset)
            assert np.allclose(bb1.x2, 5 - 0 + kp_offset)
            assert np.allclose(bb1.y1, 2.5)
            assert np.allclose(bb1.y2, 3)

    def test_augment_heatmaps_noop_single_heatmap(self):
        heatmap_arr = np.linspace(0.0, 1.0, num=4*4).reshape((4, 4, 1))
        heatmap = ia.HeatmapsOnImage(heatmap_arr.astype(np.float32),
                                     shape=(4, 4, 3))

        aug = iaa.Identity()
        heatmap_aug = aug.augment_heatmaps(heatmap)
        assert np.allclose(heatmap_aug.arr_0to1, heatmap.arr_0to1)

    def test_augment_heatmaps_rot90_single_heatmap(self):
        heatmap_arr = np.linspace(0.0, 1.0, num=4*4).reshape((4, 4, 1))
        heatmap = ia.HeatmapsOnImage(heatmap_arr.astype(np.float32),
                                     shape=(4, 4, 3))
        aug = iaa.Rot90(1, keep_size=False)

        heatmap_aug = aug.augment_heatmaps(heatmap)

        assert np.allclose(heatmap_aug.arr_0to1, np.rot90(heatmap.arr_0to1, -1))

    def test_augment_heatmaps_rot90_list_of_many_heatmaps(self):
        heatmap_arr = np.linspace(0.0, 1.0, num=4*4).reshape((4, 4, 1))
        heatmap = ia.HeatmapsOnImage(heatmap_arr.astype(np.float32),
                                     shape=(4, 4, 3))
        aug = iaa.Rot90(1, keep_size=False)

        heatmaps_aug = aug.augment_heatmaps([heatmap] * 3)

        for hm in heatmaps_aug:
            assert np.allclose(hm.arr_0to1, np.rot90(heatmap.arr_0to1, -1))

    def test_legacy_fallback_to_kp_aug_for_cbaois(self):
        class _LegacyAugmenter(iaa.Augmenter):
            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                return [kpsoi.shift(x=1) for kpsoi in keypoints_on_images]

            def get_parameters(self):
                return []

        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=1, y1=2, x2=3, y2=4)
        ], shape=(4, 5, 3))
        psoi = ia.PolygonsOnImage([
            ia.Polygon([(0, 0), (1, 0), (1, 1)])
        ], shape=(4, 5, 3))
        lsoi = ia.LineStringsOnImage([
            ia.LineString([(0, 0), (1, 0), (1, 1)])
        ], shape=(4, 5, 3))

        aug = _LegacyAugmenter()
        bbsoi_aug = aug.augment_bounding_boxes(bbsoi)
        psoi_aug = aug.augment_polygons(psoi)
        lsoi_aug = aug.augment_line_strings(lsoi)

        assert bbsoi_aug[0].coords_almost_equals(bbsoi[0].shift(x=1))
        assert psoi_aug[0].coords_almost_equals(psoi[0].shift(x=1))
        assert lsoi_aug[0].coords_almost_equals(lsoi[0].shift(x=1))

    def test_localize_random_state(self):
        aug = _DummyAugmenter()

        aug_localized = aug.localize_random_state()

        assert aug_localized is not aug
        assert aug.random_state.is_global_rng()
        assert not aug_localized.random_state.is_global_rng()

    def test_seed_(self):
        aug1 = _DummyAugmenter()
        aug2 = _DummyAugmenter().to_deterministic()
        aug0 = iaa.Sequential([aug1, aug2])

        aug0_copy = aug0.deepcopy()
        assert _same_rs(aug0.random_state, aug0_copy.random_state)
        assert _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

        aug0_copy.seed_()

        assert not _same_rs(aug0.random_state, aug0_copy.random_state)
        assert not _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

    def test_seed__deterministic_too(self):
        aug1 = _DummyAugmenter()
        aug2 = _DummyAugmenter().to_deterministic()
        aug0 = iaa.Sequential([aug1, aug2])

        aug0_copy = aug0.deepcopy()
        assert _same_rs(aug0.random_state, aug0_copy.random_state)
        assert _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

        aug0_copy.seed_(deterministic_too=True)

        assert not _same_rs(aug0.random_state, aug0_copy.random_state)
        assert not _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert not _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

    def test_seed__with_integer(self):
        aug1 = _DummyAugmenter()
        aug2 = _DummyAugmenter().to_deterministic()
        aug0 = iaa.Sequential([aug1, aug2])

        aug0_copy = aug0.deepcopy()
        assert _same_rs(aug0.random_state, aug0_copy.random_state)
        assert _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

        aug0_copy.seed_(123)

        assert not _same_rs(aug0.random_state, aug0_copy.random_state)
        assert not _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0_copy.random_state, iarandom.RNG(123))
        expected = iarandom.RNG(123).derive_rng_()
        assert _same_rs(aug0_copy[0].random_state, expected)

    def test_seed__with_rng(self):
        aug1 = _DummyAugmenter()
        aug2 = _DummyAugmenter().to_deterministic()
        aug0 = iaa.Sequential([aug1, aug2])

        aug0_copy = aug0.deepcopy()
        assert _same_rs(aug0.random_state, aug0_copy.random_state)
        assert _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)

        aug0_copy.seed_(iarandom.RNG(123))

        assert not _same_rs(aug0.random_state, aug0_copy.random_state)
        assert not _same_rs(aug0[0].random_state, aug0_copy[0].random_state)
        assert _same_rs(aug0[1].random_state, aug0_copy[1].random_state)
        assert _same_rs(aug0_copy.random_state,
                        iarandom.RNG(123))
        expected = iarandom.RNG(123).derive_rng_()
        assert _same_rs(aug0_copy[0].random_state, expected)

    def test_get_parameters(self):
        # test for "raise NotImplementedError"
        aug = _DummyAugmenterCallsParent()
        with self.assertRaises(NotImplementedError):
            aug.get_parameters()

    def test_get_all_children_flat(self):
        aug1 = _DummyAugmenter()
        aug21 = _DummyAugmenter()
        aug2 = iaa.Sequential([aug21])
        aug0 = iaa.Sequential([aug1, aug2])

        children = aug0.get_all_children(flat=True)

        assert isinstance(children, list)
        assert children[0] == aug1
        assert children[1] == aug2
        assert children[2] == aug21

    def test_get_all_children_not_flat(self):
        aug1 = _DummyAugmenter()
        aug21 = _DummyAugmenter()
        aug2 = iaa.Sequential([aug21])
        aug0 = iaa.Sequential([aug1, aug2])

        children = aug0.get_all_children(flat=False)

        assert isinstance(children, list)
        assert children[0] == aug1
        assert children[1] == aug2
        assert isinstance(children[2], list)
        assert children[2][0] == aug21

    def test___repr___and___str__(self):
        class DummyAugmenterRepr(iaa.Augmenter):
            def _augment_images(self, images, random_state, parents, hooks):
                return images

            def _augment_heatmaps(self, heatmaps, random_state, parents, hooks):
                return heatmaps

            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                return keypoints_on_images

            def get_parameters(self):
                return ["A", "B", "C"]

        aug1 = DummyAugmenterRepr(name="Example")
        aug2 = DummyAugmenterRepr(name="Example").to_deterministic()

        expected1 = (
            "DummyAugmenterRepr("
            "name=Example, parameters=[A, B, C], deterministic=False"
            ")")
        expected2 = (
            "DummyAugmenterRepr("
            "name=Example, parameters=[A, B, C], deterministic=True"
            ")")

        assert aug1.__repr__() == aug1.__str__() == expected1
        assert aug2.__repr__() == aug2.__str__() == expected2


# -----------
# lambda functions used in Test TestAugmenter_augment_batches
# in test method test_augment_batches_with_many_different_augmenters().
# They are here instead of in the test method, because otherwise there were
# issues with spawn mode not being able to pickle functions,
# see issue #414.

def _augment_batches__lambda_func_images(
        images, random_state, parents, hooks):
    return images


def _augment_batches__lambda_func_keypoints(
        keypoints_on_images, random_state, parents, hooks):
    return keypoints_on_images


def _augment_batches__assertlambda_func_images(
        images, random_state, parents, hooks):
    return True


def _augment_batches__assertlambda_func_keypoints(
        keypoints_on_images, random_state, parents, hooks):
    return True
# -----------


class TestAugmenter_augment_batches(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_augment_batches_list_of_empty_list_deprecated(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            aug = _DummyAugmenter()

            batches_aug = list(aug.augment_batches([[]]))

            assert isinstance(batches_aug, list)
            assert len(batches_aug) == 1
            assert isinstance(batches_aug[0], list)

        assert len(caught_warnings) == 1
        assert "deprecated" in str(caught_warnings[-1].message)

    def test_augment_batches_list_of_arrays_deprecated(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            aug = _DummyAugmenter()
            image_batches = [np.zeros((1, 2, 2, 3), dtype=np.uint8)]

            batches_aug = list(aug.augment_batches(image_batches))

            assert isinstance(batches_aug, list)
            assert len(batches_aug) == 1
            assert array_equal_lists(batches_aug, image_batches)

        assert len(caught_warnings) == 1
        assert "deprecated" in str(caught_warnings[-1].message)

    def test_augment_batches_list_of_list_of_arrays_deprecated(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            aug = _DummyAugmenter()
            image_batches = [[np.zeros((2, 2, 3), dtype=np.uint8),
                              np.zeros((2, 3, 3))]]

            batches_aug = list(aug.augment_batches(image_batches))

            assert isinstance(batches_aug, list)
            assert len(batches_aug) == 1
            assert array_equal_lists(batches_aug[0], image_batches[0])

        assert len(caught_warnings) == 1
        assert "deprecated" in str(caught_warnings[-1].message)

    def test_augment_batches_invalid_datatype(self):
        aug = _DummyAugmenter()
        with self.assertRaises(Exception):
            _ = list(aug.augment_batches(None))

    def test_augment_batches_list_of_invalid_datatype(self):
        aug = _DummyAugmenter()
        got_exception = False
        try:
            _ = list(aug.augment_batches([None]))
        except Exception as exc:
            got_exception = True
            assert "Unknown datatype of batch" in str(exc)
        assert got_exception

    def test_augment_batches_list_of_list_of_invalid_datatype(self):
        aug = _DummyAugmenter()
        got_exception = False
        try:
            _ = list(aug.augment_batches([[None]]))
        except Exception as exc:
            got_exception = True
            assert "Unknown datatype in batch[0]" in str(exc)
        assert got_exception

    def test_augment_batches_batch_with_list_of_images(self):
        image = np.array([[0, 0, 1, 1, 1],
                          [0, 0, 1, 1, 1],
                          [0, 1, 1, 1, 1]], dtype=np.uint8)
        image_flipped = np.fliplr(image)
        keypoint = ia.Keypoint(x=2, y=1)
        keypoints = [ia.KeypointsOnImage([keypoint], shape=image.shape + (1,))]
        kp_flipped = ia.Keypoint(
            x=image.shape[1]-keypoint.x,
            y=keypoint.y
        )

        # basic functionality test (images as list)
        for bg in [True, False]:
            seq = iaa.Fliplr(1.0)
            batches = [ia.Batch(images=[np.copy(image)], keypoints=keypoints)]
            batches_aug = list(seq.augment_batches(batches, background=bg))
            baug0 = batches_aug[0]
            assert np.array_equal(baug0.images_aug[0], image_flipped)
            assert baug0.keypoints_aug[0].keypoints[0].x == kp_flipped.x
            assert baug0.keypoints_aug[0].keypoints[0].y == kp_flipped.y
            assert np.array_equal(baug0.images_unaug[0], image)
            assert baug0.keypoints_unaug[0].keypoints[0].x == keypoint.x
            assert baug0.keypoints_unaug[0].keypoints[0].y == keypoint.y

    def test_augment_batches_batch_with_array_of_images(self):
        image = np.array([[0, 0, 1, 1, 1],
                          [0, 0, 1, 1, 1],
                          [0, 1, 1, 1, 1]], dtype=np.uint8)
        image_flipped = np.fliplr(image)
        keypoint = ia.Keypoint(x=2, y=1)
        keypoints = [ia.KeypointsOnImage([keypoint], shape=image.shape + (1,))]
        kp_flipped = ia.Keypoint(
            x=image.shape[1]-keypoint.x,
            y=keypoint.y
        )

        # basic functionality test (images as array)
        for bg in [True, False]:
            seq = iaa.Fliplr(1.0)
            batches = [ia.Batch(images=np.uint8([np.copy(image)]),
                                keypoints=keypoints)]
            batches_aug = list(seq.augment_batches(batches, background=bg))
            baug0 = batches_aug[0]
            assert np.array_equal(baug0.images_aug, np.uint8([image_flipped]))
            assert baug0.keypoints_aug[0].keypoints[0].x == kp_flipped.x
            assert baug0.keypoints_aug[0].keypoints[0].y == kp_flipped.y
            assert np.array_equal(baug0.images_unaug, np.uint8([image]))
            assert baug0.keypoints_unaug[0].keypoints[0].x == keypoint.x
            assert baug0.keypoints_unaug[0].keypoints[0].y == keypoint.y

    def test_augment_batches_background(self):
        image = np.array([[0, 0, 1, 1, 1],
                          [0, 0, 1, 1, 1],
                          [0, 1, 1, 1, 1]], dtype=np.uint8)
        image_flipped = np.fliplr(image)
        kps = ia.Keypoint(x=2, y=1)
        kpsoi = ia.KeypointsOnImage([kps], shape=image.shape + (1,))
        kp_flipped = ia.Keypoint(
            x=image.shape[1]-kps.x,
            y=kps.y
        )

        seq = iaa.Fliplr(0.5)

        for bg, as_array in itertools.product([False, True], [False, True]):
            # with images as list
            nb_flipped_images = 0
            nb_flipped_keypoints = 0
            nb_iterations = 1000
            images = (
                np.uint8([np.copy(image)])
                if as_array
                else [np.copy(image)])
            batches = [
                ia.Batch(images=images,
                         keypoints=[kpsoi.deepcopy()])
                for _ in sm.xrange(nb_iterations)
            ]

            batches_aug = list(seq.augment_batches(batches, background=bg))

            for batch_aug in batches_aug:
                image_aug = batch_aug.images_aug[0]
                keypoint_aug = batch_aug.keypoints_aug[0].keypoints[0]

                img_matches_unflipped = np.array_equal(image_aug, image)
                img_matches_flipped = np.array_equal(image_aug, image_flipped)
                assert img_matches_unflipped or img_matches_flipped
                if img_matches_flipped:
                    nb_flipped_images += 1

                kp_matches_unflipped = (
                    np.isclose(keypoint_aug.x, kps.x)
                    and np.isclose(keypoint_aug.y, kps.y))
                kp_matches_flipped = (
                    np.isclose(keypoint_aug.x, kp_flipped.x)
                    and np.isclose(keypoint_aug.y, kp_flipped.y))
                assert kp_matches_flipped or kp_matches_unflipped
                if kp_matches_flipped:
                    nb_flipped_keypoints += 1
            assert 0.4*nb_iterations <= nb_flipped_images <= 0.6*nb_iterations
            assert nb_flipped_images == nb_flipped_keypoints

    def test_augment_batches_with_many_different_augmenters(self):
        image = np.array([[0, 0, 1, 1, 1],
                          [0, 0, 1, 1, 1],
                          [0, 1, 1, 1, 1]], dtype=np.uint8)
        keypoint = ia.Keypoint(x=2, y=1)
        keypoints = [ia.KeypointsOnImage([keypoint], shape=image.shape + (1,))]

        augs = [
            iaa.Sequential([iaa.Fliplr(1.0), iaa.Flipud(1.0)]),
            iaa.SomeOf(1, [iaa.Fliplr(1.0), iaa.Flipud(1.0)]),
            iaa.OneOf([iaa.Fliplr(1.0), iaa.Flipud(1.0)]),
            iaa.Sometimes(1.0, iaa.Fliplr(1)),
            iaa.WithColorspace("HSV", children=iaa.Add((-50, 50))),
            iaa.WithChannels([0], iaa.Add((-50, 50))),
            iaa.Identity(name="Identity-nochange"),
            iaa.Lambda(
                func_images=_augment_batches__lambda_func_images,
                func_keypoints=_augment_batches__lambda_func_keypoints,
                name="Lambda-nochange"
            ),
            iaa.AssertLambda(
                func_images=_augment_batches__assertlambda_func_images,
                func_keypoints=_augment_batches__assertlambda_func_keypoints,
                name="AssertLambda-nochange"
            ),
            iaa.AssertShape(
                (None, 64, 64, 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(1.0),
            iaa.Flipud(1.0),
            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(1.0),
            iaa.AverageBlur(5),
            iaa.MedianBlur(5),
            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.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=2.0)
        ]

        nb_iterations = 100
        image = ia.data.quokka(size=(64, 64))
        batches = [ia.Batch(images=[np.copy(image)],
                            keypoints=[keypoints[0].deepcopy()])
                   for _ in sm.xrange(nb_iterations)]
        for aug in augs:
            nb_changed = 0
            batches_aug = list(aug.augment_batches(batches, background=True))
            for batch_aug in batches_aug:
                image_aug = batch_aug.images_aug[0]
                if (image.shape != image_aug.shape
                        or not np.array_equal(image, image_aug)):
                    nb_changed += 1
                    if nb_changed > 10:
                        break
            if "-nochange" not in aug.name:
                assert nb_changed > 0
            else:
                assert nb_changed == 0


class TestAugmenter_augment_batch(unittest.TestCase):
    def test_deprecation(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            aug = _InplaceDummyAugmenterImgsArray(1)

            batch = ia.UnnormalizedBatch(
                images=np.zeros((1, 1, 1, 3), dtype=np.uint8))
            _batch_aug = aug.augment_batch(batch)

            assert len(caught_warnings) == 1
            assert "is deprecated" in str(caught_warnings[0].message)

    def test_augments_correctly_images(self):
        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
            image = np.tile(image, (1, 1, 3))
            image[:, :, 0] += 0
            image[:, :, 1] += 1
            image[:, :, 2] += 2
            images = image[np.newaxis, :, :, :]
            image_cp = np.copy(image)

            aug = _InplaceDummyAugmenterImgsArray(1)

            batch = ia.UnnormalizedBatch(images=images)
            batch_aug = aug.augment_batch(batch)

            image_unaug = batch_aug.images_unaug[0, :, :, :]
            image_aug = batch_aug.images_aug[0, :, :, :]

            assert batch_aug is batch
            assert batch_aug.images_aug is not batch.images_unaug
            assert batch_aug.images_aug is not batch_aug.images_unaug

            assert np.array_equal(image, image_cp)
            assert np.array_equal(image_unaug, image_cp)
            assert np.array_equal(image_aug, image_cp + 1)


class TestAugmenter_augment_batch_(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_verify_inplace_aug__imgs__unnormalized_batch(self):
        image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
        image = np.tile(image, (1, 1, 3))
        image[:, :, 0] += 0
        image[:, :, 1] += 1
        image[:, :, 2] += 2
        images = image[np.newaxis, :, :, :]
        image_cp = np.copy(image)

        aug = _InplaceDummyAugmenterImgsArray(1)

        batch = ia.UnnormalizedBatch(images=images)
        batch_aug = aug.augment_batch_(batch)
        image_unaug = batch_aug.images_unaug[0, :, :, :]
        image_aug = batch_aug.images_aug[0, :, :, :]

        assert batch_aug is batch
        assert batch_aug.images_aug is not batch.images_unaug
        assert batch_aug.images_aug is not batch_aug.images_unaug

        assert np.array_equal(image, image_cp)
        assert np.array_equal(image_unaug, image_cp)
        assert np.array_equal(image_aug, image_cp + 1)

    def test_verify_inplace_aug__imgs__normalized_batch(self):
        image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
        image = np.tile(image, (1, 1, 3))
        image[:, :, 0] += 0
        image[:, :, 1] += 1
        image[:, :, 2] += 2
        images = image[np.newaxis, :, :, :]
        image_cp = np.copy(image)

        aug = _InplaceDummyAugmenterImgsArray(1)

        batch = ia.Batch(images=images)
        batch_aug = aug.augment_batch_(batch)
        image_unaug = batch_aug.images_unaug[0, :, :, :]
        image_aug = batch_aug.images_aug[0, :, :, :]

        assert batch_aug is batch
        assert batch_aug.images_aug is not batch.images_unaug
        assert batch_aug.images_aug is not batch_aug.images_unaug

        assert np.array_equal(image, image_cp)
        assert np.array_equal(image_unaug, image_cp)
        assert np.array_equal(image_aug, image_cp + 1)

    def test_verify_inplace_aug__imgs__batchinaug(self):
        image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
        image = np.tile(image, (1, 1, 3))
        image[:, :, 0] += 0
        image[:, :, 1] += 1
        image[:, :, 2] += 2
        images = image[np.newaxis, :, :, :]
        image_cp = np.copy(image)

        aug = _InplaceDummyAugmenterImgsArray(1)

        batch = _BatchInAugmentation(images=images)
        batch_aug = aug.augment_batch_(batch)
        image_aug = batch_aug.images[0, :, :, :]

        assert batch_aug is batch
        assert batch_aug.images is batch.images

        assert not np.array_equal(image, image_cp)
        assert np.array_equal(image_aug, image_cp + 1)

    def test_verify_inplace_aug__segmaps__normalized_batch(self):
        segmap_arr = np.zeros((10, 20, 3), dtype=np.int32)
        segmap_arr[3:6, 3:9] = 1
        segmap = ia.SegmentationMapsOnImage(segmap_arr, shape=(10, 20, 3))
        segmap_cp = ia.SegmentationMapsOnImage(np.copy(segmap_arr),
                                               shape=(10, 20, 3))

        aug = _InplaceDummyAugmenterSegMaps(1)

        batch = ia.Batch(segmentation_maps=[segmap])
        batch_aug = aug.augment_batch_(batch)
        segmap_unaug = batch_aug.segmentation_maps_unaug[0]
        segmap_aug = batch_aug.segmentation_maps_aug[0]

        assert batch_aug is batch
        assert (batch_aug.segmentation_maps_aug
                is not batch.segmentation_maps_unaug)
        assert (batch_aug.segmentation_maps_aug
                is not batch_aug.segmentation_maps_unaug)

        assert np.array_equal(segmap.get_arr(), segmap_cp.get_arr())
        assert np.array_equal(segmap_unaug.get_arr(), segmap_cp.get_arr())
        assert np.array_equal(segmap_aug.get_arr(), segmap_cp.get_arr() + 1)

    def test_verify_inplace_aug__keypoints_normalized_batch(self):
        kpsoi = ia.KeypointsOnImage([ia.Keypoint(x=1, y=2)],
                                    shape=(10, 20, 3))
        kpsoi_cp = ia.KeypointsOnImage([ia.Keypoint(x=1, y=2)],
                                       shape=(10, 20, 3))

        aug = _InplaceDummyAugmenterKeypoints(x=1, y=3)

        batch = ia.Batch(keypoints=[kpsoi])
        batch_aug = aug.augment_batch_(batch)
        kpsoi_unaug = batch_aug.keypoints_unaug[0]
        kpsoi_aug = batch_aug.keypoints_aug[0]

        assert batch_aug is batch
        assert (batch_aug.keypoints_aug
                is not batch.keypoints_unaug)
        assert (batch_aug.keypoints_aug
                is not batch_aug.keypoints_unaug)

        assert np.allclose(kpsoi.to_xy_array(), kpsoi_cp.to_xy_array())
        assert np.allclose(kpsoi_unaug.to_xy_array(), kpsoi_cp.to_xy_array())
        assert np.allclose(kpsoi_aug.to_xy_array()[:, 0],
                           kpsoi_cp.to_xy_array()[:, 0] + 1)
        assert np.allclose(kpsoi_aug.to_xy_array()[:, 1],
                           kpsoi_cp.to_xy_array()[:, 1] + 3)

    def test_call_changes_global_rng_state(self):
        state_before = copy.deepcopy(iarandom.get_global_rng().state)
        aug = iaa.Rot90(k=(0, 3))
        image = np.arange(4*4).astype(np.uint8).reshape((4, 4))
        batch = ia.UnnormalizedBatch(images=[image])

        _batch_aug = aug.augment_batch_(batch)

        state_after = iarandom.get_global_rng().state
        assert repr(state_before) != repr(state_after)

    def test_multiple_calls_produce_not_the_same_results(self):
        aug = iaa.Rot90(k=(0, 3))
        image = np.arange(4*4).astype(np.uint8).reshape((4, 4))
        nb_images = 1000
        batch1 = ia.UnnormalizedBatch(images=[image] * nb_images)
        batch2 = ia.UnnormalizedBatch(images=[image] * nb_images)
        batch3 = ia.UnnormalizedBatch(images=[image] * nb_images)

        batch_aug1 = aug.augment_batch_(batch1)
        batch_aug2 = aug.augment_batch_(batch2)
        batch_aug3 = aug.augment_batch_(batch3)

        assert batch_aug1 is not batch_aug2
        assert batch_aug1 is not batch_aug2
        assert batch_aug2 is not batch_aug3

        nb_equal = [0, 0, 0]
        for image_aug1, image_aug2, image_aug3 in zip(batch_aug1.images_aug,
                                                      batch_aug2.images_aug,
                                                      batch_aug3.images_aug):
            nb_equal[0] += int(np.array_equal(image_aug1, image_aug2))
            nb_equal[1] += int(np.array_equal(image_aug1, image_aug3))
            nb_equal[2] += int(np.array_equal(image_aug2, image_aug3))

        assert nb_equal[0] < (0.25 + 0.1) * nb_images
        assert nb_equal[1] < (0.25 + 0.1) * nb_images
        assert nb_equal[2] < (0.25 + 0.1) * nb_images

    def test_calls_affect_other_augmenters_with_global_rng(self):
        # with calling aug1
        iarandom.seed(1)
        aug1 = iaa.Rot90(k=(0, 3))
        aug2 = iaa.Add((0, 255))
        image = np.arange(4*4).astype(np.uint8).reshape((4, 4))
        nb_images = 50
        batch1 = ia.UnnormalizedBatch(images=[image] * 1)
        batch2 = ia.UnnormalizedBatch(images=[image] * nb_images)

        batch_aug11 = aug1.augment_batch_(batch1)
        batch_aug12 = aug2.augment_batch_(batch2)

        # with calling aug1, repetition (to see that seed() works)
        iarandom.seed(1)
        aug1 = iaa.Rot90(k=(0, 3))
        aug2 = iaa.Add((0, 255))
        image = np.arange(4*4).astype(np.uint8).reshape((4, 4))
        nb_images = 50
        batch1 = ia.UnnormalizedBatch(images=[image] * 1)
        batch2 = ia.UnnormalizedBatch(images=[image] * nb_images)

        batch_aug21 = aug1.augment_batch_(batch1)
        batch_aug22 = aug2.augment_batch_(batch2)

        # without calling aug1
        iarandom.seed(1)
        aug2 = iaa.Add((0, 255))
        image = np.arange(4*4).astype(np.uint8).reshape((4, 4))
        nb_images = 50
        batch2 = ia.UnnormalizedBatch(images=[image] * nb_images)

        batch_aug32 = aug2.augment_batch_(batch2)

        # comparison
        assert np.array_equal(
            np.array(batch_aug12.images_aug, dtype=np.uint8),
            np.array(batch_aug22.images_aug, dtype=np.uint8)
        )
        assert not np.array_equal(
            np.array(batch_aug12.images_aug, dtype=np.uint8),
            np.array(batch_aug32.images_aug, dtype=np.uint8)
        )


class TestAugmenter_augment_segmentation_maps(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_augment_segmentation_maps_single_instance(self):
        arr = np.int32([
            [0, 1, 1],
            [0, 1, 1],
            [0, 1, 1]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Identity()

        segmap_aug = aug.augment_segmentation_maps(segmap)

        assert np.array_equal(segmap_aug.arr, segmap.arr)

    def test_augment_segmentation_maps_list_of_single_instance(self):
        arr = np.int32([
            [0, 1, 1],
            [0, 1, 1],
            [0, 1, 1]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Identity()

        segmap_aug = aug.augment_segmentation_maps([segmap])[0]

        assert np.array_equal(segmap_aug.arr, segmap.arr)

    def test_augment_segmentation_maps_affine(self):
        arr = np.int32([
            [0, 1, 1],
            [0, 1, 1],
            [0, 1, 1]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Affine(translate_px={"x": 1})

        segmap_aug = aug.augment_segmentation_maps(segmap)

        expected = np.int32([
            [0, 0, 1],
            [0, 0, 1],
            [0, 0, 1]
        ])
        expected = expected[:, :, np.newaxis]
        assert np.array_equal(segmap_aug.arr, expected)

    def test_augment_segmentation_maps_pad(self):
        arr = np.int32([
            [0, 1, 1],
            [0, 1, 1],
            [0, 1, 1]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Pad(px=(1, 0, 0, 0), keep_size=False)

        segmap_aug = aug.augment_segmentation_maps(segmap)

        expected = np.int32([
            [0, 0, 0],
            [0, 1, 1],
            [0, 1, 1],
            [0, 1, 1]
        ])
        expected = expected[:, :, np.newaxis]
        assert np.array_equal(segmap_aug.arr, expected)

    def test_augment_segmentation_maps_pad_some_classes_not_provided(self):
        # only classes 0 and 3
        arr = np.int32([
            [0, 3, 3],
            [0, 3, 3],
            [0, 3, 3]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Pad(px=(1, 0, 0, 0), keep_size=False)

        segmap_aug = aug.augment_segmentation_maps(segmap)

        expected = np.int32([
            [0, 0, 0],
            [0, 3, 3],
            [0, 3, 3],
            [0, 3, 3]
        ])
        expected = expected[:, :, np.newaxis]
        assert np.array_equal(segmap_aug.arr, expected)

    def test_augment_segmentation_maps_pad_only_background_class(self):
        # only class 0
        arr = np.int32([
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]
        ])
        segmap = ia.SegmentationMapsOnImage(arr, shape=(3, 3))
        aug = iaa.Pad(px=(1, 0, 0, 0), keep_size=False)

        segmap_aug = aug.augment_segmentation_maps(segmap)

        expected = np.int32([
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]
        ])
        expected = expected[:, :, np.newaxis]
        assert np.array_equal(segmap_aug.arr, expected)

    def test_augment_segmentation_maps_multichannel_rot90(self):
        segmap = ia.SegmentationMapsOnImage(
            np.arange(0, 4*4).reshape((4, 4, 1)).astype(np.int32),
            shape=(4, 4, 3)
        )
        aug = iaa.Rot90(1, keep_size=False)

        segmaps_aug = aug.augment_segmentation_maps([segmap, segmap, segmap])

        for i in range(3):
            assert np.allclose(segmaps_aug[i].arr, np.rot90(segmap.arr, -1))


class TestAugmenter_draw_grid(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_draw_grid_list_of_3d_arrays(self):
        # list, shape (3, 3, 3)
        aug = _DummyAugmenter()
        image = np.zeros((3, 3, 3), dtype=np.uint8)
        image[0, 0, :] = 10
        image[0, 1, :] = 50
        image[1, 1, :] = 255

        grid = aug.draw_grid([image], rows=2, cols=2)

        grid_expected = np.vstack([
            np.hstack([image, image]),
            np.hstack([image, image])
        ])
        assert np.array_equal(grid, grid_expected)

    def test_draw_grid_list_of_2d_arrays(self):
        # list, shape (3, 3)
        aug = _DummyAugmenter()
        image = np.zeros((3, 3, 3), dtype=np.uint8)
        image[0, 0, :] = 10
        image[0, 1, :] = 50
        image[1, 1, :] = 255

        grid = aug.draw_grid([image[..., 0]], rows=2, cols=2)

        grid_expected = np.vstack([
            np.hstack([image[..., 0:1], image[..., 0:1]]),
            np.hstack([image[..., 0:1], image[..., 0:1]])
        ])
        grid_expected = np.tile(grid_expected, (1, 1, 3))
        assert np.array_equal(grid, grid_expected)

    def test_draw_grid_list_of_1d_arrays_fails(self):
        # list, shape (2,)
        aug = _DummyAugmenter()

        with self.assertRaises(Exception):
            _ = aug.draw_grid([np.zeros((2,), dtype=np.uint8)], rows=2, cols=2)

    def test_draw_grid_4d_array(self):
        # array, shape (1, 3, 3, 3)
        aug = _DummyAugmenter()
        image = np.zeros((3, 3, 3), dtype=np.uint8)
        image[0, 0, :] = 10
        image[0, 1, :] = 50
        image[1, 1, :] = 255

        grid = aug.draw_grid(np.uint8([image]), rows=2, cols=2)

        grid_expected = np.vstack([
            np.hstack([image, image]),
            np.hstack([image, image])
        ])
        assert np.array_equal(grid, grid_expected)

    def test_draw_grid_3d_array(self):
        # array, shape (3, 3, 3)
        aug = _DummyAugmenter()
        image = np.zeros((3, 3, 3), dtype=np.uint8)
        image[0, 0, :] = 10
        image[0, 1, :] = 50
        image[1, 1, :] = 255

        grid = aug.draw_grid(image, rows=2, cols=2)

        grid_expected = np.vstack([
            np.hstack([image, image]),
            np.hstack([image, image])
        ])
        assert np.array_equal(grid, grid_expected)

    def test_draw_grid_2d_array(self):
        # array, shape (3, 3)
        aug = _DummyAugmenter()
        image = np.zeros((3, 3, 3), dtype=np.uint8)
        image[0, 0, :] = 10
        image[0, 1, :] = 50
        image[1, 1, :] = 255

        grid = aug.draw_grid(image[..., 0], rows=2, cols=2)

        grid_expected = np.vstack([
            np.hstack([image[..., 0:1], image[..., 0:1]]),
            np.hstack([image[..., 0:1], image[..., 0:1]])
        ])
        grid_expected = np.tile(grid_expected, (1, 1, 3))
        assert np.array_equal(grid, grid_expected)

    def test_draw_grid_1d_array(self):
        # array, shape (2,)
        aug = _DummyAugmenter()

        with self.assertRaises(Exception):
            _ = aug.draw_grid(np.zeros((2,), dtype=np.uint8), rows=2, cols=2)


@six.add_metaclass(ABCMeta)
class _TestAugmenter_augment_cbaois(object):
    """Class that is used to test augment_polygons() and augment_line_strings().

    Originally this was only used for polygons and then made more flexible.
    This is why some descriptions are still geared towards polygons.

    Abbreviations:
        cba = coordinate based augmentable, e.g. Polygon
        cbaoi = coordinate based augmentable on image, e.g. PolygonsOnImage

    """

    def setUp(self):
        reseed()

    @abstractmethod
    def _augfunc(self, augmenter, *args, **kwargs):
        """Return augmenter.augment_*(...)."""

    @property
    @abstractmethod
    def _ObjClass(self):
        """Return Polygon, LineString or similar class."""

    @property
    @abstractmethod
    def _ObjOnImageClass(self):
        """Return PolygonsOnImage, LineStringsOnImage or similar class."""

    def _Obj(self, *args, **kwargs):
        return self._ObjClass(*args, **kwargs)

    def _ObjOnImage(self, *args, **kwargs):
        return self._ObjOnImageClass(*args, **kwargs)

    def _compare_coords_of_cba(self, observed, expected, atol=1e-4, rtol=0):
        return np.allclose(observed, expected, atol=atol, rtol=rtol)

    def test_single_empty_instance(self):
        # single instance of PolygonsOnImage with 0 polygons
        aug = iaa.Rot90(1, keep_size=False)
        cbaoi = self._ObjOnImage([], shape=(10, 11, 3))

        cbaoi_aug = self._augfunc(aug, cbaoi)

        assert isinstance(cbaoi_aug, self._ObjOnImageClass)
        assert cbaoi_aug.empty
        assert cbaoi_aug.shape == (11, 10, 3)

    def test_list_of_single_empty_instance(self):
        # list of PolygonsOnImage with 0 polygons
        aug = iaa.Rot90(1, keep_size=False)
        cbaoi = self._ObjOnImage([], shape=(10, 11, 3))

        cbaois_aug = self._augfunc(aug, [cbaoi])

        assert isinstance(cbaois_aug, list)
        assert isinstance(cbaois_aug[0], self._ObjOnImageClass)
        assert cbaois_aug[0].empty
        assert cbaois_aug[0].shape == (11, 10, 3)

    def test_two_cbaois_each_two_cbas(self):
        # 2 PolygonsOnImage, each 2 polygons
        aug = iaa.Rot90(1, keep_size=False)
        cbaois = [
            self._ObjOnImage(
                [self._Obj([(0, 0), (5, 0), (5, 5)]),
                 self._Obj([(1, 1), (6, 1), (6, 6)])],
                shape=(10, 10, 3)),
            self._ObjOnImage(
                [self._Obj([(2, 2), (7, 2), (7, 7)]),
                 self._Obj([(3, 3), (8, 3), (8, 8)])],
                shape=(10, 10, 3)),
        ]

        cbaois_aug = self._augfunc(aug, cbaois)

        assert isinstance(cbaois_aug, list)
        assert isinstance(cbaois_aug[0], self._ObjOnImageClass)
        assert isinstance(cbaois_aug[0], self._ObjOnImageClass)
        assert len(cbaois_aug[0].items) == 2
        assert len(cbaois_aug[1].items) == 2
        kp_offset = 0
        assert self._compare_coords_of_cba(
            cbaois_aug[0].items[0].coords,
            [(10-0+kp_offset, 0), (10-0+kp_offset, 5), (10-5+kp_offset, 5)],
            atol=1e-4, rtol=0
        )
        assert self._compare_coords_of_cba(
            cbaois_aug[0].items[1].coords,
            [(10-1+kp_offset, 1), (10-1+kp_offset, 6), (10-6+kp_offset, 6)],
            atol=1e-4, rtol=0
        )
        assert self._compare_coords_of_cba(
            cbaois_aug[1].items[0].coords,
            [(10-2+kp_offset, 2), (10-2+kp_offset, 7), (10-7+kp_offset, 7)],
            atol=1e-4, rtol=0
        )
        assert self._compare_coords_of_cba(
            cbaois_aug[1].items[1].coords,
            [(10-3+kp_offset, 3), (10-3+kp_offset, 8), (10-8+kp_offset, 8)],
            atol=1e-4, rtol=0
        )
        assert cbaois_aug[0].shape == (10, 10, 3)
        assert cbaois_aug[1].shape == (10, 10, 3)

    def test_randomness_between_and_within_batches(self):
        # test whether there is randomness within each batch and between
        # batches
        aug = iaa.Rot90((0, 3), keep_size=False)
        cba = self._Obj([(0, 0), (5, 0), (5, 5)])
        cbaoi = self._ObjOnImage(
            [cba.deepcopy() for _ in sm.xrange(1)],
            shape=(10, 11, 3)
        )
        cbaois = [cbaoi.deepcopy() for _ in sm.xrange(100)]

        cbaois_aug1 = self._augfunc(aug, cbaois)
        cbaois_aug2 = self._augfunc(aug, cbaois)

        # --> different between runs
        cbas1 = [cba
                 for cbaoi in cbaois_aug1
                 for cba in cbaoi.items]
        cbas2 = [cba
                 for cbaoi in cbaois_aug2
                 for cba in cbaoi.items]
        assert len(cbas1) == len(cbas2)
        same = []
        for cba1, cba2 in zip(cbas1, cbas2):
            points1 = np.float32(cba1.coords)
            points2 = np.float32(cba2.coords)
            same.append(self._compare_coords_of_cba(points1, points2,
                                                    atol=1e-2, rtol=0))
        assert not np.all(same)

        # --> different between PolygonOnImages
        same = []
        points1 = np.float32([cba.coords
                              for cba
                              in cbaois_aug1[0].items])
        for cba in cbaois_aug1[1:]:
            points2 = np.float32([cba.coords
                                  for cba
                                  in cba.items])
            same.append(self._compare_coords_of_cba(points1, points2,
                                                    atol=1e-2, rtol=0))
        assert not np.all(same)

        # --> different between polygons
        points1 = set()
        for cba in cbaois_aug1[0].items:
            for point in cba.coords:
                points1.add(tuple(
                    [int(point[0]*10), int(point[1]*10)]
                ))
        assert len(points1) > 1

    def test_determinism(self):
        aug = iaa.Rot90((0, 3), keep_size=False)
        aug_det = aug.to_deterministic()
        cba = self._Obj([(0, 0), (5, 0), (5, 5)])
        cbaoi = self._ObjOnImage(
            [cba.deepcopy() for _ in sm.xrange(1)],
            shape=(10, 11, 3)
        )
        cbaois = [cbaoi.deepcopy() for _ in sm.xrange(100)]

        cbaois_aug1 = self._augfunc(aug_det, cbaois)
        cbaois_aug2 = self._augfunc(aug_det, cbaois)

        # --> different between PolygonsOnImages
        same = []
        points1 = np.float32([cba.coords
                              for cba
                              in cbaois_aug1[0].items])
        for cbaoi in cbaois_aug1[1:]:
            points2 = np.float32([cba.coords
                                  for cba
                                  in cbaoi.items])
            same.append(self._compare_coords_of_cba(points1, points2,
                                                    atol=1e-2, rtol=0))
        assert not np.all(same)

        # --> similar between augmentation runs
        cbas1 = [cba
                 for cbaoi in cbaois_aug1
                 for cba in cbaoi.items]
        cbas2 = [cba
                 for cbaoi in cbaois_aug2
                 for cba in cbaoi.items]
        assert len(cbas1) == len(cbas2)
        for cba1, cba2 in zip(cbas1, cbas2):
            points1 = np.float32(cba1.coords)
            points2 = np.float32(cba2.coords)
            assert self._compare_coords_of_cba(points1, points2,
                                               atol=1e-2, rtol=0)

    def test_aligned_with_images(self):
        aug = iaa.Rot90((0, 3), keep_size=False)
        aug_det = aug.to_deterministic()
        image = np.zeros((10, 20), dtype=np.uint8)
        image[5, :] = 255
        image[2:5, 10] = 255
        image_rots = [iaa.Rot90(k, keep_size=False).augment_image(image)
                      for k in [0, 1, 2, 3]]
        cba = self._Obj([(0, 0), (10, 0), (10, 20)])
        kp_offs = 0  # offset
        cbas_rots = [
            [(0, 0), (10, 0), (10, 20)],
            [(10-0+kp_offs, 0), (10-0+kp_offs, 10), (10-20+kp_offs, 10)],
            [(20-0+kp_offs, 10), (20-10+kp_offs, 10), (20-10+kp_offs, -10)],
            [(10-10+kp_offs, 20), (10-10+kp_offs, 10), (10-(-10)+kp_offs, 10)]
        ]
        cbaois = [self._ObjOnImage([cba], shape=image.shape)
                  for _ in sm.xrange(50)]

        images_aug = aug_det.augment_images([image] * 50)
        cbaois_aug = self._augfunc(aug_det, cbaois)

        seen = set()
        for image_aug, cbaoi_aug in zip(images_aug, cbaois_aug):
            found_image = False
            for img_rot_idx, img_rot in enumerate(image_rots):
                if (image_aug.shape == img_rot.shape
                        and np.allclose(image_aug, img_rot)):
                    found_image = True
                    break

            found_cba = False
            for poly_rot_idx, cba_rot in enumerate(cbas_rots):
                coords_observed = cbaoi_aug.items[0].coords
                if self._compare_coords_of_cba(coords_observed, cba_rot):
                    found_cba = True
                    break

            assert found_image
            assert found_cba
            assert img_rot_idx == poly_rot_idx
            seen.add((img_rot_idx, poly_rot_idx))
        assert 2 <= len(seen) <= 4  # assert not always the same rot

    def test_aligned_with_images_despite_empty_instances(self):
        # Test if augmenting lists of e.g. PolygonsOnImage is still aligned
        # with image augmentation when one e.g. PolygonsOnImage instance is
        # empty (e.g. contains no polygons)
        cba = self._Obj([(0, 0), (5, 0), (5, 5), (0, 5)])
        cbaoi_lst = [
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.shift(x=1)], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([], shape=(1, 8)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.shift(x=1)], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20)),
            self._ObjOnImage([cba.deepcopy()], shape=(10, 20))
        ]
        image = np.zeros((10, 20), dtype=np.uint8)
        image[0, 0] = 255
        image[0, 5] = 255
        image[5, 5] = 255
        image[5, 0] = 255
        images = np.tile(image[np.newaxis, :, :], (len(cbaoi_lst), 1, 1))

        aug = iaa.Affine(translate_px={"x": (0, 8)}, order=0, mode="constant",
                         cval=0)

        for _ in sm.xrange(10):
            for is_list in [False, True]:
                aug_det = aug.to_deterministic()
                inputs = images
                if is_list:
                    inputs = list(inputs)

                images_aug = aug_det.augment_images(inputs)
                cbaoi_aug_lst = self._augfunc(aug_det, cbaoi_lst)

                if is_list:
                    images_aug = np.array(images_aug, dtype=np.uint8)
                translations_imgs = np.argmax(images_aug[:, 0, :], axis=1)

                translations_points = [
                    (cbaoi.items[0].coords[0][0] if not cbaoi.empty else None)
                    for cbaoi
                    in cbaoi_aug_lst]

                assert len([
                    pointresult for
                    pointresult
                    in translations_points
                    if pointresult is None
                ]) == 1
                assert translations_points[5] is None
                translations_imgs = np.concatenate(
                    [translations_imgs[0:5], translations_imgs[6:]])
                translations_points = np.array(
                    translations_points[0:5] + translations_points[6:],
                    dtype=translations_imgs.dtype)
                translations_points[2] -= 1
                translations_points[8-1] -= 1
                assert np.array_equal(translations_imgs, translations_points)


# This is the same as _ConcavePolygonRecoverer, but we make sure that we
# always sample random values. This is to advance the state of random_state
# and ensure that this breaks not alignment.
class _DummyRecoverer(_ConcavePolygonRecoverer):
    def recover_from(self, new_exterior, old_polygon, random_state=0):
        # sample lots of values to ensure that the RNG is advanced
        _ = random_state.integers(0, 2**30, 100)
        return super(_DummyRecoverer, self).recover_from(
            new_exterior, old_polygon, random_state=random_state)


class _DummyAugmenterWithRecoverer(iaa.Augmenter):
    def __init__(self, use_recoverer=True):
        super(_DummyAugmenterWithRecoverer, self).__init__()
        self.random_samples_images = []
        self.random_samples_kps = []

        if use_recoverer:
            self.recoverer = _DummyRecoverer()
        else:
            self.recoverer = None

    def _augment_images(self, images, random_state, parents, hooks):
        sample = random_state.integers(0, 2**30)
        self.random_samples_images.append(sample)
        return images

    def _augment_polygons(self, polygons_on_images, random_state, parents,
                          hooks):
        return self._augment_polygons_as_keypoints(
            polygons_on_images, random_state, parents, hooks,
            recoverer=self.recoverer)

    def _augment_keypoints(self, keypoints_on_images, random_state, parents,
                           hooks):
        sample = random_state.integers(0, 2**30)
        self.random_samples_kps.append(sample)

        assert len(keypoints_on_images) in [1, 2]
        assert len(keypoints_on_images[0].keypoints) == 7

        result = []

        for _ in keypoints_on_images:
            # every second call of _augment_polygons()...
            if len(self.random_samples_kps) % 2 == 1:
                # not concave
                kpsoi = ia.KeypointsOnImage([
                    ia.Keypoint(x=0, y=0),
                    ia.Keypoint(x=10, y=0),
                    ia.Keypoint(x=10, y=4),
                    ia.Keypoint(x=-1, y=5),
                    ia.Keypoint(x=10, y=6),
                    ia.Keypoint(x=10, y=10),
                    ia.Keypoint(x=0, y=10)
                ], shape=(10, 10, 3))
            else:
                # concave
                kpsoi = ia.KeypointsOnImage([
                    ia.Keypoint(x=0, y=0),
                    ia.Keypoint(x=10, y=0),
                    ia.Keypoint(x=10, y=4),
                    ia.Keypoint(x=10, y=5),
                    ia.Keypoint(x=10, y=6),
                    ia.Keypoint(x=10, y=10),
                    ia.Keypoint(x=0, y=10)
                ], shape=(10, 10, 3))
            result.append(kpsoi)
        return result

    def get_parameters(self):
        return []


class TestAugmenter_augment_polygons(_TestAugmenter_augment_cbaois,
                                     unittest.TestCase):
    def _augfunc(self, augmenter, *args, **kwargs):
        return augmenter.augment_polygons(*args, **kwargs)

    @property
    def _ObjClass(self):
        return ia.Polygon

    @property
    def _ObjOnImageClass(self):
        return ia.PolygonsOnImage

    def _coords(self, obj):
        return obj.exterior
    
    def _entities(self, obj_on_image):
        return obj_on_image.polygons

    def test_polygon_recoverer(self):
        # This is mostly a dummy polygon. The augmenter always returns the
        # same non-concave polygon.
        poly = ia.Polygon([(0, 0), (10, 0),
                           (10, 4), (10, 5), (10, 6),
                           (10, 10), (0, 10)])
        psoi = ia.PolygonsOnImage([poly], shape=(10, 10, 3))
        aug = _DummyAugmenterWithRecoverer()

        psoi_aug = aug.augment_polygons(psoi)
        poly_aug = psoi_aug.polygons[0]

        bb = ia.BoundingBox(x1=0, y1=0, x2=10, y2=10)
        bb_aug = ia.BoundingBox(
            x1=np.min(poly_aug.exterior[:, 0]),
            y1=np.min(poly_aug.exterior[:, 1]),
            x2=np.max(poly_aug.exterior[:, 0]),
            y2=np.max(poly_aug.exterior[:, 1])
        )
        assert bb.iou(bb_aug) > 0.9
        assert psoi_aug.polygons[0].is_valid

    def test_polygon_aligned_without_recoverer(self):
        # This is mostly a dummy polygon. The augmenter always returns the
        # same non-concave polygon.
        poly = ia.Polygon([(0, 0), (10, 0),
                           (10, 4), (10, 5), (10, 6),
                           (10, 10), (0, 10)])
        psoi = ia.PolygonsOnImage([poly], shape=(10, 10, 3))
        image = np.zeros((10, 10, 3))
        aug = _DummyAugmenterWithRecoverer(use_recoverer=False)

        images_aug1, psois_aug1 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug2, psois_aug2 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug3, psois_aug3 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug4, psois_aug4 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        assert not psois_aug1[0].polygons[0].is_valid
        assert not psois_aug1[1].polygons[0].is_valid
        assert psois_aug2[0].polygons[0].is_valid
        assert psois_aug2[1].polygons[0].is_valid
        assert not psois_aug3[0].polygons[0].is_valid
        assert not psois_aug3[1].polygons[0].is_valid
        assert psois_aug4[0].polygons[0].is_valid
        assert psois_aug4[1].polygons[0].is_valid

        assert aug.random_samples_images == aug.random_samples_kps

    def test_polygon_aligned_with_recoverer(self):
        # This is mostly a dummy polygon. The augmenter always returns the
        # same non-concave polygon.
        poly = ia.Polygon([(0, 0), (10, 0),
                           (10, 4), (10, 5), (10, 6),
                           (10, 10), (0, 10)])
        psoi = ia.PolygonsOnImage([poly], shape=(10, 10, 3))
        image = np.zeros((10, 10, 3))
        aug = _DummyAugmenterWithRecoverer(use_recoverer=True)

        images_aug1, psois_aug1 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug2, psois_aug2 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug3, psois_aug3 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        images_aug4, psois_aug4 = aug(images=[image, image],
                                      polygons=[psoi, psoi])

        assert psois_aug1[0].polygons[0].is_valid
        assert psois_aug1[1].polygons[0].is_valid
        assert psois_aug2[0].polygons[0].is_valid
        assert psois_aug2[1].polygons[0].is_valid
        assert psois_aug3[0].polygons[0].is_valid
        assert psois_aug3[1].polygons[0].is_valid
        assert psois_aug4[0].polygons[0].is_valid
        assert psois_aug4[1].polygons[0].is_valid

        assert aug.random_samples_images == aug.random_samples_kps


class TestAugmenter_augment_line_strings(_TestAugmenter_augment_cbaois,
                                         unittest.TestCase):
    def _augfunc(self, augmenter, *args, **kwargs):
        return augmenter.augment_line_strings(*args, **kwargs)

    @property
    def _ObjClass(self):
        return ia.LineString

    @property
    def _ObjOnImageClass(self):
        return ia.LineStringsOnImage


class TestAugmenter_augment_bounding_boxes(_TestAugmenter_augment_cbaois,
                                           unittest.TestCase):
    def _augfunc(self, augmenter, *args, **kwargs):
        return augmenter.augment_bounding_boxes(*args, **kwargs)

    @property
    def _ObjClass(self):
        return ia.BoundingBox

    @property
    def _ObjOnImageClass(self):
        return ia.BoundingBoxesOnImage

    def _Obj(self, *args, **kwargs):
        assert len(args) == 1
        coords = np.float32(args[0]).reshape((-1, 2))
        x1 = np.min(coords[:, 0])
        y1 = np.min(coords[:, 1])
        x2 = np.max(coords[:, 0])
        y2 = np.max(coords[:, 1])
        return self._ObjClass(x1=x1, y1=y1, x2=x2, y2=y2, **kwargs)

    def _compare_coords_of_cba(self, observed, expected, atol=1e-4, rtol=0):
        observed = np.float32(observed).reshape((-1, 2))
        expected = np.float32(expected).reshape((-1, 2))
        assert observed.shape[0] == 2
        assert expected.shape[1] == 2

        obs_x1 = np.min(observed[:, 0])
        obs_y1 = np.min(observed[:, 1])
        obs_x2 = np.max(observed[:, 0])
        obs_y2 = np.max(observed[:, 1])

        exp_x1 = np.min(expected[:, 0])
        exp_y1 = np.min(expected[:, 1])
        exp_x2 = np.max(expected[:, 0])
        exp_y2 = np.max(expected[:, 1])

        return np.allclose(
            [obs_x1, obs_y1, obs_x2, obs_y2],
            [exp_x1, exp_y1, exp_x2, exp_y2],
            atol=atol, rtol=rtol)


# the method is mostly tested indirectly, so very few tests here
class TestAugmenter_augment_bounding_boxes_by_keypoints(unittest.TestCase):
    def test_x_min_max(self):
        # ensure that min() and max() are applied to augmented x-coordinates
        # when they are converted back to BBs

        class _ShiftingXCoordAugmenter(iaa.Augmenter):
            def _augment_images(self, images, random_state, parents, hooks):
                return images

            def _augment_bounding_boxes(self, bounding_boxes_on_images,
                                        random_state, parents, hooks):
                return self._augment_bounding_boxes_as_keypoints(
                    bounding_boxes_on_images, random_state, parents, hooks)

            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                keypoints_on_images[0].keypoints[0].x += 10
                keypoints_on_images[0].keypoints[1].x -= 10
                return keypoints_on_images

            def get_parameters(self):
                return []

        aug = _ShiftingXCoordAugmenter()
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)], shape=(10, 10, 3))
        observed = aug(bounding_boxes=bbsoi)
        assert np.allclose(
            observed.bounding_boxes[0].coords,
            [(2-10, 1), (0+10, 3)]
        )

    def test_y_min_max(self):
        # ensure that min() and max() are applied to augmented y-coordinates
        # when they are converted back to BBs

        class _ShiftingYCoordAugmenter(iaa.Augmenter):
            def _augment_images(self, images, random_state, parents, hooks):
                return images

            def _augment_bounding_boxes(self, bounding_boxes_on_images,
                                        random_state, parents, hooks):
                return self._augment_bounding_boxes_as_keypoints(
                    bounding_boxes_on_images, random_state, parents, hooks)

            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                keypoints_on_images[0].keypoints[0].y += 10
                keypoints_on_images[0].keypoints[1].y -= 10
                return keypoints_on_images

            def get_parameters(self):
                return []

        aug = _ShiftingYCoordAugmenter()
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)], shape=(10, 10, 3))
        observed = aug(bounding_boxes=bbsoi)
        assert np.allclose(
            observed.bounding_boxes[0].coords,
            [(0, 1-10), (2, 1+10)]
        )

    def test_x1_x2_can_get_flipped(self):
        # ensure that augmented x-coordinates where x1>x2 are flipped
        # before creating BBs from them

        class _FlippingX1X2Augmenter(iaa.Augmenter):
            def _augment_images(self, images, random_state, parents, hooks):
                return images

            def _augment_bounding_boxes(self, bounding_boxes_on_images,
                                        random_state, parents, hooks):
                return self._augment_bounding_boxes_as_keypoints(
                    bounding_boxes_on_images, random_state, parents, hooks)

            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                keypoints_on_images[0].keypoints[0].x += 10  # top left
                keypoints_on_images[0].keypoints[3].x += 10  # bottom left
                return keypoints_on_images

            def get_parameters(self):
                return []

        aug = _FlippingX1X2Augmenter()
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)], shape=(10, 10, 3))
        observed = aug(bounding_boxes=bbsoi)
        assert np.allclose(
            observed.bounding_boxes[0].coords,
            [(2, 1), (0+10, 3)]
        )

    def test_y1_y2_can_get_flipped(self):
        # ensure that augmented y-coordinates where y1>y2 are flipped
        # before creating BBs from them

        class _FlippingY1Y2Augmenter(iaa.Augmenter):
            def _augment_images(self, images, random_state, parents, hooks):
                return images

            def _augment_bounding_boxes(self, bounding_boxes_on_images,
                                        random_state, parents, hooks):
                return self._augment_bounding_boxes_as_keypoints(
                    bounding_boxes_on_images, random_state, parents, hooks)

            def _augment_keypoints(self, keypoints_on_images, random_state,
                                   parents, hooks):
                keypoints_on_images[0].keypoints[0].y += 10  # top left
                keypoints_on_images[0].keypoints[1].y += 10  # top right
                return keypoints_on_images

            def get_parameters(self):
                return []

        aug = _FlippingY1Y2Augmenter()
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=1, x2=2, y2=3)], shape=(10, 10, 3))
        observed = aug(bounding_boxes=bbsoi)
        assert np.allclose(
            observed.bounding_boxes[0].coords,
            [(0, 3), (2, 1+10)]
        )


class TestAugmenter_augment(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_image(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")

        image_aug = aug.augment(image=image)

        assert image_aug.shape == image.shape
        assert np.array_equal(image_aug, image)

    def test_images_list(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")

        images_aug = aug.augment(images=[image])

        assert images_aug[0].shape == image.shape
        assert np.array_equal(images_aug[0], image)

    def test_images_and_heatmaps(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")

        images_aug, heatmaps_aug = aug.augment(images=[image],
                                               heatmaps=[heatmaps])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)

    def test_images_and_segmentation_maps(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        images_aug, segmaps_aug = aug.augment(images=[image],
                                              segmentation_maps=[segmaps])
        assert np.array_equal(images_aug[0], image)
        assert np.allclose(segmaps_aug[0].arr, segmaps.arr)

    def test_images_and_keypoints(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")

        images_aug, keypoints_aug = aug.augment(images=[image],
                                                keypoints=[keypoints])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(keypoints_aug[0], keypoints)

    def test_images_and_polygons(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        images_aug, polygons_aug = aug.augment(images=[image],
                                               polygons=[polygons])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(polygons_aug[0], polygons)

    def test_images_and_line_strings(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        psoi = ia.data.quokka_polygons((128, 128), extract="square")
        lsoi = ia.LineStringsOnImage([
            psoi.polygons[0].to_line_string(closed=False)
        ], shape=psoi.shape)

        images_aug, lsoi_aug = aug.augment(images=[image],
                                           line_strings=[lsoi])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(lsoi_aug[0], lsoi)

    def test_images_and_bounding_boxes(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        bbs = ia.data.quokka_bounding_boxes((128, 128), extract="square")

        images_aug, bbs_aug = aug.augment(images=[image], bounding_boxes=[bbs])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(bbs_aug[0], bbs)

    def test_image_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")

        batch = aug.augment(image=image, return_batch=True)

        image_aug = batch.images_aug[0]
        assert np.array_equal(image, image_aug)

    def test_images_and_heatmaps_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")

        batch = aug.augment(images=[image], heatmaps=[heatmaps],
                            return_batch=True)

        images_aug = batch.images_aug
        heatmaps_aug = batch.heatmaps_aug
        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)

    def test_images_and_segmentation_maps_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        batch = aug.augment(images=[image], segmentation_maps=[segmaps],
                            return_batch=True)

        images_aug = batch.images_aug
        segmaps_aug = batch.segmentation_maps_aug
        assert np.array_equal(images_aug[0], image)
        assert np.allclose(segmaps_aug[0].arr, segmaps.arr)

    def test_images_and_keypoints_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")

        batch = aug.augment(images=[image], keypoints=[keypoints],
                            return_batch=True)

        images_aug = batch.images_aug
        keypoints_aug = batch.keypoints_aug
        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(keypoints_aug[0], keypoints)

    def test_images_and_polygons_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        batch = aug.augment(images=[image], polygons=[polygons],
                            return_batch=True)

        images_aug = batch.images_aug
        polygons_aug = batch.polygons_aug
        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(polygons_aug[0], polygons)

    def test_images_and_line_strings_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        psoi = ia.data.quokka_polygons((128, 128), extract="square")
        lsoi = ia.LineStringsOnImage([
            psoi.polygons[0].to_line_string(closed=False)
        ], shape=psoi.shape)

        batch = aug.augment(images=[image], line_strings=[lsoi],
                            return_batch=True)

        images_aug = batch.images_aug
        lsoi_aug = batch.line_strings_aug
        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(lsoi_aug[0], lsoi)

    def test_images_and_bounding_boxes_return_batch(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        bbs = ia.data.quokka_bounding_boxes((128, 128), extract="square")

        batch = aug.augment(images=[image], bounding_boxes=[bbs],
                            return_batch=True)

        images_aug = batch.images_aug
        bbs_aug = batch.bounding_boxes_aug
        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(bbs_aug[0], bbs)

    def test_non_image_data(self):
        aug = iaa.Identity()
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        batch = aug.augment(segmentation_maps=[segmaps], keypoints=[keypoints],
                            polygons=[polygons], return_batch=True)

        segmaps_aug = batch.segmentation_maps_aug
        keypoints_aug = batch.keypoints_aug
        polygons_aug = batch.polygons_aug
        assert np.allclose(segmaps_aug[0].arr, segmaps.arr)
        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(polygons_aug[0], polygons)

    def test_non_image_data_unexpected_args_order(self):
        aug = iaa.Identity()
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        batch = aug.augment(polygons=[polygons], segmentation_maps=[segmaps],
                            keypoints=[keypoints], return_batch=True)

        segmaps_aug = batch.segmentation_maps_aug
        keypoints_aug = batch.keypoints_aug
        polygons_aug = batch.polygons_aug
        assert np.allclose(segmaps_aug[0].arr, segmaps.arr)
        assert np.allclose(keypoints_aug[0].to_xy_array(),
                           keypoints.to_xy_array())
        for polygon_aug, polygon in zip(polygons_aug[0].polygons,
                                        polygons.polygons):
            assert polygon_aug.exterior_almost_equals(polygon)

    def test_with_affine(self):
        # make sure that augment actually does something
        aug = iaa.Affine(translate_px={"x": 1}, order=0, mode="constant",
                         cval=0)
        image = np.zeros((4, 4, 1), dtype=np.uint8) + 255
        heatmaps = np.ones((1, 4, 4, 1), dtype=np.float32)
        segmaps = np.ones((1, 4, 4, 1), dtype=np.int32)
        kps = [(0, 0), (1, 2)]
        bbs = [(0, 0, 1, 1), (1, 2, 2, 3)]
        polygons = [(0, 0), (1, 0), (1, 1)]
        ls = [(0, 0), (1, 0), (1, 1)]

        image_aug = aug.augment(image=image)
        _, heatmaps_aug = aug.augment(image=image, heatmaps=heatmaps)
        _, segmaps_aug = aug.augment(image=image, segmentation_maps=segmaps)
        _, kps_aug = aug.augment(image=image, keypoints=kps)
        _, bbs_aug = aug.augment(image=image, bounding_boxes=bbs)
        _, polygons_aug = aug.augment(image=image, polygons=polygons)
        _, ls_aug = aug.augment(image=image, line_strings=ls)

        # all augmentables must have been moved to the right by 1px
        assert np.all(image_aug[:, 0] == 0)
        assert np.all(image_aug[:, 1:] == 255)
        assert np.allclose(heatmaps_aug[0][:, 0], 0.0)
        assert np.allclose(heatmaps_aug[0][:, 1:], 1.0)
        assert np.all(segmaps_aug[0][:, 0] == 0)
        assert np.all(segmaps_aug[0][:, 1:] == 1)
        assert np.allclose(kps_aug, [(1, 0), (2, 2)])
        assert np.allclose(bbs_aug, [(1, 0, 2, 1), (2, 2, 3, 3)])
        assert np.allclose(polygons_aug, [(1, 0), (2, 0), (2, 1)])
        assert np.allclose(ls_aug, [(1, 0), (2, 0), (2, 1)])

    def test_alignment(self):
        # make sure that changes from augment() are aligned and vary between
        # call
        aug = iaa.Affine(translate_px={"x": (0, 100)}, order=0, mode="constant",
                         cval=0)
        image = np.zeros((1, 100, 1), dtype=np.uint8) + 255
        heatmaps = np.ones((1, 1, 100, 1), dtype=np.float32)
        segmaps = np.ones((1, 1, 100, 1), dtype=np.int32)
        kps = [(0, 0)]
        bbs = [(0, 0, 1, 1)]
        polygons = [(0, 0), (1, 0), (1, 1)]
        ls = [(0, 0), (1, 0), (1, 1)]

        seen = []
        for _ in sm.xrange(10):
            batch_aug = aug.augment(image=image, heatmaps=heatmaps,
                                    segmentation_maps=segmaps, keypoints=kps,
                                    bounding_boxes=bbs, polygons=polygons,
                                    line_strings=ls, return_batch=True)

            shift_image = np.sum(batch_aug.images_aug[0][0, :] == 0)
            shift_heatmaps = np.sum(
                np.isclose(batch_aug.heatmaps_aug[0][0, :, 0], 0.0))
            shift_segmaps = np.sum(
                batch_aug.segmentation_maps_aug[0][0, :, 0] == 0)
            shift_kps = batch_aug.keypoints_aug[0][0]
            shift_bbs = batch_aug.bounding_boxes_aug[0][0]
            shift_polygons = batch_aug.polygons_aug[0][0]
            shift_ls = batch_aug.line_strings_aug[0][0]

            assert len({shift_image, shift_heatmaps, shift_segmaps,
                        shift_kps, shift_bbs, shift_polygons,
                        shift_ls}) == 1
            seen.append(shift_image)
        assert len(set(seen)) > 7

    def test_alignment_and_same_outputs_in_deterministic_mode(self):
        # make sure that changes from augment() are aligned
        # and do NOT vary if the augmenter was already in deterministic mode
        aug = iaa.Affine(translate_px={"x": (0, 100)}, order=0, mode="constant",
                         cval=0)
        aug = aug.to_deterministic()

        image = np.zeros((1, 100, 1), dtype=np.uint8) + 255
        heatmaps = np.ones((1, 1, 100, 1), dtype=np.float32)
        segmaps = np.ones((1, 1, 100, 1), dtype=np.int32)
        kps = [(0, 0)]
        bbs = [(0, 0, 1, 1)]
        polygons = [(0, 0), (1, 0), (1, 1)]
        ls = [(0, 0), (1, 0), (1, 1)]

        seen = []
        for _ in sm.xrange(10):
            batch_aug = aug.augment(image=image, heatmaps=heatmaps,
                                    segmentation_maps=segmaps, keypoints=kps,
                                    bounding_boxes=bbs, polygons=polygons,
                                    line_strings=ls,
                                    return_batch=True)

            shift_image = np.sum(batch_aug.images_aug[0][0, :] == 0)
            shift_heatmaps = np.sum(
                np.isclose(batch_aug.heatmaps_aug[0][0, :, 0], 0.0))
            shift_segmaps = np.sum(
                batch_aug.segmentation_maps_aug[0][0, :, 0] == 0)
            shift_kps = batch_aug.keypoints_aug[0][0]
            shift_bbs = batch_aug.bounding_boxes_aug[0][0]
            shift_polygons = batch_aug.polygons_aug[0][0]
            shift_ls = batch_aug.line_strings_aug[0][0]

            assert len({shift_image, shift_heatmaps, shift_segmaps,
                        shift_kps, shift_bbs, shift_polygons,
                        shift_ls}) == 1
            seen.append(shift_image)
        assert len(set(seen)) == 1

    def test_arrays_become_lists_if_augmenter_changes_shapes(self):
        # make sure that arrays (of images, heatmaps, segmaps) get split to
        # lists of arrays if the augmenter changes shapes in non-uniform
        # (between images) ways
        # we augment 100 images here with rotation of either 0deg or 90deg
        # and do not resize back to the original image size afterwards, so
        # shapes change
        aug = iaa.Rot90([0, 1], keep_size=False)

        # base_arr is (100, 1, 2) array, each containing [[0, 1]]
        base_arr = np.tile(np.arange(1*2).reshape((1, 2))[np.newaxis, :, :],
                           (100, 1, 1))
        images = np.copy(base_arr)[:, :, :, np.newaxis].astype(np.uint8)
        heatmaps = (
            np.copy(base_arr)[:, :, :, np.newaxis].astype(np.float32)
            / np.max(base_arr)
        )
        segmaps = np.copy(base_arr)[:, :, :, np.newaxis].astype(np.int32)

        batch_aug = aug.augment(images=images, heatmaps=heatmaps,
                                segmentation_maps=segmaps,
                                return_batch=True)
        assert isinstance(batch_aug.images_aug, list)
        assert isinstance(batch_aug.heatmaps_aug, list)
        assert isinstance(batch_aug.segmentation_maps_aug, list)
        shapes_images = [arr.shape for arr in batch_aug.images_aug]
        shapes_heatmaps = [arr.shape for arr in batch_aug.heatmaps_aug]
        shapes_segmaps = [arr.shape for arr in batch_aug.segmentation_maps_aug]
        assert (
            [shape[0:2] for shape in shapes_images]
            == [shape[0:2] for shape in shapes_heatmaps]
            == [shape[0:2] for shape in shapes_segmaps]
        )
        assert len(set(shapes_images)) == 2

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_none_of_them_images(self):
        aug = iaa.Identity()
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        keypoints_aug, polygons_aug = aug.augment(keypoints=[keypoints],
                                                  polygons=[polygons])

        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(polygons_aug[0], polygons)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_none_of_them_images_inverted(self):
        aug = iaa.Identity()
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        polygons_aug, keypoints_aug = aug.augment(polygons=[polygons],
                                                  keypoints=[keypoints])

        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(polygons_aug[0], polygons)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_heatmaps(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")

        heatmaps_aug, images_aug = aug.augment(heatmaps=[heatmaps],
                                               images=[image])
        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_segmaps(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        segmaps_aug, images_aug = aug.augment(segmentation_maps=[segmaps],
                                              images=[image])

        assert np.array_equal(images_aug[0], image)
        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_keypoints(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")

        keypoints_aug, images_aug = aug.augment(keypoints=[keypoints],
                                                images=[image])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(keypoints_aug[0], keypoints)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_bbs(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        bbs = ia.data.quokka_bounding_boxes((128, 128), extract="square")

        bbs_aug, images_aug = aug.augment(bounding_boxes=[bbs],
                                          images=[image])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(bbs_aug[0], bbs)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_polygons(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        polygons_aug, images_aug = aug.augment(polygons=[polygons],
                                               images=[image])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(polygons_aug[0], polygons)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_two_outputs_inverted_order_line_strings(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        psoi = ia.data.quokka_polygons((128, 128), extract="square")
        lsoi = ia.LineStringsOnImage([
            psoi.polygons[0].to_line_string(closed=False)
        ], shape=psoi.shape)

        lsoi_aug, images_aug = aug.augment(line_strings=[lsoi],
                                           images=[image])

        assert np.array_equal(images_aug[0], image)
        assert_cbaois_equal(lsoi_aug[0], lsoi)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_three_inputs_expected_order(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        images_aug, heatmaps_aug, segmaps_aug = aug.augment(
            images=[image],
            heatmaps=[heatmaps],
            segmentation_maps=[segmaps])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)
        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_three_inputs_expected_order2(self):
        aug = iaa.Identity()
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        segmaps_aug, keypoints_aug, polygons_aug = aug.augment(
            segmentation_maps=[segmaps],
            keypoints=[keypoints],
            polygons=[polygons])

        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)
        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(polygons_aug[0], polygons)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_three_inputs_inverted_order(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        segmaps_aug, heatmaps_aug, images_aug = aug.augment(
            segmentation_maps=[segmaps],
            heatmaps=[heatmaps],
            images=[image])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)
        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_three_inputs_inverted_order2(self):
        aug = iaa.Identity()
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        polygons_aug, keypoints_aug, segmaps_aug = aug.augment(
            polygons=[polygons],
            keypoints=[keypoints],
            segmentation_maps=[segmaps])

        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)
        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(polygons_aug[0], polygons)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_all_inputs_expected_order(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        bbs = ia.data.quokka_bounding_boxes((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")
        lsoi = ia.LineStringsOnImage([
            polygons.polygons[0].to_line_string(closed=False)
        ], shape=polygons.shape)

        images_aug, heatmaps_aug, segmaps_aug, keypoints_aug, bbs_aug, \
            polygons_aug, lsoi_aug = aug.augment(
                images=[image],
                heatmaps=[heatmaps],
                segmentation_maps=[segmaps],
                keypoints=[keypoints],
                bounding_boxes=[bbs],
                polygons=[polygons],
                line_strings=[lsoi])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)
        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)
        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(bbs_aug[0], bbs)
        assert_cbaois_equal(polygons_aug[0], polygons)
        assert_cbaois_equal(lsoi_aug[0], lsoi)

    @unittest.skipIf(not IS_PY36_OR_HIGHER,
                     "Behaviour is only supported in python 3.6+")
    def test_py_gte_36_all_inputs_inverted_order(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        bbs = ia.data.quokka_bounding_boxes((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")
        lsoi = ia.LineStringsOnImage([
            polygons.polygons[0].to_line_string(closed=False)
        ], shape=polygons.shape)

        lsoi_aug, polygons_aug, bbs_aug, keypoints_aug, segmaps_aug, \
            heatmaps_aug, images_aug = aug.augment(
                line_strings=[lsoi],
                polygons=[polygons],
                bounding_boxes=[bbs],
                keypoints=[keypoints],
                segmentation_maps=[segmaps],
                heatmaps=[heatmaps],
                images=[image])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)
        assert np.array_equal(segmaps_aug[0].arr, segmaps.arr)
        assert_cbaois_equal(keypoints_aug[0], keypoints)
        assert_cbaois_equal(bbs_aug[0], bbs)
        assert_cbaois_equal(polygons_aug[0], polygons)
        assert_cbaois_equal(lsoi_aug[0], lsoi)

    @unittest.skipIf(IS_PY36_OR_HIGHER,
                     "Test checks behaviour for python <=3.5")
    def test_py_lte_35_calls_without_images_fail(self):
        aug = iaa.Identity()
        keypoints = ia.data.quokka_keypoints((128, 128), extract="square")
        polygons = ia.data.quokka_polygons((128, 128), extract="square")

        got_exception = False
        try:
            _ = aug.augment(keypoints=[keypoints], polygons=[polygons])
        except Exception as exc:
            msg = "Requested two outputs from augment() that were not 'images'"
            assert msg in str(exc)
            got_exception = True
        assert got_exception

    @unittest.skipIf(IS_PY36_OR_HIGHER,
                     "Test checks behaviour for python <=3.5")
    def test_py_lte_35_calls_with_more_than_three_args_fail(self):
        aug = iaa.Identity()
        image = ia.data.quokka((128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap((128, 128), extract="square")
        segmaps = ia.data.quokka_segmentation_map((128, 128), extract="square")

        got_exception = False
        try:
            _ = aug.augment(images=[image], heatmaps=[heatmaps],
                            segmentation_maps=[segmaps])
        except Exception as exc:
            assert "Requested more than two outputs" in str(exc)
            got_exception = True
        assert got_exception


class TestAugmenter___call__(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_with_two_augmentables(self):
        image = ia.data.quokka(size=(128, 128), extract="square")
        heatmaps = ia.data.quokka_heatmap(size=(128, 128), extract="square")

        images_aug, heatmaps_aug = iaa.Identity()(images=[image],
                                                  heatmaps=[heatmaps])

        assert np.array_equal(images_aug[0], image)
        assert np.allclose(heatmaps_aug[0].arr_0to1, heatmaps.arr_0to1)


class TestAugmenter_pool(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_pool(self):
        augseq = iaa.Identity()

        mock_Pool = mock.MagicMock()
        mock_Pool.return_value = mock_Pool
        mock_Pool.__enter__.return_value = None
        mock_Pool.__exit__.return_value = None
        with mock.patch("imgaug.multicore.Pool", mock_Pool):
            with augseq.pool(processes=2, maxtasksperchild=10, seed=17):
                pass

        assert mock_Pool.call_count == 1
        assert mock_Pool.__enter__.call_count == 1
        assert mock_Pool.__exit__.call_count == 1
        assert mock_Pool.call_args[0][0] == augseq
        assert mock_Pool.call_args[1]["processes"] == 2
        assert mock_Pool.call_args[1]["maxtasksperchild"] == 10
        assert mock_Pool.call_args[1]["seed"] == 17


class TestAugmenter_find_augmenters_by_name(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def seq(self):
        noop1 = iaa.Identity(name="Identity")
        fliplr = iaa.Fliplr(name="Fliplr")
        flipud = iaa.Flipud(name="Flipud")
        noop2 = iaa.Identity(name="Identity2")
        seq2 = iaa.Sequential([flipud, noop2], name="Seq2")
        seq1 = iaa.Sequential([noop1, fliplr, seq2], name="Seq")
        return seq1, seq2

    def test_find_top_element(self):
        seq1, seq2 = self.seq

        augs = seq1.find_augmenters_by_name("Seq")

        assert len(augs) == 1
        assert augs[0] == seq1

    def test_find_nested_element(self):
        seq1, seq2 = self.seq

        augs = seq1.find_augmenters_by_name("Seq2")

        assert len(augs) == 1
        assert augs[0] == seq2

    def test_find_list_of_names(self):
        seq1, seq2 = self.seq

        augs = seq1.find_augmenters_by_names(["Seq", "Seq2"])

        assert len(augs) == 2
        assert augs[0] == seq1
        assert augs[1] == seq2

    def test_find_by_regex(self):
        seq1, seq2 = self.seq

        augs = seq1.find_augmenters_by_name(r"Seq.*", regex=True)

        assert len(augs) == 2
        assert augs[0] == seq1
        assert augs[1] == seq2


class TestAugmenter_find_augmenters(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def seq(self):
        noop1 = iaa.Identity(name="Identity")
        fliplr = iaa.Fliplr(name="Fliplr")
        flipud = iaa.Flipud(name="Flipud")
        noop2 = iaa.Identity(name="Identity2")
        seq2 = iaa.Sequential([flipud, noop2], name="Seq2")
        seq1 = iaa.Sequential([noop1, fliplr, seq2], name="Seq")
        return seq1, seq2

    def test_find_by_list_of_names(self):
        def _func(aug, parents):
            return aug.name in ["Seq", "Seq2"]

        seq1, seq2 = self.seq

        augs = seq1.find_augmenters(_func)

        assert len(augs) == 2
        assert augs[0] == seq1
        assert augs[1] == seq2

    def test_use_parents_arg(self):
        def _func(aug, parents):
            return (
                aug.name in ["Seq", "Seq2"]
                and len(parents) > 0
            )
        seq1, seq2 = self.seq

        augs = seq1.find_augmenters(_func)

        assert len(augs) == 1
        assert augs[0] == seq2

    def test_find_by_list_of_names_flat_false(self):
        def _func(aug, parents):
            return aug.name in ["Seq", "Seq2"]

        seq1, seq2 = self.seq

        augs = seq1.find_augmenters(_func, flat=False)

        assert len(augs) == 2
        assert augs[0] == seq1
        assert augs[1] == [seq2]


class TestAugmenter_remove(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def seq(self):
        noop1 = iaa.Identity(name="Identity")
        fliplr = iaa.Fliplr(name="Fliplr")
        flipud = iaa.Flipud(name="Flipud")
        noop2 = iaa.Identity(name="Identity2")
        seq2 = iaa.Sequential([flipud, noop2], name="Seq2")
        seq1 = iaa.Sequential([noop1, fliplr, seq2], name="Seq")
        return seq1

    def test_remove_by_name(self):
        def _func(aug, parents):
            return aug.name == "Seq2"

        augs = self.seq

        augs = augs.remove_augmenters(_func)

        seqs = augs.find_augmenters_by_name(r"Seq.*", regex=True)
        assert len(seqs) == 1
        assert seqs[0].name == "Seq"

    def test_remove_by_name_and_parents_arg(self):
        def _func(aug, parents):
            return aug.name == "Seq2" and len(parents) == 0

        augs = self.seq

        augs = augs.remove_augmenters(_func)

        seqs = augs.find_augmenters_by_name(r"Seq.*", regex=True)
        assert len(seqs) == 2
        assert seqs[0].name == "Seq"
        assert seqs[1].name == "Seq2"

    def test_remove_all_without_inplace_removal(self):
        def _func(aug, parents):
            return True

        augs = self.seq

        augs = augs.remove_augmenters(_func)

        assert augs is not None
        assert isinstance(augs, iaa.Identity)

    def test_remove_all_with_inplace_removal(self):
        def _func(aug, parents):
            return aug.name == "Seq"

        augs = self.seq
        got_exception = False
        try:
            _ = augs.remove_augmenters(_func, copy=False)
        except Exception as exc:
            got_exception = True
            expected = (
                "Inplace removal of topmost augmenter requested, "
                "which is currently not possible")
            assert expected in str(exc)
        assert got_exception

    def test_remove_all_without_inplace_removal_and_no_identity(self):
        def _func(aug, parents):
            return True

        augs = self.seq

        augs = augs.remove_augmenters(_func, identity_if_topmost=False)

        assert augs is None

    def test_remove_all_without_inplace_removal_and_no_noop(self):
        def _func(aug, parents):
            return True

        augs = self.seq

        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            augs = augs.remove_augmenters(_func, noop_if_topmost=False)
        assert len(caught_warnings) == 1
        assert "deprecated" in str(caught_warnings[-1].message)

        assert augs is None


class TestAugmenter_copy_random_state(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def image(self):
        return ia.data.quokka_square(size=(128, 128))

    @property
    def images(self):
        return np.array([self.image] * 64, dtype=np.uint8)

    @property
    def source(self):
        source = iaa.Sequential([
            iaa.Fliplr(0.5, name="hflip"),
            iaa.Dropout(0.05, name="dropout"),
            iaa.Affine(translate_px=(-10, 10), name="translate",
                       seed=3),
            iaa.GaussianBlur(1.0, name="blur", seed=4)
        ], seed=5)
        return source

    @property
    def target(self):
        target = iaa.Sequential([
            iaa.Fliplr(0.5, name="hflip"),
            iaa.Dropout(0.05, name="dropout"),
            iaa.Affine(translate_px=(-10, 10), name="translate")
        ])
        return target

    def test_matching_position(self):
        def _func(aug, parents):
            return aug.name == "blur"

        images = self.images
        source = self.source
        target = self.target
        source.localize_random_state_()

        target_cprs = target.copy_random_state(source, matching="position")

        source_alt = source.remove_augmenters(_func)
        images_aug_source = source_alt.augment_images(images)
        images_aug_target = target_cprs.augment_images(images)

        assert target_cprs.random_state.equals(source_alt.random_state)
        for i in sm.xrange(3):
            assert target_cprs[i].random_state.equals(
                source_alt[i].random_state)
        assert np.array_equal(images_aug_source, images_aug_target)

    def test_matching_position_copy_determinism(self):
        def _func(aug, parents):
            return aug.name == "blur"

        images = self.images
        source = self.source
        target = self.target
        source.localize_random_state_()
        source[0].deterministic = True

        target_cprs = target.copy_random_state(
            source, matching="position", copy_determinism=True)

        source_alt = source.remove_augmenters(_func)
        images_aug_source = source_alt.augment_images(images)
        images_aug_target = target_cprs.augment_images(images)

        assert target_cprs[0].deterministic is True
        assert np.array_equal(images_aug_source, images_aug_target)

    def test_matching_name(self):
        def _func(aug, parents):
            return aug.name == "blur"

        images = self.images
        source = self.source
        target = self.target
        source.localize_random_state_()

        target_cprs = target.copy_random_state(source, matching="name")

        source_alt = source.remove_augmenters(_func)
        images_aug_source = source_alt.augment_images(images)
        images_aug_target = target_cprs.augment_images(images)

        assert np.array_equal(images_aug_source, images_aug_target)

    def test_matching_name_copy_determinism(self):
        def _func(aug, parents):
            return aug.name == "blur"

        images = self.images
        source = self.source
        target = self.target
        source.localize_random_state_()

        source_alt = source.remove_augmenters(_func)
        source_det = source_alt.to_deterministic()

        target_cprs_det = target.copy_random_state(
            source_det, matching="name", copy_determinism=True)

        images_aug_source1 = source_det.augment_images(images)
        images_aug_target1 = target_cprs_det.augment_images(images)
        images_aug_source2 = source_det.augment_images(images)
        images_aug_target2 = target_cprs_det.augment_images(images)
        assert np.array_equal(images_aug_source1, images_aug_source2)
        assert np.array_equal(images_aug_target1, images_aug_target2)
        assert np.array_equal(images_aug_source1, images_aug_target1)
        assert np.array_equal(images_aug_source2, images_aug_target2)

    def test_copy_fails_when_source_rngs_are_not_localized__name(self):
        source = iaa.Fliplr(0.5, name="hflip")
        target = iaa.Fliplr(0.5, name="hflip")
        got_exception = False
        try:
            _ = target.copy_random_state(source, matching="name")
        except Exception as exc:
            got_exception = True
            assert "localize_random_state" in str(exc)
        assert got_exception

    def test_copy_fails_when_source_rngs_are_not_localized__position(self):
        source = iaa.Fliplr(0.5, name="hflip")
        target = iaa.Fliplr(0.5, name="hflip")
        got_exception = False
        try:
            _ = target.copy_random_state(source, matching="position")
        except Exception as exc:
            got_exception = True
            assert "localize_random_state" in str(exc)
        assert got_exception

    def test_copy_fails_when_names_not_match_and_matching_not_tolerant(self):
        source = iaa.Fliplr(0.5, name="hflip-other-name")
        target = iaa.Fliplr(0.5, name="hflip")
        source.localize_random_state_()
        got_exception = False
        try:
            _ = target.copy_random_state(
                source, matching="name", matching_tolerant=False)
        except Exception as exc:
            got_exception = True
            assert "not found among source augmenters" in str(exc)
        assert got_exception

    def test_copy_fails_for_not_tolerant_position_matching(self):
        source = iaa.Sequential([iaa.Fliplr(0.5, name="hflip"),
                                 iaa.Fliplr(0.5, name="hflip2")])
        target = iaa.Sequential([iaa.Fliplr(0.5, name="hflip")])
        source.localize_random_state_()
        got_exception = False
        try:
            _ = target.copy_random_state(
                source, matching="position", matching_tolerant=False)
        except Exception as exc:
            got_exception = True
            assert "different lengths" in str(exc)
        assert got_exception

    def test_copy_fails_for_unknown_matching_method(self):
        source = iaa.Sequential([iaa.Fliplr(0.5, name="hflip"),
                                 iaa.Fliplr(0.5, name="hflip2")])
        target = iaa.Sequential([iaa.Fliplr(0.5, name="hflip")])
        source.localize_random_state_()
        got_exception = False
        try:
            _ = target.copy_random_state(source, matching="test")
        except Exception as exc:
            got_exception = True
            assert "Unknown matching method" in str(exc)
        assert got_exception

    def test_warn_if_multiple_augmenters_with_same_name(self):
        source = iaa.Sequential([iaa.Fliplr(0.5, name="hflip"),
                                 iaa.Fliplr(0.5, name="hflip")])
        target = iaa.Sequential([iaa.Fliplr(0.5, name="hflip")])
        source.localize_random_state_()
        with warnings.catch_warnings(record=True) as caught_warnings:
            warnings.simplefilter("always")

            _ = target.copy_random_state(source, matching="name")

        assert len(caught_warnings) == 1
        assert (
            "contains multiple augmenters with the same name"
            in str(caught_warnings[-1].message)
        )


# TODO these tests change the input type from list to array. Might be
#      reasonable to change and test that scenario separetely
class TestAugmenterHooks(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def image(self):
        image = np.array([[0, 0, 1],
                          [0, 0, 1],
                          [0, 1, 1]], dtype=np.uint8)
        return np.atleast_3d(image)

    @property
    def image_lr(self):
        image_lr = np.array([[1, 0, 0],
                             [1, 0, 0],
                             [1, 1, 0]], dtype=np.uint8)
        return np.atleast_3d(image_lr)

    @property
    def image_lrud(self):
        image_lrud = np.array([[1, 1, 0],
                               [1, 0, 0],
                               [1, 0, 0]], dtype=np.uint8)
        return np.atleast_3d(image_lrud)

    def test_preprocessor(self):
        def preprocessor(images, augmenter, parents):
            img = np.copy(images)
            img[0][1, 1, 0] += 1
            return img

        hooks = ia.HooksImages(preprocessor=preprocessor)
        seq = iaa.Sequential([iaa.Fliplr(1.0), iaa.Flipud(1.0)])

        images_aug = seq.augment_images([self.image], hooks=hooks)

        expected = np.copy(self.image_lrud)
        expected[1, 1, 0] = 3
        assert np.array_equal(images_aug[0], expected)

    def test_postprocessor(self):
        def postprocessor(images, augmenter, parents):
            img = np.copy(images)
            img[0][1, 1, 0] += 1
            return img

        hooks = ia.HooksImages(postprocessor=postprocessor)
        seq = iaa.Sequential([iaa.Fliplr(1.0), iaa.Flipud(1.0)])

        images_aug = seq.augment_images([self.image], hooks=hooks)

        expected = np.copy(self.image_lrud)
        expected[1, 1, 0] = 3
        assert np.array_equal(images_aug[0], expected)

    def test_propagator(self):
        def propagator(images, augmenter, parents, default):
            if "Seq" in augmenter.name:
                return False
            else:
                return default

        hooks = ia.HooksImages(propagator=propagator)
        seq = iaa.Sequential([iaa.Fliplr(1.0), iaa.Flipud(1.0)])

        images_aug = seq.augment_images([self.image], hooks=hooks)

        assert np.array_equal(images_aug[0], self.image)

    def test_activator(self):
        def activator(images, augmenter, parents, default):
            if "Flipud" in augmenter.name:
                return False
            else:
                return default

        hooks = ia.HooksImages(activator=activator)
        seq = iaa.Sequential([iaa.Fliplr(1.0), iaa.Flipud(1.0)])

        images_aug = seq.augment_images([self.image], hooks=hooks)

        assert np.array_equal(images_aug[0], self.image_lr)

    def test_activator_keypoints(self):
        def activator(keypoints_on_images, augmenter, parents, default):
            return False

        hooks = ia.HooksKeypoints(activator=activator)
        kps = [ia.Keypoint(x=1, y=0), ia.Keypoint(x=2, y=0),
               ia.Keypoint(x=2, y=1)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 10, 3))
        aug = iaa.Affine(translate_px=1)

        keypoints_aug = aug.augment_keypoints(kpsoi, hooks=hooks)

        assert keypoints_equal([keypoints_aug], [kpsoi])


class TestAugmenterWithLoadedImages(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_with_cv2(self):
        image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
        image = np.tile(image, (1, 1, 3))
        image[:, :, 0] += 0
        image[:, :, 1] += 1
        image[:, :, 2] += 2
        images = image[np.newaxis, :, :, :]
        image_cp = np.copy(image)
        images_cp = np.copy(images)

        aug_arrs = _InplaceDummyAugmenterImgsArray(1)
        aug_lists = _InplaceDummyAugmenterImgsList(1)

        with TemporaryDirectory() as dirpath:
            imgpath = os.path.join(dirpath, "temp_cv2.png")
            imageio.imwrite(imgpath, image)
            image_reloaded = cv2.imread(imgpath)[:, :, ::-1]
            images_reloaded = image_reloaded[np.newaxis, :, :, :]

            image_aug = aug_lists(image=image_reloaded)
            assert image_aug is not image_reloaded
            assert np.array_equal(image_reloaded, image_cp)
            assert np.array_equal(image_aug, image_cp + 1)

            image_aug = aug_lists.augment_image(image=image_reloaded)
            assert image_aug is not image_reloaded
            assert np.array_equal(image_reloaded, image_cp)
            assert np.array_equal(image_aug, image_cp + 1)

            images_aug = aug_arrs(images=images_reloaded)
            assert images_aug is not images_reloaded
            assert np.array_equal(images_reloaded, images_cp)
            assert np.array_equal(images_aug, images_cp + 1)

            images_aug = aug_arrs.augment_images(images=images_reloaded)
            assert images_aug is not images_reloaded
            assert np.array_equal(images_reloaded, images_cp)
            assert np.array_equal(images_aug, images_cp + 1)

    def test_with_imageio(self):
        image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
        image = np.tile(image, (1, 1, 3))
        image[:, :, 0] += 0
        image[:, :, 1] += 1
        image[:, :, 2] += 2
        images = image[np.newaxis, :, :, :]
        image_cp = np.copy(image)
        images_cp = np.copy(images)

        aug_arrs = _InplaceDummyAugmenterImgsArray(1)
        aug_lists = _InplaceDummyAugmenterImgsList(1)

        with TemporaryDirectory() as dirpath:
            imgpath = os.path.join(dirpath, "temp_imageio.png")
            imageio.imwrite(imgpath, image)
            image_reloaded = imageio.imread(imgpath)
            images_reloaded = image_reloaded[np.newaxis, :, :, :]

            image_aug = aug_lists(image=image_reloaded)
            assert image_aug is not image_reloaded
            assert np.array_equal(image_reloaded, image_cp)
            assert np.array_equal(image_aug, image_cp + 1)

            image_aug = aug_lists.augment_image(image=image_reloaded)
            assert image_aug is not image_reloaded
            assert np.array_equal(image_reloaded, image_cp)
            assert np.array_equal(image_aug, image_cp + 1)

            images_aug = aug_arrs(images=images_reloaded)
            assert images_aug is not images_reloaded
            assert np.array_equal(images_reloaded, images_cp)
            assert np.array_equal(images_aug, images_cp + 1)

            images_aug = aug_arrs.augment_images(images=images_reloaded)
            assert images_aug is not images_reloaded
            assert np.array_equal(images_reloaded, images_cp)
            assert np.array_equal(images_aug, images_cp + 1)

    def test_with_pil(self):
        fnames = ["asarray", "array"]
        for fname in fnames:
            with self.subTest(fname=fname):
                image = np.arange(10*20).astype(np.uint8).reshape((10, 20, 1))
                image = np.tile(image, (1, 1, 3))
                image[:, :, 0] += 0
                image[:, :, 1] += 1
                image[:, :, 2] += 2
                images = image[np.newaxis, :, :, :]
                image_cp = np.copy(image)
                images_cp = np.copy(images)

                aug_arrs = _InplaceDummyAugmenterImgsArray(1)
                aug_lists = _InplaceDummyAugmenterImgsList(1)

                with TemporaryDirectory() as dirpath:
                    imgpath = os.path.join(dirpath,
                                           "temp_pil_%s.png" % (fname,))
                    imageio.imwrite(imgpath, image)
                    image_reloaded = getattr(np, fname)(PIL.Image.open(imgpath))
                    images_reloaded = image_reloaded[np.newaxis, :, :, :]

                    image_aug = aug_lists(image=image_reloaded)
                    assert image_aug is not image_reloaded
                    assert np.array_equal(image_reloaded, image_cp)
                    assert np.array_equal(image_aug, image_cp + 1)

                    image_aug = aug_lists.augment_image(image=image_reloaded)
                    assert image_aug is not image_reloaded
                    assert np.array_equal(image_reloaded, image_cp)
                    assert np.array_equal(image_aug, image_cp + 1)

                    images_aug = aug_arrs(images=images_reloaded)
                    assert images_aug is not images_reloaded
                    assert np.array_equal(images_reloaded, images_cp)
                    assert np.array_equal(images_aug, images_cp + 1)

                    images_aug = aug_arrs.augment_images(images=images_reloaded)
                    assert images_aug is not images_reloaded
                    assert np.array_equal(images_reloaded, images_cp)
                    assert np.array_equal(images_aug, images_cp + 1)


class TestSequential(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def image(self):
        image = np.array([[0, 1, 1],
                          [0, 0, 1],
                          [0, 0, 1]], dtype=np.uint8) * 255
        return np.atleast_3d(image)

    @property
    def images(self):
        return np.array([self.image], dtype=np.uint8)

    @property
    def image_lr(self):
        image_lr = np.array([[1, 1, 0],
                             [1, 0, 0],
                             [1, 0, 0]], dtype=np.uint8) * 255
        return np.atleast_3d(image_lr)

    @property
    def images_lr(self):
        return np.array([self.image_lr], dtype=np.uint8)

    @property
    def image_ud(self):
        image_ud = np.array([[0, 0, 1],
                             [0, 0, 1],
                             [0, 1, 1]], dtype=np.uint8) * 255
        return np.atleast_3d(image_ud)

    @property
    def images_ud(self):
        return np.array([self.image_ud], dtype=np.uint8)

    @property
    def image_lr_ud(self):
        image_lr_ud = np.array([[1, 0, 0],
                                [1, 0, 0],
                                [1, 1, 0]], dtype=np.uint8) * 255
        return np.atleast_3d(image_lr_ud)

    @property
    def images_lr_ud(self):
        return np.array([self.image_lr_ud])

    @property
    def keypoints(self):
        kps = [ia.Keypoint(x=1, y=0),
               ia.Keypoint(x=2, y=0),
               ia.Keypoint(x=2, y=1)]
        return ia.KeypointsOnImage(kps, shape=self.image.shape)

    @property
    def keypoints_aug(self):
        kps = [ia.Keypoint(x=3-1, y=3-0),
               ia.Keypoint(x=3-2, y=3-0),
               ia.Keypoint(x=3-2, y=3-1)]
        return ia.KeypointsOnImage(kps, shape=self.image.shape)

    @property
    def polygons(self):
        polygon = ia.Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
        return ia.PolygonsOnImage([polygon], shape=self.image.shape)

    @property
    def polygons_aug(self):
        polygon = ia.Polygon([(3-0, 3-0), (3-2, 3-0), (3-2, 3-2), (3-0, 3-2)])
        return ia.PolygonsOnImage([polygon], shape=self.image.shape)

    @property
    def lsoi(self):
        ls = ia.LineString([(0, 0), (2, 0), (2, 2), (0, 2)])
        return ia.LineStringsOnImage([ls], shape=self.image.shape)

    @property
    def lsoi_aug(self):
        ls = ia.LineString([(3-0, 3-0), (3-2, 3-0), (3-2, 3-2), (3-0, 3-2)])
        return ia.LineStringsOnImage([ls], shape=self.image.shape)

    @property
    def bbsoi(self):
        bb = ia.BoundingBox(x1=0, y1=0, x2=2, y2=2)
        return ia.BoundingBoxesOnImage([bb], shape=self.image.shape)

    @property
    def bbsoi_aug(self):
        x1 = 3-0
        x2 = 3-2
        y1 = 3-0
        y2 = 3-2
        bb = ia.BoundingBox(x1=min(x1, x2), y1=min(y1, y2),
                            x2=max(x1, x2), y2=max(y1, y2))
        return ia.BoundingBoxesOnImage([bb], shape=self.image.shape)

    @property
    def heatmaps(self):
        heatmaps_arr = np.float32([[0, 0, 1.0],
                                   [0, 0, 1.0],
                                   [0, 1.0, 1.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=self.image.shape)

    @property
    def heatmaps_aug(self):
        heatmaps_arr_expected = np.float32([[1.0, 1.0, 0.0],
                                            [1.0, 0, 0],
                                            [1.0, 0, 0]])
        return ia.HeatmapsOnImage(heatmaps_arr_expected, shape=self.image.shape)

    @property
    def segmaps(self):
        segmaps_arr = np.int32([[0, 0, 1],
                                [0, 0, 1],
                                [0, 1, 1]])
        return ia.SegmentationMapsOnImage(segmaps_arr, shape=self.image.shape)

    @property
    def segmaps_aug(self):
        segmaps_arr_expected = np.int32([[1, 1, 0],
                                         [1, 0, 0],
                                         [1, 0, 0]])
        return ia.SegmentationMapsOnImage(segmaps_arr_expected,
                                          shape=self.image.shape)

    @property
    def seq_two_flips(self):
        return iaa.Sequential([
            iaa.Fliplr(1.0),
            iaa.Flipud(1.0)
        ])

    def test_images__two_flips(self):
        aug = self.seq_two_flips
        observed = aug.augment_images(self.images)
        assert np.array_equal(observed, self.images_lr_ud)

    def test_images__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_images(self.images)

        assert np.array_equal(observed, self.images_lr_ud)

    def test_images_as_list__two_flips(self):
        aug = self.seq_two_flips

        observed = aug.augment_images([self.image])

        assert array_equal_lists(observed, [self.image_lr_ud])

    def test_images_as_list__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_images([self.image])

        assert array_equal_lists(observed, [self.image_lr_ud])

    def test_keypoints__two_flips(self):
        aug = self.seq_two_flips

        observed = aug.augment_keypoints([self.keypoints])

        assert_cbaois_equal(observed, [self.keypoints_aug])

    def test_keypoints__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_keypoints([self.keypoints])

        assert_cbaois_equal(observed, [self.keypoints_aug])

    def test_polygons__two_flips(self):
        aug = self.seq_two_flips

        observed = aug.augment_polygons(self.polygons)

        assert_cbaois_equal(observed, self.polygons_aug)

    def test_polygons__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_polygons(self.polygons)

        assert_cbaois_equal(observed, self.polygons_aug)

    def test_line_strings__two_flips(self):
        aug = self.seq_two_flips

        observed = aug.augment_line_strings(self.lsoi)

        assert_cbaois_equal(observed, self.lsoi_aug)

    def test_line_strings__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_line_strings(self.lsoi)

        assert_cbaois_equal(observed, self.lsoi_aug)

    def test_bounding_boxes__two_flips(self):
        aug = self.seq_two_flips

        observed = aug.augment_bounding_boxes(self.bbsoi)

        assert_cbaois_equal(observed, self.bbsoi_aug)

    def test_bounding_boxes__two_flips__deterministic(self):
        aug = self.seq_two_flips
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_bounding_boxes(self.bbsoi)

        assert_cbaois_equal(observed, self.bbsoi_aug)

    def test_heatmaps__two_flips(self):
        aug = self.seq_two_flips
        heatmaps = self.heatmaps

        observed = aug.augment_heatmaps([heatmaps])[0]

        assert observed.shape == (3, 3, 1)
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1.0 - 1e-6 < observed.max_value < 1.0 + 1e-6
        assert np.allclose(observed.get_arr(),
                           self.heatmaps_aug.get_arr())

    def test_segmentation_maps__two_flips(self):
        aug = self.seq_two_flips
        segmaps = self.segmaps

        observed = aug.augment_segmentation_maps([segmaps])[0]

        assert observed.shape == (3, 3, 1)
        assert np.array_equal(observed.get_arr(),
                              self.segmaps_aug.get_arr())

    def test_children_not_provided(self):
        aug = iaa.Sequential()
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, image)

    def test_children_are_none(self):
        aug = iaa.Sequential(children=None)
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, image)

    def test_children_is_single_augmenter_without_list(self):
        aug = iaa.Sequential(iaa.Fliplr(1.0))
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, np.fliplr(image))

    def test_children_is_a_sequential(self):
        aug = iaa.Sequential(iaa.Sequential(iaa.Fliplr(1.0)))
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, np.fliplr(image))

    def test_children_is_list_of_sequentials(self):
        aug = iaa.Sequential([
            iaa.Sequential(iaa.Flipud(1.0)),
            iaa.Sequential(iaa.Fliplr(1.0))
        ])
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, np.fliplr(np.flipud(image)))

    def test_randomness__two_flips(self):
        # 50% horizontal flip, 50% vertical flip
        aug = iaa.Sequential([
            iaa.Fliplr(0.5),
            iaa.Flipud(0.5)
        ])

        frac_same = self._test_randomness__two_flips__compute_fraction_same(
            aug, 200)
        assert np.isclose(frac_same, 0.25, rtol=0, atol=0.1)

    def test_randomness__two_flips__deterministic(self):
        # 50% horizontal flip, 50% vertical flip
        aug = iaa.Sequential([
            iaa.Fliplr(0.5),
            iaa.Flipud(0.5)
        ])
        aug_det = aug.to_deterministic()

        frac_same = self._test_randomness__two_flips__compute_fraction_same(
            aug_det, 200)
        assert (
            np.isclose(frac_same, 0.0, rtol=0, atol=1e-5)
            or np.isclose(frac_same, 1.0, rtol=0, atol=1e-5)
        )

    def _test_randomness__two_flips__compute_fraction_same(self, aug,
                                                           nb_iterations):
        expected = [self.images, self.images_lr, self.images_ud,
                    self.images_lr_ud]

        last_aug = None
        nb_changed_aug = 0

        for i in sm.xrange(nb_iterations):
            observed_aug = aug.augment_images(self.images)
            if i == 0:
                last_aug = observed_aug
            else:
                if not np.array_equal(observed_aug, last_aug):
                    nb_changed_aug += 1
                last_aug = observed_aug

            assert np.any([np.array_equal(observed_aug, expected_i)
                           for expected_i in expected])

        # should be the same in roughly 25% of all cases
        frac_changed = nb_changed_aug / nb_iterations
        return 1 - frac_changed

    def test_random_order_true_images(self):
        aug = iaa.Sequential([
            iaa.Affine(translate_px={"x": 1}, mode="constant", cval=0, order=0),
            iaa.Fliplr(1.0)
        ], random_order=True)

        frac_12 = self._test_random_order_images_frac_12(aug, 200)

        assert np.isclose(frac_12, 0.5, 0.075)

    def test_random_order_false_images(self):
        aug = iaa.Sequential([
            iaa.Affine(translate_px={"x": 1}, mode="constant", cval=0, order=0),
            iaa.Fliplr(1.0)
        ], random_order=False)

        frac_12 = self._test_random_order_images_frac_12(aug, 25)

        assert frac_12 >= 1.0 - 1e-4

    def test_random_order_true_deterministic_images(self):
        aug = iaa.Sequential([
            iaa.Affine(translate_px={"x": 1}, mode="constant", cval=0, order=0),
            iaa.Fliplr(1.0)
        ], random_order=True)
        aug = aug.to_deterministic()

        frac_12 = self._test_random_order_images_frac_12(aug, 25)

        assert (frac_12 >= 1.0-1e-4 or frac_12 <= 0.0+1e-4)

    @classmethod
    def _test_random_order_images_frac_12(cls, aug, nb_iterations):
        image = np.uint8([[0, 1],
                           [2, 3]])
        image_12 = np.uint8([[0, 0],
                              [2, 0]])
        image_21 = np.uint8([[0, 1],
                              [0, 3]])

        seen = [False, False]
        for _ in sm.xrange(nb_iterations):
            observed = aug.augment_images([image])[0]
            if np.array_equal(observed, image_12):
                seen[0] = True
            elif np.array_equal(observed, image_21):
                seen[1] = True
            else:
                assert False

        frac_12 = seen[0] / np.sum(seen)
        return frac_12

    # TODO add random_order=False
    def test_random_order_heatmaps(self):
        aug = iaa.Sequential([
            iaa.Affine(translate_px={"x": 1}),
            iaa.Fliplr(1.0)
        ], random_order=True)
        heatmaps_arr = np.float32([[0, 0, 1.0],
                                   [0, 0, 1.0],
                                   [0, 1.0, 1.0]])
        heatmaps_arr_expected1 = np.float32([[0.0, 0.0, 0.0],
                                             [0.0, 0.0, 0.0],
                                             [1.0, 0.0, 0.0]])
        heatmaps_arr_expected2 = np.float32([[0.0, 1.0, 0.0],
                                             [0.0, 1.0, 0.0],
                                             [0.0, 1.0, 1.0]])
        seen = [False, False]
        for _ in sm.xrange(100):
            observed = aug.augment_heatmaps([
                ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))])[0]
            if np.allclose(observed.get_arr(), heatmaps_arr_expected1):
                seen[0] = True
            elif np.allclose(observed.get_arr(), heatmaps_arr_expected2):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    # TODO add random_order=False
    def test_random_order_segmentation_maps(self):
        aug = iaa.Sequential([
            iaa.Affine(translate_px={"x": 1}),
            iaa.Fliplr(1.0)
        ], random_order=True)
        segmaps_arr = np.int32([[0, 0, 1],
                                [0, 0, 1],
                                [0, 1, 1]])
        segmaps_arr_expected1 = np.int32([[0, 0, 0],
                                          [0, 0, 0],
                                          [1, 0, 0]])
        segmaps_arr_expected2 = np.int32([[0, 1, 0],
                                          [0, 1, 0],
                                          [0, 1, 1]])
        seen = [False, False]
        for _ in sm.xrange(100):
            observed = aug.augment_segmentation_maps([
                SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))])[0]
            if np.array_equal(observed.get_arr(), segmaps_arr_expected1):
                seen[0] = True
            elif np.array_equal(observed.get_arr(), segmaps_arr_expected2):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    # TODO add random_order=False
    def test_random_order_keypoints(self):
        KP = ia.Keypoint
        kps = [KP(0, 0), KP(2, 0), KP(2, 2)]
        kps_12 = [KP((0+1)*2, 0), KP((2+1)*2, 0), KP((2+1)*2, 2)]
        kps_21 = [KP((0*2)+1, 0), KP((2*2)+1, 0), KP((2*2)+1, 2)]

        kpsoi = ia.KeypointsOnImage(kps, shape=(3, 3))
        kpsoi_12 = ia.KeypointsOnImage(kps_12, shape=(3, 3))
        kpsoi_21 = ia.KeypointsOnImage(kps_21, shape=(3, 3))

        def func1(keypoints_on_images, random_state, parents, hooks):
            for kpsoi in keypoints_on_images:
                for kp in kpsoi.keypoints:
                    kp.x += 1
            return keypoints_on_images

        def func2(keypoints_on_images, random_state, parents, hooks):
            for kpsoi in keypoints_on_images:
                for kp in kpsoi.keypoints:
                    kp.x *= 2
            return keypoints_on_images

        aug_1 = iaa.Lambda(func_keypoints=func1)
        aug_2 = iaa.Lambda(func_keypoints=func2)
        seq = iaa.Sequential([aug_1, aug_2], random_order=True)

        seen = [False, False]
        for _ in sm.xrange(100):
            observed = seq.augment_keypoints(kpsoi)
            if np.allclose(observed.to_xy_array(), kpsoi_12.to_xy_array()):
                seen[0] = True
            elif np.allclose(observed.to_xy_array(), kpsoi_21.to_xy_array()):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    # TODO add random_order=False
    def test_random_order_polygons(self):
        cba = ia.Polygon([(0, 0), (1, 0), (1, 1)])
        cba_12 = ia.Polygon([(0, 0), (1, 0), ((1+1)*2, 1)])
        cba_21 = ia.Polygon([(0, 0), (1, 0), ((1*2)+1, 1)])

        cbaoi = ia.PolygonsOnImage([cba], shape=(3, 3))

        def func1(polygons_on_images, random_state, parents, hooks):
            for cbaoi_ in polygons_on_images:
                for cba_ in cbaoi_.items:
                    cba_.exterior[-1, 0] += 1
            return polygons_on_images

        def func2(polygons_on_images, random_state, parents, hooks):
            for cbaoi_ in polygons_on_images:
                for cba_ in cbaoi_.items:
                    cba_.exterior[-1, 0] *= 2
            return polygons_on_images

        aug_1 = iaa.Lambda(func_polygons=func1)
        aug_2 = iaa.Lambda(func_polygons=func2)
        seq = iaa.Sequential([aug_1, aug_2], random_order=True)

        seen = [False, False]
        for _ in sm.xrange(100):
            observed = seq.augment_polygons(cbaoi)
            if np.allclose(observed.items[0].coords, cba_12.coords):
                seen[0] = True
            elif np.allclose(observed.items[0].coords, cba_21.coords):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    # TODO add random_order=False
    def test_random_order_line_strings(self):
        cba = ia.LineString([(0, 0), (1, 0), (1, 1)])
        cba_12 = ia.LineString([(0, 0), (1, 0), ((1+1)*2, 1)])
        cba_21 = ia.LineString([(0, 0), (1, 0), ((1*2)+1, 1)])

        cbaoi = ia.LineStringsOnImage([cba], shape=(3, 3))

        def func1(line_strings_on_images, random_state, parents, hooks):
            for cbaoi_ in line_strings_on_images:
                for cba_ in cbaoi_.items:
                    cba_.coords[-1, 0] += 1
            return line_strings_on_images

        def func2(line_strings_on_images, random_state, parents, hooks):
            for cbaoi_ in line_strings_on_images:
                for cba_ in cbaoi_.items:
                    cba_.coords[-1, 0] *= 2
            return line_strings_on_images

        aug_1 = iaa.Lambda(func_line_strings=func1)
        aug_2 = iaa.Lambda(func_line_strings=func2)
        seq = iaa.Sequential([aug_1, aug_2], random_order=True)

        seen = [False, False]
        for _ in sm.xrange(100):
            observed = seq.augment_line_strings(cbaoi)
            if np.allclose(observed.items[0].coords, cba_12.coords):
                seen[0] = True
            elif np.allclose(observed.items[0].coords, cba_21.coords):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    # TODO add random_order=False
    def test_random_order_bounding_boxes(self):
        bbs = [ia.BoundingBox(x1=1, y1=2, x2=30, y2=40)]
        bbs_12 = [ia.BoundingBox(x1=(1+1)*2, y1=2, x2=30, y2=40)]
        bbs_21 = [ia.BoundingBox(x1=(1*2)+1, y1=2, x2=30, y2=40)]

        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(3, 3))
        bbsoi_12 = ia.BoundingBoxesOnImage(bbs_12, shape=(3, 3))
        bbsoi_21 = ia.BoundingBoxesOnImage(bbs_21, shape=(3, 3))

        def func1(bounding_boxes_on_images, random_state, parents, hooks):
            for bbsoi in bounding_boxes_on_images:
                for bb in bbsoi.bounding_boxes:
                    bb.x1 += 1
            return bounding_boxes_on_images

        def func2(bounding_boxes_on_images, random_state, parents, hooks):
            for bbsoi in bounding_boxes_on_images:
                for bb in bbsoi.bounding_boxes:
                    bb.x1 *= 2
            return bounding_boxes_on_images

        aug_1 = iaa.Lambda(func_bounding_boxes=func1)
        aug_2 = iaa.Lambda(func_bounding_boxes=func2)
        seq = iaa.Sequential([aug_1, aug_2], random_order=True)

        seen = [False, False]
        for _ in sm.xrange(100):
            observed = seq.augment_bounding_boxes(bbsoi)
            if np.allclose(observed.to_xyxy_array(),
                           bbsoi_12.to_xyxy_array()):
                seen[0] = True
            elif np.allclose(observed.to_xyxy_array(),
                             bbsoi_21.to_xyxy_array()):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_zero_sized_axes(self):
        shapes = [
            (0, 0),
            (0, 1),
            (1, 0),
            (0, 1, 0),
            (1, 0, 0),
            (0, 1, 1),
            (1, 0, 1)
        ]

        for shape in shapes:
            for random_order in [False, True]:
                with self.subTest(shape=shape):
                    image = np.zeros(shape, dtype=np.uint8)
                    aug = iaa.Sequential([iaa.Identity()],
                                         random_order=random_order)

                    image_aug = aug(image=image)

                    assert image_aug.dtype.name == "uint8"
                    assert image_aug.shape == shape

    def test_unusual_channel_numbers(self):
        shapes = [
            (1, 1, 4),
            (1, 1, 5),
            (1, 1, 512),
            (1, 1, 513)
        ]

        for shape in shapes:
            for random_order in [False, True]:
                with self.subTest(shape=shape):
                    image = np.zeros(shape, dtype=np.uint8)
                    aug = iaa.Sequential([iaa.Identity()],
                                         random_order=random_order)

                    image_aug = aug(image=image)

                    assert np.all(image_aug == 0)
                    assert image_aug.dtype.name == "uint8"
                    assert image_aug.shape == shape

    def test_add_to_empty_sequential(self):
        aug = iaa.Sequential()
        aug.add(iaa.Fliplr(1.0))
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, np.fliplr(image))

    def test_add_to_sequential_with_child(self):
        aug = iaa.Sequential(iaa.Fliplr(1.0))
        aug.add(iaa.Flipud(1.0))
        image = np.arange(4*4).reshape((4, 4)).astype(np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, np.fliplr(np.flipud(image)))

    def test_get_parameters(self):
        aug1 = iaa.Sequential(iaa.Fliplr(1.0), random_order=False)
        aug2 = iaa.Sequential(iaa.Fliplr(1.0), random_order=True)
        assert aug1.get_parameters() == [False]
        assert aug2.get_parameters() == [True]

    def test_get_children_lists(self):
        flip = iaa.Fliplr(1.0)
        aug = iaa.Sequential(flip)
        assert aug.get_children_lists() == [aug]

    def test_to_deterministic(self):
        child = iaa.Identity()
        aug = iaa.Sequential([child])

        aug_det = aug.to_deterministic()

        assert aug_det.random_state is not aug.random_state
        assert aug_det.deterministic
        assert aug_det[0].deterministic

    def test___str___and___repr__(self):
        flip = iaa.Fliplr(1.0)
        aug = iaa.Sequential(flip, random_order=True)
        expected = (
            "Sequential("
            "name=%s, random_order=%s, children=[%s], deterministic=%s"
            ")" % (aug.name, "True", str(flip), "False")
        )
        assert aug.__str__() == aug.__repr__() == expected

    def test_other_dtypes_noop__bool(self):
        for random_order in [False, True]:
            aug = iaa.Sequential([
                iaa.Identity(),
                iaa.Identity()
            ], random_order=random_order)

            image = np.zeros((3, 3), dtype=bool)
            image[0, 0] = True
            image_aug = aug.augment_image(image)
            assert image_aug.dtype.name == "bool"
            assert np.all(image_aug == image)

    def test_other_dtypes__noop__uint_int(self):
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]

        for dtype, random_order in itertools.product(dtypes, [False, True]):
            with self.subTest(dtype=dtype, random_order=random_order):
                aug = iaa.Sequential([
                    iaa.Identity(),
                    iaa.Identity()
                ], random_order=random_order)

                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_noop__float(self):
        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for random_order in [False, True]:
            for dtype, value in zip(dtypes, values):
                with self.subTest(dtype=dtype, random_order=random_order):
                    aug = iaa.Sequential([
                        iaa.Identity(),
                        iaa.Identity()
                    ], random_order=random_order)

                    image = np.zeros((3, 3), dtype=dtype)
                    image[0, 0] = value
                    image_aug = aug.augment_image(image)
                    assert image_aug.dtype.name == dtype
                    assert np.all(image_aug == image)

    def test_other_dtypes_flips__bool(self):
        for random_order in [False, True]:
            # note that we use 100% probabilities with square images here,
            # so random_order does not influence the output
            aug = iaa.Sequential([
                iaa.Fliplr(1.0),
                iaa.Flipud(1.0)
            ], random_order=random_order)

            image = np.zeros((3, 3), dtype=bool)
            image[0, 0] = True
            expected = np.zeros((3, 3), dtype=bool)
            expected[2, 2] = True
            image_aug = aug.augment_image(image)
            assert image_aug.dtype.name == "bool"
            assert np.all(image_aug == expected)

    def test_other_dtypes__flips__uint_int(self):
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]

        for dtype, random_order in itertools.product(dtypes, [False, True]):
            with self.subTest(dtype=dtype, random_order=random_order):
                # note that we use 100% probabilities with square images here,
                # so random_order does not influence the output
                aug = iaa.Sequential([
                    iaa.Fliplr(1.0),
                    iaa.Flipud(1.0)
                ], random_order=random_order)

                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = np.zeros((3, 3), dtype=dtype)
                expected[2, 2] = value
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, expected)

    def test_other_dtypes_flips__float(self):
        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]

        for random_order in [False, True]:
            for dtype, value in zip(dtypes, values):
                with self.subTest(dtype=dtype, random_order=random_order):
                    # note that we use 100% probabilities with square images
                    # here, so random_order does not influence the output
                    aug = iaa.Sequential([
                        iaa.Fliplr(1.0),
                        iaa.Flipud(1.0)
                    ], random_order=random_order)

                    image = np.zeros((3, 3), dtype=dtype)
                    image[0, 0] = value
                    expected = np.zeros((3, 3), dtype=dtype)
                    expected[2, 2] = value
                    image_aug = aug.augment_image(image)
                    assert image_aug.dtype.name == dtype
                    assert np.all(image_aug == expected)

    def test_pickleable(self):
        aug = iaa.Sequential(
            [iaa.Add(1, seed=1),
             iaa.Multiply(3, seed=2)],
            random_order=True,
            seed=3)
        runtest_pickleable_uint8_img(aug, iterations=5)


class TestSomeOf(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_children_are_empty_list(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        aug = iaa.SomeOf(n=0, children=[])
        observed = aug.augment_image(zeros)
        assert np.array_equal(observed, zeros)

    def test_children_are_not_provided(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        aug = iaa.SomeOf(n=0)
        observed = aug.augment_image(zeros)
        assert np.array_equal(observed, zeros)

    def test_several_children_and_various_fixed_n(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        children = [iaa.Add(1), iaa.Add(2), iaa.Add(3)]

        ns = [0, 1, 2, 3, 4, None, (2, None), (2, 2),
              iap.Deterministic(3)]
        expecteds = [[0],  # 0
                     [9*1, 9*2, 9*3],  # 1
                     [9*1+9*2, 9*1+9*3, 9*2+9*3],  # 2
                     [9*1+9*2+9*3],  # 3
                     [9*1+9*2+9*3],  # 4
                     [9*1+9*2+9*3],  # None
                     [9*1+9*2, 9*1+9*3, 9*2+9*3, 9*1+9*2+9*3],  # (2, None)
                     [9*1+9*2, 9*1+9*3, 9*2+9*3],  # (2, 2)
                     [9*1+9*2+9*3]]  # Deterministic(3)

        for n, expected in zip(ns, expecteds):
            with self.subTest(n=n):
                aug = iaa.SomeOf(n=n, children=children)
                observed = aug.augment_image(zeros)
                assert np.sum(observed) in expected

    def test_several_children_and_n_as_tuple(self):
        zeros = np.zeros((1, 1, 1), dtype=np.uint8)
        augs = [iaa.Add(2**0), iaa.Add(2**1), iaa.Add(2**2)]
        aug = iaa.SomeOf(n=(0, 3), children=augs)

        nb_iterations = 1000
        nb_observed = [0, 0, 0, 0]
        for i in sm.xrange(nb_iterations):
            observed = aug.augment_image(zeros)
            s = observed[0, 0, 0]
            if s == 0:
                nb_observed[0] += 1
            else:
                if s & 2**0 > 0:
                    nb_observed[1] += 1
                if s & 2**1 > 0:
                    nb_observed[2] += 1
                if s & 2**2 > 0:
                    nb_observed[3] += 1
        p_observed = [n/nb_iterations for n in nb_observed]
        assert np.isclose(p_observed[0], 0.25, rtol=0, atol=0.1)
        assert np.isclose(p_observed[1], 0.5, rtol=0, atol=0.1)
        assert np.isclose(p_observed[2], 0.5, rtol=0, atol=0.1)
        assert np.isclose(p_observed[3], 0.5, rtol=0, atol=0.1)

    def test_several_children_and_various_fixed_n__heatmaps(self):
        augs = [iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"x": 1})]

        heatmaps_arr = np.float32([[1.0, 0.0, 0.0],
                                   [1.0, 0.0, 0.0],
                                   [1.0, 0.0, 0.0]])
        heatmaps_arr0 = np.float32([[1.0, 0.0, 0.0],
                                    [1.0, 0.0, 0.0],
                                    [1.0, 0.0, 0.0]])
        heatmaps_arr1 = np.float32([[0.0, 1.0, 0.0],
                                    [0.0, 1.0, 0.0],
                                    [0.0, 1.0, 0.0]])
        heatmaps_arr2 = np.float32([[0.0, 0.0, 1.0],
                                    [0.0, 0.0, 1.0],
                                    [0.0, 0.0, 1.0]])
        heatmaps_arr3 = np.float32([[0.0, 0.0, 0.0],
                                    [0.0, 0.0, 0.0],
                                    [0.0, 0.0, 0.0]])

        ns = [0, 1, 2, 3, None]
        expecteds = [[heatmaps_arr0],
                     [heatmaps_arr1],
                     [heatmaps_arr2],
                     [heatmaps_arr3],
                     [heatmaps_arr3]]

        for n, expected in zip(ns, expecteds):
            with self.subTest(n=n):
                heatmaps = ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))
                aug = iaa.SomeOf(n=n, children=augs)
                observed = aug.augment_heatmaps(heatmaps)
                assert observed.shape == (3, 3, 3)
                assert np.isclose(observed.min_value, 0.0)
                assert np.isclose(observed.max_value, 1.0)
                matches = [
                    np.allclose(observed.get_arr(), expected_i)
                    for expected_i in expected]
                assert np.any(matches)

    def test_several_children_and_various_fixed_n__segmaps(self):
        augs = [iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"x": 1})]
        segmaps_arr = np.int32([[1, 0, 0],
                                [1, 0, 0],
                                [1, 0, 0]])
        segmaps_arr0 = np.int32([[1, 0, 0],
                                 [1, 0, 0],
                                 [1, 0, 0]])
        segmaps_arr1 = np.int32([[0, 1, 0],
                                 [0, 1, 0],
                                 [0, 1, 0]])
        segmaps_arr2 = np.int32([[0, 0, 1],
                                 [0, 0, 1],
                                 [0, 0, 1]])
        segmaps_arr3 = np.int32([[0, 0, 0],
                                 [0, 0, 0],
                                 [0, 0, 0]])

        ns = [0, 1, 2, 3, None]
        expecteds = [[segmaps_arr0],
                     [segmaps_arr1],
                     [segmaps_arr2],
                     [segmaps_arr3],
                     [segmaps_arr3]]

        for n, expected in zip(ns, expecteds):
            with self.subTest(n=n):
                segmaps = SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))
                aug = iaa.SomeOf(n=n, children=augs)
                observed = aug.augment_segmentation_maps(segmaps)
                assert observed.shape == (3, 3, 3)
                matches = [
                    np.array_equal(observed.get_arr(), expected_i)
                    for expected_i in expected]
                assert np.any(matches)

    def _test_several_children_and_various_fixed_n__cbaois(
            self, cbaoi, augf_name):
        augs = [iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"y": 1})]

        cbaoi_x = cbaoi.shift(x=1)
        cbaoi_y = cbaoi.shift(y=1)
        cbaoi_xy = cbaoi.shift(x=1, y=1)

        ns = [0, 1, 2, None]
        expecteds = [[cbaoi],
                     [cbaoi_x, cbaoi_y],
                     [cbaoi_xy],
                     [cbaoi_xy]]

        for n, expected in zip(ns, expecteds):
            with self.subTest(n=n):
                aug = iaa.SomeOf(n=n, children=augs)
                cbaoi_aug = getattr(aug, augf_name)(cbaoi)
                cba = cbaoi_aug.items[0]
                assert len(cbaoi_aug.items) == len(cbaoi.items)
                assert cbaoi_aug.shape == (5, 6, 3)
                if hasattr(cba, "is_valid"):
                    assert cba.is_valid
                matches = [
                    cba.coords_almost_equals(cbaoi_i.items[0])
                    for cbaoi_i in expected
                ]
                assert np.any(matches)

    def test_several_children_and_various_fixed_n__keypoints(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 6, 3))
        self._test_several_children_and_various_fixed_n__cbaois(
            kpsoi, "augment_keypoints")

    def test_several_children_and_various_fixed_n__polygons(self):
        ps = [ia.Polygon([(0, 0), (3, 0), (3, 3), (0, 3)])]
        psoi = ia.PolygonsOnImage(ps, shape=(5, 6, 3))
        self._test_several_children_and_various_fixed_n__cbaois(
            psoi, "augment_polygons")

    def test_several_children_and_various_fixed_n__line_strings(self):
        ls = [ia.LineString([(0, 0), (3, 0), (3, 3), (0, 3)])]
        lsoi = ia.LineStringsOnImage(ls, shape=(5, 6, 3))
        self._test_several_children_and_various_fixed_n__cbaois(
            lsoi, "augment_line_strings")

    def test_several_children_and_various_fixed_n__bounding_boxes(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=3, y2=3)]
        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(5, 6, 3))
        self._test_several_children_and_various_fixed_n__cbaois(
            bbsoi, "augment_bounding_boxes")

    @classmethod
    def _test_empty_cbaoi(cls, cbaoi, augf_name):
        augs = [iaa.Affine(translate_px={"x": 1}),
                iaa.Affine(translate_px={"y": 1})]
        aug = iaa.SomeOf(n=2, children=augs)

        cbaoi_aug = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(cbaoi_aug, cbaoi)

    def test_empty_keypoints_on_image_instance(self):
        kpsoi = ia.KeypointsOnImage([], shape=(5, 6, 3))
        self._test_empty_cbaoi(kpsoi, "augment_keypoints")

    def test_empty_polygons_on_image_instance(self):
        psoi = ia.PolygonsOnImage([], shape=(5, 6, 3))
        self._test_empty_cbaoi(psoi, "augment_polygons")

    def test_empty_line_strings_on_image_instance(self):
        lsoi = ia.LineStringsOnImage([], shape=(5, 6, 3))
        self._test_empty_cbaoi(lsoi, "augment_line_strings")

    def test_empty_bounding_boxes_on_image_instance(self):
        bbsoi = ia.BoundingBoxesOnImage([], shape=(5, 6, 3))
        self._test_empty_cbaoi(bbsoi, "augment_bounding_boxes")

    def test_random_order_false__images(self):
        augs = [iaa.Multiply(2.0), iaa.Add(100)]
        aug = iaa.SomeOf(n=2, children=augs, random_order=False)
        p_observed = self._test_random_order(aug, 10)
        assert np.isclose(p_observed[0], 1.0, rtol=0, atol=1e-8)
        assert np.isclose(p_observed[1], 0.0, rtol=0, atol=1e-8)

    def test_random_order_true__images(self):
        augs = [iaa.Multiply(2.0), iaa.Add(100)]
        aug = iaa.SomeOf(n=2, children=augs, random_order=True)
        p_observed = self._test_random_order(aug, 300)
        assert np.isclose(p_observed[0], 0.5, rtol=0, atol=0.15)
        assert np.isclose(p_observed[1], 0.5, rtol=0, atol=0.15)

    @classmethod
    def _test_random_order(cls, aug, nb_iterations):
        zeros = np.ones((1, 1, 1), dtype=np.uint8)

        nb_observed = [0, 0]
        for i in sm.xrange(nb_iterations):
            observed = aug.augment_image(zeros)
            s = np.sum(observed)
            if s == (1*2)+100:
                nb_observed[0] += 1
            elif s == (1+100)*2:
                nb_observed[1] += 1
            else:
                raise Exception("Unexpected sum: %.8f (@2)" % (s,))

        p_observed = [n/nb_iterations for n in nb_observed]
        return p_observed

    @classmethod
    def _test_images_and_cbaoi_aligned(cls, cbaoi, augf_name):
        img = np.zeros((3, 3), dtype=np.uint8)
        img_x = np.copy(img)
        img_y = np.copy(img)
        img_xy = np.copy(img)
        img[1, 1] = 255
        img_x[1, 2] = 255
        img_y[2, 1] = 255
        img_xy[2, 2] = 255

        augs = [
            iaa.Affine(translate_px={"x": 1}, order=0),
            iaa.Affine(translate_px={"y": 1}, order=0)
        ]
        cbaoi_x = cbaoi.shift(x=1)
        cbaoi_y = cbaoi.shift(y=1)
        cbaoi_xy = cbaoi.shift(x=1, y=1)

        aug = iaa.SomeOf((0, 2), children=augs)
        seen = [False, False, False, False]
        for _ in sm.xrange(100):
            aug_det = aug.to_deterministic()
            img_aug = aug_det.augment_image(img)
            cbaoi_aug = getattr(aug_det, augf_name)(cbaoi)
            if np.array_equal(img_aug, img):
                assert_cbaois_equal(cbaoi_aug, cbaoi)
                seen[0] = True
            elif np.array_equal(img_aug, img_x):
                assert_cbaois_equal(cbaoi_aug, cbaoi_x)
                seen[1] = True
            elif np.array_equal(img_aug, img_y):
                assert_cbaois_equal(cbaoi_aug, cbaoi_y)
                seen[2] = True
            elif np.array_equal(img_aug, img_xy):
                assert_cbaois_equal(cbaoi_aug, cbaoi_xy)
                seen[3] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_images_and_keypoints_aligned(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=1)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 6, 3))
        self._test_images_and_cbaoi_aligned(kpsoi, "augment_keypoints")

    def test_images_and_polygons_aligned(self):
        ps = [ia.Polygon([(0, 0), (3, 0), (3, 3), (0, 3)])]
        psoi = ia.PolygonsOnImage(ps, shape=(5, 6, 3))
        self._test_images_and_cbaoi_aligned(psoi, "augment_polygons")

    def test_images_and_line_strings_aligned(self):
        ls = [ia.LineString([(0, 0), (3, 0), (3, 3), (0, 3)])]
        lsoi = ia.LineStringsOnImage(ls, shape=(5, 6, 3))
        self._test_images_and_cbaoi_aligned(lsoi, "augment_line_strings")

    def test_images_and_bounding_boxes_aligned(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=3, y2=3)]
        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(5, 6, 3))
        self._test_images_and_cbaoi_aligned(bbsoi, "augment_bounding_boxes")

    def test_invalid_argument_as_children(self):
        got_exception = False
        try:
            _ = iaa.SomeOf(1, children=False)
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_invalid_datatype_as_n(self):
        got_exception = False
        try:
            _ = iaa.SomeOf(False, children=iaa.Fliplr(1.0))
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_invalid_tuple_as_n(self):
        got_exception = False
        try:
            _ = iaa.SomeOf((2, "test"), children=iaa.Fliplr(1.0))
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_invalid_none_none_tuple_as_n(self):
        got_exception = False
        try:
            _ = iaa.SomeOf((None, None), children=iaa.Fliplr(1.0))
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_with_children_that_change_shapes_keep_size_false(self):
        # test for https://github.com/aleju/imgaug/issues/143
        # (shapes change in child augmenters, leading to problems if input
        # arrays are assumed to stay input arrays)
        image = np.zeros((8, 8, 3), dtype=np.uint8)
        aug = iaa.SomeOf(1, [
            iaa.Crop((2, 0, 2, 0), keep_size=False),
            iaa.Crop((1, 0, 1, 0), keep_size=False)
        ])
        expected_shapes = [(4, 8, 3), (6, 8, 3)]

        for _ in sm.xrange(10):
            observed = aug.augment_images(np.uint8([image] * 4))
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images([image] * 4)
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images(np.uint8([image]))
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_image(image)
            assert ia.is_np_array(image)
            assert observed.shape in expected_shapes

    def test_with_children_that_change_shapes_keep_size_true(self):
        image = np.zeros((8, 8, 3), dtype=np.uint8)
        aug = iaa.SomeOf(1, [
            iaa.Crop((2, 0, 2, 0), keep_size=True),
            iaa.Crop((1, 0, 1, 0), keep_size=True)
        ])
        expected_shapes = [(8, 8, 3)]

        for _ in sm.xrange(10):
            observed = aug.augment_images(np.uint8([image] * 4))
            assert ia.is_np_array(observed)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images([image] * 4)
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images(np.uint8([image]))
            assert ia.is_np_array(observed)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            assert np.all([img.shape in expected_shapes for img in observed])

            observed = aug.augment_image(image)
            assert ia.is_np_array(observed)
            assert observed.shape in expected_shapes

    def test_zero_sized_axes(self):
        shapes = [
            (0, 0),
            (0, 1),
            (1, 0),
            (0, 1, 0),
            (1, 0, 0),
            (0, 1, 1),
            (1, 0, 1)
        ]

        for shape in shapes:
            for random_order in [False, True]:
                with self.subTest(shape=shape):
                    image = np.zeros(shape, dtype=np.uint8)
                    aug = iaa.SomeOf(
                        1, [iaa.Identity()], random_order=random_order)

                    image_aug = aug(image=image)

                    assert image_aug.dtype.name == "uint8"
                    assert image_aug.shape == shape

    def test_unusual_channel_numbers(self):
        shapes = [
            (1, 1, 4),
            (1, 1, 5),
            (1, 1, 512),
            (1, 1, 513)
        ]

        for shape in shapes:
            for random_order in [False, True]:
                with self.subTest(shape=shape):
                    image = np.zeros(shape, dtype=np.uint8)
                    aug = iaa.SomeOf(
                        1, [iaa.Identity()], random_order=random_order)

                    image_aug = aug(image=image)

                    assert np.all(image_aug == 0)
                    assert image_aug.dtype.name == "uint8"
                    assert image_aug.shape == shape

    def test_other_dtypes_via_noop__bool(self):
        for random_order in [False, True]:
            with self.subTest(random_order=random_order):
                aug = iaa.SomeOf(2, [
                    iaa.Identity(),
                    iaa.Identity(),
                    iaa.Identity()
                ], random_order=random_order)

                image = np.zeros((3, 3), dtype=bool)
                image[0, 0] = True
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == image.dtype.name
                assert np.all(image_aug == image)

    def test_other_dtypes_via_noop__uint_int(self):
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        random_orders = [False, True]

        for dtype, random_order in itertools.product(dtypes, random_orders):
            with self.subTest(dtype=dtype, random_order=random_order):
                aug = iaa.SomeOf(2, [
                    iaa.Identity(),
                    iaa.Identity(),
                    iaa.Identity()
                ], random_order=random_order)

                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                image_aug = aug.augment_image(image)
                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_via_noop__float(self):
        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        random_orders = [False, True]

        for random_order in random_orders:
            for dtype, value in zip(dtypes, values):
                with self.subTest(dtype=dtype, random_order=random_order):
                    aug = iaa.SomeOf(2, [
                        iaa.Identity(),
                        iaa.Identity(),
                        iaa.Identity()
                    ], random_order=random_order)
                    image = np.zeros((3, 3), dtype=dtype)
                    image[0, 0] = value
                    image_aug = aug.augment_image(image)
                    assert image_aug.dtype.name == dtype
                    assert np.all(image_aug == image)

    def test_other_dtypes_via_flip__bool(self):
        for random_order in [False, True]:
            with self.subTest(random_order=random_order):
                aug = iaa.SomeOf(2, [
                    iaa.Fliplr(1.0),
                    iaa.Flipud(1.0),
                    iaa.Identity()
                ], random_order=random_order)

                image = np.zeros((3, 3), dtype=bool)
                image[0, 0] = True
                expected = [np.zeros((3, 3), dtype=bool)
                            for _ in sm.xrange(3)]
                expected[0][0, 2] = True
                expected[1][2, 0] = True
                expected[2][2, 2] = True

                for _ in sm.xrange(10):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == image.dtype.name
                    assert any([np.all(image_aug == expected_i)
                                for expected_i in expected])

    def test_other_dtypes_via_flip__uint_int(self):
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        random_orders = [False, True]

        for dtype, random_order in itertools.product(dtypes, random_orders):
            with self.subTest(dtype=dtype, random_order=random_order):
                aug = iaa.SomeOf(2, [
                    iaa.Fliplr(1.0),
                    iaa.Flipud(1.0),
                    iaa.Identity()
                ], random_order=random_order)

                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = [np.zeros((3, 3), dtype=dtype)
                            for _ in sm.xrange(3)]
                expected[0][0, 2] = value
                expected[1][2, 0] = value
                expected[2][2, 2] = value

                for _ in sm.xrange(10):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == dtype
                    assert any([np.all(image_aug == expected_i)
                                for expected_i in expected])

    def test_other_dtypes_via_flip__float(self):
        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        random_orders = [False, True]

        for random_order in random_orders:
            for dtype, value in zip(dtypes, values):
                with self.subTest(dtype=dtype, random_order=random_order):
                    aug = iaa.SomeOf(2, [
                        iaa.Fliplr(1.0),
                        iaa.Flipud(1.0),
                        iaa.Identity()
                    ], random_order=random_order)

                    image = np.zeros((3, 3), dtype=dtype)
                    image[0, 0] = value
                    expected = [np.zeros((3, 3), dtype=dtype)
                                for _ in sm.xrange(3)]
                    expected[0][0, 2] = value
                    expected[1][2, 0] = value
                    expected[2][2, 2] = value

                    for _ in sm.xrange(10):
                        image_aug = aug.augment_image(image)

                        assert image_aug.dtype.name == dtype
                        assert any([np.all(image_aug == expected_i)
                                    for expected_i in expected])

    def test_pickleable(self):
        aug = iaa.SomeOf((0, 3),
            [iaa.Add(1, seed=1),
             iaa.Add(2, seed=2),
             iaa.Multiply(1.5, seed=3),
             iaa.Multiply(2.0, seed=4)],
            random_order=True,
            seed=5)
        runtest_pickleable_uint8_img(aug, iterations=5)

    def test_get_children_lists(self):
        child = iaa.Identity()
        aug = iaa.SomeOf(1, [child])
        children_lsts = aug.get_children_lists()
        assert len(children_lsts) == 1
        assert len(children_lsts[0]) == 1
        assert children_lsts[0][0] is child

    def test_to_deterministic(self):
        child = iaa.Identity()
        aug = iaa.SomeOf(1, [child])

        aug_det = aug.to_deterministic()

        assert aug_det.random_state is not aug.random_state
        assert aug_det.deterministic
        assert aug_det[0].deterministic


class TestOneOf(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_returns_someof(self):
        child = iaa.Identity()
        aug = iaa.OneOf(children=child)
        assert isinstance(aug, iaa.SomeOf)
        assert aug.n == 1
        assert aug[0] is child

    def test_single_child_that_is_augmenter(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        aug = iaa.OneOf(children=iaa.Add(1))
        observed = aug.augment_image(zeros)
        assert np.array_equal(observed, zeros + 1)

    def test_single_child_that_is_sequential(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        aug = iaa.OneOf(children=iaa.Sequential([iaa.Add(1)]))
        observed = aug.augment_image(zeros)
        assert np.array_equal(observed, zeros + 1)

    def test_single_child_that_is_list(self):
        zeros = np.zeros((3, 3, 1), dtype=np.uint8)
        aug = iaa.OneOf(children=[iaa.Add(1)])
        observed = aug.augment_image(zeros)
        assert np.array_equal(observed, zeros + 1)

    def test_three_children(self):
        zeros = np.zeros((1, 1, 1), dtype=np.uint8)
        augs = [iaa.Add(1), iaa.Add(2), iaa.Add(3)]
        aug = iaa.OneOf(augs)

        results = {1: 0, 2: 0, 3: 0}
        nb_iterations = 1000
        for _ in sm.xrange(nb_iterations):
            result = aug.augment_image(zeros)
            s = int(np.sum(result))
            results[s] += 1

        expected = int(nb_iterations / len(augs))
        tolerance = int(nb_iterations * 0.05)
        for key, val in results.items():
            assert np.isclose(val, expected, rtol=0, atol=tolerance)
        assert len(list(results.keys())) == 3

    def test_pickleable(self):
        aug = iaa.OneOf(
            [iaa.Add(1, seed=1),
             iaa.Add(10, seed=2),
             iaa.Multiply(2.0, seed=3)],
            seed=4)
        runtest_pickleable_uint8_img(aug, iterations=5)

    def test_get_children_lists(self):
        child = iaa.Identity()
        aug = iaa.OneOf([child])
        children_lsts = aug.get_children_lists()
        assert len(children_lsts) == 1
        assert len(children_lsts[0]) == 1
        assert children_lsts[0][0] is child

    def test_to_deterministic(self):
        child = iaa.Identity()
        aug = iaa.OneOf([child])

        aug_det = aug.to_deterministic()

        assert aug_det.random_state is not aug.random_state
        assert aug_det.deterministic
        assert aug_det[0].deterministic


class TestSometimes(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def image(self):
        image = np.array([[0, 1, 1],
                          [0, 0, 1],
                          [0, 0, 1]], dtype=np.uint8) * 255
        return np.atleast_3d(image)

    @property
    def images(self):
        return np.uint8([self.image])

    @property
    def image_lr(self):
        image_lr = np.array([[1, 1, 0],
                             [1, 0, 0],
                             [1, 0, 0]], dtype=np.uint8) * 255
        return np.atleast_3d(image_lr)

    @property
    def images_lr(self):
        return np.uint8([self.image_lr])

    @property
    def image_ud(self):
        image_ud = np.array([[0, 0, 1],
                             [0, 0, 1],
                             [0, 1, 1]], dtype=np.uint8) * 255
        return np.atleast_3d(image_ud)

    @property
    def images_ud(self):
        return np.uint8([self.image_ud])

    @property
    def keypoints(self):
        keypoints = [ia.Keypoint(x=1, y=0),
                     ia.Keypoint(x=2, y=0),
                     ia.Keypoint(x=2, y=1)]
        return ia.KeypointsOnImage(keypoints, shape=self.image.shape)

    @property
    def keypoints_lr(self):
        keypoints = [ia.Keypoint(x=3-1, y=0),
                     ia.Keypoint(x=3-2, y=0),
                     ia.Keypoint(x=3-2, y=1)]
        return ia.KeypointsOnImage(keypoints, shape=self.image.shape)

    @property
    def keypoints_ud(self):
        keypoints = [ia.Keypoint(x=1, y=3-0),
                     ia.Keypoint(x=2, y=3-0),
                     ia.Keypoint(x=2, y=3-1)]
        return ia.KeypointsOnImage(keypoints, shape=self.image.shape)

    @property
    def polygons(self):
        polygons = [ia.Polygon([(0, 0), (2, 0), (2, 2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image.shape)

    @property
    def polygons_lr(self):
        polygons = [ia.Polygon([(3-0, 0), (3-2, 0), (3-2, 2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image.shape)

    @property
    def polygons_ud(self):
        polygons = [ia.Polygon([(0, 3-0), (2, 3-0), (2, 3-2)])]
        return ia.PolygonsOnImage(polygons, shape=self.image.shape)

    @property
    def lsoi(self):
        lss = [ia.LineString([(0, 0), (2, 0), (2, 2)])]
        return ia.LineStringsOnImage(lss, shape=self.image.shape)

    @property
    def lsoi_lr(self):
        lss = [ia.LineString([(3-0, 0), (3-2, 0), (3-2, 2)])]
        return ia.LineStringsOnImage(lss, shape=self.image.shape)

    @property
    def lsoi_ud(self):
        lss = [ia.LineString([(0, 3-0), (2, 3-0), (2, 3-2)])]
        return ia.LineStringsOnImage(lss, shape=self.image.shape)

    @property
    def bbsoi(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=1.5, y2=1.0)]
        return ia.BoundingBoxesOnImage(bbs, shape=self.image.shape)

    @property
    def bbsoi_lr(self):
        x1 = 3-0
        y1 = 0
        x2 = 3-1.5
        y2 = 1.0
        bbs = [ia.BoundingBox(x1=min([x1, x2]), y1=min([y1, y2]),
                              x2=max([x1, x2]), y2=max([y1, y2]))]
        return ia.BoundingBoxesOnImage(bbs, shape=self.image.shape)

    @property
    def bbsoi_ud(self):
        x1 = 0
        y1 = 3-0
        x2 = 1.5
        y2 = 3-1.0
        bbs = [ia.BoundingBox(x1=min([x1, x2]), y1=min([y1, y2]),
                              x2=max([x1, x2]), y2=max([y1, y2]))]
        return ia.BoundingBoxesOnImage(bbs, shape=self.image.shape)

    @property
    def heatmaps(self):
        heatmaps_arr = np.float32([[0.0, 0.0, 1.0],
                                   [0.0, 0.0, 1.0],
                                   [0.0, 1.0, 1.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))

    @property
    def heatmaps_lr(self):
        heatmaps_arr = np.float32([[1.0, 0.0, 0.0],
                                   [1.0, 0.0, 0.0],
                                   [1.0, 1.0, 0.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))

    @property
    def heatmaps_ud(self):
        heatmaps_arr = np.float32([[0.0, 1.0, 1.0],
                                   [0.0, 0.0, 1.0],
                                   [0.0, 0.0, 1.0]])
        return ia.HeatmapsOnImage(heatmaps_arr, shape=(3, 3, 3))

    @property
    def segmaps(self):
        segmaps_arr = np.int32([[0, 0, 1],
                                [0, 0, 1],
                                [0, 1, 1]])
        return ia.SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))

    @property
    def segmaps_lr(self):
        segmaps_arr = np.int32([[1, 0, 0],
                                [1, 0, 0],
                                [1, 1, 0]])
        return ia.SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))

    @property
    def segmaps_ud(self):
        segmaps_arr = np.int32([[0, 1, 1],
                                [0, 0, 1],
                                [0, 0, 1]])
        return ia.SegmentationMapsOnImage(segmaps_arr, shape=(3, 3, 3))

    def test_two_branches_always_first__images(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_images(self.images)

        assert np.array_equal(observed, self.images_lr)

    def test_two_branches_always_first__images__deterministic(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()
        observed = aug_det.augment_images(self.images)
        assert np.array_equal(observed, self.images_lr)

    def test_two_branches_always_first__images__list(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        observed = aug.augment_images([self.images[0]])
        assert array_equal_lists(observed, [self.images_lr[0]])

    def test_two_branches_always_first__images__deterministic__list(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()
        observed = aug_det.augment_images([self.images[0]])
        assert array_equal_lists(observed, [self.images_lr[0]])

    def test_two_branches_always_first__keypoints(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        observed = aug.augment_keypoints(self.keypoints)
        assert keypoints_equal(observed, self.keypoints_lr)

    def test_two_branches_always_first__keypoints__deterministic(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_keypoints(self.keypoints)

        assert_cbaois_equal(observed, self.keypoints_lr)

    def test_two_branches_always_first__polygons(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_polygons([self.polygons])

        assert_cbaois_equal(observed, [self.polygons_lr])

    def test_two_branches_always_first__polygons__deterministic(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_polygons([self.polygons])

        assert_cbaois_equal(observed, [self.polygons_lr])

    def test_two_branches_always_first__line_strings(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_line_strings([self.lsoi])

        assert_cbaois_equal(observed, [self.lsoi_lr])

    def test_two_branches_always_first__line_strings__deterministic(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_line_strings([self.lsoi])

        assert_cbaois_equal(observed, [self.lsoi_lr])

    def test_two_branches_always_first__bounding_boxes(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_bounding_boxes([self.bbsoi])

        assert_cbaois_equal(observed, [self.bbsoi_lr])

    def test_two_branches_always_first__bounding_boxes__deterministic(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_bounding_boxes([self.bbsoi])

        assert_cbaois_equal(observed, [self.bbsoi_lr])

    def test_two_branches_always_first__heatmaps(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_heatmaps([self.heatmaps])[0]

        assert observed.shape == self.heatmaps.shape
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.array_equal(observed.get_arr(), self.heatmaps_lr.get_arr())

    def test_two_branches_always_first__segmaps(self):
        aug = iaa.Sometimes(1.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_segmentation_maps(self.segmaps)

        assert observed.shape == self.segmaps.shape
        assert np.array_equal(observed.get_arr(), self.segmaps_lr.get_arr())

    def test_two_branches_always_second__images(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        observed = aug.augment_images(self.images)
        assert np.array_equal(observed, self.images_ud)

    def test_two_branches_always_second__images__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()
        observed = aug_det.augment_images(self.images)
        assert np.array_equal(observed, self.images_ud)

    def test_two_branches_always_second__images__list(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        observed = aug.augment_images([self.images[0]])
        assert array_equal_lists(observed, [self.images_ud[0]])

    def test_two_branches_always_second__images__list__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()
        observed = aug_det.augment_images([self.images[0]])
        assert array_equal_lists(observed, [self.images_ud[0]])

    def test_two_branches_always_second__keypoints(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_keypoints([self.keypoints])

        assert_cbaois_equal(observed[0], self.keypoints_ud)

    def test_two_branches_always_second__keypoints__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_keypoints([self.keypoints])

        assert_cbaois_equal(observed[0], self.keypoints_ud)

    def test_two_branches_always_second__polygons(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_polygons(self.polygons)

        assert_cbaois_equal(observed, self.polygons_ud)

    def test_two_branches_always_second__polygons__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_polygons(self.polygons)

        assert_cbaois_equal(observed, self.polygons_ud)

    def test_two_branches_always_second__line_strings(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_line_strings(self.lsoi)

        assert_cbaois_equal(observed, self.lsoi_ud)

    def test_two_branches_always_second__line_strings__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_line_strings(self.lsoi)

        assert_cbaois_equal(observed, self.lsoi_ud)

    def test_two_branches_always_second__bounding_boxes(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_bounding_boxes(self.bbsoi)

        assert_cbaois_equal(observed, self.bbsoi_ud)

    def test_two_branches_always_second__bounding_boxes__deterministic(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()

        observed = aug_det.augment_bounding_boxes(self.bbsoi)

        assert_cbaois_equal(observed, self.bbsoi_ud)

    def test_two_branches_always_second__heatmaps(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_heatmaps(self.heatmaps)

        assert observed.shape == self.heatmaps.shape
        assert 0 - 1e-6 < observed.min_value < 0 + 1e-6
        assert 1 - 1e-6 < observed.max_value < 1 + 1e-6
        assert np.array_equal(observed.get_arr(), self.heatmaps_ud.get_arr())

    def test_two_branches_always_second__segmaps(self):
        aug = iaa.Sometimes(0.0, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])

        observed = aug.augment_segmentation_maps(self.segmaps)

        assert observed.shape == self.segmaps.shape
        assert np.array_equal(observed.get_arr(), self.segmaps_ud.get_arr())

    def test_two_branches_both_50_percent__images(self):
        aug = iaa.Sometimes(0.5, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        last_aug = None
        nb_changed_aug = 0
        nb_iterations = 500
        nb_images_if_branch = 0
        nb_images_else_branch = 0
        for i in sm.xrange(nb_iterations):
            observed_aug = aug.augment_images(self.images)
            if i == 0:
                last_aug = observed_aug
            else:
                if not np.array_equal(observed_aug, last_aug):
                    nb_changed_aug += 1
                last_aug = observed_aug

            if np.array_equal(observed_aug, self.images_lr):
                nb_images_if_branch += 1
            elif np.array_equal(observed_aug, self.images_ud):
                nb_images_else_branch += 1
            else:
                raise Exception(
                    "Received output doesnt match any expected output.")

        p_if_branch = nb_images_if_branch / nb_iterations
        p_else_branch = nb_images_else_branch / nb_iterations
        p_changed = 1 - (nb_changed_aug / nb_iterations)

        assert np.isclose(p_if_branch, 0.5, rtol=0, atol=0.1)
        assert np.isclose(p_else_branch, 0.5, rtol=0, atol=0.1)
        # should be the same in roughly 50% of all cases
        assert np.isclose(p_changed, 0.5, rtol=0, atol=0.1)

    def test_two_branches_both_50_percent__images__deterministic(self):
        aug = iaa.Sometimes(0.5, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        aug_det = aug.to_deterministic()
        last_aug_det = None
        nb_changed_aug_det = 0
        nb_iterations = 20
        for i in sm.xrange(nb_iterations):
            observed_aug_det = aug_det.augment_images(self.images)
            if i == 0:
                last_aug_det = observed_aug_det
            else:
                if not np.array_equal(observed_aug_det, last_aug_det):
                    nb_changed_aug_det += 1
                last_aug_det = observed_aug_det

        assert nb_changed_aug_det == 0

    @classmethod
    def _test_two_branches_both_50_percent__cbaois(
            cls, cbaoi, cbaoi_lr, cbaoi_ud, augf_name):
        def _same_coords(cbaoi1, cbaoi2):
            assert len(cbaoi1.items) == len(cbaoi2.items)
            for i1, i2 in zip(cbaoi1.items, cbaoi2.items):
                if not np.allclose(i1.coords, i2.coords, atol=1e-4, rtol=0):
                    return False
            return True

        aug = iaa.Sometimes(0.5, [iaa.Fliplr(1.0)], [iaa.Flipud(1.0)])
        nb_iterations = 250
        nb_if_branch = 0
        nb_else_branch = 0
        for i in sm.xrange(nb_iterations):
            cbaoi_aug = getattr(aug, augf_name)(cbaoi)

            # use allclose() instead of coords_almost_equals() for efficiency
            if _same_coords(cbaoi_aug, cbaoi_lr):
                nb_if_branch += 1
            elif _same_coords(cbaoi_aug, cbaoi_ud):
                nb_else_branch += 1
            else:
                raise Exception(
                    "Received output doesnt match any expected output.")

        p_if_branch = nb_if_branch / nb_iterations
        p_else_branch = nb_else_branch / nb_iterations

        assert np.isclose(p_if_branch, 0.5, rtol=0, atol=0.15)
        assert np.isclose(p_else_branch, 0.5, rtol=0, atol=0.15)

    def test_two_branches_both_50_percent__keypoints(self):
        self._test_two_branches_both_50_percent__cbaois(
            self.keypoints, self.keypoints_lr, self.keypoints_ud,
            "augment_keypoints")

    def test_two_branches_both_50_percent__polygons(self):
        self._test_two_branches_both_50_percent__cbaois(
            self.polygons, self.polygons_lr, self.polygons_ud,
            "augment_polygons")

    def test_two_branches_both_50_percent__line_strings(self):
        self._test_two_branches_both_50_percent__cbaois(
            self.lsoi, self.lsoi_lr, self.lsoi_ud,
            "augment_line_strings")

    def test_two_branches_both_50_percent__bounding_boxes(self):
        self._test_two_branches_both_50_percent__cbaois(
            self.bbsoi, self.bbsoi_lr, self.bbsoi_ud,
            "augment_bounding_boxes")

    def test_one_branch_50_percent__images(self):
        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0))
        last_aug = None
        nb_changed_aug = 0
        nb_iterations = 500
        nb_images_if_branch = 0
        nb_images_else_branch = 0
        for i in sm.xrange(nb_iterations):
            observed_aug = aug.augment_images(self.images)
            if i == 0:
                last_aug = observed_aug
            else:
                if not np.array_equal(observed_aug, last_aug):
                    nb_changed_aug += 1
                last_aug = observed_aug

            if np.array_equal(observed_aug, self.images_lr):
                nb_images_if_branch += 1
            elif np.array_equal(observed_aug, self.images):
                nb_images_else_branch += 1
            else:
                raise Exception(
                    "Received output doesnt match any expected output.")

        p_if_branch = nb_images_if_branch / nb_iterations
        p_else_branch = nb_images_else_branch / nb_iterations
        p_changed = 1 - (nb_changed_aug / nb_iterations)

        assert np.isclose(p_if_branch, 0.5, rtol=0, atol=0.1)
        assert np.isclose(p_else_branch, 0.5, rtol=0, atol=0.1)
        # should be the same in roughly 50% of all cases
        assert np.isclose(p_changed, 0.5, rtol=0, atol=0.1)

    def test_one_branch_50_percent__images__deterministic(self):
        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0))
        aug_det = aug.to_deterministic()
        last_aug_det = None
        nb_changed_aug_det = 0
        nb_iterations = 10
        for i in sm.xrange(nb_iterations):
            observed_aug_det = aug_det.augment_images(self.images)
            if i == 0:
                last_aug_det = observed_aug_det
            else:
                if not np.array_equal(observed_aug_det, last_aug_det):
                    nb_changed_aug_det += 1
                last_aug_det = observed_aug_det

        assert nb_changed_aug_det == 0

    @classmethod
    def _test_one_branch_50_percent__cbaois(
            cls, cbaoi, cbaoi_lr, augf_name):
        def _same_coords(cbaoi1, cbaoi2):
            assert len(cbaoi1.items) == len(cbaoi2.items)
            for i1, i2 in zip(cbaoi1.items, cbaoi2.items):
                if not np.allclose(i1.coords, i2.coords, atol=1e-4, rtol=0):
                    return False
            return True

        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0))
        nb_iterations = 250
        nb_if_branch = 0
        nb_else_branch = 0
        for i in sm.xrange(nb_iterations):
            cbaoi_aug = getattr(aug, augf_name)(cbaoi)

            # use allclose() instead of coords_almost_equals() for efficiency
            if _same_coords(cbaoi_aug, cbaoi_lr):
                nb_if_branch += 1
            elif _same_coords(cbaoi_aug, cbaoi):
                nb_else_branch += 1
            else:
                raise Exception(
                    "Received output doesnt match any expected output.")

        p_if_branch = nb_if_branch / nb_iterations
        p_else_branch = nb_else_branch / nb_iterations

        assert np.isclose(p_if_branch, 0.5, rtol=0, atol=0.15)
        assert np.isclose(p_else_branch, 0.5, rtol=0, atol=0.15)

    def test_one_branch_50_percent__keypoints(self):
        self._test_one_branch_50_percent__cbaois(
            self.keypoints, self.keypoints_lr, "augment_keypoints")

    def test_one_branch_50_percent__polygons(self):
        self._test_one_branch_50_percent__cbaois(
            self.polygons, self.polygons_lr, "augment_polygons")

    def test_one_branch_50_percent__bounding_boxes(self):
        self._test_one_branch_50_percent__cbaois(
            self.bbsoi, self.bbsoi_lr, "augment_bounding_boxes")

    @classmethod
    def _test_empty_cbaoi(cls, cbaoi, augf_name):
        aug = iaa.Sometimes(0.5, iaa.Identity())

        observed = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(observed, cbaoi)

    def test_empty_keypoints(self):
        kpsoi = ia.KeypointsOnImage([], shape=(1, 2, 3))
        self._test_empty_cbaoi(kpsoi, "augment_keypoints")

    def test_empty_polygons(self):
        psoi = ia.PolygonsOnImage([], shape=(1, 2, 3))
        self._test_empty_cbaoi(psoi, "augment_polygons")

    def test_empty_line_strings(self):
        lsoi = ia.LineStringsOnImage([], shape=(1, 2, 3))
        self._test_empty_cbaoi(lsoi, "augment_line_strings")

    def test_empty_bounding_boxes(self):
        bbsoi = ia.BoundingBoxesOnImage([], shape=(1, 2, 3))
        self._test_empty_cbaoi(bbsoi, "augment_bounding_boxes")

    def test_p_is_stochastic_parameter(self):
        image = np.zeros((1, 1), dtype=np.uint8) + 100
        images = [image] * 10
        aug = iaa.Sometimes(
            p=iap.Binomial(iap.Choice([0.0, 1.0])),
            then_list=iaa.Add(10))

        seen = [0, 0]
        for _ in sm.xrange(100):
            observed = aug.augment_images(images)
            uq = np.unique(np.uint8(observed))
            assert len(uq) == 1
            if uq[0] == 100:
                seen[0] += 1
            elif uq[0] == 110:
                seen[1] += 1
            else:
                assert False
        assert seen[0] > 20
        assert seen[1] > 20

    def test_bad_datatype_for_p_fails(self):
        got_exception = False
        try:
            _ = iaa.Sometimes(p="foo")
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_bad_datatype_for_then_list_fails(self):
        got_exception = False
        try:
            _ = iaa.Sometimes(p=0.2, then_list=False)
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_bad_datatype_for_else_list_fails(self):
        got_exception = False
        try:
            _ = iaa.Sometimes(p=0.2, then_list=None, else_list=False)
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_two_branches_both_none(self):
        aug = iaa.Sometimes(0.2, then_list=None, else_list=None)
        image = np.random.randint(0, 255, size=(16, 16), dtype=np.uint8)
        observed = aug.augment_image(image)
        assert np.array_equal(observed, image)

    def test_using_hooks_to_deactivate_propagation(self):
        image = np.random.randint(0, 255-10, size=(16, 16), dtype=np.uint8)
        aug = iaa.Sometimes(1.0, iaa.Add(10))

        def _propagator(images, augmenter, parents, default):
            return False if augmenter == aug else default

        hooks = ia.HooksImages(propagator=_propagator)

        observed1 = aug.augment_image(image)
        observed2 = aug.augment_image(image, hooks=hooks)
        assert np.array_equal(observed1, image + 10)
        assert np.array_equal(observed2, image)

    def test_zero_sized_axes(self):
        shapes = [
            (0, 0),
            (0, 1),
            (1, 0),
            (0, 1, 0),
            (1, 0, 0),
            (0, 1, 1),
            (1, 0, 1)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.Sometimes(1.0, iaa.Identity())

                image_aug = aug(image=image)

                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_unusual_channel_numbers(self):
        shapes = [
            (1, 1, 4),
            (1, 1, 5),
            (1, 1, 512),
            (1, 1, 513)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.Sometimes(1.0, iaa.Identity())

                image_aug = aug(image=image)

                assert np.all(image_aug == 0)
                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_get_parameters(self):
        aug = iaa.Sometimes(0.75)
        params = aug.get_parameters()
        assert is_parameter_instance(params[0], iap.Binomial)
        assert is_parameter_instance(params[0].p, iap.Deterministic)
        assert 0.75 - 1e-8 < params[0].p.value < 0.75 + 1e-8

    def test___str___and___repr__(self):
        then_list = iaa.Add(1)
        else_list = iaa.Add(2)
        aug = iaa.Sometimes(
            0.5,
            then_list=then_list,
            else_list=else_list,
            name="SometimesTest")

        expected_then_list = (
            "Sequential("
            "name=SometimesTest-then, "
            "random_order=False, "
            "children=[%s], "
            "deterministic=False"
            ")" % (str(then_list),))
        expected_else_list = (
            "Sequential("
            "name=SometimesTest-else, "
            "random_order=False, "
            "children=[%s], "
            "deterministic=False"
            ")" % (str(else_list),))
        expected = (
            "Sometimes("
            "p=%s, name=%s, then_list=%s, else_list=%s, deterministic=%s"
            ")" % (
                str(aug.p),
                "SometimesTest",
                expected_then_list,
                expected_else_list,
                "False"))

        observed_str = aug.__str__()
        observed_repr = aug.__repr__()

        assert observed_str == expected
        assert observed_repr == expected

    def test___str___and___repr___with_nones_as_children(self):
        aug = iaa.Sometimes(
            0.5,
            then_list=None,
            else_list=None,
            name="SometimesTest")

        expected = (
            "Sometimes("
            "p=%s, "
            "name=%s, "
            "then_list=%s, "
            "else_list=%s, "
            "deterministic=%s"
            ")" % (
                str(aug.p),
                "SometimesTest",
                "None",
                "None",
                "False"))

        observed_str = aug.__str__()
        observed_repr = aug.__repr__()

        assert observed_str == expected
        assert observed_repr == expected

    def test_shapes_changed_by_children__no_keep_size_non_stochastic(self):
        # Test for https://github.com/aleju/imgaug/issues/143
        # (shapes change in child augmenters, leading to problems if input
        # arrays are assumed to stay input arrays)
        def _assert_all_valid_shapes(images):
            expected_shapes = [(4, 8, 3), (6, 8, 3)]
            assert np.all([img.shape in expected_shapes for img in images])

        image = np.zeros((8, 8, 3), dtype=np.uint8)
        aug = iaa.Sometimes(
            0.5,
            iaa.Crop((2, 0, 2, 0), keep_size=False),
            iaa.Crop((1, 0, 1, 0), keep_size=False)
        )

        for _ in sm.xrange(10):
            observed = aug.augment_images(
                np.uint8([image, image, image, image]))
            assert isinstance(observed, list) or ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image, image, image, image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images(np.uint8([image]))
            assert isinstance(observed, list) or ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_image(image)
            assert ia.is_np_array(image)
            _assert_all_valid_shapes([observed])

    def test_shapes_changed_by_children__no_keep_size_stochastic(self):
        def _assert_all_valid_shapes(images):
            assert np.all([
                16 <= img.shape[0] <= 30
                and img.shape[1:] == (32, 3) for img in images
            ])

        image = np.zeros((32, 32, 3), dtype=np.uint8)
        aug = iaa.Sometimes(
            0.5,
            iaa.Crop(((1, 4), 0, (1, 4), 0), keep_size=False),
            iaa.Crop(((4, 8), 0, (4, 8), 0), keep_size=False)
        )

        for _ in sm.xrange(10):
            observed = aug.augment_images(
                np.uint8([image, image, image, image]))
            assert isinstance(observed, list) or ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image, image, image, image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images(np.uint8([image]))
            assert isinstance(observed, list)  or ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_image(image)
            assert ia.is_np_array(image)
            _assert_all_valid_shapes([observed])

    def test_shapes_changed_by_children__keep_size_non_stochastic(self):
        def _assert_all_valid_shapes(images):
            expected_shapes = [(8, 8, 3)]
            assert np.all([img.shape in expected_shapes for img in images])

        image = np.zeros((8, 8, 3), dtype=np.uint8)
        aug = iaa.Sometimes(
            0.5,
            iaa.Crop((2, 0, 2, 0), keep_size=True),
            iaa.Crop((1, 0, 1, 0), keep_size=True)
        )

        for _ in sm.xrange(10):
            observed = aug.augment_images(
                np.uint8([image, image, image, image]))
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image, image, image, image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images(np.uint8([image]))
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_image(image)
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes([observed])

    def test_shapes_changed_by_children__keep_size_stochastic(self):
        def _assert_all_valid_shapes(images):
            # only one shape expected here despite stochastic crop ranges
            # due to keep_size=True
            expected_shapes = [(8, 8, 3)]
            assert np.all([img.shape in expected_shapes for img in images])

        image = np.zeros((8, 8, 3), dtype=np.uint8)
        aug = iaa.Sometimes(
            0.5,
            iaa.Crop(((1, 4), 0, (1, 4), 0), keep_size=True),
            iaa.Crop(((4, 8), 0, (4, 8), 0), keep_size=True)
        )

        for _ in sm.xrange(10):
            observed = aug.augment_images(
                np.uint8([image, image, image, image]))
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image, image, image, image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images(np.uint8([image]))
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_images([image])
            assert isinstance(observed, list)
            _assert_all_valid_shapes(observed)

            observed = aug.augment_image(image)
            assert ia.is_np_array(observed)
            _assert_all_valid_shapes([observed])

    def test_other_dtypes_via_noop__bool(self):
        aug = iaa.Sometimes(1.0, iaa.Identity())
        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True

        image_aug = aug.augment_image(image)

        assert image_aug.dtype.name == image.dtype.name
        assert np.all(image_aug == image)

    def test_other_dtypes_via_noop__uint_int(self):
        aug = iaa.Sometimes(1.0, iaa.Identity())
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, _center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_via_noop__float(self):
        aug = iaa.Sometimes(1.0, iaa.Identity())

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128
        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == image)

    def test_other_dtypes_via_flip__bool(self):
        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0), iaa.Flipud(1.0))
        image = np.zeros((3, 3), dtype=bool)
        image[0, 0] = True
        expected = [np.zeros((3, 3), dtype=bool) for _ in sm.xrange(2)]
        expected[0][0, 2] = True
        expected[1][2, 0] = True
        seen = [False, False]
        for _ in sm.xrange(100):
            image_aug = aug.augment_image(image)

            assert image_aug.dtype.name == image.dtype.name
            if np.all(image_aug == expected[0]):
                seen[0] = True
            elif np.all(image_aug == expected[1]):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_other_dtypes_via_flip__uint_int(self):
        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0), iaa.Flipud(1.0))
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, _center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = [np.zeros((3, 3), dtype=dtype) for _ in sm.xrange(2)]
                expected[0][0, 2] = value
                expected[1][2, 0] = value
                seen = [False, False]
                for _ in sm.xrange(100):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == dtype
                    if np.all(image_aug == expected[0]):
                        seen[0] = True
                    elif np.all(image_aug == expected[1]):
                        seen[1] = True
                    else:
                        assert False
                    if np.all(seen):
                        break
                assert np.all(seen)

    def test_other_dtypes_via_flip__float(self):
        aug = iaa.Sometimes(0.5, iaa.Fliplr(1.0), iaa.Flipud(1.0))

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128

        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3), dtype=dtype)
                image[0, 0] = value
                expected = [np.zeros((3, 3), dtype=dtype) for _ in sm.xrange(2)]
                expected[0][0, 2] = value
                expected[1][2, 0] = value
                seen = [False, False]
                for _ in sm.xrange(100):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == dtype
                    if np.all(image_aug == expected[0]):
                        seen[0] = True
                    elif np.all(image_aug == expected[1]):
                        seen[1] = True
                    else:
                        assert False
                    if np.all(seen):
                        break
                assert np.all(seen)

    def test_pickleable(self):
        aug = iaa.Sometimes(0.5, iaa.Add(10), [iaa.Add(1), iaa.Multiply(2.0)],
                            seed=1)
        runtest_pickleable_uint8_img(aug, iterations=5)

    def test_get_children_lists(self):
        child = iaa.Identity()
        aug = iaa.Sometimes(0.5, [child])
        children_lsts = aug.get_children_lists()
        assert len(children_lsts) == 1
        assert len(children_lsts[0]) == 1
        assert children_lsts[0][0] is child

    def test_get_children_lists_both_lists(self):
        child = iaa.Identity()
        child2 = iaa.Identity()
        aug = iaa.Sometimes(0.5, [child], [child2])
        children_lsts = aug.get_children_lists()
        assert len(children_lsts) == 2
        assert len(children_lsts[0]) == 1
        assert len(children_lsts[1]) == 1
        assert children_lsts[0][0] is child
        assert children_lsts[1][0] is child2

    def test_to_deterministic(self):
        child = iaa.Identity()
        child2 = iaa.Identity()
        aug = iaa.Sometimes(0.5, [child], [child2])

        aug_det = aug.to_deterministic()

        assert aug_det.deterministic
        assert aug_det.random_state is not aug.random_state
        assert aug_det.then_list[0].deterministic
        assert aug_det.else_list[0].deterministic


class TestWithChannels(unittest.TestCase):
    def setUp(self):
        reseed()

    @property
    def image(self):
        base_img = np.zeros((3, 3, 2), dtype=np.uint8)
        base_img[..., 0] += 100
        base_img[..., 1] += 200
        return base_img

    def test_augment_only_channel_0(self):
        aug = iaa.WithChannels(0, iaa.Add(10))
        observed = aug.augment_image(self.image)
        expected = self.image
        expected[..., 0] += 10
        assert np.allclose(observed, expected)

    def test_augment_only_channel_1(self):
        aug = iaa.WithChannels(1, iaa.Add(10))
        observed = aug.augment_image(self.image)
        expected = self.image
        expected[..., 1] += 10
        assert np.allclose(observed, expected)

    def test_augment_all_channels_via_none(self):
        aug = iaa.WithChannels(None, iaa.Add(10))
        observed = aug.augment_image(self.image)
        expected = self.image + 10
        assert np.allclose(observed, expected)

    def test_augment_channels_0_and_1_via_list(self):
        aug = iaa.WithChannels([0, 1], iaa.Add(10))
        observed = aug.augment_image(self.image)
        expected = self.image + 10
        assert np.allclose(observed, expected)

    def test_apply_multiple_augmenters(self):
        image = np.zeros((3, 3, 2), dtype=np.uint8)
        image[..., 0] += 5
        image[..., 1] += 10
        aug = iaa.WithChannels(1, [iaa.Add(10), iaa.Multiply(2.0)])

        observed = aug.augment_image(image)

        expected = np.copy(image)
        expected[..., 1] += 10
        expected[..., 1] *= 2
        assert np.allclose(observed, expected)

    def test_multiple_images_given_as_array(self):
        images = np.concatenate([
            self.image[np.newaxis, ...],
            self.image[np.newaxis, ...]],
            axis=0)
        aug = iaa.WithChannels(1, iaa.Add(10))

        observed = aug.augment_images(images)

        expected = np.copy(images)
        expected[..., 1] += 10
        assert np.allclose(observed, expected)

    def test_multiple_images_given_as_list_of_arrays(self):
        images = [self.image, self.image]
        aug = iaa.WithChannels(1, iaa.Add(10))

        observed = aug.augment_images(images)

        expected = self.image
        expected[..., 1] += 10
        expected = [expected, expected]
        assert array_equal_lists(observed, expected)

    def test_children_list_is_none(self):
        aug = iaa.WithChannels(1, children=None)
        observed = aug.augment_image(self.image)
        expected = self.image
        assert np.array_equal(observed, expected)

    def test_channels_is_empty_list(self):
        aug = iaa.WithChannels([], iaa.Add(10))
        observed = aug.augment_image(self.image)
        expected = self.image
        assert np.array_equal(observed, expected)

    def test_heatmap_augmentation_single_channel(self):
        heatmap_arr = np.float32([
            [0.0, 0.0, 1.0],
            [0.0, 1.0, 1.0],
            [1.0, 1.0, 1.0]
        ])
        heatmap = HeatmapsOnImage(heatmap_arr, shape=(3, 3, 3))
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels(1, children=[affine])

        heatmap_aug = aug.augment_heatmaps(heatmap)

        assert heatmap_aug.shape == (3, 3, 3)
        assert np.allclose(heatmap_aug.get_arr(), heatmap_arr)

    def test_heatmap_augmentation_multiple_channels(self):
        heatmap_arr = np.float32([
            [0.0, 0.0, 1.0],
            [0.0, 1.0, 1.0],
            [1.0, 1.0, 1.0]
        ])
        heatmap_arr_shifted = np.float32([
            [0.0, 0.0, 0.0],
            [0.0, 0.0, 1.0],
            [0.0, 1.0, 1.0]
        ])
        heatmap = HeatmapsOnImage(heatmap_arr, shape=(3, 3, 3))
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels([0, 1, 2], children=[affine])

        heatmap_aug = aug.augment_heatmaps(heatmap)

        assert heatmap_aug.shape == (3, 3, 3)
        assert np.allclose(heatmap_aug.get_arr(), heatmap_arr_shifted)

    def test_segmentation_map_augmentation_single_channel(self):
        segmap_arr = np.int32([
            [0, 0, 1],
            [0, 1, 1],
            [1, 1, 1]
        ])
        segmap = SegmentationMapsOnImage(segmap_arr, shape=(3, 3, 3))

        aug = iaa.WithChannels(1, children=[iaa.Affine(translate_px={"x": 1})])
        segmap_aug = aug.augment_segmentation_maps(segmap)
        assert segmap_aug.shape == (3, 3, 3)
        assert np.array_equal(segmap_aug.get_arr(), segmap_arr)

    def test_segmentation_map_augmentation_multiple_channels(self):
        segmap_arr = np.int32([
            [0, 0, 1],
            [0, 1, 1],
            [1, 1, 1]
        ])
        segmap_arr_shifted = np.int32([
            [0, 0, 0],
            [0, 0, 1],
            [0, 1, 1]
        ])
        segmap = SegmentationMapsOnImage(segmap_arr, shape=(3, 3, 3))
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels([0, 1, 2], children=[affine])

        segmap_aug = aug.augment_segmentation_maps(segmap)

        assert segmap_aug.shape == (3, 3, 3)
        assert np.array_equal(segmap_aug.get_arr(), segmap_arr_shifted)

    @classmethod
    def _test_cbaoi_augmentation_single_channel(cls, cbaoi, augf_name):
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels(1, children=[affine])

        observed = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(observed, cbaoi)

    @classmethod
    def _test_cbaoi_augmentation_all_channels_via_list(cls, cbaoi, cbaoi_x,
                                                       augf_name):
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels([0, 1, 2], children=[affine])

        observed = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(observed, cbaoi_x)

    @classmethod
    def _test_cbaoi_augmentation_subset_of_channels(cls, cbaoi, cbaoi_x,
                                                    augf_name):
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels([0, 1], children=[affine])

        observed = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(observed, cbaoi_x)

    @classmethod
    def _test_cbaoi_augmentation_with_empty_cbaoi(cls, cbaoi, augf_name):
        affine = iaa.Affine(translate_px={"x": 1})
        aug = iaa.WithChannels([0, 1], children=[affine])

        observed = getattr(aug, augf_name)(cbaoi)

        assert_cbaois_equal(observed, cbaoi)

    def test_keypoint_augmentation_single_channel(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=2)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 6, 3))
        self._test_cbaoi_augmentation_single_channel(kpsoi, "augment_keypoints")

    def test_keypoint_augmentation_all_channels_via_list(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=2)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 6, 3))
        kpsoi_x = kpsoi.shift(x=1)
        self._test_cbaoi_augmentation_all_channels_via_list(
            kpsoi, kpsoi_x, "augment_keypoints")

    def test_keypoint_augmentation_subset_of_channels(self):
        kps = [ia.Keypoint(x=0, y=0), ia.Keypoint(x=1, y=2)]
        kpsoi = ia.KeypointsOnImage(kps, shape=(5, 6, 3))
        kpsoi_x = kpsoi.shift(x=1)
        self._test_cbaoi_augmentation_subset_of_channels(
            kpsoi, kpsoi_x, "augment_keypoints")

    def test_keypoint_augmentation_with_empty_keypoints_instance(self):
        kpsoi = ia.KeypointsOnImage([], shape=(5, 6, 3))
        self._test_cbaoi_augmentation_with_empty_cbaoi(
            kpsoi, "augment_keypoints")

    def test_polygon_augmentation(self):
        polygons = [ia.Polygon([(0, 0), (3, 0), (3, 3), (0, 3)])]
        psoi = ia.PolygonsOnImage(polygons, shape=(5, 6, 3))
        self._test_cbaoi_augmentation_single_channel(psoi, "augment_polygons")

    def test_polygon_augmentation_all_channels_via_list(self):
        polygons = [ia.Polygon([(0, 0), (3, 0), (3, 3), (0, 3)])]
        psoi = ia.PolygonsOnImage(polygons, shape=(5, 6, 3))
        psoi_x = psoi.shift(x=1)
        self._test_cbaoi_augmentation_all_channels_via_list(
            psoi, psoi_x, "augment_polygons")

    def test_polygon_augmentation_subset_of_channels(self):
        polygons = [ia.Polygon([(0, 0), (3, 0), (3, 3), (0, 3)])]
        psoi = ia.PolygonsOnImage(polygons, shape=(5, 6, 3))
        psoi_x = psoi.shift(x=1)
        self._test_cbaoi_augmentation_subset_of_channels(
            psoi, psoi_x, "augment_polygons")

    def test_polygon_augmentation_with_empty_polygons_instance(self):
        psoi = ia.PolygonsOnImage([], shape=(5, 6, 3))
        self._test_cbaoi_augmentation_with_empty_cbaoi(
            psoi, "augment_polygons")

    def test_line_string_augmentation(self):
        lss = [ia.LineString([(0, 0), (3, 0), (3, 3), (0, 3)])]
        lsoi = ia.LineStringsOnImage(lss, shape=(5, 6, 3))
        self._test_cbaoi_augmentation_single_channel(
            lsoi, "augment_line_strings")

    def test_line_string_augmentation_all_channels_via_list(self):
        lss = [ia.LineString([(0, 0), (3, 0), (3, 3), (0, 3)])]
        lsoi = ia.LineStringsOnImage(lss, shape=(5, 6, 3))
        lsoi_x = lsoi.shift(x=1)
        self._test_cbaoi_augmentation_all_channels_via_list(
            lsoi, lsoi_x, "augment_line_strings")

    def test_line_string_augmentation_subset_of_channels(self):
        lss = [ia.LineString([(0, 0), (3, 0), (3, 3), (0, 3)])]
        lsoi = ia.LineStringsOnImage(lss, shape=(5, 6, 3))
        lsoi_x = lsoi.shift(x=1)
        self._test_cbaoi_augmentation_subset_of_channels(
            lsoi, lsoi_x, "augment_line_strings")

    def test_line_string_augmentation_with_empty_polygons_instance(self):
        lsoi = ia.LineStringsOnImage([], shape=(5, 6, 3))
        self._test_cbaoi_augmentation_with_empty_cbaoi(
            lsoi, "augment_line_strings")

    def test_bounding_boxes_augmentation(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=1.0, y2=1.5)]
        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(5, 6, 3))
        self._test_cbaoi_augmentation_single_channel(
            bbsoi, "augment_bounding_boxes")

    def test_bounding_boxes_augmentation_all_channels_via_list(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=1.0, y2=1.5)]
        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(5, 6, 3))
        bbsoi_x = bbsoi.shift(x=1)
        self._test_cbaoi_augmentation_all_channels_via_list(
            bbsoi, bbsoi_x, "augment_bounding_boxes")

    def test_bounding_boxes_augmentation_subset_of_channels(self):
        bbs = [ia.BoundingBox(x1=0, y1=0, x2=1.0, y2=1.5)]
        bbsoi = ia.BoundingBoxesOnImage(bbs, shape=(5, 6, 3))
        bbsoi_x = bbsoi.shift(x=1)
        self._test_cbaoi_augmentation_subset_of_channels(
            bbsoi, bbsoi_x, "augment_bounding_boxes")

    def test_bounding_boxes_augmentation_with_empty_bb_instance(self):
        bbsoi = ia.BoundingBoxesOnImage([], shape=(5, 6, 3))
        self._test_cbaoi_augmentation_with_empty_cbaoi(
            bbsoi, "augment_bounding_boxes")

    def test_invalid_datatype_for_channels_fails(self):
        got_exception = False
        try:
            _ = iaa.WithChannels(False, iaa.Add(10))
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_invalid_datatype_for_children_fails(self):
        got_exception = False
        try:
            _ = iaa.WithChannels(1, False)
        except Exception as exc:
            assert "Expected " in str(exc)
            got_exception = True
        assert got_exception

    def test_zero_sized_axes(self):
        shapes = [
            (0, 0),
            (0, 1),
            (1, 0),
            (0, 1, 0),
            (1, 0, 0),
            (0, 1, 1),
            (1, 0, 1)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.WithChannels([0], iaa.Add(1))

                image_aug = aug(image=image)

                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_unusual_channel_numbers(self):
        shapes = [
            (1, 1, 4),
            (1, 1, 5),
            (1, 1, 512),
            (1, 1, 513)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.WithChannels([0], iaa.Add(1))

                image_aug = aug(image=image)

                assert np.all(image_aug[..., 0] == 1)
                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_get_parameters(self):
        aug = iaa.WithChannels([1], iaa.Add(10))
        params = aug.get_parameters()
        assert len(params) == 1
        assert params[0] == [1]

    def test_get_children_lists(self):
        children = iaa.Sequential([iaa.Add(10)])
        aug = iaa.WithChannels(1, children)
        assert aug.get_children_lists() == [children]

    def test_to_deterministic(self):
        child = iaa.Identity()
        aug = iaa.WithChannels(1, [child])

        aug_det = aug.to_deterministic()

        assert aug_det.deterministic
        assert aug_det.random_state is not aug.random_state
        assert aug_det.children[0].deterministic

    def test___repr___and___str__(self):
        children = iaa.Sequential([iaa.Identity()])
        aug = iaa.WithChannels(1, children, name="WithChannelsTest")
        expected = (
            "WithChannels("
            "channels=[1], "
            "name=WithChannelsTest, "
            "children=%s, "
            "deterministic=False"
            ")" % (str(children),))

        assert aug.__repr__() == expected
        assert aug.__str__() == expected

    def test_other_dtypes_via_noop__bool(self):
        aug = iaa.WithChannels([0], iaa.Identity())

        image = np.zeros((3, 3, 2), dtype=bool)
        image[0, 0, :] = True
        image_aug = aug.augment_image(image)
        assert image_aug.dtype.name == image.dtype.name
        assert np.all(image_aug == image)

    def test_other_dtypes_via_noop__uint_int(self):
        aug = iaa.WithChannels([0], iaa.Identity())
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, :] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, image)

    def test_other_dtypes_via_noop__float(self):
        aug = iaa.WithChannels([0], iaa.Identity())

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128

        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, :] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == image)

    def test_other_dtypes_via_flips__bool(self):
        aug = iaa.WithChannels([0], iaa.Fliplr(1.0))

        image = np.zeros((3, 3, 2), dtype=bool)
        image[0, 0, :] = True
        expected = np.zeros((3, 3, 2), dtype=bool)
        expected[0, 2, 0] = True
        expected[0, 0, 1] = True

        image_aug = aug.augment_image(image)

        assert image_aug.dtype.name == image.dtype.name
        assert np.all(image_aug == expected)

    def test_other_dtypes_via_flips__uint_int(self):
        aug = iaa.WithChannels([0], iaa.Fliplr(1.0))
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, :] = value
                expected = np.zeros((3, 3, 2), dtype=dtype)
                expected[0, 2, 0] = value
                expected[0, 0, 1] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.array_equal(image_aug, expected)

    def test_other_dtypes_via_flips__float(self):
        aug = iaa.WithChannels([0], iaa.Fliplr(1.0))

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128

        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, :] = value
                expected = np.zeros((3, 3, 2), dtype=dtype)
                expected[0, 2, 0] = value
                expected[0, 0, 1] = value

                image_aug = aug.augment_image(image)

                assert image_aug.dtype.name == dtype
                assert np.all(image_aug == expected)

    def test_pickleable(self):
        aug = iaa.WithChannels([0], iaa.Add((1, 10), seed=2),
                               seed=1)
        runtest_pickleable_uint8_img(aug, iterations=5)


class TestChannelShuffle(unittest.TestCase):
    def setUp(self):
        reseed()

    def test___init__(self):
        aug = iaa.ChannelShuffle(p=0.9, channels=[0, 2])
        assert is_parameter_instance(aug.p, iap.Binomial)
        assert is_parameter_instance(aug.p.p, iap.Deterministic)
        assert np.allclose(aug.p.p.value, 0.9)
        assert aug.channels == [0, 2]

    def test_p_is_1(self):
        aug = iaa.ChannelShuffle(p=1.0)
        img = np.uint8([0, 1]).reshape((1, 1, 2))
        expected = [
            np.uint8([0, 1]).reshape((1, 1, 2)),
            np.uint8([1, 0]).reshape((1, 1, 2))
        ]
        seen = [False, False]
        for _ in sm.xrange(100):
            img_aug = aug.augment_image(img)
            if np.array_equal(img_aug, expected[0]):
                seen[0] = True
            elif np.array_equal(img_aug, expected[1]):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_p_is_0(self):
        aug = iaa.ChannelShuffle(p=0)
        img = np.uint8([0, 1]).reshape((1, 1, 2))
        for _ in sm.xrange(20):
            img_aug = aug.augment_image(img)
            assert np.array_equal(img_aug, img)

    def test_p_is_1_and_channels_is_limited_subset(self):
        aug = iaa.ChannelShuffle(p=1.0, channels=[0, 2])
        img = np.uint8([0, 1, 2]).reshape((1, 1, 3))
        expected = [
            np.uint8([0, 1, 2]).reshape((1, 1, 3)),
            np.uint8([2, 1, 0]).reshape((1, 1, 3))
        ]
        seen = [False, False]
        for _ in sm.xrange(100):
            img_aug = aug.augment_image(img)
            if np.array_equal(img_aug, expected[0]):
                seen[0] = True
            elif np.array_equal(img_aug, expected[1]):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_get_parameters(self):
        aug = iaa.ChannelShuffle(p=1.0, channels=[0, 2])
        assert aug.get_parameters()[0] == aug.p
        assert aug.get_parameters()[1] == aug.channels

    def test_heatmaps_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        hm = ia.HeatmapsOnImage(np.float32([[0, 0.5, 1.0]]), shape=(4, 4, 3))
        hm_aug = aug.augment_heatmaps([hm])[0]
        assert hm_aug.shape == (4, 4, 3)
        assert hm_aug.arr_0to1.shape == (1, 3, 1)
        assert np.allclose(hm.arr_0to1, hm_aug.arr_0to1)

    def test_segmentation_maps_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        segmap = SegmentationMapsOnImage(np.int32([[0, 1, 2]]), shape=(4, 4, 3))
        segmap_aug = aug.augment_segmentation_maps([segmap])[0]
        assert segmap_aug.shape == (4, 4, 3)
        assert segmap_aug.arr.shape == (1, 3, 1)
        assert np.array_equal(segmap.arr, segmap_aug.arr)

    def test_keypoints_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        kpsoi = ia.KeypointsOnImage([
            ia.Keypoint(x=3, y=1), ia.Keypoint(x=2, y=4)
        ], shape=(10, 10, 3))

        kpsoi_aug = aug.augment_keypoints([kpsoi])[0]

        assert_cbaois_equal(kpsoi_aug, kpsoi)

    def test_polygons_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        psoi = ia.PolygonsOnImage([
            ia.Polygon([(0, 0), (5, 0), (5, 5)])
        ], shape=(10, 10, 3))

        psoi_aug = aug.augment_polygons(psoi)

        assert_cbaois_equal(psoi_aug, psoi)

    def test_line_strings_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        lsoi = ia.LineStringsOnImage([
            ia.LineString([(0, 0), (5, 0), (5, 5)])
        ], shape=(10, 10, 3))

        lsoi_aug = aug.augment_line_strings(lsoi)

        assert_cbaois_equal(lsoi_aug, lsoi)

    def test_bounding_boxes_must_not_change(self):
        aug = iaa.ChannelShuffle(p=1.0)
        bbsoi = ia.BoundingBoxesOnImage([
            ia.BoundingBox(x1=0, y1=0, x2=1.0, y2=1.5)
        ], shape=(10, 10, 3))

        bbsoi_aug = aug.augment_bounding_boxes(bbsoi)

        assert_cbaois_equal(bbsoi_aug, bbsoi)

    def test_zero_sized_axes(self):
        shapes = [
            (0, 0),
            (0, 1),
            (1, 0),
            (0, 1, 0),
            (1, 0, 0),
            (0, 1, 1),
            (1, 0, 1)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.ChannelShuffle(1.0)

                image_aug = aug(image=image)

                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_unusual_channel_numbers(self):
        shapes = [
            (1, 1, 4),
            (1, 1, 5),
            (1, 1, 512),
            (1, 1, 513)
        ]

        for shape in shapes:
            with self.subTest(shape=shape):
                image = np.zeros(shape, dtype=np.uint8)
                aug = iaa.ChannelShuffle(1.0)

                image_aug = aug(image=image)

                assert image_aug.dtype.name == "uint8"
                assert image_aug.shape == shape

    def test_other_dtypes_bool(self):
        aug = iaa.ChannelShuffle(p=0.5)

        image = np.zeros((3, 3, 2), dtype=bool)
        image[0, 0, 0] = True
        expected = [np.zeros((3, 3, 2), dtype=bool) for _ in sm.xrange(2)]
        expected[0][0, 0, 0] = True
        expected[1][0, 0, 1] = True
        seen = [False, False]
        for _ in sm.xrange(100):
            image_aug = aug.augment_image(image)

            assert image_aug.dtype.name == image.dtype.name
            if np.all(image_aug == expected[0]):
                seen[0] = True
            elif np.all(image_aug == expected[1]):
                seen[1] = True
            else:
                assert False
            if np.all(seen):
                break
        assert np.all(seen)

    def test_other_dtypes_uint_int(self):
        aug = iaa.ChannelShuffle(p=0.5)
        dtypes = ["uint8", "uint16", "uint32", "uint64",
                  "int8", "int32", "int64"]
        for dtype in dtypes:
            with self.subTest(dtype=dtype):
                min_value, center_value, max_value = \
                    iadt.get_value_range_of_dtype(dtype)
                value = max_value
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, 0] = value
                expected = [np.zeros((3, 3, 2), dtype=dtype)
                            for _
                            in sm.xrange(2)]
                expected[0][0, 0, 0] = value
                expected[1][0, 0, 1] = value
                seen = [False, False]
                for _ in sm.xrange(100):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == dtype
                    if np.all(image_aug == expected[0]):
                        seen[0] = True
                    elif np.all(image_aug == expected[1]):
                        seen[1] = True
                    else:
                        assert False
                    if np.all(seen):
                        break
                assert np.all(seen)

    def test_other_dtypes_float(self):
        aug = iaa.ChannelShuffle(p=0.5)

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = ["float16", "float32", "float64"] + f128

        values = [5000, 1000 ** 2, 1000 ** 3, 1000 ** 4]
        for dtype, value in zip(dtypes, values):
            with self.subTest(dtype=dtype):
                image = np.zeros((3, 3, 2), dtype=dtype)
                image[0, 0, 0] = value
                expected = [np.zeros((3, 3, 2), dtype=dtype)
                            for _
                            in sm.xrange(2)]
                expected[0][0, 0, 0] = value
                expected[1][0, 0, 1] = value
                seen = [False, False]
                for _ in sm.xrange(100):
                    image_aug = aug.augment_image(image)

                    assert image_aug.dtype.name == dtype
                    if np.all(image_aug == expected[0]):
                        seen[0] = True
                    elif np.all(image_aug == expected[1]):
                        seen[1] = True
                    else:
                        assert False
                    if np.all(seen):
                        break
                assert np.all(seen)

    def test_pickleable(self):
        aug = iaa.ChannelShuffle(0.5, seed=1)
        runtest_pickleable_uint8_img(aug, iterations=5, shape=(2, 2, 10))


class TestRemoveCBAsByOutOfImageFraction(unittest.TestCase):
    def setUp(self):
        reseed()

    def test___init__(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        assert np.isclose(aug.fraction, 0.51)

    def test_no_cbas_in_batch(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = [
            "uint8", "uint16", "uint32", "uint64",
            "int8", "int16", "int32", "int64",
            "float16", "float32", "float64",
            "bool"
        ] + f128

        for dt in dtypes:
            arr = np.ones((5, 10, 3), dtype=dt)

            image_aug = aug(image=arr)

            assert image_aug.dtype.name == dt
            assert image_aug.shape == (5, 10, 3)
            if arr.dtype.kind == "f":
                assert np.allclose(image_aug, 1.0)
            else:
                assert np.all(image_aug == 1)

    def test_keypoints(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        item1 = ia.Keypoint(x=5, y=1)
        item2 = ia.Keypoint(x=15, y=1)
        cbaoi = ia.KeypointsOnImage([item1, item2], shape=(10, 10, 3))

        cbaoi_aug = aug(keypoints=cbaoi)

        assert len(cbaoi_aug.items) == 1
        for item_obs, item_exp in zip(cbaoi_aug.items, [item1]):
            assert item_obs.coords_almost_equals(item_exp)

    def test_bounding_boxes(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        item1 = ia.BoundingBox(y1=1, x1=5, y2=6, x2=9)
        item2 = ia.BoundingBox(y1=1, x1=5, y2=6, x2=15)
        item3 = ia.BoundingBox(y1=1, x1=15, y2=6, x2=25)
        cbaoi = ia.BoundingBoxesOnImage([item1, item2, item3],
                                        shape=(10, 10, 3))

        cbaoi_aug = aug(bounding_boxes=cbaoi)

        assert len(cbaoi_aug.items) == 2
        for item_obs, item_exp in zip(cbaoi_aug.items, [item1, item2]):
            assert item_obs.coords_almost_equals(item_exp)

    def test_polygons(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        item1 = ia.Polygon([(5, 1), (9, 1), (9, 2), (5, 2)])
        item2 = ia.Polygon([(5, 1), (15, 1), (15, 2), (5, 2)])
        item3 = ia.Polygon([(15, 1), (25, 1), (25, 2), (15, 2)])
        cbaoi = ia.PolygonsOnImage([item1, item2, item3],
                                   shape=(10, 10, 3))

        cbaoi_aug = aug(polygons=cbaoi)

        assert len(cbaoi_aug.items) == 2
        for item_obs, item_exp in zip(cbaoi_aug.items, [item1, item2]):
            assert item_obs.coords_almost_equals(item_exp)

    def test_line_strings(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        item1 = ia.LineString([(5, 1), (9, 1)])
        item2 = ia.LineString([(5, 1), (15, 1)])
        item3 = ia.LineString([(15, 1), (25, 1)])
        cbaoi = ia.LineStringsOnImage([item1, item2, item3],
                                      shape=(10, 10, 3))

        cbaoi_aug = aug(line_strings=cbaoi)

        assert len(cbaoi_aug.items) == 2
        for item_obs, item_exp in zip(cbaoi_aug.items, [item1, item2]):
            assert item_obs.coords_almost_equals(item_exp)

    def test_get_parameters(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        params = aug.get_parameters()
        assert len(params) == 1
        assert np.isclose(params[0], 0.51)

    def test_pickleable(self):
        item1 = ia.Keypoint(x=5, y=1)
        item2 = ia.Keypoint(x=15, y=1)
        cbaoi = ia.KeypointsOnImage([item1, item2], shape=(10, 10, 3))

        augmenter = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        augmenter_pkl = pickle.loads(pickle.dumps(augmenter, protocol=-1))

        for _ in np.arange(3):
            cbaoi_aug = augmenter(keypoints=cbaoi)
            cbaoi_aug_pkl = augmenter_pkl(keypoints=cbaoi)
            assert np.allclose(cbaoi_aug.to_xy_array(), cbaoi_aug_pkl.to_xy_array())


class TestClipCBAsToImagePlanes(unittest.TestCase):
    def setUp(self):
        reseed()

    def test_no_cbas_in_batch(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)

        try:
            f128 = [np.dtype("float128")]
        except TypeError:
            f128 = []  # float128 not known by user system

        dtypes = [
            "uint8", "uint16", "uint32", "uint64",
            "int8", "int16", "int32", "int64",
            "float16", "float32", "float64",
            "bool"
        ] + f128

        for dt in dtypes:
            arr = np.ones((5, 10, 3), dtype=dt)

            image_aug = aug(image=arr)

            assert image_aug.dtype.name == dt
            assert image_aug.shape == (5, 10, 3)
            if arr.dtype.kind == "f":
                assert np.allclose(image_aug, 1.0)
            else:
                assert np.all(image_aug == 1)

    def test_keypoints(self):
        aug = iaa.RemoveCBAsByOutOfImageFraction(0.51)
        item1 = ia.Keypoint(x=5, y=1)
        item2 = ia.Keypoint(x=15, y=1)
        cbaoi = ia.KeypointsOnImage([item1, item2], shape=(10, 10, 3))

        cbaoi_aug = aug(keypoints=cbaoi)

        assert len(cbaoi_aug.items) == 1
        for item_obs, item_exp in zip(cbaoi_aug.items, [item1]):
            assert item_obs.coords_almost_equals(item_exp)

    def test_bounding_boxes(self):
        aug = iaa.ClipCBAsToImagePlanes()
        item1 = ia.BoundingBox(y1=1, x1=5, y2=6, x2=9)
        item2 = ia.BoundingBox(y1=1, x1=5, y2=6, x2=15)
        item3 = ia.BoundingBox(y1=1, x1=15, y2=6, x2=25)
        cbaoi = ia.BoundingBoxesOnImage([item1, item2, item3],
                                        shape=(10, 10, 3))

        cbaoi_aug = aug(bounding_boxes=cbaoi)

        expected = [
            ia.BoundingBox(y1=1, x1=5, y2=6, x2=9),
            ia.BoundingBox(y1=1, x1=5, y2=6, x2=10)
        ]
        assert len(cbaoi_aug.items) == len(expected)
        for item_obs, item_exp in zip(cbaoi_aug.items, expected):
            assert item_obs.coords_almost_equals(item_exp)

    def test_polygons(self):
        aug = iaa.ClipCBAsToImagePlanes()
        item1 = ia.Polygon([(5, 1), (9, 1), (9, 2), (5, 2)])
        item2 = ia.Polygon([(5, 1), (15, 1), (15, 2), (5, 2)])
        item3 = ia.Polygon([(15, 1), (25, 1), (25, 2), (15, 2)])
        cbaoi = ia.PolygonsOnImage([item1, item2, item3],
                                   shape=(10, 10, 3))

        cbaoi_aug = aug(polygons=cbaoi)

        expected = [
            ia.Polygon([(5, 1), (9, 1), (9, 2), (5, 2)]),
            ia.Polygon([(5, 1), (10, 1), (10, 2), (5, 2)])
        ]
        assert len(cbaoi_aug.items) == len(expected)
        for item_obs, item_exp in zip(cbaoi_aug.items, expected):
            assert item_obs.coords_almost_equals(item_exp)

    def test_line_strings(self):
        aug = iaa.ClipCBAsToImagePlanes()
        item1 = ia.LineString([(5, 1), (9, 1)])
        item2 = ia.LineString([(5, 1), (15, 1)])
        item3 = ia.LineString([(15, 1), (25, 1)])
        cbaoi = ia.LineStringsOnImage([item1, item2, item3],
                                      shape=(10, 10, 3))

        cbaoi_aug = aug(line_strings=cbaoi)

        expected = [
            ia.LineString([(5, 1), (9, 1)]),
            ia.LineString([(5, 1), (10, 1)])
        ]
        assert len(cbaoi_aug.items) == len(expected)
        for item_obs, item_exp in zip(cbaoi_aug.items, expected):
            assert item_obs.coords_almost_equals(item_exp, max_distance=1e-2)

    def test_get_parameters(self):
        aug = iaa.ClipCBAsToImagePlanes()
        params = aug.get_parameters()
        assert len(params) == 0

    def test_pickleable(self):
        item1 = ia.Keypoint(x=5, y=1)
        item2 = ia.Keypoint(x=15, y=1)
        cbaoi = ia.KeypointsOnImage([item1, item2], shape=(10, 10, 3))

        augmenter = iaa.ClipCBAsToImagePlanes()
        augmenter_pkl = pickle.loads(pickle.dumps(augmenter, protocol=-1))

        for _ in np.arange(3):
            cbaoi_aug = augmenter(keypoints=cbaoi)
            cbaoi_aug_pkl = augmenter_pkl(keypoints=cbaoi)
            assert np.allclose(cbaoi_aug.to_xy_array(), cbaoi_aug_pkl.to_xy_array())