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)
