def test_astype(self):
t = MetaTensor([1.0], affine=torch.tensor(1), meta={"fname": "filename"})
for np_types in ("float32", "np.float32", "numpy.float32", np.float32, float, "int", np.compat.long, np.uint16):
self.assertIsInstance(t.astype(np_types), np.ndarray)
for pt_types in ("torch.float", torch.float, "torch.float64"):
self.assertIsInstance(t.astype(pt_types), torch.Tensor)
self.assertIsInstance(t.astype("torch.float", device="cpu"), torch.Tensor)
def test_constructor(self, device, dtype):
m, t = self.get_im(device=device, dtype=dtype)
# construct from pre-existing
m1 = MetaTensor(m.clone())
self.check(m, m1, ids=False, meta=False)
# meta already has affine
m2 = MetaTensor(t.clone(), meta=m.meta)
self.check(m, m2, ids=False, meta=False)
# meta dosen't have affine
affine = m.meta.pop("affine")
m3 = MetaTensor(t.clone(), affine=affine, meta=m.meta)
self.check(m, m3, ids=False, meta=False)
def test_check(self):
im = torch.zeros(1, 2, 3)
with self.assertRaises(ValueError): # not MetaTensor
EnsureChannelFirst()(im)
with self.assertRaises(ValueError): # no meta
EnsureChannelFirst()(MetaTensor(im))
with self.assertRaises(ValueError): # no meta channel
EnsureChannelFirst()(MetaTensor(
im, meta={"original_channel_dim": None}))
EnsureChannelFirst(strict_check=False)(im)
EnsureChannelFirst(strict_check=False)(MetaTensor(
im, meta={"original_channel_dim": None}))
def test_exceptions(self):
im = torch.zeros((1, 2, 3))
with self.assertRaises(ValueError): # no meta
EnsureChannelFirstd("img")({"img": im})
with self.assertRaises(ValueError): # no meta channel
EnsureChannelFirstd("img")({
"img":
MetaTensor(im, meta={"original_channel_dim": None})
})
EnsureChannelFirstd("img", strict_check=False)({"img": im})
EnsureChannelFirstd("img", strict_check=False)({
"img":
MetaTensor(im, meta={"original_channel_dim": None})
})
def test_multiprocessing(self, device=None, dtype=None):
"""multiprocessing sharing with 'device' and 'dtype'"""
buf = io.BytesIO()
t = MetaTensor([0.0, 0.0], device=device, dtype=dtype)
t.is_batch = True
if t.is_cuda:
with self.assertRaises(NotImplementedError):
ForkingPickler(buf).dump(t)
return
ForkingPickler(buf).dump(t)
obj = ForkingPickler.loads(buf.getvalue())
self.assertIsInstance(obj, MetaTensor)
assert_allclose(obj.as_tensor(), t)
assert_allclose(obj.is_batch, True)
def test_array_function(self, device="cpu", dtype=float):
a = np.random.RandomState().randn(100, 100)
b = MetaTensor(a, device=device)
assert_allclose(np.sum(a), np.sum(b))
assert_allclose(np.sum(a, axis=1), np.sum(b, axis=1))
assert_allclose(np.linalg.qr(a), np.linalg.qr(b))
c = MetaTensor([1.0, 2.0, 3.0], device=device, dtype=dtype)
assert_allclose(np.argwhere(c == 1.0).astype(int).tolist(), [[0]])
assert_allclose(np.concatenate([c, c]), np.asarray([1.0, 2.0, 3.0, 1.0, 2.0, 3.0]))
if pytorch_after(1, 8, 1):
assert_allclose(c > np.asarray([1.0, 1.0, 1.0]), np.asarray([False, True, True]))
assert_allclose(
c > torch.as_tensor([1.0, 1.0, 1.0], device=device), torch.as_tensor([False, True, True], device=device)
)
def test_as_dict(self):
m, _ = self.get_im()
m_dict = m.as_dict("im")
im, meta = m_dict["im"], m_dict[PostFix.meta("im")]
affine = meta.pop("affine")
m2 = MetaTensor(im, affine, meta)
self.check(m2, m, check_ids=False)
def test_construct_with_pre_applied_transforms(self):
key = "im"
_, im = self.get_im()
tr = Compose([BorderPadd(key, 1), DivisiblePadd(key, 16)])
data = tr({key: im})
m = MetaTensor(im, applied_operations=data["im"].applied_operations)
self.assertEqual(len(m.applied_operations), len(tr.transforms))
def test_str(self):
t = MetaTensor([1.0], affine=torch.tensor(1), meta={"fname": "filename"})
s1 = str(t)
s2 = t.__repr__()
expected_out = (
"tensor([1.])\n"
+ "MetaData\n"
+ "\tfname: filename\n"
+ "\taffine: 1\n"
+ "\n"
+ "Applied operations\n"
+ "[]\n"
+ "Is batch?: False"
)
for s in (s1, s2):
self.assertEqual(s, expected_out)
def png_rw(self, test_data, reader, writer, dtype, resample=True):
test_data = test_data.astype(dtype)
ndim = len(test_data.shape) - 1
for p in TEST_NDARRAYS:
output_ext = ".png"
filepath = f"testfile_{ndim}d"
saver = SaveImage(output_dir=self.test_dir,
output_ext=output_ext,
resample=resample,
separate_folder=False,
writer=writer)
test_data = MetaTensor(p(test_data),
meta={
"filename_or_obj": f"{filepath}.png",
"spatial_shape": (6, 8)
})
saver(test_data)
saved_path = os.path.join(self.test_dir,
filepath + "_trans" + output_ext)
self.assertTrue(os.path.exists(saved_path))
loader = LoadImage(image_only=True, reader=reader)
data = loader(saved_path)
meta = data.meta
if meta["original_channel_dim"] == -1:
_test_data = moveaxis(test_data, 0, -1)
else:
_test_data = test_data[0]
assert_allclose(data, torch.as_tensor(_test_data))
def __call__(
self, data: Mapping[Hashable, NdarrayOrTensor]
) -> Dict[Hashable, NdarrayOrTensor]:
d = dict(data)
for key in self.key_iterator(d):
self.push_transform(d, key)
im, meta = d[key], d.pop(PostFix.meta(key), None)
im = MetaTensor(im, meta=meta) # type: ignore
d[key] = im
return d
def get_im(shape=None, dtype=None, device=None):
if shape is None:
shape = (1, 10, 8)
affine = torch.randint(0, 10, (4, 4))
meta = {"fname": rand_string()}
t = torch.rand(shape)
if dtype is not None:
t = t.to(dtype)
if device is not None:
t = t.to(device)
m = MetaTensor(t.clone(), affine, meta)
return m, t
def test_copy(self, device, dtype):
m, _ = self.get_im(device=device, dtype=dtype)
# shallow copy
a = m
self.check(a, m, ids=True)
# deepcopy
a = deepcopy(m)
self.check(a, m, ids=False)
# clone
a = m.clone()
self.check(a, m, ids=False)
a = MetaTensor([[]], device=device, dtype=dtype)
self.check(a, deepcopy(a), ids=False)
def inverse(
self, data: Mapping[Hashable, NdarrayOrTensor]
) -> Dict[Hashable, NdarrayOrTensor]:
d = deepcopy(dict(data))
for key in self.key_iterator(d):
# check transform
_ = self.get_most_recent_transform(d, key)
# do the inverse
im, meta = d[key], d.pop(PostFix.meta(key), None)
im = MetaTensor(im, meta=meta) # type: ignore
d[key] = im
# Remove the applied transform
self.pop_transform(d, key)
return d
def test_ornt_meta(
self,
init_param,
img: torch.Tensor,
affine: torch.Tensor,
expected_data: torch.Tensor,
expected_code: str,
device,
):
img = MetaTensor(img, affine=affine).to(device)
ornt = Orientation(**init_param)
res: MetaTensor = ornt(img)
assert_allclose(res, expected_data.to(device))
new_code = nib.orientations.aff2axcodes(res.affine.cpu(), labels=ornt.labels)
self.assertEqual("".join(new_code), expected_code)
def test_dataloader(self, dtype):
batch_size = 5
ims = [self.get_im(dtype=dtype)[0] for _ in range(batch_size * 2)]
ims = [MetaTensor(im, applied_operations=[f"t{i}"]) for i, im in enumerate(ims)]
ds = Dataset(ims)
im_shape = tuple(ims[0].shape)
affine_shape = tuple(ims[0].affine.shape)
expected_im_shape = (batch_size,) + im_shape
expected_affine_shape = (batch_size,) + affine_shape
dl = DataLoader(ds, num_workers=batch_size, batch_size=batch_size)
for batch in dl:
self.assertIsInstance(batch, MetaTensor)
self.assertTupleEqual(tuple(batch.shape), expected_im_shape)
self.assertTupleEqual(tuple(batch.affine.shape), expected_affine_shape)
self.assertEqual(len(batch.applied_operations), batch_size)
def test_orntd(self, init_param, img: torch.Tensor,
affine: Optional[torch.Tensor], expected_shape,
expected_code, device):
ornt = Orientationd(**init_param)
if affine is not None:
img = MetaTensor(img, affine=affine)
img = img.to(device)
data = {k: img.clone() for k in ornt.keys}
res = ornt(data)
for k in ornt.keys:
_im = res[k]
self.assertIsInstance(_im, MetaTensor)
np.testing.assert_allclose(_im.shape, expected_shape)
code = nib.aff2axcodes(_im.affine.cpu(),
ornt.ornt_transform.labels)
self.assertEqual("".join(code), expected_code)
def test_spacing(self, init_param, img, affine, data_param,
expected_output, device):
img = MetaTensor(img, affine=affine).to(device)
res: MetaTensor = Spacing(**init_param)(img, **data_param)
self.assertEqual(img.device, res.device)
assert_allclose(res, expected_output, atol=1e-1, rtol=1e-1)
sr = min(len(res.shape) - 1, 3)
if isinstance(init_param["pixdim"], float):
init_param["pixdim"] = [init_param["pixdim"]] * sr
init_pixdim = ensure_tuple(init_param["pixdim"])
init_pixdim = init_param["pixdim"][:sr]
norm = affine_to_spacing(res.affine, sr).cpu().numpy()
assert_allclose(fall_back_tuple(init_pixdim, norm),
norm,
type_test=False)
def test_collate(self, device, dtype):
numel = 3
ims = [self.get_im(device=device, dtype=dtype)[0] for _ in range(numel)]
ims = [MetaTensor(im, applied_operations=[f"t{i}"]) for i, im in enumerate(ims)]
collated = list_data_collate(ims)
# tensor
self.assertIsInstance(collated, MetaTensor)
expected_shape = (numel,) + tuple(ims[0].shape)
self.assertTupleEqual(tuple(collated.shape), expected_shape)
for i, im in enumerate(ims):
self.check(im, ims[i], ids=True)
# affine
self.assertIsInstance(collated.affine, torch.Tensor)
expected_shape = (numel,) + tuple(ims[0].affine.shape)
self.assertTupleEqual(tuple(collated.affine.shape), expected_shape)
self.assertEqual(len(collated.applied_operations), numel)
def test_inverse(self, device):
img_t = torch.rand((1, 10, 9, 8), dtype=torch.float32, device=device)
affine = torch.tensor(
[[0, 0, -1, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=torch.float32, device="cpu"
)
meta = {"fname": "somewhere"}
img = MetaTensor(img_t, affine=affine, meta=meta)
tr = Orientation("LPS")
# check that image and affine have changed
img = tr(img)
self.assertNotEqual(img.shape, img_t.shape)
self.assertGreater((affine - img.affine).max(), 0.5)
# check that with inverse, image affine are back to how they were
img = tr.inverse(img)
self.assertEqual(img.shape, img_t.shape)
self.assertLess((affine - img.affine).max(), 1e-2)
def test_saved_content(self, test_data, meta_data, output_ext, resample):
if meta_data is not None:
test_data = MetaTensor(test_data, meta=meta_data)
with tempfile.TemporaryDirectory() as tempdir:
trans = SaveImage(
output_dir=tempdir,
output_ext=output_ext,
resample=resample,
separate_folder=False, # test saving into the same folder
)
trans(test_data)
filepath = "testfile0" if meta_data is not None else "0"
self.assertTrue(
os.path.exists(
os.path.join(tempdir, filepath + "_trans" + output_ext)))
def test_flips_inverse(self, img, device, dst_affine, kwargs,
expected_output):
img = MetaTensor(img, affine=torch.eye(4)).to(device)
data = {"img": img, "dst_affine": dst_affine}
xform = SpatialResampled(keys="img", **kwargs)
output_data = xform(data)
out = output_data["img"]
assert_allclose(out, expected_output, rtol=1e-2, atol=1e-2)
assert_allclose(out.affine, dst_affine, rtol=1e-2, atol=1e-2)
inverted = xform.inverse(output_data)["img"]
self.assertEqual(inverted.applied_operations,
[]) # no further invert after inverting
expected_affine = to_affine_nd(len(out.affine) - 1, torch.eye(4))
assert_allclose(inverted.affine, expected_affine, rtol=1e-2, atol=1e-2)
assert_allclose(inverted, img, rtol=1e-2, atol=1e-2)
def test_kwargs(self):
spatial_size = (32, 64, 128)
test_image = np.random.rand(*spatial_size)
with tempfile.TemporaryDirectory() as tempdir:
filename = os.path.join(tempdir, "test_image.nii.gz")
itk_np_view = itk.image_view_from_array(test_image)
itk.imwrite(itk_np_view, filename)
loader = LoadImage(image_only=True)
reader = ITKReader(fallback_only=False)
loader.register(reader)
result = loader(filename)
reader = ITKReader()
img = reader.read(filename, fallback_only=False)
result_raw = reader.get_data(img)
result_raw = MetaTensor.ensure_torch_and_prune_meta(*result_raw)
self.assertTupleEqual(result.shape, result_raw.shape)
def test_inverse(self, device):
img_t = torch.rand((1, 10, 9, 8), dtype=torch.float32, device=device)
affine = torch.tensor(
[[0, 0, -1, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
dtype=torch.float32,
device="cpu")
meta = {"fname": "somewhere"}
img = MetaTensor(img_t, affine=affine, meta=meta)
tr = Spacing(pixdim=[1.1, 1.2, 0.9])
# check that image and affine have changed
img = tr(img)
self.assertNotEqual(img.shape, img_t.shape)
l2_norm_affine = ((affine - img.affine)**2).sum()**0.5
self.assertGreater(l2_norm_affine, 5e-2)
# check that with inverse, image affine are back to how they were
img = tr.inverse(img)
self.assertEqual(img.applied_operations, [])
self.assertEqual(img.shape, img_t.shape)
l2_norm_affine = ((affine - img.affine)**2).sum()**0.5
self.assertLess(l2_norm_affine, 5e-2)
def get_most_recent_transform(self,
data,
key: Hashable = None,
check: bool = True,
pop: bool = False):
"""
Get most recent transform for the stack.
Args:
data: dictionary of data or `MetaTensor`.
key: if data is a dictionary, data[key] will be modified.
check: if true, check that `self` is the same type as the most recently-applied transform.
pop: if true, remove the transform as it is returned.
Returns:
Dictionary of most recently applied transform
Raises:
- RuntimeError: data is neither `MetaTensor` nor dictionary
"""
if not self.tracing:
raise RuntimeError(
"Transform Tracing must be enabled to get the most recent transform."
)
if isinstance(data, MetaTensor):
all_transforms = data.applied_operations
elif isinstance(data, Mapping):
if key in data and isinstance(data[key], MetaTensor):
all_transforms = data[key].applied_operations
else:
all_transforms = data.get(
self.trace_key(key),
MetaTensor.get_default_applied_operations())
else:
raise ValueError(
f"`data` should be either `MetaTensor` or dictionary, got {type(data)}."
)
if check:
self.check_transforms_match(all_transforms[-1])
return all_transforms.pop() if pop else all_transforms[-1]
def nifti_rw(self, test_data, reader, writer, dtype, resample=True):
test_data = test_data.astype(dtype)
ndim = len(test_data.shape) - 1
for p in TEST_NDARRAYS:
output_ext = ".nii.gz"
filepath = f"testfile_{ndim}d"
saver = SaveImage(output_dir=self.test_dir,
output_ext=output_ext,
resample=resample,
separate_folder=False,
writer=writer)
meta_dict = {
"filename_or_obj":
f"{filepath}.png",
"affine":
np.eye(4),
"original_affine":
np.array([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]]),
}
test_data = MetaTensor(p(test_data), meta=meta_dict)
self.assertEqual(test_data.meta[MetaKeys.SPACE], "RAS")
saver(test_data)
saved_path = os.path.join(self.test_dir,
filepath + "_trans" + output_ext)
self.assertTrue(os.path.exists(saved_path))
loader = LoadImage(image_only=True,
reader=reader,
squeeze_non_spatial_dims=True)
data = loader(saved_path)
meta = data.meta
if meta["original_channel_dim"] == -1:
_test_data = moveaxis(test_data, 0, -1)
else:
_test_data = test_data[0]
if resample:
_test_data = moveaxis(_test_data, 0, 1)
assert_allclose(data, torch.as_tensor(_test_data))
def nrrd_rw(self, test_data, reader, writer, dtype, resample=True):
test_data = test_data.astype(dtype)
ndim = len(test_data.shape)
for p in TEST_NDARRAYS:
output_ext = ".nrrd"
filepath = f"testfile_{ndim}d"
saver = SaveImage(output_dir=self.test_dir,
output_ext=output_ext,
resample=resample,
separate_folder=False,
writer=writer)
test_data = MetaTensor(p(test_data),
meta={
"filename_or_obj":
f"{filepath}{output_ext}",
"spatial_shape": test_data.shape
})
saver(test_data)
saved_path = os.path.join(self.test_dir,
filepath + "_trans" + output_ext)
loader = LoadImage(image_only=True, reader=reader)
data = loader(saved_path)
assert_allclose(data, torch.as_tensor(test_data))
def test_numpy(self, device=None, dtype=None):
"""device, dtype"""
t = MetaTensor([0.0], device=device, dtype=dtype)
self.assertIsInstance(t, MetaTensor)
assert_allclose(t.array, np.asarray([0.0]))
t.array = np.asarray([1.0])
self.check_meta(t, MetaTensor([1.0]))
assert_allclose(t.as_tensor(), torch.as_tensor([1.0]))
t.array = [2.0]
self.check_meta(t, MetaTensor([2.0]))
assert_allclose(t.as_tensor(), torch.as_tensor([2.0]))
if not t.is_cuda:
t.array[0] = torch.as_tensor(3.0, device=device, dtype=dtype)
self.check_meta(t, MetaTensor([3.0]))
assert_allclose(t.as_tensor(), torch.as_tensor([3.0]))
def test_value_3d(
self,
keys,
data,
expected_convert_result,
expected_zoom_result,
expected_zoom_keepsize_result,
expected_flip_result,
expected_clip_result,
expected_rotate_result,
):
test_dtype = [torch.float32]
for dtype in test_dtype:
data = CastToTyped(keys=["image", "boxes"], dtype=dtype)(data)
# test ConvertBoxToStandardModed
transform_convert_mode = ConvertBoxModed(**keys)
convert_result = transform_convert_mode(data)
assert_allclose(convert_result["boxes"],
expected_convert_result,
type_test=True,
device_test=True,
atol=1e-3)
invert_transform_convert_mode = Invertd(
keys=["boxes"],
transform=transform_convert_mode,
orig_keys=["boxes"])
data_back = invert_transform_convert_mode(convert_result)
if "boxes_transforms" in data_back: # if the transform is tracked in dict:
self.assertEqual(data_back["boxes_transforms"],
[]) # it should be updated
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
# test ZoomBoxd
transform_zoom = ZoomBoxd(image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
zoom=[0.5, 3, 1.5],
keep_size=False)
zoom_result = transform_zoom(data)
self.assertEqual(len(zoom_result["image"].applied_operations), 1)
assert_allclose(zoom_result["boxes"],
expected_zoom_result,
type_test=True,
device_test=True,
atol=1e-3)
invert_transform_zoom = Invertd(keys=["image", "boxes"],
transform=transform_zoom,
orig_keys=["image", "boxes"])
data_back = invert_transform_zoom(zoom_result)
self.assertEqual(data_back["image"].applied_operations, [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
transform_zoom = ZoomBoxd(image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
zoom=[0.5, 3, 1.5],
keep_size=True)
zoom_result = transform_zoom(data)
self.assertEqual(len(zoom_result["image"].applied_operations), 1)
assert_allclose(zoom_result["boxes"],
expected_zoom_keepsize_result,
type_test=True,
device_test=True,
atol=1e-3)
# test RandZoomBoxd
transform_zoom = RandZoomBoxd(
image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
prob=1.0,
min_zoom=(0.3, ) * 3,
max_zoom=(3.0, ) * 3,
keep_size=False,
)
zoom_result = transform_zoom(data)
self.assertEqual(len(zoom_result["image"].applied_operations), 1)
invert_transform_zoom = Invertd(keys=["image", "boxes"],
transform=transform_zoom,
orig_keys=["image", "boxes"])
data_back = invert_transform_zoom(zoom_result)
self.assertEqual(data_back["image"].applied_operations, [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=0.01)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
# test AffineBoxToImageCoordinated, AffineBoxToWorldCoordinated
transform_affine = AffineBoxToImageCoordinated(
box_keys="boxes", box_ref_image_keys="image")
if not isinstance(
data["image"], MetaTensor
): # metadict should be undefined and it's an exception
with self.assertRaises(Exception) as context:
transform_affine(deepcopy(data))
self.assertTrue(
"Please check whether it is the correct the image meta key."
in str(context.exception))
data["image"] = MetaTensor(
data["image"],
meta={
"affine": torch.diag(1.0 / torch.Tensor([0.5, 3, 1.5, 1]))
})
affine_result = transform_affine(data)
if "boxes_transforms" in affine_result:
self.assertEqual(len(affine_result["boxes_transforms"]), 1)
assert_allclose(affine_result["boxes"],
expected_zoom_result,
type_test=True,
device_test=True,
atol=0.01)
invert_transform_affine = Invertd(keys=["boxes"],
transform=transform_affine,
orig_keys=["boxes"])
data_back = invert_transform_affine(affine_result)
if "boxes_transforms" in data_back:
self.assertEqual(data_back["boxes_transforms"], [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=0.01)
invert_transform_affine = AffineBoxToWorldCoordinated(
box_keys="boxes", box_ref_image_keys="image")
data_back = invert_transform_affine(affine_result)
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=0.01)
# test FlipBoxd
transform_flip = FlipBoxd(image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
spatial_axis=[0, 1, 2])
flip_result = transform_flip(data)
if "boxes_transforms" in flip_result:
self.assertEqual(len(flip_result["boxes_transforms"]), 1)
assert_allclose(flip_result["boxes"],
expected_flip_result,
type_test=True,
device_test=True,
atol=1e-3)
invert_transform_flip = Invertd(keys=["image", "boxes"],
transform=transform_flip,
orig_keys=["image", "boxes"])
data_back = invert_transform_flip(flip_result)
if "boxes_transforms" in data_back:
self.assertEqual(data_back["boxes_transforms"], [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
# test RandFlipBoxd
for spatial_axis in [(0, ), (1, ), (2, ), (0, 1), (1, 2)]:
transform_flip = RandFlipBoxd(
image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
prob=1.0,
spatial_axis=spatial_axis,
)
flip_result = transform_flip(data)
if "boxes_transforms" in flip_result:
self.assertEqual(len(flip_result["boxes_transforms"]), 1)
invert_transform_flip = Invertd(keys=["image", "boxes"],
transform=transform_flip,
orig_keys=["image", "boxes"])
data_back = invert_transform_flip(flip_result)
if "boxes_transforms" in data_back:
self.assertEqual(data_back["boxes_transforms"], [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
# test ClipBoxToImaged
transform_clip = ClipBoxToImaged(box_keys="boxes",
box_ref_image_keys="image",
label_keys=["labels", "scores"],
remove_empty=True)
clip_result = transform_clip(data)
assert_allclose(clip_result["boxes"],
expected_clip_result,
type_test=True,
device_test=True,
atol=1e-3)
assert_allclose(clip_result["labels"],
data["labels"][1:],
type_test=True,
device_test=True,
atol=1e-3)
assert_allclose(clip_result["scores"],
data["scores"][1:],
type_test=True,
device_test=True,
atol=1e-3)
transform_clip = ClipBoxToImaged(
box_keys="boxes",
box_ref_image_keys="image",
label_keys=[],
remove_empty=True) # corner case when label_keys is empty
clip_result = transform_clip(data)
assert_allclose(clip_result["boxes"],
expected_clip_result,
type_test=True,
device_test=True,
atol=1e-3)
# test RandCropBoxByPosNegLabeld
transform_crop = RandCropBoxByPosNegLabeld(
image_keys="image",
box_keys="boxes",
label_keys=["labels", "scores"],
spatial_size=2,
num_samples=3)
crop_result = transform_crop(data)
assert len(crop_result) == 3
for ll in range(3):
assert_allclose(
crop_result[ll]["boxes"].shape[0],
crop_result[ll]["labels"].shape[0],
type_test=True,
device_test=True,
atol=1e-3,
)
assert_allclose(
crop_result[ll]["boxes"].shape[0],
crop_result[ll]["scores"].shape[0],
type_test=True,
device_test=True,
atol=1e-3,
)
# test RotateBox90d
transform_rotate = RotateBox90d(image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
k=1,
spatial_axes=[0, 1])
rotate_result = transform_rotate(data)
self.assertEqual(len(rotate_result["image"].applied_operations), 1)
assert_allclose(rotate_result["boxes"],
expected_rotate_result,
type_test=True,
device_test=True,
atol=1e-3)
invert_transform_rotate = Invertd(keys=["image", "boxes"],
transform=transform_rotate,
orig_keys=["image", "boxes"])
data_back = invert_transform_rotate(rotate_result)
self.assertEqual(data_back["image"].applied_operations, [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
transform_rotate = RandRotateBox90d(image_keys="image",
box_keys="boxes",
box_ref_image_keys="image",
prob=1.0,
max_k=3,
spatial_axes=[0, 1])
rotate_result = transform_rotate(data)
self.assertEqual(len(rotate_result["image"].applied_operations), 1)
invert_transform_rotate = Invertd(keys=["image", "boxes"],
transform=transform_rotate,
orig_keys=["image", "boxes"])
data_back = invert_transform_rotate(rotate_result)
self.assertEqual(data_back["image"].applied_operations, [])
assert_allclose(data_back["boxes"],
data["boxes"],
type_test=False,
device_test=False,
atol=1e-3)
assert_allclose(data_back["image"],
data["image"],
type_test=False,
device_test=False,
atol=1e-3)
# limitations under the License.
import os
import tempfile
import unittest
import torch
from parameterized import parameterized
from monai.data.meta_tensor import MetaTensor
from monai.transforms import SaveImaged
TEST_CASE_1 = [
{
"img":
MetaTensor(torch.randint(0, 255, (1, 2, 3, 4)),
meta={"filename_or_obj": "testfile0.nii.gz"})
},
".nii.gz",
False,
]
TEST_CASE_2 = [
{
"img":
MetaTensor(torch.randint(0, 255, (1, 2, 3, 4)),
meta={"filename_or_obj": "testfile0.nii.gz"}),
"patch_index":
6,
},
".nii.gz",
False,
