def test_correct_results(self, im_type, degrees, keep_size, mode, padding_mode, align_corners): rotate_fn = RandRotated( "img", range_x=degrees, prob=1.0, keep_size=keep_size, mode=mode, padding_mode=padding_mode, align_corners=align_corners, dtype=np.float64, ) im = im_type(self.imt[0]) rotate_fn.set_random_state(243) rotated = rotate_fn({"img": im, "seg": im_type(self.segn[0])}) _order = 0 if mode == "nearest" else 1 if padding_mode == "border": _mode = "nearest" elif padding_mode == "reflection": _mode = "reflect" else: _mode = "constant" angle = rotate_fn.rand_rotate.x expected = scipy.ndimage.rotate( self.imt[0, 0], -np.rad2deg(angle), (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False ) test_local_inversion(rotate_fn, rotated, {"img": im}, "img") for k, v in rotated.items(): rotated[k] = v.cpu() if isinstance(v, torch.Tensor) else v expected = np.stack(expected).astype(np.float32) good = np.sum(np.isclose(expected, rotated["img"][0], atol=1e-3)) self.assertLessEqual(np.abs(good - expected.size), 5, "diff at most 5 pixels")
def test_correct_results(self, _, spatial_axis): for p in TEST_NDARRAYS_ALL: flip = Flipd(keys="img", spatial_axis=spatial_axis) expected = [np.flip(channel, spatial_axis) for channel in self.imt[0]] expected = np.stack(expected) im = p(self.imt[0]) result = flip({"img": im})["img"] assert_allclose(result, p(expected), type_test="tensor") test_local_inversion(flip, {"img": result}, {"img": im}, "img")
def test_affine(self, input_param, input_data, expected_val): input_copy = deepcopy(input_data) g = Affined(**input_param) result = g(input_data) test_local_inversion(g, result, input_copy, dict_key="img") assert_allclose(result["img"], expected_val, rtol=1e-4, atol=1e-4, type_test="tensor")
def test_correct_results(self, _, spatial_axis): for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) flip = Flip(spatial_axis=spatial_axis) expected = [ np.flip(channel, spatial_axis) for channel in self.imt[0] ] expected = np.stack(expected) result = flip(im) assert_allclose(result, p(expected), type_test="tensor") test_local_inversion(flip, result, im)
def test_correct_shape(self, im_type, angle, mode, padding_mode, align_corners): rotate_fn = Rotate(angle, True, align_corners=align_corners, dtype=np.float64) im = im_type(self.imt[0]) set_track_meta(False) rotated = rotate_fn(im, mode=mode, padding_mode=padding_mode) self.assertNotIsInstance(rotated, MetaTensor) np.testing.assert_allclose(self.imt[0].shape, rotated.shape) set_track_meta(True) rotated = rotate_fn(im, mode=mode, padding_mode=padding_mode) np.testing.assert_allclose(self.imt[0].shape, rotated.shape) test_local_inversion(rotate_fn, rotated, im)
def test_prob_k_spatial_axes(self): key = "test" rotate = Rotate90d(keys=key, k=2, spatial_axes=(0, 1)) for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) rotated = rotate({key: im}) test_local_inversion(rotate, rotated, {key: im}, key) expected = [ np.rot90(channel, 2, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated[key], p(expected), type_test="tensor")
def test_spatial_axes(self): key = "test" rotate = RandRotate90d(keys=key, spatial_axes=(0, 1)) for p in TEST_NDARRAYS_ALL: rotate.set_random_state(234) im = {key: p(self.imt[0])} rotated = rotate(im) test_local_inversion(rotate, rotated, im, key) expected = [ np.rot90(channel, 0, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated[key], p(expected), type_test="tensor")
def test_keep_size(self): for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) random_zoom = RandZoom(prob=1.0, min_zoom=0.6, max_zoom=0.7, keep_size=True) random_zoom.set_random_state(12) zoomed = random_zoom(im) test_local_inversion(random_zoom, zoomed, im) self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:])) zoomed = random_zoom(im) self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:])) zoomed = random_zoom(im) self.assertTrue(np.array_equal(zoomed.shape, self.imt.shape[1:]))
def test_rotate90_default(self): rotate = Rotate90() for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) rotated = rotate(im) test_local_inversion(rotate, rotated, im) expected = [ np.rot90(channel, 1, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
def test_correct_results(self): for p in TEST_NDARRAYS_ALL: flip = RandAxisFlip(prob=1.0) im = p(self.imt[0]) result = flip(im) expected = [ np.flip(channel, flip._axis) for channel in self.imt[0] ] assert_allclose(result, p(np.stack(expected)), type_test="tensor") test_local_inversion(flip, result, im) set_track_meta(False) result = flip(im) self.assertNotIsInstance(result, MetaTensor) self.assertIsInstance(result, torch.Tensor) set_track_meta(True)
def test_prob_k_spatial_axes(self): rotate = RandRotate90(prob=1.0, max_k=2, spatial_axes=(0, 1)) for p in TEST_NDARRAYS_ALL: rotate.set_random_state(234) im = p(self.imt[0]) rotated = rotate(im) test_local_inversion(rotate, rotated, im) expected = [ np.rot90(channel, 1, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
def test_rotate90_default(self): key = "test" rotate = Rotate90d(keys=key) for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) set_track_meta(True) rotated = rotate({key: im}) test_local_inversion(rotate, rotated, {key: im}, key) expected = [ np.rot90(channel, 1, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated[key], p(expected), type_test="tensor") set_track_meta(False) rotated = rotate({key: im}) self.assertNotIsInstance(rotated[key], MetaTensor) set_track_meta(True)
def test_spatial_axes(self): rotate = RandRotate90(spatial_axes=(0, 1), prob=1.0) for p in TEST_NDARRAYS_ALL: rotate.set_random_state(1234) im = p(self.imt[0]) rotated = rotate(im) self.assertEqual(len(rotated.applied_operations), 1) expected = [ np.rot90(channel, rotate._rand_k, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor") test_local_inversion(rotate, rotated, im)
def test_correct_results(self, im_type, angle, keep_size, mode, padding_mode, align_corners): rotate_fn = Rotated(("img", "seg"), angle, keep_size, (mode, "nearest"), padding_mode, align_corners, dtype=np.float64) im = im_type(self.imt[0]) rotated = rotate_fn({"img": im, "seg": im_type(self.segn[0])}) if keep_size: np.testing.assert_allclose(self.imt[0].shape, rotated["img"].shape) _order = 0 if mode == "nearest" else 1 if padding_mode == "border": _mode = "nearest" elif padding_mode == "reflection": _mode = "reflect" else: _mode = "constant" expected = scipy.ndimage.rotate(self.imt[0, 0], -np.rad2deg(angle), (0, 1), not keep_size, order=_order, mode=_mode, prefilter=False) for k, v in rotated.items(): rotated[k] = v.cpu() if isinstance(v, torch.Tensor) else v good = np.sum(np.isclose(expected, rotated["img"][0], atol=1e-3)) self.assertLessEqual(np.abs(good - expected.size), 5, "diff at most 5 pixels") test_local_inversion(rotate_fn, rotated, {"img": im}, "img") expected = scipy.ndimage.rotate(self.segn[0, 0], -np.rad2deg(angle), (0, 1), not keep_size, order=0, mode=_mode, prefilter=False) expected = np.stack(expected).astype(int) if isinstance(rotated["seg"], MetaTensor): rotated["seg"] = rotated["seg"].as_tensor( ) # pytorch 1.7 compatible self.assertLessEqual(np.count_nonzero(expected != rotated["seg"][0]), 30)
def test_default(self): key = None rotate = RandRotate90d(keys=key) for p in TEST_NDARRAYS_ALL: rotate.set_random_state(1323) im = {key: p(self.imt[0])} rotated = rotate(im) test_local_inversion(rotate, rotated, im, key) expected = [ np.rot90(channel, 0, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated[key], p(expected), type_test="tensor") set_track_meta(False) rotated = rotate(im)[key] self.assertNotIsInstance(rotated, MetaTensor) self.assertIsInstance(rotated, torch.Tensor) set_track_meta(True)
def test_correct_results(self, zoom, mode): for p in TEST_NDARRAYS_ALL: zoom_fn = Zoom(zoom=zoom, mode=mode, keep_size=False) im = p(self.imt[0]) zoomed = zoom_fn(im) test_local_inversion(zoom_fn, zoomed, im) _order = 0 if mode.endswith("linear"): _order = 1 expected = [] for channel in self.imt[0]: expected.append( zoom_scipy(channel, zoom=zoom, mode="nearest", order=_order, prefilter=False)) expected = np.stack(expected).astype(np.float32) assert_allclose(zoomed, p(expected), atol=1.0, type_test=False)
def test_keep_size(self): for p in TEST_NDARRAYS_ALL: zoom_fn = Zoom(zoom=[0.6, 0.6], keep_size=True, align_corners=True) im = p(self.imt[0]) zoomed = zoom_fn(im, mode="bilinear") assert_allclose(zoomed.shape, self.imt.shape[1:], type_test=False) test_local_inversion(zoom_fn, zoomed, im) zoom_fn = Zoom(zoom=[1.3, 1.3], keep_size=True) im = p(self.imt[0]) zoomed = zoom_fn(im) assert_allclose(zoomed.shape, self.imt.shape[1:], type_test=False) test_local_inversion(zoom_fn, zoomed, p(self.imt[0])) set_track_meta(False) rotated = zoom_fn(im) self.assertNotIsInstance(rotated, MetaTensor) np.testing.assert_allclose(zoomed.shape, self.imt.shape[1:]) set_track_meta(True)
def test_affine(self, input_param, input_data, expected_val): input_copy = deepcopy(input_data["img"]) g = Affine(**input_param) result = g(**input_data) if isinstance(result, tuple): result = result[0] test_local_inversion(g, result, input_copy) assert_allclose(result, expected_val, rtol=1e-4, atol=1e-4, type_test=False) set_track_meta(False) result = g(**input_data) if isinstance(result, tuple): result = result[0] self.assertNotIsInstance(result, MetaTensor) self.assertIsInstance(result, torch.Tensor) set_track_meta(True)
def test_correct_results(self, min_zoom, max_zoom, mode, keep_size): for p in TEST_NDARRAYS_ALL: random_zoom = RandZoom(prob=1.0, min_zoom=min_zoom, max_zoom=max_zoom, mode=mode, keep_size=keep_size) random_zoom.set_random_state(1234) im = p(self.imt[0]) zoomed = random_zoom(im) test_local_inversion(random_zoom, zoomed, im) expected = [ zoom_scipy(channel, zoom=random_zoom._zoom, mode="nearest", order=0, prefilter=False) for channel in self.imt[0] ] expected = np.stack(expected).astype(np.float32) assert_allclose(zoomed, p(expected), atol=1.0, type_test=False)
def test_k(self): rotate = RandRotate90(max_k=2) for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) set_track_meta(False) rotated = rotate(im) self.assertNotIsInstance(rotated, MetaTensor) self.assertIsInstance(rotated, torch.Tensor) set_track_meta(True) rotate.set_random_state(123) rotated = rotate(im) test_local_inversion(rotate, rotated, im) expected = [ np.rot90(channel, 0, (0, 1)) for channel in self.imt[0] ] expected = np.stack(expected) assert_allclose(rotated, p(expected), rtol=1.0e-5, atol=1.0e-8, type_test="tensor")
def test_correct_results(self, spatial_size, mode): resize = Resized("img", spatial_size, mode=mode) _order = 0 if mode.endswith("linear"): _order = 1 if spatial_size == (32, -1): spatial_size = (32, 64) expected = [ skimage.transform.resize(channel, spatial_size, order=_order, clip=False, preserve_range=False, anti_aliasing=False) for channel in self.imt[0] ] expected = np.stack(expected).astype(np.float32) for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) out = resize({"img": im}) test_local_inversion(resize, out, {"img": im}, "img") assert_allclose(out["img"], expected, type_test=False, atol=0.9)
def test_correct_results(self, zoom, mode, keep_size): key = "img" zoom_fn = Zoomd(key, zoom=zoom, mode=mode, keep_size=keep_size) for p in TEST_NDARRAYS_ALL: im = p(self.imt[0]) zoomed = zoom_fn({key: im}) test_local_inversion(zoom_fn, zoomed, {key: im}, key) _order = 0 if mode.endswith("linear"): _order = 1 expected = [ zoom_scipy(channel, zoom=zoom, mode="nearest", order=_order, prefilter=False) for channel in self.imt[0] ] expected = np.stack(expected).astype(np.float32) assert_allclose(zoomed[key], p(expected), atol=1.0, type_test=False)
def test_correct_results(self, im_type, x, y, z, keep_size, mode, padding_mode, align_corners, expected): rotate_fn = RandRotate( range_x=x, range_y=y, range_z=z, prob=1.0, keep_size=keep_size, mode=mode, padding_mode=padding_mode, align_corners=align_corners, dtype=np.float64, ) rotate_fn.set_random_state(243) im = im_type(self.imt[0]) rotated = rotate_fn(im) torch.testing.assert_allclose(rotated.shape, expected, rtol=1e-7, atol=0) test_local_inversion(rotate_fn, rotated, im) set_track_meta(False) rotated = rotate_fn(im) self.assertNotIsInstance(rotated, MetaTensor) self.assertIsInstance(rotated, torch.Tensor) set_track_meta(True)