monai-weekly 1.5.dev2505__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/apps/pathology/transforms/test_pathology_he_stain_dict.py

@@ -0,0 +1,225 @@
+# 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.apps.pathology.transforms import ExtractHEStainsD, NormalizeHEStainsD
+
+# None inputs
+EXTRACT_STAINS_TEST_CASE_0 = (None,)
+EXTRACT_STAINS_TEST_CASE_00 = (None, None)
+NORMALIZE_STAINS_TEST_CASE_0 = (None,)
+NORMALIZE_STAINS_TEST_CASE_00: tuple = ({}, None, None)
+
+# input pixels all transparent and below the beta absorbance threshold
+EXTRACT_STAINS_TEST_CASE_1 = [np.full((3, 2, 3), 240)]
+
+# input pixels uniformly filled, but above beta absorbance threshold
+EXTRACT_STAINS_TEST_CASE_2 = [np.full((3, 2, 3), 100)]
+
+# input pixels uniformly filled (different value), but above beta absorbance threshold
+EXTRACT_STAINS_TEST_CASE_3 = [np.full((3, 2, 3), 150)]
+
+# input pixels uniformly filled with zeros, leading to two identical stains extracted
+EXTRACT_STAINS_TEST_CASE_4 = [
+    np.zeros((3, 2, 3)),
+    np.array([[0.0, 0.0], [0.70710678, 0.70710678], [0.70710678, 0.70710678]]),
+]
+
+# input pixels not uniformly filled, leading to two different stains extracted
+EXTRACT_STAINS_TEST_CASE_5 = [
+    np.array([[[100, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]),
+    np.array([[0.70710677, 0.18696113], [0.0, 0.0], [0.70710677, 0.98236734]]),
+]
+
+# input pixels all transparent and below the beta absorbance threshold
+NORMALIZE_STAINS_TEST_CASE_1 = [np.full((3, 2, 3), 240)]
+
+# input pixels uniformly filled with zeros, and target stain matrix provided
+NORMALIZE_STAINS_TEST_CASE_2 = [{"target_he": np.full((3, 2), 1)}, np.zeros((3, 2, 3)), np.full((3, 2, 3), 11)]
+
+# input pixels uniformly filled with zeros, and target stain matrix not provided
+NORMALIZE_STAINS_TEST_CASE_3 = [
+    {},
+    np.zeros((3, 2, 3)),
+    np.array([[[63, 25, 60], [63, 25, 60]], [[63, 25, 60], [63, 25, 60]], [[63, 25, 60], [63, 25, 60]]]),
+]
+
+# input pixels not uniformly filled
+NORMALIZE_STAINS_TEST_CASE_4 = [
+    {"target_he": np.full((3, 2), 1)},
+    np.array([[[100, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]),
+    np.array([[[87, 87, 87], [33, 33, 33]], [[33, 33, 33], [33, 33, 33]], [[33, 33, 33], [33, 33, 33]]]),
+]
+
+
+class TestExtractHEStainsD(unittest.TestCase):
+
+    @parameterized.expand([EXTRACT_STAINS_TEST_CASE_0, EXTRACT_STAINS_TEST_CASE_1])
+    def test_transparent_image(self, image):
+        """
+        Test HE stain extraction on an image that comprises
+        only transparent pixels - pixels with absorbance below the
+        beta absorbance threshold. A ValueError should be raised,
+        since once the transparent pixels are removed, there are no
+        remaining pixels to compute eigenvectors.
+        """
+        key = "image"
+        if image is None:
+            with self.assertRaises(TypeError):
+                ExtractHEStainsD([key])({key: image})
+        else:
+            with self.assertRaises(ValueError):
+                ExtractHEStainsD([key])({key: image})
+
+    @parameterized.expand([EXTRACT_STAINS_TEST_CASE_0, EXTRACT_STAINS_TEST_CASE_2, EXTRACT_STAINS_TEST_CASE_3])
+    def test_identical_result_vectors(self, image):
+        """
+        Test HE stain extraction on input images that are
+        uniformly filled with pixels that have absorbance above the
+        beta absorbance threshold. Since input image is uniformly filled,
+        the two extracted stains should have the same RGB values. So,
+        we assert that the first column is equal to the second column
+        of the returned stain matrix.
+        """
+        key = "image"
+        if image is None:
+            with self.assertRaises(TypeError):
+                ExtractHEStainsD([key])({key: image})
+        else:
+            result = ExtractHEStainsD([key])({key: image})
+            np.testing.assert_array_equal(result[key][:, 0], result[key][:, 1])
+
+    @parameterized.expand([EXTRACT_STAINS_TEST_CASE_00, EXTRACT_STAINS_TEST_CASE_4, EXTRACT_STAINS_TEST_CASE_5])
+    def test_result_value(self, image, expected_data):
+        """
+        Test that an input image returns an expected stain matrix.
+
+        For test case 4:
+        - a uniformly filled input image should result in
+          eigenvectors [[1,0,0],[0,1,0],[0,0,1]]
+        - phi should be an array containing only values of
+          arctan(1) since the ratio between the eigenvectors
+          corresponding to the two largest eigenvalues is 1
+        - maximum phi and minimum phi should thus be arctan(1)
+        - thus, maximum vector and minimum vector should be
+          [[0],[0.70710677],[0.70710677]]
+        - the resulting extracted stain should be
+          [[0,0],[0.70710678,0.70710678],[0.70710678,0.70710678]]
+
+        For test case 5:
+        - the non-uniformly filled input image should result in
+          eigenvectors [[0,0,1],[1,0,0],[0,1,0]]
+        - maximum phi and minimum phi should thus be 0.785 and
+          0.188 respectively
+        - thus, maximum vector and minimum vector should be
+          [[0.18696113],[0],[0.98236734]] and
+          [[0.70710677],[0],[0.70710677]] respectively
+        - the resulting extracted stain should be
+          [[0.70710677,0.18696113],[0,0],[0.70710677,0.98236734]]
+        """
+        key = "image"
+        if image is None:
+            with self.assertRaises(TypeError):
+                ExtractHEStainsD([key])({key: image})
+        else:
+            result = ExtractHEStainsD([key])({key: image})
+            np.testing.assert_allclose(result[key], expected_data)
+
+
+class TestNormalizeHEStainsD(unittest.TestCase):
+
+    @parameterized.expand([NORMALIZE_STAINS_TEST_CASE_0, NORMALIZE_STAINS_TEST_CASE_1])
+    def test_transparent_image(self, image):
+        """
+        Test HE stain normalization on an image that comprises
+        only transparent pixels - pixels with absorbance below the
+        beta absorbance threshold. A ValueError should be raised,
+        since once the transparent pixels are removed, there are no
+        remaining pixels to compute eigenvectors.
+        """
+        key = "image"
+        if image is None:
+            with self.assertRaises(TypeError):
+                NormalizeHEStainsD([key])({key: image})
+        else:
+            with self.assertRaises(ValueError):
+                NormalizeHEStainsD([key])({key: image})
+
+    @parameterized.expand(
+        [
+            NORMALIZE_STAINS_TEST_CASE_00,
+            NORMALIZE_STAINS_TEST_CASE_2,
+            NORMALIZE_STAINS_TEST_CASE_3,
+            NORMALIZE_STAINS_TEST_CASE_4,
+        ]
+    )
+    def test_result_value(self, arguments, image, expected_data):
+        """
+        Test that an input image returns an expected normalized image.
+
+        For test case 2:
+        - This case tests calling the stain normalizer, after the
+          _deconvolution_extract_conc function. This is because the normalized
+          concentration returned for each pixel is the same as the reference
+          maximum stain concentrations in the case that the image is uniformly
+          filled, as in this test case. This is because the maximum concentration
+          for each stain is the same as each pixel's concentration.
+        - Thus, the normalized concentration matrix should be a (2, 6) matrix
+          with the first row having all values of 1.9705, second row all 1.0308.
+        - Taking the matrix product of the target stain matrix and the concentration
+          matrix, then using the inverse Beer-Lambert transform to obtain the RGB
+          image from the absorbance image, and finally converting to uint8,
+          we get that the stain normalized image should be a matrix of
+          dims (3, 2, 3), with all values 11.
+
+        For test case 3:
+        - This case also tests calling the stain normalizer, after the
+          _deconvolution_extract_conc function returns the image concentration
+          matrix.
+        - As in test case 2, the normalized concentration matrix should be a (2, 6) matrix
+          with the first row having all values of 1.9705, second row all 1.0308.
+        - Taking the matrix product of the target default stain matrix and the concentration
+          matrix, then using the inverse Beer-Lambert transform to obtain the RGB
+          image from the absorbance image, and finally converting to uint8,
+          we get that the stain normalized image should be [[[63, 25, 60], [63, 25, 60]],
+          [[63, 25, 60], [63, 25, 60]], [[63, 25, 60], [63, 25, 60]]]
+
+        For test case 4:
+        - For this non-uniformly filled image, the stain extracted should be
+          [[0.70710677,0.18696113],[0,0],[0.70710677,0.98236734]], as validated for the
+          ExtractHEStains class. Solving the linear least squares problem (since
+          absorbance matrix = stain matrix * concentration matrix), we obtain the concentration
+          matrix that should be [[-0.3101, 7.7508, 7.7508, 7.7508, 7.7508, 7.7508],
+          [5.8022, 0, 0, 0, 0, 0]]
+        - Normalizing the concentration matrix, taking the matrix product of the
+          target stain matrix and the concentration matrix, using the inverse
+          Beer-Lambert transform to obtain the RGB image from the absorbance
+          image, and finally converting to uint8, we get that the stain normalized
+          image should be [[[87, 87, 87], [33, 33, 33]], [[33, 33, 33], [33, 33, 33]],
+          [[33, 33, 33], [33, 33, 33]]]
+        """
+        key = "image"
+        if image is None:
+            with self.assertRaises(TypeError):
+                NormalizeHEStainsD([key])({key: image})
+        else:
+            result = NormalizeHEStainsD([key], **arguments)({key: image})
+            np.testing.assert_allclose(result[key], expected_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/__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/apps/reconstruction/nets/__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/apps/reconstruction/nets/test_recon_net_utils.py

@@ -0,0 +1,82 @@
+# 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.apps.reconstruction.networks.nets.utils import (
+    complex_normalize,
+    divisible_pad_t,
+    inverse_divisible_pad_t,
+    reshape_batch_channel_to_channel_dim,
+    reshape_channel_complex_to_last_dim,
+    reshape_channel_to_batch_dim,
+    reshape_complex_to_channel_dim,
+    sensitivity_map_expand,
+    sensitivity_map_reduce,
+)
+from tests.test_utils import assert_allclose
+
+# no need for checking devices, these functions don't change device format
+# reshape test case
+im_2d, im_3d = torch.ones([3, 4, 50, 70, 2]), torch.ones([3, 4, 50, 70, 80, 2])
+TEST_RESHAPE = [(im_2d,), (im_3d,)]
+
+# normalize test case
+im_2d, im_3d = (torch.randint(0, 3, [3, 4, 50, 70]).float(), torch.randint(0, 3, [3, 4, 50, 70, 80]).float())
+TEST_NORMALIZE = [(im_2d,), (im_3d,)]
+
+# pad test case
+im_2d, im_3d = torch.ones([3, 4, 50, 70]), torch.ones([3, 4, 50, 70, 80])
+TEST_PAD = [(im_2d,), (im_3d,)]
+
+# test case for sensitivity map expansion/reduction
+ksp_2d, ksp_3d = torch.ones([3, 4, 50, 70, 2]), torch.ones([3, 4, 50, 70, 80, 2])
+sens_2d, sens_3d = torch.ones([3, 4, 50, 70, 2]), torch.ones([3, 4, 50, 70, 80, 2])
+TEST_SENS = [(ksp_2d, sens_2d), (ksp_3d, sens_3d)]
+
+
+class TestReconNetUtils(unittest.TestCase):
+    @parameterized.expand(TEST_RESHAPE)
+    def test_reshape_channel_complex(self, test_data):
+        result = reshape_complex_to_channel_dim(test_data)
+        result = reshape_channel_complex_to_last_dim(result)
+        self.assertEqual(result.shape, test_data.shape)
+
+        result, batch_size = reshape_channel_to_batch_dim(test_data)
+        result = reshape_batch_channel_to_channel_dim(result, batch_size)
+        self.assertEqual(result.shape, test_data.shape)
+
+    @parameterized.expand(TEST_NORMALIZE)
+    def test_complex_normalize(self, test_data):
+        result, mean, std = complex_normalize(test_data)
+        result = result * std + mean
+        self.assertLess((((result - test_data) ** 2).mean() ** 0.5).item(), 1e-5)
+
+    @parameterized.expand(TEST_PAD)
+    def test_pad(self, test_data):
+        result, padding_sizes = divisible_pad_t(test_data, k=16)
+        result = inverse_divisible_pad_t(result, padding_sizes)
+        assert_allclose(result, test_data)
+
+    @parameterized.expand(TEST_SENS)
+    def test_sens_expand_reduce(self, test_data, sens):
+        result = sensitivity_map_reduce(test_data, sens)
+        result = sensitivity_map_expand(result, sens)
+        self.assertEqual(result.shape, test_data.shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/test_complex_utils.py

@@ -0,0 +1,77 @@
+# 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.apps.reconstruction.complex_utils import complex_abs, complex_conj, complex_mul, convert_to_tensor_complex
+from monai.utils.type_conversion import convert_data_type
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+# test case for convert_to_tensor_complex
+im_complex = [[1.0 + 1.0j, 1.0 + 1.0j], [1.0 + 1.0j, 1.0 + 1.0j]]
+expected_shape = convert_data_type((2, 2, 2), torch.Tensor)[0]
+TESTS = [(im_complex, expected_shape)]
+for p in TEST_NDARRAYS:
+    TESTS.append((p(im_complex), expected_shape))
+
+# test case for complex_abs
+im = [[3.0, 4.0], [3.0, 4.0]]
+res = [5.0, 5.0]
+TESTSC = []
+for p in TEST_NDARRAYS:
+    TESTSC.append((p(im), p(res)))
+
+# test case for complex_mul
+x = [[1.0, 2.0], [3.0, 4.0]]
+y = [[1.0, 1.0], [1.0, 1.0]]
+res = [[-1.0, 3.0], [-1.0, 7.0]]  # type: ignore
+TESTSM = []
+for p in TEST_NDARRAYS:
+    TESTSM.append((p(x), p(y), p(res)))
+
+# test case for complex_conj
+im = [[1.0, 2.0], [3.0, 4.0]]
+res = [[1.0, -2.0], [3.0, -4.0]]  # type: ignore
+TESTSJ = []
+for p in TEST_NDARRAYS:
+    TESTSJ.append((p(im), p(res)))
+
+
+class TestMRIUtils(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_to_tensor_complex(self, test_data, expected_shape):
+        result = convert_to_tensor_complex(test_data)
+        self.assertTrue(isinstance(result, torch.Tensor))
+        self.assertTupleEqual(result.shape, expected_shape)
+
+    @parameterized.expand(TESTSC)
+    def test_complex_abs(self, test_data, res_data):
+        result = complex_abs(test_data)
+        assert_allclose(result, res_data, type_test=False)
+
+    @parameterized.expand(TESTSM)
+    def test_complex_mul(self, test_x, test_y, res_data):
+        result = complex_mul(test_x, test_y)
+        assert_allclose(result, res_data, type_test=False)
+
+    @parameterized.expand(TESTSJ)
+    def test_complex_conj(self, test_data, res_data):
+        result = complex_conj(test_data)
+        assert_allclose(result, res_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/test_fastmri_reader.py

@@ -0,0 +1,82 @@
+# 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.apps.reconstruction.fastmri_reader import FastMRIReader
+from tests.test_utils import SkipIfNoModule, assert_allclose
+
+TEST_CASE1 = [
+    {
+        "kspace": np.array([[1.0, 2.0]]),
+        "filename": "test1",
+        "reconstruction_rss": np.array([[1.0, 2.0]]),
+        "acquisition": "FS",
+        "max": 2.0,
+        "norm": 2.2,
+        "patient_id": 12,
+    },
+    np.array([[1.0, 2.0]]),
+    {
+        "filename": "test1",
+        "reconstruction_rss": np.array([[1.0, 2.0]]),
+        "acquisition": "FS",
+        "max": 2.0,
+        "norm": 2.2,
+        "patient_id": 12,
+        "mask": np.zeros([1, 2]),
+    },
+]
+
+TEST_CASE2 = [
+    {
+        "kspace": np.array([[1.0, 2.0], [3.0, 4.0]]),
+        "filename": "test2",
+        "reconstruction_rss": np.array([[1.0, 2.0], [3.0, 4.0]]),
+        "acquisition": "FS",
+        "max": 4.0,
+        "norm": 5.5,
+        "patient_id": 1234,
+    },
+    np.array([[1.0, 2.0], [3.0, 4.0]]),
+    {
+        "filename": "test2",
+        "reconstruction_rss": np.array([[1.0, 2.0], [3.0, 4.0]]),
+        "acquisition": "FS",
+        "max": 4.0,
+        "norm": 5.5,
+        "patient_id": 1234,
+        "mask": np.zeros([2, 2]),
+    },
+]
+
+
+@SkipIfNoModule("h5py")
+class TestMRIUtils(unittest.TestCase):
+    @parameterized.expand([TEST_CASE1, TEST_CASE2])
+    def test_get_data(self, test_data, test_res, test_meta):
+        reader = FastMRIReader()
+        res, meta = reader.get_data(test_data)
+        assert_allclose(res, test_res)
+        for key in test_meta:
+            if isinstance(test_meta[key], np.ndarray):
+                assert_allclose(test_meta[key], meta[key])
+            else:
+                self.assertEqual(test_meta[key], meta[key])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/test_mri_utils.py

@@ -0,0 +1,37 @@
+# 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 parameterized import parameterized
+
+from monai.apps.reconstruction.mri_utils import root_sum_of_squares
+from tests.test_utils import TEST_NDARRAYS, assert_allclose
+
+# root_sum_of_squares
+im = [[3.0, 4.0], [3.0, 4.0]]
+res = [5.0, 5.0]
+TESTS = []
+for p in TEST_NDARRAYS:
+    TESTS.append((p(im), p(res)))
+
+
+class TestMRIUtils(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_rss(self, test_data, res_data):
+        result = root_sum_of_squares(test_data, spatial_dim=1)
+        assert_allclose(result, res_data, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/transforms/__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/apps/reconstruction/transforms/test_kspace_mask.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 numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.apps.reconstruction.transforms.array import EquispacedKspaceMask, RandomKspaceMask
+from monai.utils.type_conversion import convert_data_type
+
+# test case for apply_mask
+ksp, *_ = convert_data_type(np.ones([50, 50, 2]), torch.Tensor)
+TESTSM = [(ksp,)]
+
+
+class TestMRIUtils(unittest.TestCase):
+
+    @parameterized.expand(TESTSM)
+    def test_mask(self, test_data):
+        # random mask
+        masker = RandomKspaceMask(center_fractions=[0.08], accelerations=[4.0], spatial_dims=1, is_complex=True)
+        masker.set_random_state(seed=0)
+        result, _ = masker(test_data)
+        mask = masker.mask
+        result = result[..., mask.squeeze() == 0, :].sum()
+        self.assertEqual(result.item(), 0)
+
+        # equispaced mask
+        masker = EquispacedKspaceMask(center_fractions=[0.08], accelerations=[4.0], spatial_dims=1, is_complex=True)
+        masker.set_random_state(seed=0)
+        result, _ = masker(test_data)
+        mask = masker.mask
+        result = result[..., mask.squeeze() == 0, :].sum()
+        self.assertEqual(result.item(), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/reconstruction/transforms/test_reference_based_normalize_intensity.py

@@ -0,0 +1,77 @@
+# 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.apps.reconstruction.transforms.dictionary import ReferenceBasedNormalizeIntensityd
+from monai.utils.type_conversion import convert_to_numpy
+from tests.test_utils import TEST_NDARRAYS_NO_META_TENSOR, assert_allclose
+
+# see test_normalize_intensityd for typical tests (like non-zero
+# normalization, device test, etc.)
+# here, we test DetailedNormalizeIntensityd's functionality
+# which focuses on (1) automatic target normalization and (2) mean-std
+# return values
+
+TESTS = []
+for p in TEST_NDARRAYS_NO_META_TENSOR:
+    TESTS.append(
+        [
+            {"keys": ["kspace_masked_ifft", "target"], "ref_key": "kspace_masked_ifft", "channel_wise": True},
+            {"kspace_masked_ifft": p(np.array([[-2.0, 0.0, 2.0]])), "target": p(np.array([[1.0, 2.0, 3.0]]))},
+            p(np.array([[-1.225, 0.0, 1.225]])),  # normalized input
+            p(np.array([[0.612, 1.225, 1.837]])),  # normalized target
+            np.array([0.0]),  # mean
+            np.array([1.633]),  # std
+        ]
+    )
+
+    TESTS.append(
+        [
+            {"keys": ["kspace_masked_ifft", "target"], "ref_key": "kspace_masked_ifft", "channel_wise": False},
+            {"kspace_masked_ifft": p(np.array([[-2.0, 0.0, 2.0]])), "target": p(np.array([[1.0, 2.0, 3.0]]))},
+            p(np.array([[-1.225, 0.0, 1.225]])),  # normalized input
+            p(np.array([[0.612, 1.225, 1.837]])),  # normalized target
+            0.0,  # mean
+            1.633,  # std
+        ]
+    )
+
+
+class TestDetailedNormalizeIntensityd(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_target_mean_std(self, args, data, normalized_data, normalized_target, mean, std):
+        dtype = data[args["keys"][0]].dtype
+        normalizer = ReferenceBasedNormalizeIntensityd(
+            keys=args["keys"], ref_key=args["ref_key"], channel_wise=args["channel_wise"], dtype=dtype
+        )
+        res_data = normalizer(data)
+
+        img = np.round(convert_to_numpy(res_data[args["keys"][0]]), 3)
+        normalized_data = np.round(convert_to_numpy(normalized_data), 3)
+
+        target = np.round(convert_to_numpy(res_data[args["keys"][1]]), 3)
+        normalized_target = np.round(convert_to_numpy(normalized_target), 3)
+
+        assert_allclose(img, normalized_data)
+        assert_allclose(target, normalized_target)
+
+        assert_allclose(np.round(res_data["mean"], 3), mean)
+        assert_allclose(np.round(res_data["std"], 3), std)
+
+
+if __name__ == "__main__":
+    unittest.main()