monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

tests/transforms/functional/test_apply.py

@@ -0,0 +1,75 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+
+from monai.transforms.lazy.functional import apply_pending
+from monai.transforms.utils import create_rotate
+from monai.utils import LazyAttr, convert_to_tensor
+from tests.test_utils import get_arange_img
+
+
+def single_2d_transform_cases():
+    return [
+        (
+            torch.as_tensor(get_arange_img((32, 32))),
+            [{LazyAttr.AFFINE: create_rotate(2, np.pi / 4)}, {LazyAttr.AFFINE: create_rotate(2, -np.pi / 4)}],
+            (1, 32, 32),
+        ),
+        (torch.as_tensor(get_arange_img((32, 32))), [create_rotate(2, np.pi / 2)], (1, 32, 32)),
+        (
+            torch.as_tensor(get_arange_img((16, 16))),
+            [{LazyAttr.AFFINE: create_rotate(2, np.pi / 2), LazyAttr.SHAPE: (45, 45)}],
+            (1, 45, 45),
+        ),
+    ]
+
+
+class TestApply(unittest.TestCase):
+    def _test_apply_impl(self, tensor, pending_transforms, expected_shape):
+        result = apply_pending(tensor, pending_transforms)
+        self.assertListEqual(result[1], pending_transforms)
+        self.assertEqual(result[0].shape, expected_shape)
+
+    def _test_apply_metatensor_impl(self, tensor, pending_transforms, expected_shape, pending_as_parameter):
+        tensor_ = convert_to_tensor(tensor, track_meta=True)
+        if pending_as_parameter:
+            result, transforms = apply_pending(tensor_, pending_transforms)
+        else:
+            for p in pending_transforms:
+                tensor_.push_pending_operation(p)
+                if not isinstance(p, dict):
+                    return
+            result, transforms = apply_pending(tensor_)
+        self.assertEqual(result.shape, expected_shape)
+
+    SINGLE_TRANSFORM_CASES = single_2d_transform_cases()
+
+    def test_apply_single_transform(self):
+        for case in self.SINGLE_TRANSFORM_CASES:
+            self._test_apply_impl(*case)
+
+    def test_apply_single_transform_metatensor(self):
+        for case in self.SINGLE_TRANSFORM_CASES:
+            self._test_apply_metatensor_impl(*case, False)
+
+    def test_apply_single_transform_metatensor_override(self):
+        for case in self.SINGLE_TRANSFORM_CASES:
+            self._test_apply_metatensor_impl(*case, True)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/functional/test_resample.py

@@ -0,0 +1,50 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.transforms.lazy.functional import resample
+from monai.utils import convert_to_tensor
+from tests.test_utils import assert_allclose, get_arange_img
+
+
+def rotate_90_2d():
+    t = torch.eye(3)
+    t[:, 0] = torch.FloatTensor([0, -1, 0])
+    t[:, 1] = torch.FloatTensor([1, 0, 0])
+    return t
+
+
+RESAMPLE_FUNCTION_CASES = [
+    (get_arange_img((3, 3)), rotate_90_2d(), [[0, 3, 6], [0, 3, 6], [0, 3, 6]]),
+    (get_arange_img((3, 3)), torch.eye(3), get_arange_img((3, 3))[0]),
+]
+
+
+class TestResampleFunction(unittest.TestCase):
+    @parameterized.expand(RESAMPLE_FUNCTION_CASES)
+    def test_resample_function_impl(self, img, matrix, expected):
+        out = resample(convert_to_tensor(img), matrix, {"lazy_shape": img.shape[1:], "lazy_padding_mode": "border"})
+        assert_allclose(out[0], expected, type_test=False)
+
+        img = convert_to_tensor(img, dtype=torch.uint8)
+        out = resample(img, matrix, {"lazy_resample_mode": "auto", "lazy_dtype": torch.float})
+        out_1 = resample(img, matrix, {"lazy_resample_mode": "other value", "lazy_dtype": torch.float})
+        self.assertIs(out.dtype, out_1.dtype)  # testing dtype in different lazy_resample_mode
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

tests/transforms/intensity/test_compute_ho_ver_maps.py

@@ -0,0 +1,75 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms.intensity.array import ComputeHoVerMaps
+from monai.utils import min_version, optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+_, has_skimage = optional_import("skimage", "0.19.0", min_version)
+
+INSTANCE_MASK = np.zeros((1, 16, 16), dtype="int16")
+INSTANCE_MASK[:, 5:8, 4:11] = 1
+INSTANCE_MASK[:, 3:5, 6:9] = 1
+INSTANCE_MASK[:, 8:10, 6:9] = 1
+INSTANCE_MASK[:, 13:, 13:] = 2
+H_MAP = torch.zeros((16, 16), dtype=torch.float32)
+H_MAP[5:8, 4] = -1.0
+H_MAP[5:8, 5] = -2.0 / 3.0
+H_MAP[3:10, 6] = -1.0 / 3.0
+H_MAP[3:10, 7] = 0.0
+H_MAP[3:10, 8] = 1.0 / 3.0
+H_MAP[5:8, 9] = 2.0 / 3.0
+H_MAP[5:8, 10] = 1.0
+H_MAP[13:, 13] = -1.0
+H_MAP[13:, 14] = 0.0
+H_MAP[13:, 15] = 1.0
+V_MAP = torch.zeros((16, 16), dtype=torch.float32)
+V_MAP[3, 6:9] = -1.0
+V_MAP[4, 6:9] = -2.0 / 3.0
+V_MAP[5, 4:11] = -1.0 / 3.0
+V_MAP[6, 4:11] = 0.0
+V_MAP[7, 4:11] = 1.0 / 3.0
+V_MAP[8, 6:9] = 2.0 / 3.0
+V_MAP[9, 6:9] = 1.0
+V_MAP[13, 13:] = -1.0
+V_MAP[14, 13:] = 0.0
+V_MAP[15, 13:] = 1.0
+HV_MAPS = torch.stack([H_MAP, V_MAP])
+TEST_CASE_0 = [{}, INSTANCE_MASK, HV_MAPS]
+TEST_CASE_1 = [{"dtype": "float64"}, INSTANCE_MASK, HV_MAPS]
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, *TEST_CASE_0])
+    TESTS.append([p, *TEST_CASE_1])
+
+
+@unittest.skipUnless(has_skimage, "Requires scikit-image library.")
+class ComputeHoVerMapsTests(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_horizontal_certical_maps(self, in_type, arguments, mask, hv_mask):
+        input_image = in_type(mask)
+        result = ComputeHoVerMaps(**arguments)(input_image)
+        self.assertIsInstance(result, torch.Tensor)
+        self.assertEqual(str(result.dtype).split(".")[1], arguments.get("dtype", "float32"))
+        assert_allclose(result, hv_mask, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/test_compute_ho_ver_maps_d.py

@@ -0,0 +1,79 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms.intensity.dictionary import ComputeHoVerMapsd
+from monai.utils import min_version, optional_import
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+_, has_skimage = optional_import("skimage", "0.19.0", min_version)
+
+INSTANCE_MASK = np.zeros((1, 16, 16), dtype="int16")
+INSTANCE_MASK[:, 5:8, 4:11] = 1
+INSTANCE_MASK[:, 3:5, 6:9] = 1
+INSTANCE_MASK[:, 8:10, 6:9] = 1
+INSTANCE_MASK[:, 13:, 13:] = 2
+H_MAP = torch.zeros((16, 16), dtype=torch.float32)
+H_MAP[5:8, 4] = -1.0
+H_MAP[5:8, 5] = -2.0 / 3.0
+H_MAP[3:10, 6] = -1.0 / 3.0
+H_MAP[3:10, 7] = 0.0
+H_MAP[3:10, 8] = 1.0 / 3.0
+H_MAP[5:8, 9] = 2.0 / 3.0
+H_MAP[5:8, 10] = 1.0
+H_MAP[13:, 13] = -1.0
+H_MAP[13:, 14] = 0.0
+H_MAP[13:, 15] = 1.0
+V_MAP = torch.zeros((16, 16), dtype=torch.float32)
+V_MAP[3, 6:9] = -1.0
+V_MAP[4, 6:9] = -2.0 / 3.0
+V_MAP[5, 4:11] = -1.0 / 3.0
+V_MAP[6, 4:11] = 0.0
+V_MAP[7, 4:11] = 1.0 / 3.0
+V_MAP[8, 6:9] = 2.0 / 3.0
+V_MAP[9, 6:9] = 1.0
+V_MAP[13, 13:] = -1.0
+V_MAP[14, 13:] = 0.0
+V_MAP[15, 13:] = 1.0
+HV_MAPS = torch.stack([H_MAP, V_MAP])
+TEST_CASE_0 = [{}, {"mask": INSTANCE_MASK}, {"hover_mask": HV_MAPS}]
+TEST_CASE_1 = [{"dtype": "float64"}, {"mask": INSTANCE_MASK}, {"hover_mask": HV_MAPS}]
+TEST_CASE_1 = [{"dtype": "float64", "new_key_prefix": ""}, {"mask": INSTANCE_MASK}, {"mask": HV_MAPS}]
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, *TEST_CASE_0])
+    TESTS.append([p, *TEST_CASE_1])
+
+
+@unittest.skipUnless(has_skimage, "Requires scikit-image library.")
+class ComputeHoVerMapsDictTests(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_horizontal_certical_maps(self, in_type, arguments, mask, hv_mask):
+        hv_key = list(hv_mask.keys())[0]
+        input_image = {}
+        for k in mask.keys():
+            input_image[k] = in_type(mask[k])
+        result = ComputeHoVerMapsd(keys="mask", **arguments)(input_image)[hv_key]
+        self.assertIsInstance(result, torch.Tensor)
+        self.assertEqual(str(result.dtype).split(".")[1], arguments.get("dtype", "float32"))
+        assert_allclose(result, hv_mask[hv_key], type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/test_foreground_mask.py

@@ -0,0 +1,98 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.intensity.array import ForegroundMask
+from monai.utils import min_version, optional_import, set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+skimage, has_skimage = optional_import("skimage", "0.19.0", min_version)
+set_determinism(1234)
+
+A = np.random.randint(64, 128, (3, 3, 2)).astype(np.uint8)
+A3D = np.random.randint(64, 128, (3, 3, 2, 2)).astype(np.uint8)
+B = np.ones_like(A[:1])
+B3D = np.ones_like(A3D[:1])
+MASK = np.pad(B, ((0, 0), (2, 2), (2, 2)), constant_values=0)
+MASK3D = np.pad(B3D, ((0, 0), (2, 2), (2, 2), (2, 2)), constant_values=0)
+IMAGE1 = np.pad(A, ((0, 0), (2, 2), (2, 2)), constant_values=255)
+IMAGE3D = np.pad(A3D, ((0, 0), (2, 2), (2, 2), (2, 2)), constant_values=255)
+IMAGE2 = np.copy(IMAGE1)
+IMAGE2[0] = 0
+IMAGE3 = np.pad(A, ((0, 0), (2, 2), (2, 2)), constant_values=0)
+TEST_CASE_0 = [{}, IMAGE1, MASK]
+TEST_CASE_1 = [{"threshold": "otsu"}, IMAGE1, MASK]
+TEST_CASE_2 = [{"threshold": "otsu"}, IMAGE2, MASK]
+TEST_CASE_3 = [{"threshold": 140}, IMAGE1, MASK]
+TEST_CASE_4 = [{"threshold": "otsu", "invert": True}, IMAGE3, MASK]
+TEST_CASE_5 = [{"threshold": 0.5}, MASK, np.logical_not(MASK)]
+TEST_CASE_6 = [{"threshold": 140}, IMAGE2, np.ones_like(MASK)]
+TEST_CASE_7 = [{"threshold": {"R": "otsu", "G": "otsu", "B": "otsu"}}, IMAGE2, MASK]
+TEST_CASE_8 = [{"threshold": {"R": 140, "G": "otsu", "B": "otsu"}}, IMAGE2, np.ones_like(MASK)]
+TEST_CASE_9 = [{"threshold": {"R": 140, "G": skimage.filters.threshold_otsu, "B": "otsu"}}, IMAGE2, np.ones_like(MASK)]
+TEST_CASE_10 = [{"threshold": skimage.filters.threshold_mean}, IMAGE1, MASK]
+TEST_CASE_11 = [{"threshold": None, "hsv_threshold": "otsu"}, IMAGE1, np.ones_like(MASK)]
+TEST_CASE_12 = [{"threshold": None, "hsv_threshold": {"S": "otsu"}}, IMAGE1, MASK]
+TEST_CASE_13 = [{"threshold": 100, "invert": True}, IMAGE1, np.logical_not(MASK)]
+TEST_CASE_14 = [{}, IMAGE3D, MASK3D]
+TEST_CASE_15 = [{"hsv_threshold": {"S": 0.1}}, IMAGE3D, MASK3D]
+
+TEST_CASE_ERROR_1 = [{"threshold": None}, IMAGE1]
+TEST_CASE_ERROR_2 = [{"threshold": {"K": 1}}, IMAGE1]
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, *TEST_CASE_0])
+    TESTS.append([p, *TEST_CASE_1])
+    TESTS.append([p, *TEST_CASE_2])
+    TESTS.append([p, *TEST_CASE_3])
+    TESTS.append([p, *TEST_CASE_4])
+    TESTS.append([p, *TEST_CASE_5])
+    TESTS.append([p, *TEST_CASE_6])
+    TESTS.append([p, *TEST_CASE_7])
+    TESTS.append([p, *TEST_CASE_8])
+    TESTS.append([p, *TEST_CASE_9])
+    TESTS.append([p, *TEST_CASE_10])
+    TESTS.append([p, *TEST_CASE_11])
+    TESTS.append([p, *TEST_CASE_12])
+    TESTS.append([p, *TEST_CASE_13])
+    TESTS.append([p, *TEST_CASE_14])
+    TESTS.append([p, *TEST_CASE_15])
+
+TESTS_ERROR = []
+for p in TEST_NDARRAYS:
+    TESTS_ERROR.append([p, *TEST_CASE_ERROR_1])
+    TESTS_ERROR.append([p, *TEST_CASE_ERROR_2])
+
+
+@unittest.skipUnless(has_skimage, "Requires sci-kit image")
+class TestForegroundMask(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_foreground_mask(self, in_type, arguments, image, mask):
+        input_image = in_type(image)
+        result = ForegroundMask(**arguments)(input_image)
+        assert_allclose(result, mask, type_test="tensor")
+
+    @parameterized.expand(TESTS_ERROR)
+    def test_foreground_mask_error(self, in_type, arguments, image):
+        input_image = in_type(image)
+        with self.assertRaises(ValueError):
+            ForegroundMask(**arguments)(input_image)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/test_foreground_maskd.py

@@ -0,0 +1,106 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.intensity.dictionary import ForegroundMaskd
+from monai.utils import min_version, optional_import, set_determinism
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+skimage, has_skimage = optional_import("skimage", "0.19.0", min_version)
+set_determinism(1234)
+
+A = np.random.randint(64, 128, (3, 3, 2)).astype(np.uint8)
+A3D = np.random.randint(64, 128, (3, 3, 2, 2)).astype(np.uint8)
+B = np.ones_like(A[:1])
+B3D = np.ones_like(A3D[:1])
+MASK = np.pad(B, ((0, 0), (2, 2), (2, 2)), constant_values=0)
+MASK3D = np.pad(B3D, ((0, 0), (2, 2), (2, 2), (2, 2)), constant_values=0)
+IMAGE1 = np.pad(A, ((0, 0), (2, 2), (2, 2)), constant_values=255)
+IMAGE3D = np.pad(A3D, ((0, 0), (2, 2), (2, 2), (2, 2)), constant_values=255)
+IMAGE2 = np.copy(IMAGE1)
+IMAGE2[0] = 0
+IMAGE3 = np.pad(A, ((0, 0), (2, 2), (2, 2)), constant_values=0)
+TEST_CASE_0 = [{"keys": "image"}, {"image": IMAGE1}, MASK]
+TEST_CASE_1 = [{"keys": "image", "threshold": "otsu"}, {"image": IMAGE1}, MASK]
+TEST_CASE_2 = [{"keys": "image", "threshold": "otsu"}, {"image": IMAGE2}, MASK]
+TEST_CASE_3 = [{"keys": "image", "threshold": 140}, {"image": IMAGE1}, MASK]
+TEST_CASE_4 = [{"keys": "image", "threshold": "otsu", "invert": True}, {"image": IMAGE3}, MASK]
+TEST_CASE_5 = [{"keys": "image", "threshold": 0.5}, {"image": MASK}, np.logical_not(MASK)]
+TEST_CASE_6 = [{"keys": "image", "threshold": 140}, {"image": IMAGE2}, np.ones_like(MASK)]
+TEST_CASE_7 = [{"keys": "image", "threshold": {"R": "otsu", "G": "otsu", "B": "otsu"}}, {"image": IMAGE2}, MASK]
+TEST_CASE_8 = [
+    {"keys": "image", "threshold": {"R": 140, "G": "otsu", "B": "otsu"}},
+    {"image": IMAGE2},
+    np.ones_like(MASK),
+]
+TEST_CASE_9 = [
+    {"keys": "image", "threshold": {"R": 140, "G": skimage.filters.threshold_otsu, "B": "otsu"}},
+    {"image": IMAGE2},
+    np.ones_like(MASK),
+]
+TEST_CASE_10 = [{"keys": "image", "threshold": skimage.filters.threshold_mean}, {"image": IMAGE1}, MASK]
+TEST_CASE_11 = [{"keys": "image", "threshold": None, "hsv_threshold": "otsu"}, {"image": IMAGE1}, np.ones_like(MASK)]
+TEST_CASE_12 = [{"keys": "image", "threshold": None, "hsv_threshold": {"S": "otsu"}}, {"image": IMAGE1}, MASK]
+TEST_CASE_13 = [{"keys": "image", "threshold": 100, "invert": True}, {"image": IMAGE1}, np.logical_not(MASK)]
+TEST_CASE_14 = [{"keys": "image"}, {"image": IMAGE3D}, MASK3D]
+TEST_CASE_15 = [{"keys": "image", "hsv_threshold": {"S": 0.1}}, {"image": IMAGE3D}, MASK3D]
+
+TEST_CASE_ERROR_1 = [{"keys": "image", "threshold": None}, {"image": IMAGE1}]
+TEST_CASE_ERROR_2 = [{"keys": "image", "threshold": {"K": 1}}, {"image": IMAGE1}]
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append([p, *TEST_CASE_0])
+    TESTS.append([p, *TEST_CASE_1])
+    TESTS.append([p, *TEST_CASE_2])
+    TESTS.append([p, *TEST_CASE_3])
+    TESTS.append([p, *TEST_CASE_4])
+    TESTS.append([p, *TEST_CASE_5])
+    TESTS.append([p, *TEST_CASE_6])
+    TESTS.append([p, *TEST_CASE_7])
+    TESTS.append([p, *TEST_CASE_8])
+    TESTS.append([p, *TEST_CASE_9])
+    TESTS.append([p, *TEST_CASE_10])
+    TESTS.append([p, *TEST_CASE_11])
+    TESTS.append([p, *TEST_CASE_12])
+    TESTS.append([p, *TEST_CASE_13])
+    TESTS.append([p, *TEST_CASE_14])
+    TESTS.append([p, *TEST_CASE_15])
+
+TESTS_ERROR = []
+for p in TEST_NDARRAYS:
+    TESTS_ERROR.append([p, *TEST_CASE_ERROR_1])
+    TESTS_ERROR.append([p, *TEST_CASE_ERROR_2])
+
+
+@unittest.skipUnless(has_skimage, "Requires sci-kit image")
+class TestForegroundMaskd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_foreground_mask(self, in_type, arguments, data_dict, mask):
+        data_dict[arguments["keys"]] = in_type(data_dict[arguments["keys"]])
+        result = ForegroundMaskd(**arguments)(data_dict)[arguments["keys"]]
+        assert_allclose(result, mask, type_test=False)
+
+    @parameterized.expand(TESTS_ERROR)
+    def test_foreground_mask_error(self, in_type, arguments, data_dict):
+        data_dict[arguments["keys"]] = in_type(data_dict[arguments["keys"]])
+        with self.assertRaises(ValueError):
+            ForegroundMaskd(**arguments)(data_dict)[arguments["keys"]]
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/test_rand_histogram_shiftd.py

@@ -0,0 +1,76 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.transforms.intensity.dictionary import RandHistogramShiftd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append(
+        [
+            {"keys": ("img",), "num_control_points": 5, "prob": 0.0},
+            {"img": p(np.arange(8).reshape((1, 2, 2, 2))), "seg": p(np.ones(8).reshape((1, 2, 2, 2)))},
+            {"img": np.arange(8).reshape((1, 2, 2, 2)), "seg": np.ones(8).reshape((1, 2, 2, 2))},
+        ]
+    )
+    TESTS.append(
+        [
+            {"keys": ("img",), "num_control_points": 5, "prob": 0.9},
+            {
+                "img": p(np.arange(8).reshape((1, 2, 2, 2)).astype(np.float32)),
+                "seg": p(np.ones(8).reshape((1, 2, 2, 2))),
+            },
+            {
+                "img": np.array(
+                    [[[[0.0, 0.57227867], [1.1391707, 1.68990281]], [[2.75833219, 4.34445884], [5.70913743, 7.0]]]]
+                ),
+                "seg": np.ones(8).reshape((1, 2, 2, 2)),
+            },
+        ]
+    )
+    TESTS.append(
+        [
+            {"keys": ("img",), "num_control_points": (5, 20), "prob": 0.9},
+            {
+                "img": p(np.arange(8).reshape((1, 2, 2, 2)).astype(np.float32)),
+                "seg": p(np.ones(8).reshape((1, 2, 2, 2))),
+            },
+            {
+                "img": np.array(
+                    [[[[0.0, 1.17472492], [2.21553091, 2.88292011]], [[3.98407301, 5.01302123], [6.09275004, 7.0]]]]
+                ),
+                "seg": np.ones(8).reshape((1, 2, 2, 2)),
+            },
+        ]
+    )
+
+
+class TestRandHistogramShiftD(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rand_histogram_shiftd(self, input_param, input_data, expected_val):
+        g = RandHistogramShiftd(**input_param)
+        g.set_random_state(123)
+        res = g(input_data)
+        for key in ("img",):
+            result = res[key]
+            expected = expected_val[key] if isinstance(expected_val, dict) else expected_val
+            assert_allclose(result, expected, rtol=1e-4, atol=1e-4, type_test="tensor")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/intensity/test_scale_intensity_range_percentiles.py

@@ -0,0 +1,96 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+
+from monai.transforms.intensity.array import ScaleIntensityRangePercentiles
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestScaleIntensityRangePercentiles(NumpyImageTestCase2D):
+    def test_scaling(self):
+        img = self.imt[0]
+        lower = 10
+        upper = 99
+        b_min = 0
+        b_max = 255
+
+        a_min = np.percentile(img, lower)
+        a_max = np.percentile(img, upper)
+        expected = (((img - a_min) / (a_max - a_min)) * (b_max - b_min) + b_min).astype(np.uint8)
+        scaler = ScaleIntensityRangePercentiles(lower=lower, upper=upper, b_min=b_min, b_max=b_max, dtype=np.uint8)
+        for p in TEST_NDARRAYS:
+            result = scaler(p(img))
+            self.assertEqual(result.dtype, torch.uint8)
+            assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4)
+
+    def test_relative_scaling(self):
+        img = self.imt[0]
+        lower = 10
+        upper = 99
+        b_min = 100
+        b_max = 300
+        scaler = ScaleIntensityRangePercentiles(lower=lower, upper=upper, b_min=b_min, b_max=b_max, relative=True)
+
+        expected_a_min = np.percentile(img, lower)
+        expected_a_max = np.percentile(img, upper)
+        expected_b_min = ((b_max - b_min) * (lower / 100.0)) + b_min
+        expected_b_max = ((b_max - b_min) * (upper / 100.0)) + b_min
+        expected_img = (img - expected_a_min) / (expected_a_max - expected_a_min)
+        expected_img = (expected_img * (expected_b_max - expected_b_min)) + expected_b_min
+
+        for p in TEST_NDARRAYS:
+            result = scaler(p(img))
+            assert_allclose(result, p(expected_img), type_test="tensor", rtol=1e-3)
+
+        scaler = ScaleIntensityRangePercentiles(
+            lower=lower, upper=upper, b_min=b_min, b_max=b_max, relative=True, clip=True
+        )
+        for p in TEST_NDARRAYS:
+            result = scaler(p(img))
+            assert_allclose(
+                result, p(np.clip(expected_img, expected_b_min, expected_b_max)), type_test="tensor", rtol=0.1
+            )
+
+    def test_invalid_instantiation(self):
+        self.assertRaises(ValueError, ScaleIntensityRangePercentiles, lower=-10, upper=99, b_min=0, b_max=255)
+        self.assertRaises(ValueError, ScaleIntensityRangePercentiles, lower=101, upper=99, b_min=0, b_max=255)
+        self.assertRaises(ValueError, ScaleIntensityRangePercentiles, lower=30, upper=-20, b_min=0, b_max=255)
+        self.assertRaises(ValueError, ScaleIntensityRangePercentiles, lower=30, upper=900, b_min=0, b_max=255)
+
+    def test_channel_wise(self):
+        img = np.tile(self.imt, (3, 1, 1, 1))
+        lower = 10
+        upper = 99
+        b_min = 0
+        b_max = 255
+        scaler = ScaleIntensityRangePercentiles(
+            lower=lower, upper=upper, b_min=b_min, b_max=b_max, channel_wise=True, dtype=np.uint8
+        )
+        expected = []
+        for c in img:
+            a_min = np.percentile(c, lower)
+            a_max = np.percentile(c, upper)
+            expected.append((((c - a_min) / (a_max - a_min)) * (b_max - b_min) + b_min).astype(np.uint8))
+        expected = np.stack(expected)
+
+        for p in TEST_NDARRAYS:
+            result = scaler(p(img))
+            assert_allclose(result, p(expected), type_test="tensor", rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()