junifer 0.0.7.dev332__py3-none-any.whl → 0.0.8__py3-none-any.whl

junifer/markers/tests/test_lost_regions.py

@@ -0,0 +1,279 @@
+"""Provide tests for markers on regions lost in resampling."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from collections.abc import Iterator
+from importlib.util import find_spec
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+from junifer import markers
+from junifer.data import deregister_data, register_data
+from junifer.datareader import DefaultDataReader
+from junifer.pipeline import WorkDirManager
+
+
+COMPLEXITY_MARKERS = (
+    "HurstExponent",
+    "RangeEntropy",
+    "RangeEntropyAUC",
+    "MultiscaleEntropyAUC",
+    "PermEntropy",
+    "WeightedPermEntropy",
+    "SampleEntropy",
+)
+
+skip_no_neurokit2 = pytest.mark.skipif(
+    find_spec("neurokit2") is None, reason="requires neurokit2"
+)
+
+
+@pytest.fixture(scope="module")
+def element(tmp_path_factory: pytest.TempPathFactory) -> Iterator[dict]:
+    """Provide BOLD data where regions of the parcellations are lost.
+
+    The parcellations are on a 1mm grid and the BOLD data on a 3mm grid,
+    which does not sample their single-voxel regions:
+
+    * ``LostRegion`` (and ``LostRegion2``, the same): regions ``a``, ``b``,
+      ``lost``, ``c`` and ``d``.
+    * ``OneRegionLeft``: regions ``kept``, ``lost`` and ``lost_too``.
+
+    Parameters
+    ----------
+    tmp_path_factory : pytest.TempPathFactory
+        The pytest factory for temporary directories.
+
+    Yields
+    ------
+    dict
+        The element data.
+
+    """
+    tmp_path = tmp_path_factory.mktemp("lost_regions")
+    # Voxels 0, 3, 6, ... are sampled by the 3mm grid, 7 and 13 are not
+    lost_region = np.zeros((24, 24, 24), dtype=np.int16)
+    lost_region[0:12, 0:12] = 1
+    lost_region[12:24, 0:12] = 2
+    lost_region[7, 13, 7] = 3
+    lost_region[0:12, 15:24] = 4
+    lost_region[12:24, 15:24] = 5
+    one_region_left = np.zeros((24, 24, 24), dtype=np.int16)
+    one_region_left[0:12, 0:12] = 1
+    one_region_left[7, 13, 7] = 2
+    one_region_left[13, 7, 7] = 3
+    for name, data, labels in (
+        ("LostRegion", lost_region, ["a", "b", "lost", "c", "d"]),
+        ("LostRegion2", lost_region, ["a", "b", "lost", "c", "d"]),
+        ("OneRegionLeft", one_region_left, ["kept", "lost", "lost_too"]),
+    ):
+        path = tmp_path / f"{name}.nii.gz"
+        nib.save(nib.Nifti1Image(data, np.eye(4)), path)
+        register_data(
+            kind="parcellation",
+            name=name,
+            parcellation_path=path,
+            parcels_labels=labels,
+            space="MNI152NLin6Asym",
+        )
+    # Random walks, so all the measures are defined
+    rng = np.random.default_rng(0)
+    bold = rng.normal(size=(8, 8, 8, 120)).cumsum(axis=-1) + 1000
+    bold_img = nib.Nifti1Image(
+        bold.astype(np.float32), np.diag([3.0, 3.0, 3.0, 1.0])
+    )
+    bold_img.header.set_xyzt_units("mm", "sec")
+    bold_path = tmp_path / "bold.nii.gz"
+    nib.save(bold_img, bold_path)
+    yield DefaultDataReader().fit_transform(
+        {"BOLD": {"path": bold_path, "space": "MNI152NLin6Asym"}}
+    )
+    for name in ("LostRegion", "LostRegion2", "OneRegionLeft"):
+        deregister_data(kind="parcellation", name=name)
+
+
+def _case(name: str, params: dict, feature: str, nan: list) -> object:
+    """Get a test case.
+
+    Parameters
+    ----------
+    name : str
+        The name of the marker class.
+    params : dict
+        The parameters of the marker.
+    feature : str
+        The name of the feature to check.
+    nan : list
+        The values that are NaN.
+
+    Returns
+    -------
+    object
+        The test case, named after the parcellation, marker and feature.
+        Complexity markers are skipped if neurokit2 is not installed.
+
+    """
+    parcellation = params.get("parcellation", params.get("parcellation_one"))
+    return pytest.param(
+        name,
+        params,
+        feature,
+        nan,
+        marks=skip_no_neurokit2 if name in COMPLEXITY_MARKERS else (),
+        id=f"{parcellation}-{name}-{feature}",
+    )
+
+
+# Whether the values are NaN for LostRegion, whose 3rd region is lost
+REGIONS = [False, False, True, False, False]
+# For connectivity, a region pair is NaN if one of the regions is lost
+PAIRS = [[r or c for c in REGIONS] for r in REGIONS]
+# For edge-centric FC, the edges are the region pairs (lower triangle)
+EDGES = [r or c for i, r in enumerate(REGIONS) for c in REGIONS[:i]]
+EDGE_PAIRS = [[r or c for c in EDGES] for r in EDGES]
+
+
+@pytest.mark.parametrize(
+    "name, params, feature, nan",
+    [
+        _case(
+            "ParcelAggregation",
+            {"parcellation": "LostRegion", "method": "mean", "on": "BOLD"},
+            "aggregation",
+            [REGIONS] * 120,
+        ),
+        _case(
+            "FunctionalConnectivityParcels",
+            {"parcellation": "LostRegion"},
+            "functional_connectivity",
+            PAIRS,
+        ),
+        _case(
+            "EdgeCentricFCParcels",
+            {"parcellation": "LostRegion"},
+            "functional_connectivity",
+            EDGE_PAIRS,
+        ),
+        _case(
+            "CrossParcellationFC",
+            {
+                "parcellation_one": "LostRegion",
+                "parcellation_two": "LostRegion2",
+            },
+            "functional_connectivity",
+            PAIRS,
+        ),
+        _case(
+            "ReHoParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "reho",
+            [REGIONS],
+        ),
+        _case(
+            "ALFFParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "alff",
+            [REGIONS],
+        ),
+        _case(
+            "ALFFParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "falff",
+            [REGIONS],
+        ),
+        _case(
+            "TemporalSNRParcels",
+            {"parcellation": "LostRegion"},
+            "tsnr",
+            [REGIONS],
+        ),
+        # Computed with the edges with data
+        _case(
+            "RSSETSMarker",
+            {"parcellation": "LostRegion"},
+            "rss_ets",
+            [[False]] * 120,
+        ),
+        *[
+            _case(
+                name, {"parcellation": "LostRegion"}, "complexity", [REGIONS]
+            )
+            for name in COMPLEXITY_MARKERS
+        ],
+        # Only the kept region with itself
+        _case(
+            "FunctionalConnectivityParcels",
+            {"parcellation": "OneRegionLeft"},
+            "functional_connectivity",
+            [[False, True, True], [True, True, True], [True, True, True]],
+        ),
+        # All the edges have a lost region
+        _case(
+            "EdgeCentricFCParcels",
+            {"parcellation": "OneRegionLeft"},
+            "functional_connectivity",
+            [[True] * 3] * 3,
+        ),
+        # No edges with data
+        _case(
+            "RSSETSMarker",
+            {"parcellation": "OneRegionLeft"},
+            "rss_ets",
+            [[True]] * 120,
+        ),
+        *[
+            _case(
+                name,
+                {"parcellation": "OneRegionLeft"},
+                "complexity",
+                [[False, True, True]],
+            )
+            for name in COMPLEXITY_MARKERS
+        ],
+    ],
+)
+def test_lost_regions(
+    tmp_path: Path,
+    element: dict,
+    name: str,
+    params: dict,
+    feature: str,
+    nan: list,
+) -> None:
+    """Test markers on regions lost in resampling.
+
+    The lost regions have no data (NaN), and the other regions are not
+    affected.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    element : dict
+        The element data.
+    name : str
+        The parametrized name of the marker class.
+    params : dict
+        The parametrized parameters of the marker.
+    feature : str
+        The parametrized name of the feature to check.
+    nan : list
+        The parametrized values that are NaN.
+
+    """
+    if name in COMPLEXITY_MARKERS:
+        from junifer.markers import complexity
+
+        marker = getattr(complexity, name)(**params)
+    else:
+        marker = getattr(markers, name)(**params)
+    WorkDirManager().workdir = tmp_path
+    with pytest.warns(RuntimeWarning, match=r"region\(s\) .* have no voxels"):
+        # Copy the data, as some markers change their input
+        out = marker.fit_transform({"BOLD": dict(element["BOLD"])})
+    data = np.asarray(out["BOLD"][feature]["data"], dtype=float)
+    assert np.array_equal(np.isnan(data), nan)

junifer/markers/tests/test_maps_aggregation.py

@@ -12,63 +12,67 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal
 
 from junifer.data import MapsRegistry, MaskRegistry
 from junifer.data.masks import compute_brain_mask
-from junifer.datagrabber import PatternDataladDataGrabber
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers import MapsAggregation
-from junifer.storage import HDF5FeatureStorage
+from junifer.storage import HDF5FeatureStorage, StorageType
+from junifer.testing.datagrabbers import ADHDTestingDataGrabber
+
+
+pytestmark = pytest.mark.external
 
 
 @pytest.mark.parametrize(
     "input_type, storage_type",
     [
         (
-            "T1w",
-            "vector",
+            DataType.T1w,
+            StorageType.Vector,
         ),
         (
-            "T2w",
-            "vector",
+            DataType.T2w,
+            StorageType.Vector,
         ),
         (
-            "BOLD",
-            "timeseries",
+            DataType.BOLD,
+            StorageType.Timeseries,
         ),
         (
-            "VBM_GM",
-            "vector",
+            DataType.VBM_GM,
+            StorageType.Vector,
         ),
         (
-            "VBM_WM",
-            "vector",
+            DataType.VBM_WM,
+            StorageType.Vector,
         ),
         (
-            "VBM_CSF",
-            "vector",
+            DataType.VBM_CSF,
+            StorageType.Vector,
         ),
         (
-            "fALFF",
-            "vector",
+            DataType.FALFF,
+            StorageType.Vector,
         ),
         (
-            "GCOR",
-            "vector",
+            DataType.GCOR,
+            StorageType.Vector,
         ),
         (
-            "LCOR",
-            "vector",
+            DataType.LCOR,
+            StorageType.Vector,
         ),
     ],
 )
 def test_MapsAggregation_input_output(
-    input_type: str, storage_type: str
+    input_type: DataType, storage_type: StorageType
 ) -> None:
     """Test MapsAggregation input and output types.
 
     Parameters
     ----------
-    input_type : str
+    input_type : DataType
         The parametrized input type.
-    storage_type : str
+    storage_type : StorageType
         The parametrized storage type.
 
     """
@@ -77,19 +81,10 @@ def test_MapsAggregation_input_output(
     ).storage_type(input_type=input_type, output_feature="aggregation")
 
 
-def test_MapsAggregation_3D(
-    maps_datagrabber: PatternDataladDataGrabber,
-) -> None:
-    """Test MapsAggregation on 3D data.
-
-    Parameters
-    ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
-
-    """
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+def test_MapsAggregation_3D() -> None:
+    """Test MapsAggregation on 3D data."""
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         # Deepcopy data for later use
         input_data = deepcopy(element_data)
@@ -122,19 +117,10 @@ def test_MapsAggregation_3D(
         assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
 
 
-def test_MapsAggregation_4D(
-    maps_datagrabber: PatternDataladDataGrabber,
-) -> None:
-    """Test MapsAggregation on 4D data.
-
-    Parameters
-    ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
-
-    """
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+def test_MapsAggregation_4D() -> None:
+    """Test MapsAggregation on 4D data."""
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         # Deepcopy data for later use
         input_data = deepcopy(element_data)
@@ -162,29 +148,25 @@ def test_MapsAggregation_4D(
         assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
 
 
-def test_MapsAggregation_storage(
-    maps_datagrabber: PatternDataladDataGrabber, tmp_path: Path
-) -> None:
+def test_MapsAggregation_storage(tmp_path: Path) -> None:
     """Test MapsAggregation storage.
 
     Parameters
     ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
     # Store 3D
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         storage = HDF5FeatureStorage(
             uri=tmp_path / "test_maps_storage_3D.hdf5"
         )
         marker = MapsAggregation(
             maps="Smith_rsn_10",
-            on="BOLD",
+            on=DataType.BOLD,
         )
         element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
             ..., 0:1
@@ -197,15 +179,15 @@ def test_MapsAggregation_storage(
         )
 
     # Store 4D
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         storage = HDF5FeatureStorage(
-            uri=tmp_path / "test_maps_storage_4D.sqlite"
+            uri=tmp_path / "test_maps_storage_4D.hdf5"
         )
         marker = MapsAggregation(
             maps="Smith_rsn_10",
-            on="BOLD",
+            on=DataType.BOLD,
         )
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
@@ -215,19 +197,10 @@ def test_MapsAggregation_storage(
         )
 
 
-def test_MapsAggregation_3D_mask(
-    maps_datagrabber: PatternDataladDataGrabber,
-) -> None:
-    """Test MapsAggregation on 3D data with mask.
-
-    Parameters
-    ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
-
-    """
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+def test_MapsAggregation_3D_mask() -> None:
+    """Test MapsAggregation on 3D data with mask."""
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         # Deepcopy data for later use
         input_data = deepcopy(element_data)
@@ -238,8 +211,8 @@ def test_MapsAggregation_3D_mask(
         ]
         marker = MapsAggregation(
             maps="Smith_rsn_10",
-            on="BOLD",
-            masks="compute_brain_mask",
+            on=DataType.BOLD,
+            masks=["compute_brain_mask"],
         )
         maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
             "aggregation"
@@ -268,19 +241,10 @@ def test_MapsAggregation_3D_mask(
         assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
 
 
-def test_MapsAggregation_3D_mask_computed(
-    maps_datagrabber: PatternDataladDataGrabber,
-) -> None:
-    """Test MapsAggregation on 3D data with computed masks.
-
-    Parameters
-    ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
-
-    """
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+def test_MapsAggregation_3D_mask_computed() -> None:
+    """Test MapsAggregation on 3D data with computed masks."""
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
 
         # Compare with nilearn
@@ -306,8 +270,8 @@ def test_MapsAggregation_3D_mask_computed(
         # Use the MapsAggregation object
         marker = MapsAggregation(
             maps="Smith_rsn_10",
-            masks={"compute_brain_mask": {"threshold": 0.2}},
-            on="BOLD",
+            masks=[{"compute_brain_mask": {"threshold": 0.2}}],
+            on=DataType.BOLD,
         )
         maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
             "aggregation"
@@ -324,25 +288,16 @@ def test_MapsAggregation_3D_mask_computed(
             )
 
 
-def test_MapsAggregation_4D_agg_time(
-    maps_datagrabber: PatternDataladDataGrabber,
-):
-    """Test MapsAggregation on 4D data, aggregating time.
-
-    Parameters
-    ----------
-    maps_datagrabber : PatternDataladDataGrabber
-        The testing PatternDataladDataGrabber, as fixture.
-
-    """
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+def test_MapsAggregation_4D_agg_time() -> None:
+    """Test MapsAggregation on 4D data, aggregating time."""
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         # Create MapsAggregation object
         marker = MapsAggregation(
             maps="Smith_rsn_10",
             time_method="mean",
-            on="BOLD",
+            on=DataType.BOLD,
         )
         maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
             "aggregation"
@@ -375,7 +330,7 @@ def test_MapsAggregation_4D_agg_time(
             maps="Smith_rsn_10",
             time_method="select",
             time_method_params={"pick": [0]},
-            on="BOLD",
+            on=DataType.BOLD,
         )
         maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
             "aggregation"
@@ -395,7 +350,7 @@ def test_MapsAggregation_errors() -> None:
             maps="Smith_rsn_10",
             time_method="select",
             time_method_params={"pick": [0]},
-            on="VBM_GM",
+            on=[DataType.VBM_GM],
         )
 
     with pytest.raises(
@@ -404,16 +359,14 @@ def test_MapsAggregation_errors() -> None:
         MapsAggregation(
             maps="Smith_rsn_10",
             time_method_params={"pick": [0]},
-            on="VBM_GM",
+            on=[DataType.VBM_GM],
         )
 
 
-def test_MapsAggregation_warning(
-    maps_datagrabber: PatternDataladDataGrabber,
-) -> None:
+def test_MapsAggregation_warning() -> None:
     """Test warning for MapsAggregation."""
-    with maps_datagrabber as dg:
-        element = dg[("sub-01", "sub-001", "rest", "1")]
+    with ADHDTestingDataGrabber() as dg:
+        element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
         with pytest.warns(
             RuntimeWarning, match="No time dimension to aggregate"
@@ -422,7 +375,7 @@ def test_MapsAggregation_warning(
                 maps="Smith_rsn_10",
                 time_method="select",
                 time_method_params={"pick": [0]},
-                on="BOLD",
+                on=DataType.BOLD,
             )
             element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
                 ..., 0:1

junifer/markers/tests/test_marker_utils.py

@@ -6,10 +6,14 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from pathlib import Path
+
+import nibabel as nib
 import numpy as np
 import pytest
 
-from junifer.markers.utils import _ets
+from junifer.markers.utils import _ets, _save_mask
+from junifer.pipeline import WorkDirManager
 
 
 def test_ets() -> None:
@@ -48,3 +52,38 @@ def test_ets_incorrect_label_list() -> None:
         ValueError, match="List of roi names does not correspond"
     ):
         _ets(bold_ts, roi_labels)
+
+
+def test_save_mask(tmp_path: Path) -> None:
+    """Test saving masks in the element directory, named by their content.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    data = np.zeros((3, 4, 5), dtype=np.int8)
+    data[1, 1:3, 2:4] = 1
+    mask = nib.Nifti1Image(data, np.eye(4))
+    path = _save_mask(mask, prefix="test_mask")
+    # In the element directory, with the voxels in the mask
+    assert path.parent == workdir_mgr.elementdir
+    assert path.name.startswith("test_mask_")
+    assert np.array_equal(np.asarray(nib.load(path).dataobj), data)
+    # The same mask (another image) has the same path, a different one not
+    assert (
+        _save_mask(nib.Nifti1Image(data.copy(), np.eye(4)), prefix="test_mask")
+        == path
+    )
+    other = data.copy()
+    other[0, 0, 0] = 1
+    assert (
+        _save_mask(nib.Nifti1Image(other, np.eye(4)), prefix="test_mask")
+        != path
+    )
+    # Deleted with the element directory
+    workdir_mgr.cleanup_elementdir()
+    assert not path.exists()