junifer 0.0.3.dev186__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/data/tests/test_masks.py

@@ -5,16 +5,16 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import socket
 from pathlib import Path
-from typing import Callable, Dict, List, Union
+from typing import Callable, Dict, List, Optional, Union
 
+import nibabel as nib
 import numpy as np
 import pytest
-from nilearn.datasets import fetch_icbm152_brain_gm_mask
 from nilearn.image import resample_to_img
 from nilearn.masking import (
     compute_background_mask,
-    compute_brain_mask,
     compute_epi_mask,
     intersect_masks,
 )
@@ -23,24 +23,103 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal
 from junifer.data.masks import (
     _available_masks,
     _load_vickery_patil_mask,
+    compute_brain_mask,
     get_mask,
     list_masks,
     load_mask,
     register_mask,
 )
+from junifer.datagrabber import DMCC13Benchmark
 from junifer.datareader import DefaultDataReader
 from junifer.testing.datagrabbers import (
     OasisVBMTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
     SPMAuditoryTestingDataGrabber,
 )
 
 
+@pytest.mark.parametrize(
+    "mask_type, threshold",
+    [
+        ("brain", 0.2),
+        ("brain", 0.5),
+        ("brain", 0.8),
+        ("gm", 0.2),
+        ("gm", 0.5),
+        ("gm", 0.8),
+        ("wm", 0.2),
+        ("wm", 0.5),
+        ("wm", 0.8),
+    ],
+)
+def test_compute_brain_mask(mask_type: str, threshold: float) -> None:
+    """Test compute_brain_mask().
+
+    Parameters
+    ----------
+    mask_type : str
+        The parametrized mask type.
+    threshold : float
+        The parametrized threshold.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        mask = compute_brain_mask(
+            target_data=element_data["BOLD"],
+            extra_input=None,
+            mask_type=mask_type,
+        )
+        assert isinstance(mask, nib.Nifti1Image)
+
+
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+@pytest.mark.parametrize(
+    "mask_type",
+    [
+        "brain",
+        "gm",
+        "wm",
+    ],
+)
+def test_compute_brain_mask_for_native(mask_type: str) -> None:
+    """Test compute_brain_mask().
+
+    Parameters
+    ----------
+    mask_type : str
+        The parametrized mask type.
+
+    """
+    with DMCC13Benchmark(
+        types=["BOLD"],
+        sessions=["ses-wave1bas"],
+        tasks=["Rest"],
+        phase_encodings=["AP"],
+        runs=["1"],
+        native_t1w=True,
+    ) as dg:
+        element_data = DefaultDataReader().fit_transform(
+            dg[("sub-f1031ax", "ses-wave1bas", "Rest", "AP", "1")]
+        )
+        mask = compute_brain_mask(
+            target_data=element_data["BOLD"],
+            extra_input=None,
+            mask_type=mask_type,
+        )
+        assert isinstance(mask, nib.Nifti1Image)
+
+
 def test_register_mask_built_in_check() -> None:
     """Test mask registration check for built-in masks."""
     with pytest.raises(ValueError, match=r"built-in mask"):
         register_mask(
             name="GM_prob0.2",
             mask_path="testmask.nii.gz",
+            space="MNI",
             overwrite=True,
         )
 
@@ -57,6 +136,7 @@ def test_register_mask_already_registered() -> None:
     register_mask(
         name="testmask",
         mask_path="testmask.nii.gz",
+        space="MNI",
     )
     out = load_mask("testmask", path_only=True)
     assert out[1] is not None
@@ -67,10 +147,12 @@ def test_register_mask_already_registered() -> None:
         register_mask(
             name="testmask",
             mask_path="testmask.nii.gz",
+            space="MNI",
         )
     register_mask(
         name="testmask",
         mask_path="testmask2.nii.gz",
+        space="MNI",
         overwrite=True,
     )
 
@@ -80,16 +162,17 @@ def test_register_mask_already_registered() -> None:
 
 
 @pytest.mark.parametrize(
-    "name, mask_path, overwrite",
+    "name, mask_path, space, overwrite",
     [
-        ("testmask_1", "testmask_1.nii.gz", True),
-        ("testmask_2", "testmask_2.nii.gz", True),
-        ("testmask_3", Path("testmask_3.nii.gz"), True),
+        ("testmask_1", "testmask_1.nii.gz", "MNI", True),
+        ("testmask_2", "testmask_2.nii.gz", "MNI", True),
+        ("testmask_3", Path("testmask_3.nii.gz"), "MNI", True),
     ],
 )
 def test_register_mask(
     name: str,
     mask_path: str,
+    space: str,
     overwrite: bool,
 ) -> None:
     """Test mask registration.
@@ -100,6 +183,8 @@ def test_register_mask(
         The parametrized mask name.
     mask_path : str or pathlib.Path
         The parametrized mask path.
+    space : str
+        The parametrized mask space.
     overwrite : bool
         The parametrized mask overwrite value.
 
@@ -108,16 +193,18 @@ def test_register_mask(
     register_mask(
         name=name,
         mask_path=mask_path,
+        space=space,
         overwrite=overwrite,
     )
     # List available mask and check registration
     masks = list_masks()
     assert name in masks
     # Load registered mask
-    _, fname = load_mask(name=name, path_only=True)
+    _, fname, mask_space = load_mask(name=name, path_only=True)
     # Check values for registered mask
     assert fname is not None
     assert fname.name == f"{name}.nii.gz"
+    assert space == mask_space
 
 
 @pytest.mark.parametrize(
@@ -146,52 +233,79 @@ def test_load_mask_incorrect() -> None:
         load_mask("wrongmask")
 
 
-def test_vickery_patil() -> None:
-    """Test Vickery-Patil mask."""
-    mask, fname = load_mask("GM_prob0.2")
-    assert_array_almost_equal(
-        mask.header["pixdim"][1:4], [1.5, 1.5, 1.5]  # type: ignore
-    )
-
-    assert fname is not None
-    assert fname.name == "CAT12_IXI555_MNI152_TMP_GS_GMprob0.2_clean.nii.gz"
-
-    mask, fname = load_mask("GM_prob0.2", resolution=3)
-    assert_array_almost_equal(
-        mask.header["pixdim"][1:4], [3.0, 3.0, 3.0]  # type: ignore
-    )
+@pytest.mark.parametrize(
+    "name, resolution, pixdim, fname",
+    [
+        (
+            "GM_prob0.2",
+            None,
+            [1.5, 1.5, 1.5],
+            "CAT12_IXI555_MNI152_TMP_GS_GMprob0.2_clean.nii.gz",
+        ),
+        (
+            "GM_prob0.2",
+            3.0,
+            [3.0, 3.0, 3.0],
+            "CAT12_IXI555_MNI152_TMP_GS_GMprob0.2_clean_3mm.nii.gz",
+        ),
+        (
+            "GM_prob0.2_cortex",
+            None,
+            [3.0, 3.0, 3.0],
+            "GMprob0.2_cortex_3mm_NA_rm.nii.gz",
+        ),
+    ],
+)
+def test_vickery_patil(
+    name: str,
+    resolution: Optional[float],
+    pixdim: List[float],
+    fname: str,
+) -> None:
+    """Test Vickery-Patil mask.
 
-    assert fname is not None
-    assert (
-        fname.name == "CAT12_IXI555_MNI152_TMP_GS_GMprob0.2_clean_3mm.nii.gz"
-    )
+    Parameters
+    ----------
+    name : str
+        The parametrized name of the mask.
+    resolution : float or None
+        The parametrized resolution of the mask.
+    pixdim : list of float
+        The parametrized pixel dimensions of the mask.
+    fname : str
+        The parametrized name of the mask file.
 
-    mask, fname = load_mask("GM_prob0.2_cortex")
+    """
+    mask, mask_fname, space = load_mask(name, resolution=resolution)
     assert_array_almost_equal(
-        mask.header["pixdim"][1:4], [3.0, 3.0, 3.0]  # type: ignore
+        mask.header["pixdim"][1:4], pixdim  # type: ignore
     )
+    assert space == "IXI549Space"
+    assert mask_fname is not None
+    assert mask_fname.name == fname
 
-    assert fname is not None
-    assert fname.name == "GMprob0.2_cortex_3mm_NA_rm.nii.gz"
 
+def test_vickery_patil_error() -> None:
+    """Test error for Vickery-Patil mask."""
     with pytest.raises(ValueError, match=r"find a Vickery-Patil mask "):
-        _load_vickery_patil_mask("wrong", resolution=2)
+        _load_vickery_patil_mask(name="wrong", resolution=2.0)
 
 
 def test_get_mask() -> None:
     """Test the get_mask function."""
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         vbm_gm_img = vbm_gm["data"]
-        mask = get_mask(masks="GM_prob0.2", target_data=vbm_gm)
+        mask = get_mask(masks="compute_brain_mask", target_data=vbm_gm)
 
         assert mask.shape == vbm_gm_img.shape
         assert_array_equal(mask.affine, vbm_gm_img.affine)
 
-        raw_mask_img, _ = load_mask("GM_prob0.2", resolution=1.5)
+        raw_mask_callable, _, _ = load_mask(
+            "compute_brain_mask", resolution=1.5
+        )
+        raw_mask_img = raw_mask_callable(vbm_gm)  # type: ignore
         res_mask_img = resample_to_img(
             raw_mask_img,
             vbm_gm_img,
@@ -207,12 +321,14 @@ def test_mask_callable() -> None:
     def ident(x):
         return x
 
-    _available_masks["identity"] = {"family": "Callable", "func": ident}
-    reader = DefaultDataReader()
+    _available_masks["identity"] = {
+        "family": "Callable",
+        "func": ident,
+        "space": "MNI152Lin",
+    }
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         vbm_gm_img = vbm_gm["data"]
         mask = get_mask(masks="identity", target_data=vbm_gm)
 
@@ -223,11 +339,9 @@ def test_mask_callable() -> None:
 
 def test_get_mask_errors() -> None:
     """Test passing wrong parameters to get_mask."""
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         # Test wrong masks definitions (more than one key per dict)
         with pytest.raises(ValueError, match=r"only one key"):
             get_mask(masks={"GM_prob0.2": {}, "Other": {}}, target_data=vbm_gm)
@@ -247,7 +361,8 @@ def test_get_mask_errors() -> None:
             ValueError, match=r"parameters to the intersection"
         ):
             get_mask(
-                masks=["GM_prob0.2", {"threshold": 1}], target_data=vbm_gm
+                masks=["compute_brain_mask", {"threshold": 1}],
+                target_data=vbm_gm,
             )
 
         # Test "inherited" masks errors
@@ -271,19 +386,20 @@ def test_get_mask_errors() -> None:
                 masks="inherit", target_data=vbm_gm, extra_input=extra_input
             )
 
+        # Block fetch_icbm152_brain_gm_mask space transformation
+        with pytest.raises(RuntimeError, match="prohibited"):
+            get_mask(
+                masks="fetch_icbm152_brain_gm_mask",
+                target_data=vbm_gm,
+                extra_input=extra_input,
+            )
+
 
 @pytest.mark.parametrize(
     "mask_name,function,params,resample",
     [
-        ("compute_brain_mask", compute_brain_mask, {"threshold": 0.2}, False),
         ("compute_background_mask", compute_background_mask, None, False),
         ("compute_epi_mask", compute_epi_mask, None, False),
-        (
-            "fetch_icbm152_brain_gm_mask",
-            fetch_icbm152_brain_gm_mask,
-            None,
-            True,
-        ),
     ],
 )
 def test_nilearn_compute_masks(
@@ -304,12 +420,11 @@ def test_nilearn_compute_masks(
         Parameters to pass to the function.
     resample : bool
         Whether to resample the mask to the target data.
+
     """
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
-        bold = input["BOLD"]
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        bold = element_data["BOLD"]
         bold_img = bold["data"]
 
         if params is None:
@@ -338,25 +453,30 @@ def test_nilearn_compute_masks(
 
 def test_get_mask_inherit() -> None:
     """Test using the inherit mask functionality."""
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Compute brain mask using nilearn
-        gm_mask = compute_brain_mask(input["BOLD"]["data"], threshold=0.2)
+        gm_mask = compute_brain_mask(element_data["BOLD"], threshold=0.2)
 
         # Get mask using the compute_brain_mask function
         mask1 = get_mask(
             masks={"compute_brain_mask": {"threshold": 0.2}},
-            target_data=input["BOLD"],
+            target_data=element_data["BOLD"],
         )
 
         # Now get the mask using the inherit functionality, passing the
         # computed mask as extra data
-        extra_input = {"BOLD_MASK": {"data": gm_mask}}
-        input["BOLD"]["mask_item"] = "BOLD_MASK"
+        extra_input = {
+            "BOLD_MASK": {
+                "data": gm_mask,
+                "space": element_data["BOLD"]["space"],
+            }
+        }
+        element_data["BOLD"]["mask_item"] = "BOLD_MASK"
         mask2 = get_mask(
-            masks="inherit", target_data=input["BOLD"], extra_input=extra_input
+            masks="inherit",
+            target_data=element_data["BOLD"],
+            extra_input=extra_input,
         )
 
         # Both masks should be equal
@@ -366,19 +486,8 @@ def test_get_mask_inherit() -> None:
 @pytest.mark.parametrize(
     "masks,params",
     [
-        (["GM_prob0.2", "compute_brain_mask"], {}),
-        (
-            ["GM_prob0.2", "compute_brain_mask"],
-            {"threshold": 0.2},
-        ),
-        (
-            [
-                "GM_prob0.2",
-                "compute_brain_mask",
-                "fetch_icbm152_brain_gm_mask",
-            ],
-            {"threshold": 1, "connected": True},
-        ),
+        (["compute_brain_mask", "compute_background_mask"], {}),
+        (["compute_brain_mask", "compute_epi_mask"], {}),
     ],
 )
 def test_get_mask_multiple(
@@ -392,11 +501,10 @@ def test_get_mask_multiple(
         Masks to get, junifer style.
     params : dict
         Parameters to pass to the intersect_masks function.
+
     """
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
         if not isinstance(masks, list):
             junifer_masks = [masks]
         else:
@@ -405,13 +513,15 @@ def test_get_mask_multiple(
             # Convert params to junifer style (one dict per param)
             junifer_params = [{k: params[k]} for k in params.keys()]
             junifer_masks.extend(junifer_params)
-        target_img = input["BOLD"]["data"]
+        target_img = element_data["BOLD"]["data"]
         resolution = np.min(target_img.header.get_zooms()[:3])
 
-        computed = get_mask(masks=junifer_masks, target_data=input["BOLD"])
+        computed = get_mask(
+            masks=junifer_masks, target_data=element_data["BOLD"]
+        )
 
         masks_names = [
-            list(x.keys())[0] if isinstance(x, dict) else x for x in masks
+            next(iter(x.keys())) if isinstance(x, dict) else x for x in masks
         ]
 
         mask_funcs = [
@@ -431,7 +541,13 @@ def test_get_mask_multiple(
         ]
 
         for t_func in mask_funcs:
-            mask_imgs.append(_available_masks[t_func]["func"](target_img))
+            # Bypass for custom mask
+            if t_func == "compute_brain_mask":
+                mask_imgs.append(
+                    _available_masks[t_func]["func"](element_data["BOLD"])
+                )
+            else:
+                mask_imgs.append(_available_masks[t_func]["func"](target_img))
 
         mask_imgs = [
             resample_to_img(