def setUp(self):
if not has_nib:
self.skipTest("nibabel required for test_inverse")
set_determinism(seed=0)
b_size = 11
im_fname, seg_fname = (make_nifti_image(i)
for i in create_test_image_3d(101, 100, 107))
load_ims = Compose([LoadImaged(KEYS), AddChanneld(KEYS)])
self.data_3d = [
load_ims({
"image": im_fname,
"label": seg_fname
}) for _ in range(b_size)
]
b_size = 8
im_fname, seg_fname = (
make_nifti_image(i)
for i in create_test_image_2d(62, 37, rad_max=10))
load_ims = Compose([LoadImaged(KEYS), AddChanneld(KEYS)])
self.data_2d = [
load_ims({
"image": im_fname,
"label": seg_fname
}) for _ in range(b_size)
]
self.batch_size = 7
def setUp(self):
set_determinism(seed=0)
im, seg = create_test_image_3d(25, 28, 63, rad_max=10, noise_max=1, num_objs=4, num_seg_classes=1)
self.img_name = make_nifti_image(im)
self.seg_name = make_nifti_image(seg)
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu:0")
def setUp(self):
if not has_nib:
self.skipTest("nibabel required for test_inverse")
set_determinism(seed=0)
self.all_data = {}
affine = make_rand_affine()
affine[0] *= 2
for size in [10, 11]:
# pad 5 onto both ends so that cropping can be lossless
im_1d = np.pad(np.arange(size), 5)[None]
name = "1D even" if size % 2 == 0 else "1D odd"
self.all_data[name] = {
"image": np.array(im_1d, copy=True),
"label": np.array(im_1d, copy=True),
"other": np.array(im_1d, copy=True),
}
im_2d_fname, seg_2d_fname = [make_nifti_image(i) for i in create_test_image_2d(101, 100)]
im_3d_fname, seg_3d_fname = [make_nifti_image(i, affine) for i in create_test_image_3d(100, 101, 107)]
load_ims = Compose([LoadImaged(KEYS), AddChanneld(KEYS)])
self.all_data["2D"] = load_ims({"image": im_2d_fname, "label": seg_2d_fname})
self.all_data["3D"] = load_ims({"image": im_3d_fname, "label": seg_3d_fname})
def run_test(batch_size=2, device=torch.device("cpu:0")):
im, seg = create_test_image_3d(25,
28,
63,
rad_max=10,
noise_max=1,
num_objs=4,
num_seg_classes=1)
input_shape = im.shape
img_name = make_nifti_image(im)
seg_name = make_nifti_image(seg)
ds = NiftiDataset([img_name], [seg_name],
transform=AddChannel(),
seg_transform=AddChannel(),
image_only=False)
loader = DataLoader(ds, batch_size=1, pin_memory=torch.cuda.is_available())
net = UNet(
dimensions=3,
in_channels=1,
num_classes=1,
channels=(4, 8, 16, 32),
strides=(2, 2, 2),
num_res_units=2,
)
roi_size = (16, 32, 48)
sw_batch_size = batch_size
def _sliding_window_processor(_engine, batch):
net.eval()
img, seg, meta_data = batch
with torch.no_grad():
seg_probs = sliding_window_inference(img, roi_size, sw_batch_size,
lambda x: net(x)[0], device)
return predict_segmentation(seg_probs)
infer_engine = Engine(_sliding_window_processor)
with tempfile.TemporaryDirectory() as temp_dir:
SegmentationSaver(output_path=temp_dir,
output_ext='.nii.gz',
output_postfix='seg').attach(infer_engine)
infer_engine.run(loader)
basename = os.path.basename(img_name)[:-len('.nii.gz')]
saved_name = os.path.join(temp_dir, basename,
'{}_seg.nii.gz'.format(basename))
testing_shape = nib.load(saved_name).get_fdata().shape
if os.path.exists(img_name):
os.remove(img_name)
if os.path.exists(seg_name):
os.remove(seg_name)
return testing_shape == input_shape
def setUp(self):
np.random.seed(0)
torch.manual_seed(0)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
im, seg = create_test_image_3d(25, 28, 63, rad_max=10, noise_max=1, num_objs=4, num_seg_classes=1)
self.img_name = make_nifti_image(im)
self.seg_name = make_nifti_image(seg)
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu:0")
def setUp(self) -> None:
set_determinism(seed=0)
im = create_test_image_2d(100, 101)[0]
self.data_dict = [{
"image": make_nifti_image(im) if has_nib else im
} for _ in range(6)]
self.data_list = [
make_nifti_image(im) if has_nib else im for _ in range(6)
]
def test_orientation(self, array, affine, reader_param, expected):
test_image = make_nifti_image(array, affine)
# read test cases
loader = LoadNifti(**reader_param)
load_result = loader(test_image)
if isinstance(load_result, tuple):
data_array, header = load_result
else:
data_array = load_result
header = None
if os.path.exists(test_image):
os.remove(test_image)
# write test cases
if header is not None:
write_nifti(data_array, test_image, header["affine"],
header.get("original_affine", None))
elif affine is not None:
write_nifti(data_array, test_image, affine)
saved = nib.load(test_image)
saved_affine = saved.affine
saved_data = saved.get_fdata()
if os.path.exists(test_image):
os.remove(test_image)
if affine is not None:
np.testing.assert_allclose(saved_affine, affine)
np.testing.assert_allclose(saved_data, expected)
def test_consistency(self):
np.set_printoptions(suppress=True, precision=3)
test_image = make_nifti_image(
np.arange(64).reshape(1, 8, 8), np.diag([1.5, 1.5, 1.5, 1]))
data, header = LoadImage(reader="NibabelReader",
as_closest_canonical=False)(test_image)
data, original_affine, new_affine = Spacing([0.8, 0.8,
0.8])(data[None],
header["affine"],
mode="nearest")
data, _, new_affine = Orientation("ILP")(data, new_affine)
if os.path.exists(test_image):
os.remove(test_image)
write_nifti(data[0],
test_image,
new_affine,
original_affine,
mode="nearest",
padding_mode="border")
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data,
np.arange(64).reshape(1, 8, 8),
atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
write_nifti(
data[0],
test_image,
new_affine,
original_affine,
mode="nearest",
padding_mode="border",
output_spatial_shape=(1, 8, 8),
)
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data,
np.arange(64).reshape(1, 8, 8),
atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
# test the case that only correct orientation but don't resample
write_nifti(data[0],
test_image,
new_affine,
original_affine,
resample=False)
saved = nib.load(test_image)
# compute expected affine
start_ornt = nib.orientations.io_orientation(new_affine)
target_ornt = nib.orientations.io_orientation(original_affine)
ornt_transform = nib.orientations.ornt_transform(
start_ornt, target_ornt)
data_shape = data[0].shape
expected_affine = new_affine @ nib.orientations.inv_ornt_aff(
ornt_transform, data_shape)
np.testing.assert_allclose(saved.affine, expected_affine)
if os.path.exists(test_image):
os.remove(test_image)
def test_consistency(self):
np.set_printoptions(suppress=True, precision=3)
test_image = make_nifti_image(np.arange(64).reshape(1, 8, 8), np.diag([1.5, 1.5, 1.5, 1]))
data, header = LoadNifti(as_closest_canonical=False)(test_image)
data, original_affine, new_affine = Spacing([0.8, 0.8, 0.8])(
data[None], header["affine"], interp_order="nearest"
)
data, _, new_affine = Orientation("ILP")(data, new_affine)
if os.path.exists(test_image):
os.remove(test_image)
write_nifti(data[0], test_image, new_affine, original_affine, interp_order="nearest", mode="border")
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data, np.arange(64).reshape(1, 8, 8), atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
write_nifti(
data[0],
test_image,
new_affine,
original_affine,
interp_order="nearest",
mode="border",
output_shape=(1, 8, 8),
)
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data, np.arange(64).reshape(1, 8, 8), atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
def test_orientation(self, array, affine, reader_param, expected):
test_image = make_nifti_image(array, affine)
# read test cases
loader = LoadImage(**reader_param)
load_result = loader(test_image)
if isinstance(load_result, tuple):
data_array, header = load_result
else:
data_array = load_result
header = None
if os.path.exists(test_image):
os.remove(test_image)
# write test cases
writer_obj = NibabelWriter()
writer_obj.set_data_array(data_array, channel_dim=None)
if header is not None:
writer_obj.set_metadata(header)
elif affine is not None:
writer_obj.set_metadata({"affine": affine})
writer_obj.write(test_image, verbose=True)
saved = nib.load(test_image)
saved_affine = saved.affine
saved_data = saved.get_fdata()
if os.path.exists(test_image):
os.remove(test_image)
if affine is not None:
assert_allclose(saved_affine, affine, type_test=False)
assert_allclose(saved_data, expected, type_test=False)
def test_decollation(self, batch_size=2, num_workers=2):
im = create_test_image_2d(100, 101)[0]
data = [{
"image": make_nifti_image(im) if has_nib else im
} for _ in range(6)]
transforms = Compose([
AddChanneld("image"),
SpatialPadd("image", 150),
RandFlipd("image", prob=1.0, spatial_axis=1),
ToTensord("image"),
])
# If nibabel present, read from disk
if has_nib:
transforms = Compose([LoadImaged("image"), transforms])
dataset = CacheDataset(data, transforms, progress=False)
loader = DataLoader(dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
for b, batch_data in enumerate(loader):
decollated_1 = decollate_batch(batch_data)
decollated_2 = Decollated()(batch_data)
for decollated in [decollated_1, decollated_2]:
for i, d in enumerate(decollated):
self.check_match(dataset[b * batch_size + i], d)
def setUpClass(cls):
arr = np.random.rand(2, 10, 8, 7)
affine = make_rand_affine()
data = {"i": make_nifti_image(arr, affine)}
loader = LoadImaged("i")
cls.data: MetaTensor = loader(data)
def test_consistency(self):
np.set_printoptions(suppress=True, precision=3)
test_image = make_nifti_image(
np.arange(64).reshape(1, 8, 8), np.diag([1.5, 1.5, 1.5, 1]))
data, header = LoadImage(reader="NibabelReader",
as_closest_canonical=False)(test_image)
data, original_affine, new_affine = Spacing([0.8, 0.8,
0.8])(data[None],
header["affine"],
mode="nearest")
data, _, new_affine = Orientation("ILP")(data, new_affine)
if os.path.exists(test_image):
os.remove(test_image)
writer_obj = NibabelWriter()
writer_obj.set_data_array(data[0], channel_dim=None)
writer_obj.set_metadata(meta_dict={
"affine": new_affine,
"original_affine": original_affine
},
mode="nearest",
padding_mode="border")
writer_obj.write(test_image, verbose=True)
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data,
np.arange(64).reshape(1, 8, 8),
atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
writer_obj.set_data_array(data[0], channel_dim=None)
writer_obj.set_metadata(
meta_dict={
"affine": new_affine,
"original_affine": original_affine,
"spatial_shape": (1, 8, 8)
},
mode="nearest",
padding_mode="border",
)
writer_obj.write(test_image, verbose=True)
saved = nib.load(test_image)
saved_data = saved.get_fdata()
np.testing.assert_allclose(saved_data,
np.arange(64).reshape(1, 8, 8),
atol=1e-7)
if os.path.exists(test_image):
os.remove(test_image)
# test the case no resample
writer_obj.set_data_array(data[0], channel_dim=None)
writer_obj.set_metadata(meta_dict={
"affine": new_affine,
"original_affine": original_affine
},
resample=False)
writer_obj.write(test_image, verbose=True)
saved = nib.load(test_image)
np.testing.assert_allclose(saved.affine, new_affine)
if os.path.exists(test_image):
os.remove(test_image)
def setUp(self):
if not has_nib:
self.skipTest("nibabel required for test_inverse")
set_determinism(seed=0)
im_fname, seg_fname = [make_nifti_image(i) for i in create_test_image_3d(101, 100, 107)]
load_ims = Compose([LoadImaged(KEYS), AddChanneld(KEYS)])
self.batch_size = 10
self.data = [load_ims({"image": im_fname, "label": seg_fname}) for _ in range(self.batch_size)]
def setUp(self):
if not has_nib:
self.skipTest("nibabel required for test_inverse")
set_determinism(seed=0)
self.all_data = {}
affine = make_rand_affine()
affine[0] *= 2
im_1d = AddChannel()(np.arange(0, 10))
self.all_data["1D"] = {"image": im_1d, "label": im_1d, "other": im_1d}
im_2d_fname, seg_2d_fname = [make_nifti_image(i) for i in create_test_image_2d(101, 100)]
im_3d_fname, seg_3d_fname = [make_nifti_image(i, affine) for i in create_test_image_3d(100, 101, 107)]
load_ims = Compose([LoadImaged(KEYS), AddChanneld(KEYS)])
self.all_data["2D"] = load_ims({"image": im_2d_fname, "label": seg_2d_fname})
self.all_data["3D"] = load_ims({"image": im_3d_fname, "label": seg_3d_fname})
def test_invert(self):
set_determinism(seed=0)
im_fname = make_nifti_image(create_test_image_3d(101, 100, 107, noise_max=100)[1]) # label image, discrete
data = [im_fname for _ in range(12)]
transform = Compose(
[
LoadImage(image_only=True),
EnsureChannelFirst(),
Orientation("RPS"),
Spacing(pixdim=(1.2, 1.01, 0.9), mode="bilinear", dtype=np.float32),
RandFlip(prob=0.5, spatial_axis=[1, 2]),
RandAxisFlip(prob=0.5),
RandRotate90(prob=0, spatial_axes=(1, 2)),
RandZoom(prob=0.5, min_zoom=0.5, max_zoom=1.1, keep_size=True),
RandRotate(prob=0.5, range_x=np.pi, mode="bilinear", align_corners=True, dtype=np.float64),
RandAffine(prob=0.5, rotate_range=np.pi, mode="nearest"),
ResizeWithPadOrCrop(100),
CastToType(dtype=torch.uint8),
]
)
# num workers = 0 for mac or gpu transforms
num_workers = 0 if sys.platform != "linux" or torch.cuda.is_available() else 2
dataset = Dataset(data, transform=transform)
self.assertIsInstance(transform.inverse(dataset[0]), MetaTensor)
loader = DataLoader(dataset, num_workers=num_workers, batch_size=1)
inverter = Invert(transform=transform, nearest_interp=True, device="cpu")
for d in loader:
d = decollate_batch(d)
for item in d:
orig = deepcopy(item)
i = inverter(item)
self.assertTupleEqual(orig.shape[1:], (100, 100, 100))
# check the nearest interpolation mode
torch.testing.assert_allclose(i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape[1:], (100, 101, 107))
# check labels match
reverted = i.detach().cpu().numpy().astype(np.int32)
original = LoadImage(image_only=True)(data[-1])
n_good = np.sum(np.isclose(reverted, original.numpy(), atol=1e-3))
reverted_name = i.meta["filename_or_obj"]
original_name = original.meta["filename_or_obj"]
self.assertEqual(reverted_name, original_name)
print("invert diff", reverted.size - n_good)
self.assertTrue((reverted.size - n_good) < 300000, f"diff. {reverted.size - n_good}")
set_determinism(seed=None)
def test_invert(self):
set_determinism(seed=0)
im_fname, seg_fname = [
make_nifti_image(i)
for i in create_test_image_3d(101, 100, 107, noise_max=100)
]
transform = Compose([
LoadImaged(KEYS),
AddChanneld(KEYS),
Orientationd(KEYS, "RPS"),
Spacingd(KEYS,
pixdim=(1.2, 1.01, 0.9),
mode=["bilinear", "nearest"],
dtype=np.float32),
ScaleIntensityd("image", minv=1, maxv=10),
RandFlipd(KEYS, prob=0.5, spatial_axis=[1, 2]),
RandAxisFlipd(KEYS, prob=0.5),
RandRotate90d(KEYS, spatial_axes=(1, 2)),
RandZoomd(KEYS,
prob=0.5,
min_zoom=0.5,
max_zoom=1.1,
keep_size=True),
RandRotated(KEYS,
prob=0.5,
range_x=np.pi,
mode="bilinear",
align_corners=True),
RandAffined(KEYS, prob=0.5, rotate_range=np.pi, mode="nearest"),
ResizeWithPadOrCropd(KEYS, 100),
ToTensord(
"image"
), # test to support both Tensor and Numpy array when inverting
CastToTyped(KEYS, dtype=[torch.uint8, np.uint8]),
])
data = [{"image": im_fname, "label": seg_fname} for _ in range(12)]
# num workers = 0 for mac or gpu transforms
num_workers = 0 if sys.platform == "darwin" or torch.cuda.is_available(
) else 2
dataset = CacheDataset(data, transform=transform, progress=False)
loader = DataLoader(dataset, num_workers=num_workers, batch_size=5)
inverter = Invertd(
keys=["image", "label"],
transform=transform,
loader=loader,
orig_keys="label",
nearest_interp=True,
postfix="inverted",
to_tensor=[True, False],
device="cpu",
num_workers=0
if sys.platform == "darwin" or torch.cuda.is_available() else 2,
)
# execute 1 epoch
for d in loader:
d = inverter(d)
# this unit test only covers basic function, test_handler_transform_inverter covers more
self.assertTupleEqual(d["image"].shape[1:], (1, 100, 100, 100))
self.assertTupleEqual(d["label"].shape[1:], (1, 100, 100, 100))
# check the nearest inerpolation mode
for i in d["image_inverted"]:
torch.testing.assert_allclose(
i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
for i in d["label_inverted"]:
np.testing.assert_allclose(
i.astype(np.uint8).astype(np.float32),
i.astype(np.float32))
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
set_determinism(seed=None)
import numpy as np
import torch
from parameterized import parameterized
from monai.data import CacheDataset, DataLoader, create_test_image_2d
from monai.data.utils import decollate_batch
from monai.transforms import AddChanneld, Compose, LoadImaged, RandFlipd, SpatialPadd, ToTensord
from monai.transforms.post.dictionary import Decollated
from monai.utils import optional_import, set_determinism
from tests.utils import make_nifti_image
_, has_nib = optional_import("nibabel")
IM_2D = create_test_image_2d(100, 101)[0]
DATA_2D = {"image": make_nifti_image(IM_2D) if has_nib else IM_2D}
TESTS = []
TESTS.append((
"2D",
[DATA_2D for _ in range(6)],
))
class TestDeCollate(unittest.TestCase):
def setUp(self) -> None:
set_determinism(seed=0)
def tearDown(self) -> None:
set_determinism(None)
def test_make_nifti(self, params):
im, _ = create_test_image_2d(100, 88)
created_file = make_nifti_image(im, verbose=True, **params)
self.assertTrue(os.path.isfile(created_file))
def test_invert(self):
set_determinism(seed=0)
im_fname, seg_fname = [
make_nifti_image(i)
for i in create_test_image_3d(101, 100, 107, noise_max=100)
]
transform = Compose([
LoadImaged(KEYS),
AddChanneld(KEYS),
Orientationd(KEYS, "RPS"),
Spacingd(KEYS,
pixdim=(1.2, 1.01, 0.9),
mode=["bilinear", "nearest"],
dtype=np.float32),
ScaleIntensityd("image", minv=1, maxv=10),
RandFlipd(KEYS, prob=0.5, spatial_axis=[1, 2]),
RandAxisFlipd(KEYS, prob=0.5),
RandRotate90d(KEYS, spatial_axes=(1, 2)),
RandZoomd(KEYS,
prob=0.5,
min_zoom=0.5,
max_zoom=1.1,
keep_size=True),
RandRotated(KEYS,
prob=0.5,
range_x=np.pi,
mode="bilinear",
align_corners=True),
RandAffined(KEYS, prob=0.5, rotate_range=np.pi, mode="nearest"),
ResizeWithPadOrCropd(KEYS, 100),
ToTensord(
"image"
), # test to support both Tensor and Numpy array when inverting
CastToTyped(KEYS, dtype=[torch.uint8, np.uint8]),
])
data = [{"image": im_fname, "label": seg_fname} for _ in range(12)]
# num workers = 0 for mac or gpu transforms
num_workers = 0 if sys.platform == "darwin" or torch.cuda.is_available(
) else 2
dataset = CacheDataset(data, transform=transform, progress=False)
loader = DataLoader(dataset, num_workers=num_workers, batch_size=5)
# set up engine
def _train_func(engine, batch):
self.assertTupleEqual(batch["image"].shape[1:], (1, 100, 100, 100))
engine.state.output = batch
engine.fire_event(IterationEvents.MODEL_COMPLETED)
return engine.state.output
engine = Engine(_train_func)
engine.register_events(*IterationEvents)
# set up testing handler
TransformInverter(
transform=transform,
loader=loader,
output_keys=["image", "label"],
batch_keys="label",
nearest_interp=True,
postfix="inverted1",
to_tensor=[True, False],
device="cpu",
num_workers=0
if sys.platform == "darwin" or torch.cuda.is_available() else 2,
).attach(engine)
# test different nearest interpolation values
TransformInverter(
transform=transform,
loader=loader,
output_keys=["image", "label"],
batch_keys="image",
nearest_interp=[True, False],
post_func=[lambda x: x + 10, lambda x: x],
postfix="inverted2",
num_workers=0
if sys.platform == "darwin" or torch.cuda.is_available() else 2,
).attach(engine)
engine.run(loader, max_epochs=1)
set_determinism(seed=None)
self.assertTupleEqual(engine.state.output["image"].shape,
(2, 1, 100, 100, 100))
self.assertTupleEqual(engine.state.output["label"].shape,
(2, 1, 100, 100, 100))
# check the nearest inerpolation mode
for i in engine.state.output["image_inverted1"]:
torch.testing.assert_allclose(
i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
for i in engine.state.output["label_inverted1"]:
np.testing.assert_allclose(
i.astype(np.uint8).astype(np.float32), i.astype(np.float32))
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
# check labels match
reverted = engine.state.output["label_inverted1"][-1].astype(np.int32)
original = LoadImaged(KEYS)(data[-1])["label"]
n_good = np.sum(np.isclose(reverted, original, atol=1e-3))
reverted_name = engine.state.output["label_meta_dict"][
"filename_or_obj"][-1]
original_name = data[-1]["label"]
self.assertEqual(reverted_name, original_name)
print("invert diff", reverted.size - n_good)
# 25300: 2 workers (cpu, non-macos)
# 1812: 0 workers (gpu or macos)
# 1824: torch 1.5.1
self.assertTrue((reverted.size - n_good) in (25300, 1812, 1824),
"diff. in 3 possible values")
# check the case that different items use different interpolation mode to invert transforms
for i in engine.state.output["image_inverted2"]:
# if the interpolation mode is nearest, accumulated diff should be smaller than 1
self.assertLess(
torch.sum(
i.to(torch.float) -
i.to(torch.uint8).to(torch.float)).item(), 1.0)
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
for i in engine.state.output["label_inverted2"]:
# if the interpolation mode is not nearest, accumulated diff should be greater than 10000
self.assertGreater(
torch.sum(
i.to(torch.float) -
i.to(torch.uint8).to(torch.float)).item(), 10000.0)
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
def setUpClass(cls):
arr = np.random.rand(2, 10, 8, 7)
affine = make_rand_affine()
data = {"i": make_nifti_image(arr, affine)}
cls.data = LoadImaged("i")(data)
def test_invert(self):
set_determinism(seed=0)
im_fname, seg_fname = (
make_nifti_image(i)
for i in create_test_image_3d(101, 100, 107, noise_max=100))
transform = Compose([
LoadImaged(KEYS),
AddChanneld(KEYS),
Orientationd(KEYS, "RPS"),
Spacingd(KEYS,
pixdim=(1.2, 1.01, 0.9),
mode=["bilinear", "nearest"],
dtype=np.float32),
ScaleIntensityd("image", minv=1, maxv=10),
RandFlipd(KEYS, prob=0.5, spatial_axis=[1, 2]),
RandAxisFlipd(KEYS, prob=0.5),
RandRotate90d(KEYS, spatial_axes=(1, 2)),
RandZoomd(KEYS,
prob=0.5,
min_zoom=0.5,
max_zoom=1.1,
keep_size=True),
RandRotated(KEYS,
prob=0.5,
range_x=np.pi,
mode="bilinear",
align_corners=True,
dtype=np.float64),
RandAffined(KEYS, prob=0.5, rotate_range=np.pi, mode="nearest"),
ResizeWithPadOrCropd(KEYS, 100),
# test EnsureTensor for complicated dict data and invert it
CopyItemsd(PostFix.meta("image"), times=1, names="test_dict"),
# test to support Tensor, Numpy array and dictionary when inverting
EnsureTyped(keys=["image", "test_dict"]),
ToTensord("image"),
CastToTyped(KEYS, dtype=[torch.uint8, np.uint8]),
CopyItemsd("label",
times=2,
names=["label_inverted", "label_inverted1"]),
CopyItemsd("image",
times=2,
names=["image_inverted", "image_inverted1"]),
])
data = [{"image": im_fname, "label": seg_fname} for _ in range(12)]
# num workers = 0 for mac or gpu transforms
num_workers = 0 if sys.platform != "linux" or torch.cuda.is_available(
) else 2
dataset = CacheDataset(data, transform=transform, progress=False)
loader = DataLoader(dataset, num_workers=num_workers, batch_size=5)
inverter = Invertd(
# `image` was not copied, invert the original value directly
keys=["image_inverted", "label_inverted", "test_dict"],
transform=transform,
orig_keys=["label", "label", "test_dict"],
meta_keys=[
PostFix.meta("image_inverted"),
PostFix.meta("label_inverted"), None
],
orig_meta_keys=[
PostFix.meta("label"),
PostFix.meta("label"), None
],
nearest_interp=True,
to_tensor=[True, False, False],
device="cpu",
)
inverter_1 = Invertd(
# `image` was not copied, invert the original value directly
keys=["image_inverted1", "label_inverted1"],
transform=transform,
orig_keys=["image", "image"],
meta_keys=[
PostFix.meta("image_inverted1"),
PostFix.meta("label_inverted1")
],
orig_meta_keys=[PostFix.meta("image"),
PostFix.meta("image")],
nearest_interp=[True, False],
to_tensor=[True, True],
device="cpu",
)
expected_keys = [
"image",
"image_inverted",
"image_inverted1",
PostFix.meta("image_inverted1"),
PostFix.meta("image_inverted"),
PostFix.meta("image"),
"image_transforms",
"label",
"label_inverted",
"label_inverted1",
PostFix.meta("label_inverted1"),
PostFix.meta("label_inverted"),
PostFix.meta("label"),
"label_transforms",
"test_dict",
"test_dict_transforms",
]
# execute 1 epoch
for d in loader:
d = decollate_batch(d)
for item in d:
item = inverter(item)
item = inverter_1(item)
self.assertListEqual(sorted(item), expected_keys)
self.assertTupleEqual(item["image"].shape[1:], (100, 100, 100))
self.assertTupleEqual(item["label"].shape[1:], (100, 100, 100))
# check the nearest interpolation mode
i = item["image_inverted"]
torch.testing.assert_allclose(
i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape[1:], (100, 101, 107))
i = item["label_inverted"]
torch.testing.assert_allclose(
i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape[1:], (100, 101, 107))
# test inverted test_dict
self.assertTrue(
isinstance(item["test_dict"]["affine"], np.ndarray))
self.assertTrue(
isinstance(item["test_dict"]["filename_or_obj"], str))
# check the case that different items use different interpolation mode to invert transforms
d = item["image_inverted1"]
# if the interpolation mode is nearest, accumulated diff should be smaller than 1
self.assertLess(
torch.sum(
d.to(torch.float) -
d.to(torch.uint8).to(torch.float)).item(), 1.0)
self.assertTupleEqual(d.shape, (1, 100, 101, 107))
d = item["label_inverted1"]
# if the interpolation mode is not nearest, accumulated diff should be greater than 10000
self.assertGreater(
torch.sum(
d.to(torch.float) -
d.to(torch.uint8).to(torch.float)).item(), 10000.0)
self.assertTupleEqual(d.shape, (1, 100, 101, 107))
# check labels match
reverted = item["label_inverted"].detach().cpu().numpy().astype(
np.int32)
original = LoadImaged(KEYS)(data[-1])["label"]
n_good = np.sum(np.isclose(reverted, original, atol=1e-3))
reverted_name = item[PostFix.meta("label_inverted")]["filename_or_obj"]
original_name = data[-1]["label"]
self.assertEqual(reverted_name, original_name)
print("invert diff", reverted.size - n_good)
# 25300: 2 workers (cpu, non-macos)
# 1812: 0 workers (gpu or macos)
# 1821: windows torch 1.10.0
self.assertTrue((reverted.size - n_good) in (34007, 1812, 1821),
f"diff. {reverted.size - n_good}")
set_determinism(seed=None)
def test_invert(self):
set_determinism(seed=0)
im_fname, seg_fname = [
make_nifti_image(i)
for i in create_test_image_3d(101, 100, 107, noise_max=100)
]
transform = Compose([
LoadImaged(KEYS),
AddChanneld(KEYS),
Orientationd(KEYS, "RPS"),
Spacingd(KEYS,
pixdim=(1.2, 1.01, 0.9),
mode=["bilinear", "nearest"],
dtype=np.float32),
ScaleIntensityd("image", minv=1, maxv=10),
RandFlipd(KEYS, prob=0.5, spatial_axis=[1, 2]),
RandAxisFlipd(KEYS, prob=0.5),
RandRotate90d(KEYS, spatial_axes=(1, 2)),
RandZoomd(KEYS,
prob=0.5,
min_zoom=0.5,
max_zoom=1.1,
keep_size=True),
RandRotated(KEYS,
prob=0.5,
range_x=np.pi,
mode="bilinear",
align_corners=True),
RandAffined(KEYS, prob=0.5, rotate_range=np.pi, mode="nearest"),
ResizeWithPadOrCropd(KEYS, 100),
ToTensord(KEYS),
CastToTyped(KEYS, dtype=torch.uint8),
])
data = [{"image": im_fname, "label": seg_fname} for _ in range(12)]
# num workers = 0 for mac or gpu transforms
num_workers = 0 if sys.platform == "darwin" or torch.cuda.is_available(
) else 2
dataset = CacheDataset(data, transform=transform, progress=False)
loader = DataLoader(dataset, num_workers=num_workers, batch_size=5)
# set up engine
def _train_func(engine, batch):
self.assertTupleEqual(batch["image"].shape[1:], (1, 100, 100, 100))
engine.state.output = batch
engine.fire_event(IterationEvents.MODEL_COMPLETED)
return engine.state.output
engine = Engine(_train_func)
engine.register_events(*IterationEvents)
# set up testing handler
TransformInverter(
transform=transform,
loader=loader,
output_keys=["image", "label"],
batch_keys="label",
nearest_interp=True,
num_workers=0
if sys.platform == "darwin" or torch.cuda.is_available() else 2,
).attach(engine)
engine.run(loader, max_epochs=1)
set_determinism(seed=None)
self.assertTupleEqual(engine.state.output["image"].shape,
(2, 1, 100, 100, 100))
self.assertTupleEqual(engine.state.output["label"].shape,
(2, 1, 100, 100, 100))
for i in engine.state.output["image_inverted"] + engine.state.output[
"label_inverted"]:
torch.testing.assert_allclose(
i.to(torch.uint8).to(torch.float), i.to(torch.float))
self.assertTupleEqual(i.shape, (1, 100, 101, 107))
# check labels match
reverted = engine.state.output["label_inverted"][-1].detach().cpu(
).numpy()[0].astype(np.int32)
original = LoadImaged(KEYS)(data[-1])["label"]
n_good = np.sum(np.isclose(reverted, original, atol=1e-3))
reverted_name = engine.state.output["label_meta_dict"][
"filename_or_obj"][-1]
original_name = data[-1]["label"]
self.assertEqual(reverted_name, original_name)
print("invert diff", reverted.size - n_good)
self.assertTrue((reverted.size - n_good) in (25300, 1812),
"diff. in two possible values")
