def test_use_case(self):
with tempfile.TemporaryDirectory() as tempdir:
img_ = nib.Nifti1Image(np.random.randint(0, 2, size=(20, 20, 20)),
np.eye(4))
seg_ = nib.Nifti1Image(np.random.randint(0, 2, size=(20, 20, 20)),
np.eye(4))
img_name, seg_name = os.path.join(tempdir,
"img.nii.gz"), os.path.join(
tempdir, "seg.nii.gz")
nib.save(img_, img_name)
nib.save(seg_, seg_name)
img_list, seg_list = [img_name], [seg_name]
img_xform = _TestCompose([
EnsureChannelFirst(),
Spacing(pixdim=(1.5, 1.5, 3.0)),
RandAdjustContrast()
])
seg_xform = _TestCompose([
EnsureChannelFirst(),
Spacing(pixdim=(1.5, 1.5, 3.0), mode="nearest")
])
img_dataset = ImageDataset(
image_files=img_list,
seg_files=seg_list,
transform=img_xform,
seg_transform=seg_xform,
image_only=False,
transform_with_metadata=True,
)
self.assertTupleEqual(img_dataset[0][0].shape, (1, 14, 14, 7))
self.assertTupleEqual(img_dataset[0][1].shape, (1, 14, 14, 7))
def test_check(self):
with self.assertRaises(ValueError): # no meta
EnsureChannelFirst()(np.zeros((1, 2, 3)), None)
with self.assertRaises(ValueError): # no meta channel
EnsureChannelFirst()(np.zeros((1, 2, 3)), {
"original_channel_dim": None
})
EnsureChannelFirst(strict_check=False)(np.zeros((1, 2, 3)), None)
EnsureChannelFirst(strict_check=False)(np.zeros((1, 2, 3)), {
"original_channel_dim": None
})
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_load_png(self):
spatial_size = (256, 256, 3)
test_image = np.random.randint(0, 256, size=spatial_size)
with tempfile.TemporaryDirectory() as tempdir:
filename = os.path.join(tempdir, "test_image.png")
Image.fromarray(test_image.astype("uint8")).save(filename)
result, header = LoadImage(image_only=False)(filename)
result = EnsureChannelFirst()(result, header)
self.assertEqual(result.shape[0], 3)
def test_load_nifti(self, input_param, filenames, original_channel_dim):
if original_channel_dim is None:
test_image = np.random.rand(128, 128, 128)
elif original_channel_dim == -1:
test_image = np.random.rand(128, 128, 128, 1)
with tempfile.TemporaryDirectory() as tempdir:
for i, name in enumerate(filenames):
filenames[i] = os.path.join(tempdir, name)
nib.save(nib.Nifti1Image(test_image, np.eye(4)), filenames[i])
result, header = LoadImage(**input_param)(filenames)
result = EnsureChannelFirst()(result, header)
self.assertEqual(result.shape[0], len(filenames))
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_linear_consistent(self, xform_cls, input_dict, atol):
"""xform cls testing itk consistency"""
img = LoadImage(image_only=True, simple_keys=True)(FILE_PATH)
img = EnsureChannelFirst()(img)
ref_1 = _create_itk_obj(img[0], img.affine)
output = self.run_transform(img, xform_cls, input_dict)
ref_2 = _create_itk_obj(output[0], output.affine)
assert_allclose(output.pixdim,
np.asarray(ref_2.GetSpacing()),
type_test=False)
expected = _resample_to_affine(ref_1, ref_2)
# compare ref_2 and expected results from itk
diff = np.abs(
itk.GetArrayFromImage(ref_2) - itk.GetArrayFromImage(expected))
avg_diff = np.mean(diff)
self.assertTrue(avg_diff < atol,
f"{xform_cls} avg_diff: {avg_diff}, tol: {atol}")
def test_itk_dicom_series_reader(self, input_param, filenames,
original_channel_dim):
result, header = LoadImage(**input_param)(filenames)
result = EnsureChannelFirst()(result, header)
self.assertEqual(result.shape[0], 1)
def test_itk_dicom_series_reader(self, input_param, filenames, _):
result = LoadImage(image_only=True, **input_param)(filenames)
result = EnsureChannelFirst()(result)
self.assertEqual(result.shape[0], 1)
