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

tests/transforms/intensity/test_scale_intensity_range_percentilesd.py

@@ -0,0 +1,100 @@
+# 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 monai.transforms.intensity.dictionary import ScaleIntensityRangePercentilesd
+from tests.test_utils import TEST_NDARRAYS, NumpyImageTestCase2D, assert_allclose
+
+
+class TestScaleIntensityRangePercentilesd(NumpyImageTestCase2D):
+    def test_scaling(self):
+        img = self.imt
+        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)
+
+        for p in TEST_NDARRAYS:
+            data = {"img": p(img)}
+            scaler = ScaleIntensityRangePercentilesd(
+                keys=data.keys(), lower=lower, upper=upper, b_min=b_min, b_max=b_max, dtype=np.uint8
+            )
+            assert_allclose(scaler(data)["img"], p(expected), type_test="tensor", rtol=1e-4)
+
+    def test_relative_scaling(self):
+        img = self.imt
+        data = {"img": img}
+        lower = 10
+        upper = 99
+        b_min = 100
+        b_max = 300
+        scaler = ScaleIntensityRangePercentilesd(
+            keys=data.keys(), 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
+
+        np.testing.assert_allclose(expected_img, scaler(data)["img"], rtol=1e-3, atol=0.1)
+
+    def test_invalid_instantiation(self):
+        self.assertRaises(
+            ValueError, ScaleIntensityRangePercentilesd, keys=["img"], lower=-1, upper=99, b_min=0, b_max=255
+        )
+        self.assertRaises(
+            ValueError, ScaleIntensityRangePercentilesd, keys=["img"], lower=101, upper=99, b_min=0, b_max=255
+        )
+        self.assertRaises(
+            ValueError, ScaleIntensityRangePercentilesd, keys=["img"], lower=30, upper=-2, b_min=0, b_max=255
+        )
+        self.assertRaises(
+            ValueError, ScaleIntensityRangePercentilesd, keys=["img"], lower=30, upper=1000, b_min=0, b_max=255
+        )
+        with self.assertRaises(ValueError):
+            s = ScaleIntensityRangePercentilesd(keys=["img"], lower=30, upper=90, b_min=None, b_max=20, relative=True)
+            s(self.imt)
+
+    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 = ScaleIntensityRangePercentilesd(
+            keys="img", 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:
+            data = {"img": p(img)}
+            assert_allclose(scaler(data)["img"], p(expected), type_test="tensor", rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/inverse/__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/inverse/test_inverse_array.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 torch
+from parameterized import parameterized
+
+from monai.data import MetaTensor
+from monai.transforms import Compose, EnsureChannelFirst, Flip, Orientation, Spacing
+from monai.transforms.inverse import InvertibleTransform
+from monai.utils import optional_import
+from tests.test_utils import TEST_DEVICES
+
+_, has_nib = optional_import("nibabel")
+
+TESTS = []
+for use_compose in (False, True):
+    for dtype in (torch.float32, torch.float64):
+        for device in TEST_DEVICES:
+            TESTS.append([use_compose, dtype, *device])
+
+
+@unittest.skipUnless(has_nib, "Requires nibabel")
+class TestInverseArray(unittest.TestCase):
+    @staticmethod
+    def get_image(dtype, device) -> MetaTensor:
+        affine = torch.tensor([[0, 0, 1, 0], [-1, 0, 0, 0], [0, 10, 0, 0], [0, 0, 0, 1]]).to(dtype).to(device)
+        img = torch.rand((15, 16, 17)).to(dtype).to(device)
+        return MetaTensor(img, affine=affine)
+
+    @parameterized.expand(TESTS)
+    def test_inverse_array(self, use_compose: bool, dtype: torch.dtype, device: torch.device):
+        img: MetaTensor
+        tr = Compose(
+            [
+                EnsureChannelFirst(channel_dim="no_channel"),
+                Orientation("RAS"),
+                Flip(1),
+                Spacing([1.0, 1.2, 0.9], align_corners=False),
+            ]
+        )
+        num_invertible = len([i for i in tr.transforms if isinstance(i, InvertibleTransform)])
+
+        # forward
+        img = tr(self.get_image(dtype, device))
+        self.assertEqual(len(img.applied_operations), num_invertible)
+
+        # inverse with Compose
+        if use_compose:
+            img = tr.inverse(img)
+            self.assertEqual(len(img.applied_operations), 0)
+
+        # inverse individually
+        else:
+            _tr: InvertibleTransform
+            num_to_inverse = num_invertible
+            for _tr in tr.transforms[::-1]:
+                if isinstance(_tr, InvertibleTransform):
+                    img = _tr.inverse(img)
+                    num_to_inverse -= 1
+                    self.assertEqual(len(img.applied_operations), num_to_inverse)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/inverse/test_traceable_transform.py

@@ -0,0 +1,59 @@
+# 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
+
+from monai.transforms.inverse import TraceableTransform
+
+
+class _TraceTest(TraceableTransform):
+
+    def __call__(self, data):
+        self.push_transform(data)
+        return data
+
+    def pop(self, data):
+        self.pop_transform(data)
+        return data
+
+
+class TestTraceable(unittest.TestCase):
+
+    def test_default(self):
+        expected_key = "_transforms"
+        a = _TraceTest()
+        for x in a.transform_info_keys():
+            self.assertIn(x, a.get_transform_info())
+        self.assertEqual(a.trace_key(), expected_key)
+
+        data = {"image": "test"}
+        data = a(data)  # adds to the stack
+        self.assertIsInstance(data[expected_key], list)
+        self.assertEqual(data[expected_key][0]["class"], "_TraceTest")
+
+        data = a(data)  # adds to the stack
+        self.assertEqual(len(data[expected_key]), 2)
+        self.assertEqual(data[expected_key][-1]["class"], "_TraceTest")
+
+        with self.assertRaises(IndexError):
+            a.pop({"test": "test"})  # no stack in the data
+        data = a.pop(data)
+        data = a.pop(data)
+        self.assertEqual(data[expected_key], [])
+
+        with self.assertRaises(IndexError):  # no more items
+            a.pop(data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/post/__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/post/test_label_filterd.py

@@ -0,0 +1,78 @@
+# 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.post.dictionary import LabelFilterd
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+grid_1 = torch.tensor([[[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]])
+
+VALID_TESTS = []
+for p in TEST_NDARRAYS:
+    VALID_TESTS.append(
+        [
+            "filter_single_label",
+            {"applied_labels": 3},
+            p(grid_1),
+            p(torch.tensor([[[[0, 0, 3], [0, 0, 0], [0, 0, 0]]]])),
+        ]
+    )
+
+    VALID_TESTS.append(
+        [
+            "filter_single_label_list",
+            {"applied_labels": [3]},
+            p(grid_1),
+            p(torch.tensor([[[[0, 0, 3], [0, 0, 0], [0, 0, 0]]]])),
+        ]
+    )
+
+    VALID_TESTS.append(
+        [
+            "filter_multi_label",
+            {"applied_labels": [3, 5, 8]},
+            p(grid_1),
+            p(torch.tensor([[[[0, 0, 3], [0, 5, 0], [0, 8, 0]]]])),
+        ]
+    )
+
+    VALID_TESTS.append(["filter_all", {"applied_labels": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, p(grid_1), p(grid_1)])
+
+ITEST_CASE_1 = ["invalid_image_data_type", {"applied_labels": 1}, [[[[1, 1, 1]]]], NotImplementedError]
+
+INVALID_CASES = [ITEST_CASE_1]
+
+
+class TestLabelFilter(unittest.TestCase):
+    @parameterized.expand(VALID_TESTS)
+    def test_correct_results(self, _, args, input_image, expected):
+        converter = LabelFilterd(keys="image", **args)
+        result = converter({"image": input_image})["image"]
+        assert_allclose(result, expected)
+
+    @parameterized.expand(INVALID_CASES)
+    def test_raise_exception(self, _, args, input_image, expected_error):
+        with self.assertRaises(expected_error):
+            converter = LabelFilterd(keys="image", **args)
+            if isinstance(input_image, torch.Tensor) and torch.cuda.is_available():
+                _ = converter({"image": input_image.cuda()})
+            else:
+                _ = converter({"image": input_image})
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/post/test_probnms.py

@@ -0,0 +1,72 @@
+# 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.post.array import ProbNMS
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+TESTS = []
+for p in TEST_NDARRAYS:
+    probs_map_1 = p(np.random.rand(100, 100).clip(0, 0.5))
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": 10}, probs_map_1, []])
+
+    probs_map_2 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_2[33, 33] = 0.7
+    probs_map_2[66, 66] = 0.9
+    expected_2 = [[0.9, 66, 66], [0.7, 33, 33]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": [10, 10]}, probs_map_2, expected_2])
+
+    probs_map_3 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_3[56, 58] = 0.7
+    probs_map_3[60, 66] = 0.8
+    probs_map_3[66, 66] = 0.9
+    expected_3 = [[0.9, 66, 66], [0.8, 60, 66]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": (10, 20)}, probs_map_3, expected_3])
+
+    probs_map_4 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_4[33, 33] = 0.7
+    probs_map_4[66, 66] = 0.9
+    expected_4 = [[0.9, 66, 66]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.8, "box_size": 10}, probs_map_4, expected_4])
+
+    probs_map_5 = p(np.random.rand(100, 100).clip(0, 0.5))
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "sigma": 0.1}, probs_map_5, []])
+
+    probs_map_6 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_6[33, 33] = 0.7
+    probs_map_6[66, 66] = 0.9
+    expected_6 = [[0.9, 66, 66], [0.7, 33, 33]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "sigma": 0.1}, probs_map_6, expected_6])
+
+    probs_map_3d = p(torch.rand([50, 50, 50]).uniform_(0, 0.5))
+    probs_map_3d[25, 25, 25] = 0.7
+    probs_map_3d[45, 45, 45] = 0.9
+    expected_3d = [[0.9, 45, 45, 45], [0.7, 25, 25, 25]]
+    TESTS.append([{"spatial_dims": 3, "prob_threshold": 0.5, "box_size": (10, 10, 10)}, probs_map_3d, expected_3d])
+
+
+class TestProbNMS(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_output(self, class_args, probs_map, expected):
+        nms = ProbNMS(**class_args)
+        output = nms(probs_map)
+        assert_allclose(output, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/post/test_probnmsd.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
+from typing import Any
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.transforms.post.dictionary import ProbNMSD
+from tests.test_utils import TEST_NDARRAYS
+
+TESTS: list[Any] = []
+for p in TEST_NDARRAYS:
+    probs_map_1 = p(np.random.rand(100, 100).clip(0, 0.5))
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": 10}, {"prob_map": probs_map_1}, []])
+
+    probs_map_2 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_2[33, 33] = 0.7
+    probs_map_2[66, 66] = 0.9
+    expected_2 = [[0.9, 66, 66], [0.7, 33, 33]]
+    TESTS.append(
+        [{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": [10, 10]}, {"prob_map": probs_map_2}, expected_2]
+    )
+
+    probs_map_3 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_3[56, 58] = 0.7
+    probs_map_3[60, 66] = 0.8
+    probs_map_3[66, 66] = 0.9
+    expected_3 = [[0.9, 66, 66], [0.8, 60, 66]]
+    TESTS.append(
+        [{"spatial_dims": 2, "prob_threshold": 0.5, "box_size": (10, 20)}, {"prob_map": probs_map_3}, expected_3]
+    )
+
+    probs_map_4 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_4[33, 33] = 0.7
+    probs_map_4[66, 66] = 0.9
+    expected_4 = [[0.9, 66, 66]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.8, "box_size": 10}, {"prob_map": probs_map_4}, expected_4])
+
+    probs_map_5 = p(np.random.rand(100, 100).clip(0, 0.5))
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "sigma": 0.1}, {"prob_map": probs_map_5}, []])
+
+    probs_map_6 = p(np.random.rand(100, 100).clip(0, 0.5))
+    probs_map_6[33, 33] = 0.7
+    probs_map_6[66, 66] = 0.9
+    expected_6 = [[0.9, 66, 66], [0.7, 33, 33]]
+    TESTS.append([{"spatial_dims": 2, "prob_threshold": 0.5, "sigma": 0.1}, {"prob_map": probs_map_6}, expected_6])
+
+    probs_map_3d = p(torch.rand([50, 50, 50]).uniform_(0, 0.5))
+    probs_map_3d[25, 25, 25] = 0.7
+    probs_map_3d[45, 45, 45] = 0.9
+    expected_3d = [[0.9, 45, 45, 45], [0.7, 25, 25, 25]]
+    TESTS.append(
+        [{"spatial_dims": 3, "prob_threshold": 0.5, "box_size": (10, 10, 10)}, {"prob_map": probs_map_3d}, expected_3d]
+    )
+
+
+class TestProbNMS(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_output(self, class_args, probs_map, expected):
+        nms = ProbNMSD(keys="prob_map", **class_args)
+        output = nms(probs_map)
+        np.testing.assert_allclose(output["prob_map"], expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/post/test_remove_small_objects.py

@@ -0,0 +1,102 @@
+# 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.data.meta_tensor import MetaTensor
+from monai.transforms.post.array import RemoveSmallObjects
+from monai.transforms.post.dictionary import RemoveSmallObjectsd
+from monai.utils import optional_import
+from tests.test_utils import TEST_NDARRAYS, SkipIfNoModule, assert_allclose
+
+morphology, has_morphology = optional_import("skimage.morphology")
+
+TEST_ZEROS = np.zeros((1, 9, 8, 7))
+TEST_ONES = np.ones((3, 7, 8, 9))
+
+TEST_INPUT1 = np.array([[[0, 0, 2, 1, 0], [1, 1, 1, 2, 0], [1, 1, 1, 0, 1]]])
+
+TEST_OUTPUT1 = np.array([[[0, 0, 2, 1, 0], [1, 1, 1, 2, 0], [1, 1, 1, 0, 0]]])
+
+TEST_INPUT2 = np.array([[[1, 1, 1, 0, 0], [1, 1, 1, 0, 0], [0, 0, 0, 0, 0], [0, 1, 1, 0, 1], [0, 0, 0, 1, 1]]])
+affine = torch.eye(4, dtype=torch.float64)
+affine[0, 0] = 2.0
+TEST_INPUT3 = MetaTensor(TEST_INPUT2, affine=affine)
+
+TESTS: list[tuple] = []
+for dtype in (int, float):
+    for p in TEST_NDARRAYS:
+        TESTS.append((dtype, p, TEST_ZEROS, None))
+        TESTS.append((dtype, p, TEST_ONES, None))
+        TESTS.append((dtype, p, TEST_INPUT1, None, {"min_size": 6}))
+        TESTS.append((dtype, p, TEST_INPUT1, None, {"min_size": 7, "connectivity": 2}))
+        # for non-independent channels, the twos should stay
+        TESTS.append((dtype, p, TEST_INPUT1, TEST_OUTPUT1, {"min_size": 2, "independent_channels": False}))
+
+TESTS_PHYSICAL: list[tuple] = []
+for dtype in (int, float):
+    TESTS_PHYSICAL.append((dtype, np.array, TEST_INPUT2, None, {"min_size": 3, "by_measure": True, "pixdim": (2, 1)}))
+    TESTS_PHYSICAL.append((dtype, MetaTensor, TEST_INPUT3, None, {"min_size": 3, "by_measure": True}))
+
+
+@SkipIfNoModule("skimage.morphology")
+class TestRemoveSmallObjects(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_remove_small_objects(self, dtype, im_type, lbl, expected, params=None):
+        params = params or {}
+        if expected is None:
+            dtype = bool if len(np.unique(lbl)) == 1 else int
+            expected = morphology.remove_small_objects(lbl.astype(dtype), **params)
+        expected = im_type(expected, dtype=dtype)
+        lbl = im_type(lbl, dtype=dtype)
+        lbl_clean = RemoveSmallObjects(**params)(lbl)
+        assert_allclose(lbl_clean, expected, device_test=True)
+        if isinstance(lbl, MetaTensor):
+            assert_allclose(lbl.affine, lbl_clean.affine)
+
+    @parameterized.expand(TESTS_PHYSICAL)
+    def test_remove_small_objects_physical(self, dtype, im_type, lbl, expected, params):
+        params = params or {}
+        min_size = np.ceil(params["min_size"] / 2)
+
+        if expected is None:
+            dtype = bool if lbl.max() <= 1 else int
+            expected = morphology.remove_small_objects(lbl.astype(dtype), min_size=min_size)
+        expected = im_type(expected, dtype=dtype)
+        lbl = im_type(lbl, dtype=dtype)
+        lbl_clean = RemoveSmallObjects(**params)(lbl)
+        assert_allclose(lbl_clean, expected, device_test=True)
+
+        lbl_clean = RemoveSmallObjectsd("lbl", **params)({"lbl": lbl})["lbl"]
+        assert_allclose(lbl_clean, expected, device_test=True)
+
+    @parameterized.expand(TESTS)
+    def test_remove_small_objects_dict(self, dtype, im_type, lbl, expected, params=None):
+        params = params or {}
+        if expected is None:
+            dtype = bool if len(np.unique(lbl)) == 1 else int
+            expected = morphology.remove_small_objects(lbl.astype(dtype), **params)
+        expected = im_type(expected, dtype=dtype)
+        lbl = im_type(lbl, dtype=dtype)
+        lbl_clean = RemoveSmallObjectsd("lbl", **params)({"lbl": lbl})["lbl"]
+        assert_allclose(lbl_clean, expected, device_test=True)
+        if isinstance(lbl, MetaTensor):
+            assert_allclose(lbl.affine, lbl_clean.affine)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/transforms/spatial/__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.