3087 enhance usage of intensity RandomizableTransform

tests/test_grid_dataset.py

@@ -56,7 +56,7 @@ def test_loading_array(self):
             np.testing.assert_equal(tuple(item[0].shape), (2, 1, 2, 2))
         np.testing.assert_allclose(
             item[0],
-            np.array([[[[1.7413, 2.7413], [5.7413, 6.7413]]], [[[9.1419, 10.1419], [13.1419, 14.1419]]]]),
+            np.array([[[[2.0577, 3.0577], [6.0577, 7.0577]]], [[[10.5540, 11.5540], [14.5540, 15.5540]]]]),
             rtol=1e-5,
         )
         np.testing.assert_allclose(
@@ -69,7 +69,7 @@ def test_loading_array(self):
                 np.testing.assert_equal(tuple(item[0].shape), (2, 1, 2, 2))
             np.testing.assert_allclose(
                 item[0],
-                np.array([[[[2.3944, 3.3944], [6.3944, 7.3944]]], [[[10.6551, 11.6551], [14.6551, 15.6551]]]]),
+                np.array([[[[1.6533, 2.6533], [5.6533, 6.6533]]], [[[9.8524, 10.8524], [13.8524, 14.8524]]]]),
                 rtol=1e-3,
             )
             np.testing.assert_allclose(

tests/test_patch_dataset.py

@@ -59,7 +59,7 @@ def test_loading_array(self):
         np.testing.assert_allclose(
             item[0],
             np.array(
-                [[[1.779992, 2.779992, 3.779992], [5.779992, 6.779992, 7.779992], [9.779992, 10.779992, 11.779992]]]
+                [[[1.338681, 2.338681, 3.338681], [5.338681, 6.338681, 7.338681], [9.338681, 10.338681, 11.338681]]]
             ),
             rtol=1e-5,
         )
@@ -71,11 +71,11 @@ def test_loading_array(self):
                 np.array(
                     [
                         [
-                            [5.025618, 6.025618, 7.025618],
-                            [9.025618, 10.025618, 11.025618],
-                            [13.025618, 14.025618, 15.025618],
-                        ]
-                    ]
+                            [4.957847, 5.957847, 6.957847],
+                            [8.957847, 9.957847, 10.957847],
+                            [12.957847, 13.957847, 14.957847],
+                        ],
+                    ],
                 ),
                 rtol=1e-5,
             )

tests/test_rand_adjust_contrastd.py

@@ -32,7 +32,7 @@ def test_correct_results(self, gamma):
             img_min = self.imt.min()
             img_range = self.imt.max() - img_min
             expected = (
-                np.power(((self.imt - img_min) / float(img_range + epsilon)), adjuster.gamma_value) * img_range
+                np.power(((self.imt - img_min) / float(img_range + epsilon)), adjuster.adjuster.gamma_value) * img_range
                 + img_min
             )
             assert_allclose(expected, result["img"], rtol=1e-05, type_test=False)

tests/test_random_bias_field.py → tests/test_rand_bias_field.py

@@ -16,10 +16,13 @@
 
 from monai.transforms import RandBiasField
 
-TEST_CASES_2D = [{}, (3, 32, 32)]
-TEST_CASES_3D = [{}, (3, 32, 32, 32)]
-TEST_CASES_2D_ZERO_RANGE = [{"coeff_range": (0.0, 0.0)}, (2, 3, 3)]
-TEST_CASES_2D_ONES = [{"coeff_range": (1.0, 1.0)}, np.asarray([[[7.389056, 0.1353353], [7.389056, 22026.46]]])]
+TEST_CASES_2D = [{"prob": 1.0}, (3, 32, 32)]
+TEST_CASES_3D = [{"prob": 1.0}, (3, 32, 32, 32)]
+TEST_CASES_2D_ZERO_RANGE = [{"prob": 1.0, "coeff_range": (0.0, 0.0)}, (2, 3, 3)]
+TEST_CASES_2D_ONES = [
+    {"prob": 1.0, "coeff_range": (1.0, 1.0)},
+    np.asarray([[[7.389056, 0.1353353], [7.389056, 22026.46]]]),
+]
 
 
 class TestRandBiasField(unittest.TestCase):

tests/test_random_bias_fieldd.py → tests/test_rand_bias_fieldd.py

@@ -16,11 +16,11 @@
 
 from monai.transforms import RandBiasFieldd
 
-TEST_CASES_2D = [{}, (3, 32, 32)]
-TEST_CASES_3D = [{}, (3, 32, 32, 32)]
-TEST_CASES_2D_ZERO_RANGE = [{"coeff_range": (0.0, 0.0)}, (3, 32, 32)]
+TEST_CASES_2D = [{"prob": 1.0}, (3, 32, 32)]
+TEST_CASES_3D = [{"prob": 1.0}, (3, 32, 32, 32)]
+TEST_CASES_2D_ZERO_RANGE = [{"prob": 1.0, "coeff_range": (0.0, 0.0)}, (3, 32, 32)]
 TEST_CASES_2D_ONES = [
-    {"coeff_range": (1.0, 1.0)},
+    {"prob": 1.0, "coeff_range": (1.0, 1.0)},
     np.asarray([[[7.3890562e00, 1.3533528e-01], [7.3890562e00, 2.2026465e04]]]),
 ]
 

tests/test_rand_coarse_shuffled.py

@@ -28,17 +28,17 @@
         np.asarray(
             [
                 [
-                    [[13, 17, 5], [6, 16, 25], [12, 15, 22]],
-                    [[24, 7, 3], [9, 2, 23], [0, 4, 26]],
-                    [[19, 11, 14], [1, 20, 8], [18, 10, 21]],
-                ]
-            ]
+                    [[8, 19, 26], [24, 6, 15], [0, 13, 25]],
+                    [[17, 3, 5], [10, 1, 12], [22, 4, 11]],
+                    [[21, 20, 23], [14, 2, 16], [18, 9, 7]],
+                ],
+            ],
         ),
     ],
     [
         {"keys": "img", "holes": 2, "spatial_size": 1, "max_spatial_size": -1, "prob": 1.0},
         {"img": np.arange(16).reshape((2, 2, 2, 2))},
-        np.asarray([[[[7, 2], [1, 4]], [[5, 0], [3, 6]]], [[[8, 13], [10, 15]], [[14, 12], [11, 9]]]]),
+        np.asarray([[[[6, 1], [4, 3]], [[0, 2], [7, 5]]], [[[14, 10], [9, 8]], [[12, 15], [13, 11]]]]),
     ],
 ]
 

tests/test_rand_gaussian_noised.py

@@ -34,9 +34,11 @@ def test_correct_results(self, _, im_type, keys, mean, std):
         im = im_type(self.imt)
         noised = gaussian_fn({k: im for k in keys})
         np.random.seed(seed)
+        # simulate the randomize() of transform
         np.random.random()
+        noise = np.random.normal(mean, np.random.uniform(0, std), size=self.imt.shape)
         for k in keys:
-            expected = self.imt + np.random.normal(mean, np.random.uniform(0, std), size=self.imt.shape)
+            expected = self.imt + noise
             self.assertEqual(type(im), type(noised[k]))
             if isinstance(noised[k], torch.Tensor):
                 noised[k] = noised[k].cpu()

tests/test_rand_gibbs_noised.py

@@ -110,7 +110,7 @@ def test_alpha(self, im_shape, input_type):
         alpha = [0.5, 0.51]
         t = RandGibbsNoised(KEYS, 1.0, alpha)
         _ = t(deepcopy(data))
-        self.assertTrue(0.5 <= t.sampled_alpha <= 0.51)
+        self.assertTrue(0.5 <= t.rand_gibbs_noise.sampled_alpha <= 0.51)
 
 
 if __name__ == "__main__":

tests/test_rand_histogram_shift.py

@@ -15,7 +15,7 @@
 from parameterized import parameterized
 
 from monai.transforms import RandHistogramShift
-from tests.utils import TEST_NDARRAYS
+from tests.utils import TEST_NDARRAYS, assert_allclose
 
 TESTS = []
 for p in TEST_NDARRAYS:
@@ -48,7 +48,7 @@ def test_rand_histogram_shift(self, input_param, input_data, expected_val):
         g = RandHistogramShift(**input_param)
         g.set_random_state(123)
         result = g(**input_data)
-        np.testing.assert_allclose(result, expected_val, rtol=1e-4, atol=1e-4)
+        assert_allclose(result, expected_val, rtol=1e-4, atol=1e-4, type_test=False)
 
 
 if __name__ == "__main__":

tests/test_rand_k_space_spike_noised.py

@@ -49,18 +49,16 @@ def test_same_result(self, im_shape, im_type):
 
         data = self.get_data(im_shape, im_type)
 
-        intensity_ranges = {"image": (13, 15), "label": (13, 15)}
         t = RandKSpaceSpikeNoised(
             KEYS,
-            global_prob=1.0,
             prob=1.0,
-            intensity_ranges=intensity_ranges,
+            intensity_range=(13, 15),
             channel_wise=True,
         )
-        t.set_rand_state(42)
+        t.set_random_state(42)
         out1 = t(deepcopy(data))
 
-        t.set_rand_state(42)
+        t.set_random_state(42)
         out2 = t(deepcopy(data))
 
         for k in KEYS:
@@ -74,20 +72,18 @@ def test_same_result(self, im_shape, im_type):
     @parameterized.expand(TESTS)
     def test_0_prob(self, im_shape, im_type):
         data = self.get_data(im_shape, im_type)
-        intensity_ranges = {"image": (13, 15), "label": (13, 15)}
+
         t1 = RandKSpaceSpikeNoised(
             KEYS,
-            global_prob=0.0,
-            prob=1.0,
-            intensity_ranges=intensity_ranges,
+            prob=0.0,
+            intensity_range=(13, 15),
             channel_wise=True,
         )
 
         t2 = RandKSpaceSpikeNoised(
             KEYS,
-            global_prob=0.0,
-            prob=1.0,
-            intensity_ranges=intensity_ranges,
+            prob=0.0,
+            intensity_range=(13, 15),
             channel_wise=True,
         )
         out1 = t1(data)
@@ -104,52 +100,6 @@ def test_0_prob(self, im_shape, im_type):
             np.testing.assert_allclose(data[k], out1[k])
             np.testing.assert_allclose(data[k], out2[k])
 
-    @parameterized.expand(TESTS)
-    def test_intensity(self, im_shape, im_type):
-
-        data = self.get_data(im_shape, im_type)
-        intensity_ranges = {"image": (13, 13.1), "label": (13, 13.1)}
-        t = RandKSpaceSpikeNoised(
-            KEYS,
-            global_prob=1.0,
-            prob=1.0,
-            intensity_ranges=intensity_ranges,
-            channel_wise=True,
-        )
-
-        _ = t(data)
-        self.assertGreaterEqual(t.transforms["image"].sampled_k_intensity[0], 13)
-        self.assertLessEqual(t.transforms["image"].sampled_k_intensity[0], 13.1)
-        self.assertGreaterEqual(t.transforms["label"].sampled_k_intensity[0], 13)
-        self.assertLessEqual(t.transforms["label"].sampled_k_intensity[0], 13.1)
-
-    @parameterized.expand(TESTS)
-    def test_same_transformation(self, im_shape, im_type):
-        data = self.get_data(im_shape, im_type)
-        # use same image for both dictionary entries to check same trans is applied to them
-        data = {KEYS[0]: deepcopy(data[KEYS[0]]), KEYS[1]: deepcopy(data[KEYS[0]])}
-
-        intensity_ranges = {"image": (13, 15), "label": (13, 15)}
-        # use common_sampling = True to ask for the same transformation
-        t = RandKSpaceSpikeNoised(
-            KEYS,
-            global_prob=1.0,
-            prob=1.0,
-            intensity_ranges=intensity_ranges,
-            channel_wise=True,
-            common_sampling=True,
-        )
-
-        out = t(deepcopy(data))
-
-        for k in KEYS:
-            self.assertEqual(type(out[k]), type(data[k]))
-            if isinstance(out[k], torch.Tensor):
-                self.assertEqual(out[k].device, data[k].device)
-                out[k] = out[k].cpu()
-
-        np.testing.assert_allclose(out[KEYS[0]], out[KEYS[1]])
-
 
 if __name__ == "__main__":
     unittest.main()

tests/test_rand_rician_noised.py

@@ -34,6 +34,7 @@ def test_correct_results(self, _, in_type, keys, mean, std):
         noised = rician_fn({k: in_type(self.imt) for k in keys})
         np.random.seed(seed)
         for k in keys:
+            # simulate the `randomize` function of transform
             np.random.random()
             _std = np.random.uniform(0, std)
             expected = np.sqrt(

tests/test_rand_scale_intensity.py

@@ -24,6 +24,8 @@ def test_value(self):
             scaler.set_random_state(seed=0)
             result = scaler(p(self.imt))
             np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
             expected = p((self.imt * (1 + np.random.uniform(low=-0.5, high=0.5))).astype(np.float32))
             assert_allclose(result, p(expected), rtol=1e-7, atol=0)
 

tests/test_rand_scale_intensityd.py

@@ -25,6 +25,8 @@ def test_value(self):
             scaler.set_random_state(seed=0)
             result = scaler({key: p(self.imt)})
             np.random.seed(0)
+            # simulate the randomize function of transform
+            np.random.random()
             expected = (self.imt * (1 + np.random.uniform(low=-0.5, high=0.5))).astype(np.float32)
             assert_allclose(result[key], p(expected))
 

tests/test_rand_shift_intensity.py

@@ -23,6 +23,8 @@ def test_value(self):
         shifter.set_random_state(seed=0)
         result = shifter(self.imt, factor=1.0)
         np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
         expected = self.imt + np.random.uniform(low=-1.0, high=1.0)
         np.testing.assert_allclose(result, expected)
 

tests/test_rand_shift_intensityd.py

@@ -25,6 +25,8 @@ def test_value(self):
             shifter.set_random_state(seed=0)
             result = shifter({key: p(self.imt)})
             np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
             expected = self.imt + np.random.uniform(low=-1.0, high=1.0)
             assert_allclose(result[key], p(expected))
 
@@ -36,6 +38,8 @@ def test_factor(self):
         shifter.set_random_state(seed=0)
         result = shifter(stats(data))
         np.random.seed(0)
+        # simulate the randomize() of transform
+        np.random.random()
         expected = self.imt + np.random.uniform(low=-1.0, high=1.0) * np.nanmax(self.imt)
         np.testing.assert_allclose(result[key], expected)
 

tests/test_rand_std_shift_intensity.py

@@ -22,6 +22,8 @@ class TestRandStdShiftIntensity(NumpyImageTestCase2D):
     def test_value(self):
         for p in TEST_NDARRAYS:
             np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
             factor = np.random.uniform(low=-1.0, high=1.0)
             offset = factor * np.std(self.imt)
             expected = p(self.imt + offset)

tests/test_rand_std_shift_intensityd.py

@@ -23,6 +23,8 @@ def test_value(self):
         for p in TEST_NDARRAYS:
             key = "img"
             np.random.seed(0)
+            # simulate the randomize() of transform
+            np.random.random()
             factor = np.random.uniform(low=-1.0, high=1.0)
             expected = self.imt + factor * np.std(self.imt)
             shifter = RandStdShiftIntensityd(keys=[key], factors=1.0, prob=1.0)