def _test_augment_polygons__kernel_size_differs(self, shape, shape_exp): from imgaug.augmentables.polys import Polygon, PolygonsOnImage polys = [Polygon([(1.5, 5.5), (5.5, 1.5), (5.5, 5.5)])] psoi = PolygonsOnImage(polys, shape=shape) aug = self.augmenter( (iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) psoi_aug = aug.augment_polygons(psoi) expected = PolygonsOnImage( [Polygon([ ((1.5/shape[1])*shape_exp[1], (5.5/shape[0])*shape_exp[0]), ((5.5/shape[1])*shape_exp[1], (1.5/shape[0])*shape_exp[0]), ((5.5/shape[1])*shape_exp[1], (5.5/shape[0])*shape_exp[0]) ])], shape=shape_exp) assert_cbaois_equal(psoi_aug, expected)
def _test_augment_keypoints__kernel_size_differs(self, shape, shape_exp): from imgaug.augmentables.kps import Keypoint, KeypointsOnImage kps = [Keypoint(x=1.5, y=5.5), Keypoint(x=5.5, y=1.5)] kpsoi = KeypointsOnImage(kps, shape=shape) aug = self.augmenter( (iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) kpsoi_aug = aug.augment_keypoints(kpsoi) expected = KeypointsOnImage.from_xy_array( np.float32([ [(1.5/shape[1])*shape_exp[1], (5.5/shape[0])*shape_exp[0]], [(5.5/shape[1])*shape_exp[1], (1.5/shape[0])*shape_exp[0]] ]), shape=shape_exp) assert_cbaois_equal(kpsoi_aug, expected)
def test_augment_images__kernel_size_differs(self): aug = iaa.AveragePooling((iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) image = np.uint8([ [50 - 2, 50 - 1, 120 - 4, 120 + 4], [50 + 1, 50 + 2, 120 + 2, 120 - 1], [50 - 5, 50 + 5, 120 - 2, 120 + 1], ]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) expected = np.uint8([[50, 120]]) expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3)) image_aug = aug.augment_image(image) diff = np.abs(image_aug.astype(np.int32) - expected) assert image_aug.dtype.name == "uint8" assert image_aug.shape == (1, 2, 3) assert np.all(diff <= 1)
def _test_augment_bounding_boxes__kernel_size_differs( self, shape, shape_exp): from imgaug.augmentables.bbs import BoundingBox, BoundingBoxesOnImage bbs = [BoundingBox(x1=1.5, y1=2.5, x2=5.5, y2=6.5)] bbsoi = BoundingBoxesOnImage(bbs, shape=shape) aug = self.augmenter((iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) bbsoi_aug = aug.augment_bounding_boxes(bbsoi) expected = BoundingBoxesOnImage([ BoundingBox( x1=(1.5 / shape[1]) * shape_exp[1], y1=(2.5 / shape[0]) * shape_exp[0], x2=(5.5 / shape[1]) * shape_exp[1], y2=(6.5 / shape[0]) * shape_exp[0], ) ], shape=shape_exp) assert_cbaois_equal(bbsoi_aug, expected)
def _test_augment_line_strings__kernel_size_differs( self, shape, shape_exp): from imgaug.augmentables.lines import LineString, LineStringsOnImage ls = [LineString([(1.5, 5.5), (5.5, 1.5), (5.5, 5.5)])] lsoi = LineStringsOnImage(ls, shape=shape) aug = self.augmenter((iap.Deterministic(3), iap.Deterministic(2)), keep_size=False) lsoi_aug = aug.augment_line_strings(lsoi) expected = LineStringsOnImage([ LineString([((1.5 / shape[1]) * shape_exp[1], (5.5 / shape[0]) * shape_exp[0]), ((5.5 / shape[1]) * shape_exp[1], (1.5 / shape[0]) * shape_exp[0]), ((5.5 / shape[1]) * shape_exp[1], (5.5 / shape[0]) * shape_exp[0])]) ], shape=shape_exp) assert_cbaois_equal(lsoi_aug, expected)
def test_augment_images__kernel_size_differs__requires_padding(self): aug = iaa.AveragePooling((iap.Deterministic(3), iap.Deterministic(1)), keep_size=False) image = np.uint8([[50 - 2, 50 - 1, 120 - 4, 120 + 4], [50 + 1, 50 + 2, 120 + 2, 120 - 1]]) image = np.tile(image[:, :, np.newaxis], (1, 1, 3)) expected = np.uint8([[(50 - 2 + 50 + 1 + 50 - 2) / 3, (50 - 1 + 50 + 2 + 50 - 1) / 3, (120 - 4 + 120 + 2 + 120 - 4) / 3, (120 + 4 + 120 - 1 + 120 + 4) / 3]]) expected = np.tile(expected[:, :, np.newaxis], (1, 1, 3)) image_aug = aug.augment_image(image) diff = np.abs(image_aug.astype(np.int32) - expected) assert image_aug.dtype.name == "uint8" assert image_aug.shape == (1, 4, 3) assert np.all(diff <= 1)
def test___str___single_value_hysteresis(self): alpha = iap.Deterministic(0.2) hysteresis_thresholds = iap.Deterministic(10) sobel_kernel_size = iap.Deterministic(3) colorizer = iaa.RandomColorsBinaryImageColorizer( color_true=10, color_false=20) aug = iaa.Canny( alpha=alpha, hysteresis_thresholds=hysteresis_thresholds, sobel_kernel_size=sobel_kernel_size, colorizer=colorizer ) observed = aug.__str__() expected = ("Canny(alpha=%s, hysteresis_thresholds=%s, " "sobel_kernel_size=%s, colorizer=%s, name=UnnamedCanny, " "deterministic=False)") % ( str(aug.alpha), str(aug.hysteresis_thresholds), str(aug.sobel_kernel_size), colorizer) assert observed == expected
def test__draw_samples__tuple_as_hysteresis(self): seed = 1 nb_images = 10 aug = iaa.Canny( alpha=0.2, hysteresis_thresholds=([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], iap.DiscreteUniform(5, 100)), sobel_kernel_size=[3, 5, 7], random_state=iarandom.RNG(seed)) aug.alpha = remove_prefetching(aug.alpha) aug.hysteresis_thresholds = ( remove_prefetching(aug.hysteresis_thresholds[0]), remove_prefetching(aug.hysteresis_thresholds[1]) ) aug.sobel_kernel_size = remove_prefetching(aug.sobel_kernel_size) example_image = np.zeros((5, 5, 3), dtype=np.uint8) samples = aug._draw_samples([example_image] * nb_images, random_state=iarandom.RNG(seed)) alpha_samples = samples[0] hthresh_samples = samples[1] sobel_samples = samples[2] rss = iarandom.RNG(seed).duplicate(4) alpha_expected = iap.Deterministic(0.2).draw_samples((nb_images,), rss[0]) hthresh_expected = [None, None] hthresh_expected[0] = iap.Choice( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).draw_samples((nb_images,), rss[1]) # TODO simplify this to rss[2].randint(5, 100+1) # would currenlty be a bit more ugly, because DiscrUniform # samples two values for a and b first from rss[2] hthresh_expected[1] = iap.DiscreteUniform(5, 100).draw_samples( (nb_images,), rss[2]) hthresh_expected = np.stack(hthresh_expected, axis=-1) sobel_expected = iap.Choice([3, 5, 7]).draw_samples((nb_images,), rss[3]) invalid = hthresh_expected[:, 0] > hthresh_expected[:, 1] hthresh_expected[invalid, :] = hthresh_expected[invalid, :][:, [1, 0]] assert hthresh_expected.shape == (nb_images, 2) assert not np.any(hthresh_expected[:, 0] > hthresh_expected[:, 1]) assert np.allclose(alpha_samples, alpha_expected) assert np.allclose(hthresh_samples, hthresh_expected) assert np.allclose(sobel_samples, sobel_expected)
def _test_augmenter(cls, augmenter_name, func_expected, dependent_on_seed): # this test verifies: # - called function seems to be the expected function # - images produced by augmenter match images produced by function # - a different seed (and sometimes severity) will lead to a # different image # - augmenter can be pickled severity = 5 aug_cls = getattr(iaa.imgcorruptlike, augmenter_name) image = np.mod( np.arange(32*32*3), 256 ).reshape((32, 32, 3)).astype(np.uint8) with iap.no_prefetching(): rng = iarandom.RNG(1) # Replay sampling of severities. # Even for deterministic values this is required as currently # there is an advance() at the end of each draw_samples(). _ = iap.Deterministic(1).draw_samples((1,), rng) # As for the functions above, we can't just change the seed value # to get different augmentations as many functions are dependend # only on the severity. So we change only for some functions only # the seed and for the others severity+seed. image_aug1 = aug_cls(severity=severity, seed=1)(image=image) image_aug2 = aug_cls(severity=severity, seed=1)(image=image) if dependent_on_seed: image_aug3 = aug_cls(severity=severity, seed=2)( image=image) else: image_aug3 = aug_cls(severity=severity-1, seed=2)( image=image) image_aug_exp = func_expected( image, severity=severity, seed=rng.generate_seed_()) assert aug_cls(severity=severity).func is func_expected assert np.array_equal(image_aug1, image_aug_exp) assert np.array_equal(image_aug2, image_aug_exp) assert not np.array_equal(image_aug3, image_aug2) # pickling test aug = aug_cls(severity=(1, 5)) runtest_pickleable_uint8_img(aug, shape=(32, 32, 3))
def test__draw_samples__single_value_hysteresis(self): seed = 1 nb_images = 1000 aug = iaa.Canny( alpha=0.2, hysteresis_thresholds=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], sobel_kernel_size=[3, 5, 7], random_state=iarandom.RNG(seed)) aug.alpha = remove_prefetching(aug.alpha) aug.hysteresis_thresholds = remove_prefetching( aug.hysteresis_thresholds) aug.sobel_kernel_size = remove_prefetching(aug.sobel_kernel_size) example_image = np.zeros((5, 5, 3), dtype=np.uint8) samples = aug._draw_samples([example_image] * nb_images, random_state=iarandom.RNG(seed)) alpha_samples = samples[0] hthresh_samples = samples[1] sobel_samples = samples[2] rss = iarandom.RNG(seed).duplicate(4) alpha_expected = iap.Deterministic(0.2).draw_samples((nb_images,), rss[0]) hthresh_expected = iap.Choice( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).draw_samples((nb_images, 2), rss[1]) sobel_expected = iap.Choice([3, 5, 7]).draw_samples((nb_images,), rss[2]) invalid = hthresh_expected[:, 0] > hthresh_expected[:, 1] assert np.any(invalid) hthresh_expected[invalid, :] = hthresh_expected[invalid, :][:, [1, 0]] assert hthresh_expected.shape == (nb_images, 2) assert not np.any(hthresh_expected[:, 0] > hthresh_expected[:, 1]) assert np.allclose(alpha_samples, alpha_expected) assert np.allclose(hthresh_samples, hthresh_expected) assert np.allclose(sobel_samples, sobel_expected)
def test_Superpixels(): reseed() def _array_equals_tolerant(a, b, tolerance): diff = np.abs(a.astype(np.int32) - b.astype(np.int32)) return np.all(diff <= tolerance) base_img = [[255, 255, 255, 0, 0, 0], [255, 235, 255, 0, 20, 0], [250, 250, 250, 5, 5, 5]] base_img = np.tile( np.array(base_img, dtype=np.uint8)[..., np.newaxis], (1, 1, 3)) base_img_superpixels = [[251, 251, 251, 4, 4, 4], [251, 251, 251, 4, 4, 4], [251, 251, 251, 4, 4, 4]] base_img_superpixels = np.tile( np.array(base_img_superpixels, dtype=np.uint8)[..., np.newaxis], (1, 1, 3)) base_img_superpixels_left = np.copy(base_img_superpixels) base_img_superpixels_left[:, 3:, :] = base_img[:, 3:, :] base_img_superpixels_right = np.copy(base_img_superpixels) base_img_superpixels_right[:, :3, :] = base_img[:, :3, :] aug = iaa.Superpixels(p_replace=0, n_segments=2) observed = aug.augment_image(base_img) expected = base_img assert np.allclose(observed, expected) aug = iaa.Superpixels(p_replace=1.0, n_segments=2) observed = aug.augment_image(base_img) expected = base_img_superpixels assert _array_equals_tolerant(observed, expected, 2) aug = iaa.Superpixels(p_replace=1.0, n_segments=iap.Deterministic(2)) observed = aug.augment_image(base_img) expected = base_img_superpixels assert _array_equals_tolerant(observed, expected, 2) aug = iaa.Superpixels(p_replace=iap.Binomial(iap.Choice([0.0, 1.0])), n_segments=2) observed = aug.augment_image(base_img) assert np.allclose(observed, base_img) or _array_equals_tolerant( observed, base_img_superpixels, 2) aug = iaa.Superpixels(p_replace=0.5, n_segments=2) seen = {"none": False, "left": False, "right": False, "both": False} for _ in sm.xrange(100): observed = aug.augment_image(base_img) if _array_equals_tolerant(observed, base_img, 2): seen["none"] = True elif _array_equals_tolerant(observed, base_img_superpixels_left, 2): seen["left"] = True elif _array_equals_tolerant(observed, base_img_superpixels_right, 2): seen["right"] = True elif _array_equals_tolerant(observed, base_img_superpixels, 2): seen["both"] = True else: raise Exception( "Generated superpixels image does not match any expected image." ) if all(seen.values()): break assert all(seen.values()) # test exceptions for wrong parameter types got_exception = False try: _ = iaa.Superpixels(p_replace="test", n_segments=100) except Exception: got_exception = True assert got_exception got_exception = False try: _ = iaa.Superpixels(p_replace=1, n_segments="test") except Exception: got_exception = True assert got_exception # test get_parameters() aug = iaa.Superpixels(p_replace=0.5, n_segments=2, max_size=100, interpolation="nearest") params = aug.get_parameters() assert isinstance(params[0], iap.Binomial) assert isinstance(params[0].p, iap.Deterministic) assert isinstance(params[1], iap.Deterministic) assert 0.5 - 1e-4 < params[0].p.value < 0.5 + 1e-4 assert params[1].value == 2 assert params[2] == 100 assert params[3] == "nearest"
def test_p_replace_1_n_segments_stochastic_parameter(self): aug = iaa.Superpixels(p_replace=1.0, n_segments=iap.Deterministic(2)) observed = aug.augment_image(self.base_img) expected = self.base_img_superpixels assert self._array_equals_tolerant(observed, expected, 2)
def test_Superpixels(): reseed() def _array_equals_tolerant(a, b, tolerance): diff = np.abs(a.astype(np.int32) - b.astype(np.int32)) return np.all(diff <= tolerance) base_img = [[255, 255, 255, 0, 0, 0], [255, 235, 255, 0, 20, 0], [250, 250, 250, 5, 5, 5]] base_img = np.tile( np.array(base_img, dtype=np.uint8)[..., np.newaxis], (1, 1, 3)) base_img_superpixels = [[251, 251, 251, 4, 4, 4], [251, 251, 251, 4, 4, 4], [251, 251, 251, 4, 4, 4]] base_img_superpixels = np.tile( np.array(base_img_superpixels, dtype=np.uint8)[..., np.newaxis], (1, 1, 3)) base_img_superpixels_left = np.copy(base_img_superpixels) base_img_superpixels_left[:, 3:, :] = base_img[:, 3:, :] base_img_superpixels_right = np.copy(base_img_superpixels) base_img_superpixels_right[:, :3, :] = base_img[:, :3, :] aug = iaa.Superpixels(p_replace=0, n_segments=2) observed = aug.augment_image(base_img) expected = base_img assert np.allclose(observed, expected) aug = iaa.Superpixels(p_replace=1.0, n_segments=2) observed = aug.augment_image(base_img) expected = base_img_superpixels assert _array_equals_tolerant(observed, expected, 2) aug = iaa.Superpixels(p_replace=1.0, n_segments=iap.Deterministic(2)) observed = aug.augment_image(base_img) expected = base_img_superpixels assert _array_equals_tolerant(observed, expected, 2) aug = iaa.Superpixels(p_replace=iap.Binomial(iap.Choice([0.0, 1.0])), n_segments=2) observed = aug.augment_image(base_img) assert np.allclose(observed, base_img) or _array_equals_tolerant( observed, base_img_superpixels, 2) aug = iaa.Superpixels(p_replace=0.5, n_segments=2) seen = {"none": False, "left": False, "right": False, "both": False} for _ in sm.xrange(100): observed = aug.augment_image(base_img) if _array_equals_tolerant(observed, base_img, 2): seen["none"] = True elif _array_equals_tolerant(observed, base_img_superpixels_left, 2): seen["left"] = True elif _array_equals_tolerant(observed, base_img_superpixels_right, 2): seen["right"] = True elif _array_equals_tolerant(observed, base_img_superpixels, 2): seen["both"] = True else: raise Exception( "Generated superpixels image does not match any expected image." ) if all(seen.values()): break assert all(seen.values()) # test exceptions for wrong parameter types got_exception = False try: _ = iaa.Superpixels(p_replace="test", n_segments=100) except Exception: got_exception = True assert got_exception got_exception = False try: _ = iaa.Superpixels(p_replace=1, n_segments="test") except Exception: got_exception = True assert got_exception # test get_parameters() aug = iaa.Superpixels(p_replace=0.5, n_segments=2, max_size=100, interpolation="nearest") params = aug.get_parameters() assert isinstance(params[0], iap.Binomial) assert isinstance(params[0].p, iap.Deterministic) assert isinstance(params[1], iap.Deterministic) assert 0.5 - 1e-4 < params[0].p.value < 0.5 + 1e-4 assert params[1].value == 2 assert params[2] == 100 assert params[3] == "nearest" ################### # test other dtypes ################### # bool aug = iaa.Superpixels(p_replace=1.0, n_segments=2) img = np.array([[False, False, True, True], [False, False, True, True]], dtype=bool) img_aug = aug.augment_image(img) assert img_aug.dtype == img.dtype assert np.all(img_aug == img) aug = iaa.Superpixels(p_replace=1.0, n_segments=1) img = np.array([[True, True, True, True], [False, True, True, True]], dtype=bool) img_aug = aug.augment_image(img) assert img_aug.dtype == img.dtype assert np.all(img_aug) for dtype in [np.uint8, np.uint16, np.uint32, np.int8, np.int16, np.int32]: min_value, center_value, max_value = iadt.get_value_range_of_dtype( dtype) if np.dtype(dtype).kind == "i": values = [ int(center_value), int(0.1 * max_value), int(0.2 * max_value), int(0.5 * max_value), max_value - 100 ] values = [((-1) * value, value) for value in values] else: values = [(0, int(center_value)), (10, int(0.1 * max_value)), (10, int(0.2 * max_value)), (10, int(0.5 * max_value)), (0, max_value), (int(center_value), max_value)] for v1, v2 in values: aug = iaa.Superpixels(p_replace=1.0, n_segments=2) img = np.array([[v1, v1, v2, v2], [v1, v1, v2, v2]], dtype=dtype) img_aug = aug.augment_image(img) assert img_aug.dtype == np.dtype(dtype) assert np.array_equal(img_aug, img) aug = iaa.Superpixels(p_replace=1.0, n_segments=1) img = np.array([[v2, v2, v2, v2], [v1, v2, v2, v2]], dtype=dtype) img_aug = aug.augment_image(img) assert img_aug.dtype == np.dtype(dtype) assert np.all(img_aug == int(np.round((7 / 8) * v2 + (1 / 8) * v1))) for dtype in []: def _allclose(a, b): atol = 1e-4 if dtype == np.float16 else 1e-8 return np.allclose(a, b, atol=atol, rtol=0) isize = np.dtype(dtype).itemsize for value in [0, 1.0, 10.0, 1000**(isize - 1)]: v1 = (-1) * value v2 = value aug = iaa.Superpixels(p_replace=1.0, n_segments=2) img = np.array([[v1, v1, v2, v2], [v1, v1, v2, v2]], dtype=dtype) img_aug = aug.augment_image(img) assert img_aug.dtype == np.dtype(dtype) assert _allclose(img_aug, img) aug = iaa.Superpixels(p_replace=1.0, n_segments=1) img = np.array([[v2, v2, v2, v2], [v1, v2, v2, v2]], dtype=dtype) img_aug = aug.augment_image(img) assert img_aug.dtype == np.dtype(dtype) assert _allclose(img_aug, (7 / 8) * v2 + (1 / 8) * v1)
def test_SigmoidContrast(): reseed() img = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] img = np.uint8(img) img3d = np.tile(img[:, :, np.newaxis], (1, 1, 3)) # check basic functionality with per_chanenl on/off (makes no difference due to deterministic # parameters) for per_channel in [False, 0, 0.0, True, 1, 1.0]: for gain, cutoff in itertools.product([5, 10], [0.25, 0.75]): aug = iaa.SigmoidContrast(gain=iap.Deterministic(gain), cutoff=iap.Deterministic(cutoff), per_channel=per_channel) img_aug = aug.augment_image(img) img3d_aug = aug.augment_image(img3d) assert img_aug.dtype.type == np.uint8 assert img3d_aug.dtype.type == np.uint8 assert np.array_equal(img_aug, skimage.exposure.adjust_sigmoid(img, gain=gain, cutoff=cutoff)) assert np.array_equal(img3d_aug, skimage.exposure.adjust_sigmoid(img3d, gain=gain, cutoff=cutoff)) # check that tuple to uniform works # note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match # the order of skimage's function aug = iaa.SigmoidContrast(gain=(1, 2), cutoff=(0.25, 0.75)) assert isinstance(aug.params1d[0], iap.Uniform) assert isinstance(aug.params1d[0].a, iap.Deterministic) assert isinstance(aug.params1d[0].b, iap.Deterministic) assert np.allclose(aug.params1d[0].a.value, 0.25) assert np.allclose(aug.params1d[0].b.value, 0.75) assert isinstance(aug.params1d[1], iap.Uniform) assert isinstance(aug.params1d[1].a, iap.Deterministic) assert isinstance(aug.params1d[1].b, iap.Deterministic) assert aug.params1d[1].a.value == 1 assert aug.params1d[1].b.value == 2 # check that list to choice works # note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match # the order of skimage's function aug = iaa.SigmoidContrast(gain=[1, 2], cutoff=[0.25, 0.75]) assert isinstance(aug.params1d[0], iap.Choice) assert all([np.allclose(val, val_choice) for val, val_choice in zip([0.25, 0.75], aug.params1d[0].a)]) assert isinstance(aug.params1d[1], iap.Choice) assert all([val in aug.params1d[1].a for val in [1, 2]]) # check that per_channel at 50% prob works aug = iaa.SigmoidContrast(gain=(1, 10), cutoff=(0.25, 0.75), per_channel=0.5) seen = [False, False] img1000d = np.zeros((1, 1, 1000), dtype=np.uint8) + 128 for _ in sm.xrange(100): img_aug = aug.augment_image(img1000d) assert img_aug.dtype.type == np.uint8 l = len(set(img_aug.flatten().tolist())) if l == 1: seen[0] = True else: seen[1] = True if all(seen): break assert all(seen) # check that keypoints are not changed kpsoi = ia.KeypointsOnImage([ia.Keypoint(1, 1)], shape=(3, 3, 3)) kpsoi_aug = iaa.SigmoidContrast(gain=10, cutoff=0.5).augment_keypoints([kpsoi]) assert keypoints_equal([kpsoi], kpsoi_aug) # check that heatmaps are not changed heatmaps = ia.HeatmapsOnImage(np.zeros((3, 3, 1), dtype=np.float32) + 0.5, shape=(3, 3, 3)) heatmaps_aug = iaa.SigmoidContrast(gain=10, cutoff=0.5).augment_heatmaps([heatmaps])[0] assert np.allclose(heatmaps.arr_0to1, heatmaps_aug.arr_0to1)
def test_LinearContrast(): reseed() img = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] img = np.uint8(img) img3d = np.tile(img[:, :, np.newaxis], (1, 1, 3)) # check basic functionality with alpha=1 or 2 (deterministic) and per_chanenl on/off (makes # no difference due to deterministic alpha) for per_channel in [False, 0, 0.0, True, 1, 1.0]: for alpha in [1, 2]: aug = iaa.LinearContrast(alpha=iap.Deterministic(alpha), per_channel=per_channel) img_aug = aug.augment_image(img) img3d_aug = aug.augment_image(img3d) assert img_aug.dtype.type == np.uint8 assert img3d_aug.dtype.type == np.uint8 assert np.array_equal( img_aug, contrast_lib._adjust_linear(img, alpha=alpha)) assert np.array_equal( img3d_aug, contrast_lib._adjust_linear(img3d, alpha=alpha)) # check that tuple to uniform works aug = iaa.LinearContrast((1, 2)) assert isinstance(aug.params1d[0], iap.Uniform) assert isinstance(aug.params1d[0].a, iap.Deterministic) assert isinstance(aug.params1d[0].b, iap.Deterministic) assert aug.params1d[0].a.value == 1 assert aug.params1d[0].b.value == 2 # check that list to choice works aug = iaa.LinearContrast([1, 2]) assert isinstance(aug.params1d[0], iap.Choice) assert all([val in aug.params1d[0].a for val in [1, 2]]) # check that per_channel at 50% prob works aug = iaa.LinearContrast((0.5, 2.0), per_channel=0.5) seen = [False, False] # must not use just value 128 here, otherwise nothing will change as all values would have # distance 0 to 128 img1000d = np.zeros((1, 1, 1000), dtype=np.uint8) + 128 + 20 for _ in sm.xrange(100): img_aug = aug.augment_image(img1000d) assert img_aug.dtype.type == np.uint8 l = len(set(img_aug.flatten().tolist())) if l == 1: seen[0] = True else: seen[1] = True if all(seen): break assert all(seen) # check that keypoints are not changed kpsoi = ia.KeypointsOnImage([ia.Keypoint(1, 1)], shape=(3, 3, 3)) kpsoi_aug = iaa.LinearContrast(alpha=2).augment_keypoints([kpsoi]) assert keypoints_equal([kpsoi], kpsoi_aug) # check that heatmaps are not changed heatmaps = ia.HeatmapsOnImage(np.zeros((3, 3, 1), dtype=np.float32) + 0.5, shape=(3, 3, 3)) heatmaps_aug = iaa.LinearContrast(alpha=2).augment_heatmaps([heatmaps])[0] assert np.allclose(heatmaps.arr_0to1, heatmaps_aug.arr_0to1)
def test_GammaContrast(): reseed() img = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] img = np.uint8(img) img3d = np.tile(img[:, :, np.newaxis], (1, 1, 3)) # check basic functionality with gamma=1 or 2 (deterministic) and per_chanenl on/off (makes # no difference due to deterministic gamma) for per_channel in [False, 0, 0.0, True, 1, 1.0]: for gamma in [1, 2]: aug = iaa.GammaContrast(gamma=iap.Deterministic(gamma), per_channel=per_channel) img_aug = aug.augment_image(img) img3d_aug = aug.augment_image(img3d) assert img_aug.dtype.type == np.uint8 assert img3d_aug.dtype.type == np.uint8 assert np.array_equal( img_aug, skimage.exposure.adjust_gamma(img, gamma=gamma)) assert np.array_equal( img3d_aug, skimage.exposure.adjust_gamma(img3d, gamma=gamma)) # check that tuple to uniform works aug = iaa.GammaContrast((1, 2)) assert isinstance(aug.params1d[0], iap.Uniform) assert isinstance(aug.params1d[0].a, iap.Deterministic) assert isinstance(aug.params1d[0].b, iap.Deterministic) assert aug.params1d[0].a.value == 1 assert aug.params1d[0].b.value == 2 # check that list to choice works aug = iaa.GammaContrast([1, 2]) assert isinstance(aug.params1d[0], iap.Choice) assert all([val in aug.params1d[0].a for val in [1, 2]]) # check that per_channel at 50% prob works aug = iaa.GammaContrast((0.5, 2.0), per_channel=0.5) seen = [False, False] img1000d = np.zeros((1, 1, 1000), dtype=np.uint8) + 128 for _ in sm.xrange(100): img_aug = aug.augment_image(img1000d) assert img_aug.dtype.type == np.uint8 l = len(set(img_aug.flatten().tolist())) if l == 1: seen[0] = True else: seen[1] = True if all(seen): break assert all(seen) # check that keypoints are not changed kpsoi = ia.KeypointsOnImage([ia.Keypoint(1, 1)], shape=(3, 3, 3)) kpsoi_aug = iaa.GammaContrast(gamma=2).augment_keypoints([kpsoi]) assert keypoints_equal([kpsoi], kpsoi_aug) # check that heatmaps are not changed heatmaps = ia.HeatmapsOnImage(np.zeros((3, 3, 1), dtype=np.float32) + 0.5, shape=(3, 3, 3)) heatmaps_aug = iaa.GammaContrast(gamma=2).augment_heatmaps([heatmaps])[0] assert np.allclose(heatmaps.arr_0to1, heatmaps_aug.arr_0to1) ################### # test other dtypes ################### # uint, int for dtype in [ np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64 ]: min_value, center_value, max_value = meta.get_value_range_of_dtype( dtype) exps = [1, 2, 3] values = [0, 100, int(center_value + 0.1 * max_value)] tolerances = [ 0, 0, 1e-8 * max_value if dtype in [np.uint64, np.int64] else 0 ] for exp in exps: aug = iaa.GammaContrast(exp) for value, tolerance in zip(values, tolerances): image = np.full((3, 3), value, dtype=dtype) expected = (((image.astype(np.float128) / max_value)**exp) * max_value).astype(dtype) image_aug = aug.augment_image(image) assert image_aug.dtype == np.dtype(dtype) assert len(np.unique(image_aug)) == 1 value_aug = int(image_aug[0, 0]) value_expected = int(expected[0, 0]) diff = abs(value_aug - value_expected) assert diff <= tolerance # float for dtype in [np.float16, np.float32, np.float64]: def _allclose(a, b): atol = 1e-3 if dtype == np.float16 else 1e-8 return np.allclose(a, b, atol=atol, rtol=0) exps = [1, 2] isize = np.dtype(dtype).itemsize values = [0, 1.0, 50.0, 100**(isize - 1)] for exp in exps: aug = iaa.GammaContrast(exp) for value in values: image = np.full((3, 3), value, dtype=dtype) expected = (image.astype(np.float128)**exp).astype(dtype) image_aug = aug.augment_image(image) assert image_aug.dtype == np.dtype(dtype) assert _allclose(image_aug, expected)
def test_SigmoidContrast(): reseed() img = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] img = np.uint8(img) img3d = np.tile(img[:, :, np.newaxis], (1, 1, 3)) # check basic functionality with per_chanenl on/off (makes no difference due to deterministic # parameters) for per_channel in [False, 0, 0.0, True, 1, 1.0]: for gain, cutoff in itertools.product([5, 10], [0.25, 0.75]): aug = iaa.SigmoidContrast(gain=iap.Deterministic(gain), cutoff=iap.Deterministic(cutoff), per_channel=per_channel) img_aug = aug.augment_image(img) img3d_aug = aug.augment_image(img3d) assert img_aug.dtype.type == np.uint8 assert img3d_aug.dtype.type == np.uint8 assert np.array_equal( img_aug, skimage.exposure.adjust_sigmoid(img, gain=gain, cutoff=cutoff)) assert np.array_equal( img3d_aug, skimage.exposure.adjust_sigmoid(img3d, gain=gain, cutoff=cutoff)) # check that tuple to uniform works # note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match # the order of skimage's function aug = iaa.SigmoidContrast(gain=(1, 2), cutoff=(0.25, 0.75)) assert isinstance(aug.params1d[0], iap.Uniform) assert isinstance(aug.params1d[0].a, iap.Deterministic) assert isinstance(aug.params1d[0].b, iap.Deterministic) assert np.allclose(aug.params1d[0].a.value, 0.25) assert np.allclose(aug.params1d[0].b.value, 0.75) assert isinstance(aug.params1d[1], iap.Uniform) assert isinstance(aug.params1d[1].a, iap.Deterministic) assert isinstance(aug.params1d[1].b, iap.Deterministic) assert aug.params1d[1].a.value == 1 assert aug.params1d[1].b.value == 2 # check that list to choice works # note that gain and cutoff are saved in inverted order in _ContrastFuncWrapper to match # the order of skimage's function aug = iaa.SigmoidContrast(gain=[1, 2], cutoff=[0.25, 0.75]) assert isinstance(aug.params1d[0], iap.Choice) assert all([ np.allclose(val, val_choice) for val, val_choice in zip([0.25, 0.75], aug.params1d[0].a) ]) assert isinstance(aug.params1d[1], iap.Choice) assert all([val in aug.params1d[1].a for val in [1, 2]]) # check that per_channel at 50% prob works aug = iaa.SigmoidContrast(gain=(1, 10), cutoff=(0.25, 0.75), per_channel=0.5) seen = [False, False] img1000d = np.zeros((1, 1, 1000), dtype=np.uint8) + 128 for _ in sm.xrange(100): img_aug = aug.augment_image(img1000d) assert img_aug.dtype.type == np.uint8 l = len(set(img_aug.flatten().tolist())) if l == 1: seen[0] = True else: seen[1] = True if all(seen): break assert all(seen) # check that keypoints are not changed kpsoi = ia.KeypointsOnImage([ia.Keypoint(1, 1)], shape=(3, 3, 3)) kpsoi_aug = iaa.SigmoidContrast(gain=10, cutoff=0.5).augment_keypoints([kpsoi]) assert keypoints_equal([kpsoi], kpsoi_aug) # check that heatmaps are not changed heatmaps = ia.HeatmapsOnImage(np.zeros((3, 3, 1), dtype=np.float32) + 0.5, shape=(3, 3, 3)) heatmaps_aug = iaa.SigmoidContrast(gain=10, cutoff=0.5).augment_heatmaps([heatmaps ])[0] assert np.allclose(heatmaps.arr_0to1, heatmaps_aug.arr_0to1) ################### # test other dtypes ################### # uint, int for dtype in [ np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64 ]: min_value, center_value, max_value = meta.get_value_range_of_dtype( dtype) gains = [5, 20] cutoffs = [0.25, 0.75] values = [0, 100, int(center_value + 0.1 * max_value)] tmax = 1e-8 * max_value if dtype in [np.uint64, np.int64] else 0 tolerances = [tmax, tmax, tmax] for gain, cutoff in itertools.product(gains, cutoffs): aug = iaa.SigmoidContrast(gain=gain, cutoff=cutoff) for value, tolerance in zip(values, tolerances): image = np.full((3, 3), value, dtype=dtype) # 1/(1 + exp(gain*(cutoff - I_ij/max))) expected = (1 / (1 + np.exp( gain * (cutoff - image.astype(np.float128) / max_value)))) expected = (expected * max_value).astype(dtype) image_aug = aug.augment_image(image) assert image_aug.dtype == np.dtype(dtype) assert len(np.unique(image_aug)) == 1 value_aug = int(image_aug[0, 0]) value_expected = int(expected[0, 0]) diff = abs(value_aug - value_expected) assert diff <= tolerance # float for dtype in [np.float16, np.float32, np.float64]: def _allclose(a, b): atol = 1e-3 if dtype == np.float16 else 1e-8 return np.allclose(a, b, atol=atol, rtol=0) gains = [5, 20] cutoffs = [0.25, 0.75] isize = np.dtype(dtype).itemsize values = [0, 1.0, 50.0, 100**(isize - 1)] for gain, cutoff in itertools.product(gains, cutoffs): aug = iaa.SigmoidContrast(gain=gain, cutoff=cutoff) for value in values: image = np.full((3, 3), value, dtype=dtype) expected = (1 / (1 + np.exp(gain * (cutoff - image.astype(np.float128)))) ).astype(dtype) image_aug = aug.augment_image(image) assert image_aug.dtype == np.dtype(dtype) assert _allclose(image_aug, expected)