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)