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

junifer/markers/reho/reho_base.py

@@ -4,11 +4,23 @@
 # License: AGPL
 
 
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 
 from ...utils import logger, raise_error
 from ..base import BaseMarker
-from .reho_estimator import ReHoEstimator
+from ._afni_reho import AFNIReHo
+from ._junifer_reho import JuniferReHo
 
 
 if TYPE_CHECKING:
@@ -20,32 +32,47 @@ class ReHoBase(BaseMarker):
 
     Parameters
     ----------
-    use_afni : bool, optional
-        Whether to use AFNI for computing. If None, will use AFNI only
-        if available (default None).
+    using : {"junifer", "afni"}
+        Implementation to use for computing ReHo:
+
+        * "junifer" : Use ``junifer``'s own ReHo implementation
+        * "afni" : Use AFNI's ``3dReHo``
+
     name : str, optional
         The name of the marker. If None, it will use the class name
         (default None).
 
+    Raises
+    ------
+    ValueError
+        If ``using`` is invalid.
+
     """
 
-    _EXT_DEPENDENCIES: ClassVar[
-        List[Dict[str, Union[str, bool, List[str]]]]
-    ] = [
+    _CONDITIONAL_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, Type]]]] = [
         {
-            "name": "afni",
-            "optional": True,
-            "commands": ["3dReHo", "3dAFNItoNIFTI"],
+            "using": "afni",
+            "depends_on": AFNIReHo,
+        },
+        {
+            "using": "junifer",
+            "depends_on": JuniferReHo,
         },
     ]
 
     def __init__(
         self,
-        use_afni: Optional[bool] = None,
+        using: str,
         name: Optional[str] = None,
     ) -> None:
+        # Validate `using` parameter
+        valid_using = [dep["using"] for dep in self._CONDITIONAL_DEPENDENCIES]
+        if using not in valid_using:
+            raise_error(
+                f"Invalid value for `using`, should be one of: {valid_using}"
+            )
+        self.using = using
         super().__init__(on="BOLD", name=name)
-        self.use_afni = use_afni
 
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
@@ -74,12 +101,12 @@ class ReHoBase(BaseMarker):
         """
         return "vector"
 
-    def compute_reho_map(
+    def _compute(
         self,
-        input: Dict[str, Any],
+        input_data: Dict[str, Any],
         **reho_params: Any,
-    ) -> "Nifti1Image":
-        """Compute.
+    ) -> Tuple["Nifti1Image", Path]:
+        """Compute voxel-wise ReHo.
 
         Calculates Kendall's W per voxel using neighborhood voxels.
         Instead of the time series values themselves, Kendall's W uses the
@@ -90,7 +117,7 @@ class ReHoBase(BaseMarker):
 
         Parameters
         ----------
-        input : dict
+        input_data : dict
             The BOLD data as dictionary.
         **reho_params : dict
             Extra keyword arguments for ReHo.
@@ -98,6 +125,10 @@ class ReHoBase(BaseMarker):
         Returns
         -------
         Niimg-like object
+            The ReHo map as NIfTI.
+        pathlib.Path
+            The path to the ReHo map as NIfTI or the input data path if the
+            input data space is "native".
 
         References
         ----------
@@ -108,21 +139,25 @@ class ReHoBase(BaseMarker):
                https://doi.org/10.1177/1073858415595004
 
         """
-        if self.use_afni is None:
-            raise_error(
-                "Parameter `use_afni` must be set to True or False in order "
-                "to compute this marker. It is currently set to None (default "
-                "behaviour). This is intended to be for auto-detection. In "
-                "order for that to happen, please call the `validate` method "
-                "before calling the `compute` method."
-            )
-        logger.info("Calculating ReHO map.")
-        # Initialize reho estimator
-        reho_estimator = ReHoEstimator()
-        # Fit-transform reho estimator
-        reho_map = reho_estimator.fit_transform(
-            use_afni=self.use_afni,
-            input_data=input,
+        logger.debug("Calculating voxel-wise ReHo")
+
+        # Conditional estimator
+        if self.using == "afni":
+            estimator = AFNIReHo()
+        elif self.using == "junifer":
+            estimator = JuniferReHo()
+        # Compute reho
+        reho_map, reho_map_path = estimator.compute(  # type: ignore
+            data=input_data["data"],
             **reho_params,
         )
-        return reho_map
+
+        # If the input data space is native already, the original path should
+        # be propagated down as it might be required for transforming
+        # parcellation / coordinates to native space, else the reho map
+        # path should be passed for use later if required.
+        # TODO(synchon): will be taken care in #292
+        if input_data["space"] == "native":
+            return reho_map, input_data["path"]
+
+        return reho_map, reho_map_path

junifer/markers/reho/reho_parcels.py

@@ -20,15 +20,18 @@ class ReHoParcels(ReHoBase):
 
     Parameters
     ----------
-    parcellation : str
-        The name of the parcellation. Check valid options by calling
+    parcellation : str or list of str
+        The name(s) of the parcellation(s). Check valid options by calling
         :func:`.list_parcellations`.
-    use_afni : bool, optional
-        Whether to use AFNI for computing. If None, will use AFNI only
-        if available (default None).
+    using : {"junifer", "afni"}
+        Implementation to use for computing ReHo:
+
+        * "junifer" : Use ``junifer``'s own ReHo implementation
+        * "afni" : Use AFNI's ``3dReHo``
+
     reho_params : dict, optional
         Extra parameters for computing ReHo map as a dictionary (default None).
-        If ``use_afni = True``, then the valid keys are:
+        If ``using="afni"``, then the valid keys are:
 
         * ``nneigh`` : {7, 19, 27}, optional (default 27)
             Number of voxels in the neighbourhood, inclusive. Can be:
@@ -58,7 +61,7 @@ class ReHoParcels(ReHoBase):
             The number of voxels for +/- z-axis of cuboidal volumes
             (default None).
 
-        else if ``use_afni = False``, then the valid keys are:
+        else if ``using="junifer"``, then the valid keys are:
 
         * ``nneigh`` : {7, 19, 27, 125}, optional (default 27)
             Number of voxels in the neighbourhood, inclusive. Can be:
@@ -86,20 +89,21 @@ class ReHoParcels(ReHoBase):
 
     def __init__(
         self,
-        parcellation: str,
-        use_afni: Optional[bool] = None,
+        parcellation: Union[str, List[str]],
+        using: str,
         reho_params: Optional[Dict] = None,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
+        # Superclass init first to validate `using` parameter
+        super().__init__(using=using, name=name)
         self.parcellation = parcellation
         self.reho_params = reho_params
         self.agg_method = agg_method
         self.agg_method_params = agg_method_params
         self.masks = masks
-        super().__init__(use_afni=use_afni, name=name)
 
     def compute(
         self,
@@ -125,12 +129,19 @@ class ReHoParcels(ReHoBase):
             * ``col_names`` : the column labels for the parcels as a list
 
         """
-        logger.info("Calculating ReHo for parcels.")
-        # Calculate reho map
+        logger.info("Calculating ReHo for parcels")
+
+        # Compute voxelwise reho
+        # If the input data space is "native", then reho_file_path points to
+        # the input data path as it might be required for parcellation
+        # transformation to native space.
         if self.reho_params is not None:
-            reho_map = self.compute_reho_map(input=input, **self.reho_params)
+            reho_map, reho_file_path = self._compute(
+                input_data=input, **self.reho_params
+            )
         else:
-            reho_map = self.compute_reho_map(input=input)
+            reho_map, reho_file_path = self._compute(input_data=input)
+
         # Initialize parcel aggregation
         parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
@@ -142,8 +153,7 @@ class ReHoParcels(ReHoBase):
         # Perform aggregation on reho map
         parcel_aggregation_input = dict(input.items())
         parcel_aggregation_input["data"] = reho_map
-        parcel_aggregation_input["path"] = None
-
+        parcel_aggregation_input["path"] = reho_file_path
         output = parcel_aggregation.compute(
             input=parcel_aggregation_input,
             extra_input=extra_input,

junifer/markers/reho/reho_spheres.py

@@ -23,6 +23,12 @@ class ReHoSpheres(ReHoBase):
     coords : str
         The name of the coordinates list to use. See
         :func:`.list_coordinates` for options.
+    using : {"junifer", "afni"}
+        Implementation to use for computing ReHo:
+
+        * "junifer" : Use ``junifer``'s own ReHo implementation
+        * "afni" : Use AFNI's ``3dReHo``
+
     radius : float, optional
         The radius of the sphere in millimeters. If None, the signal will be
         extracted from a single voxel. See
@@ -36,7 +42,7 @@ class ReHoSpheres(ReHoBase):
         if available (default None).
     reho_params : dict, optional
         Extra parameters for computing ReHo map as a dictionary (default None).
-        If ``use_afni = True``, then the valid keys are:
+        If ``using="afni"``, then the valid keys are:
 
         * ``nneigh`` : {7, 19, 27}, optional (default 27)
             Number of voxels in the neighbourhood, inclusive. Can be:
@@ -66,7 +72,7 @@ class ReHoSpheres(ReHoBase):
             The number of voxels for +/- z-axis of cuboidal volumes
             (default None).
 
-        else if ``use_afni = False``, then the valid keys are:
+        else if ``using="junifer"``, then the valid keys are:
 
         * ``nneigh`` : {7, 19, 27, 125}, optional (default 27)
             Number of voxels in the neighbourhood, inclusive. Can be:
@@ -95,15 +101,17 @@ class ReHoSpheres(ReHoBase):
     def __init__(
         self,
         coords: str,
+        using: str,
         radius: Optional[float] = None,
         allow_overlap: bool = False,
-        use_afni: Optional[bool] = None,
         reho_params: Optional[Dict] = None,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
+        # Superclass init first to validate `using` parameter
+        super().__init__(using=using, name=name)
         self.coords = coords
         self.radius = radius
         self.allow_overlap = allow_overlap
@@ -111,7 +119,6 @@ class ReHoSpheres(ReHoBase):
         self.agg_method = agg_method
         self.agg_method_params = agg_method_params
         self.masks = masks
-        super().__init__(use_afni=use_afni, name=name)
 
     def compute(
         self,
@@ -137,12 +144,19 @@ class ReHoSpheres(ReHoBase):
             * ``col_names`` : the column labels for the spheres as a list
 
         """
-        logger.info("Calculating ReHo for spheres.")
-        # Calculate reho map
+        logger.info("Calculating ReHo for spheres")
+
+        # Compute voxelwise reho
+        # If the input data space is "native", then reho_file_path points to
+        # the input data path as it might be required for coordinates
+        # transformation to native space.
         if self.reho_params is not None:
-            reho_map = self.compute_reho_map(input=input, **self.reho_params)
+            reho_map, reho_file_path = self._compute(
+                input_data=input, **self.reho_params
+            )
         else:
-            reho_map = self.compute_reho_map(input=input)
+            reho_map, reho_file_path = self._compute(input_data=input)
+
         # Initialize sphere aggregation
         sphere_aggregation = SphereAggregation(
             coords=self.coords,
@@ -156,7 +170,7 @@ class ReHoSpheres(ReHoBase):
         # Perform aggregation on reho map
         sphere_aggregation_input = dict(input.items())
         sphere_aggregation_input["data"] = reho_map
-        sphere_aggregation_input["path"] = None
+        sphere_aggregation_input["path"] = reho_file_path
         output = sphere_aggregation.compute(
             input=sphere_aggregation_input, extra_input=extra_input
         )

junifer/markers/reho/tests/test_reho_parcels.py

@@ -1,94 +1,88 @@
-"""Provide tests for ReHo on parcels."""
+"""Provide tests for ReHoParcels."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import logging
 from pathlib import Path
 
 import pytest
-from nilearn import image as nimg
-from scipy.stats import pearsonr
-
-from junifer.markers.reho.reho_parcels import ReHoParcels
-from junifer.pipeline.utils import _check_afni
-from junifer.storage.sqlite import SQLiteFeatureStorage
-from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
-
+import scipy as sp
+
+from junifer.datareader import DefaultDataReader
+from junifer.markers import ReHoParcels
+from junifer.pipeline import WorkDirManager
+from junifer.pipeline.utils import _check_afni, _check_ants
+from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import (
+    PartlyCloudyTestingDataGrabber,
+    SPMAuditoryTestingDataGrabber,
+)
 
-PARCELLATION = "Schaefer100x7"
 
+def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
+    """Test ReHoParcels.
 
-def test_reho_parcels_computation() -> None:
-    """Test ReHoParcels fit-transform."""
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
-        # Initialize marker
-        reho_parcels_marker = ReHoParcels(parcellation=PARCELLATION)
-        # Fit transform marker on data
-        reho_parcels_output = reho_parcels_marker.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
-        # Get BOLD output
-        reho_parcels_output_bold = reho_parcels_output["BOLD"]
-        # Assert BOLD output keys
-        assert "data" in reho_parcels_output_bold
-        assert "col_names" in reho_parcels_output_bold
+    Parameters
+    ----------
+    caplog : pytest.LogCaptureFixture
+        The pytest.LogCaptureFixture object.
+    tmp_path : pathlib.Path
+        The path to the test directory.
 
-        reho_parcels_output_bold_data = reho_parcels_output_bold["data"]
-        # Assert BOLD output data dimension
-        assert reho_parcels_output_bold_data.ndim == 2
-        # Assert BOLD output data is normalized
-        assert (reho_parcels_output_bold_data > 0).all() and (
-            reho_parcels_output_bold_data < 1
-        ).all()
+    """
+    with caplog.at_level(logging.DEBUG):
+        with PartlyCloudyTestingDataGrabber() as dg:
+            element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+            # Update workdir to current test's tmp_path
+            WorkDirManager().workdir = tmp_path
+
+            # Initialize marker
+            marker = ReHoParcels(
+                parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+                using="junifer",
+            )
+            # Fit transform marker on data
+            output = marker.fit_transform(element_data)
+
+            assert "Creating cache" in caplog.text
+
+            # Get BOLD output
+            assert "BOLD" in output
+            output_bold = output["BOLD"]
+            # Assert BOLD output keys
+            assert "data" in output_bold
+            assert "col_names" in output_bold
+
+            output_bold_data = output_bold["data"]
+            # Assert BOLD output data dimension
+            assert output_bold_data.ndim == 2
+            # Assert BOLD output data is normalized
+            assert (output_bold_data > 0).all() and (
+                output_bold_data < 1
+            ).all()
+
+            # Reset log capture
+            caplog.clear()
+            # Initialize storage
+            storage = SQLiteFeatureStorage(tmp_path / "reho_parcels.sqlite")
+            # Fit transform marker on data with storage
+            marker.fit_transform(
+                input=element_data,
+                storage=storage,
+            )
+            # Cache working correctly
+            assert "Creating cache" not in caplog.text
 
 
 @pytest.mark.skipif(
-    _check_afni() is False, reason="requires afni to be in PATH"
+    _check_ants() is False, reason="requires ANTs to be in PATH"
 )
-def test_reho_parcels_computation_comparison() -> None:
-    """Test ReHoParcels fit-transform implementation comparison.."""
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
-
-        # Initialize marker with use_afni=False
-        reho_parcels_marker_python = ReHoParcels(
-            parcellation=PARCELLATION, use_afni=False
-        )
-        # Fit transform marker on data
-        reho_parcels_output_python = reho_parcels_marker_python.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
-        # Get BOLD output
-        reho_parcels_output_bold_python = reho_parcels_output_python["BOLD"]
-
-        # Initialize marker with use_afni=True
-        reho_parcels_marker_afni = ReHoParcels(
-            parcellation=PARCELLATION, use_afni=True
-        )
-        # Fit transform marker on data
-        reho_parcels_output_afni = reho_parcels_marker_afni.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
-        # Get BOLD output
-        reho_parcels_output_bold_afni = reho_parcels_output_afni["BOLD"]
-
-        # Check for Pearson correlation coefficient
-        r, _ = pearsonr(
-            reho_parcels_output_bold_python["data"].flatten(),
-            reho_parcels_output_bold_afni["data"].flatten(),
-        )
-        assert r >= 0.3  # this is very bad, but they differ...
-
-
-def test_reho_parcels_storage(tmp_path: Path) -> None:
-    """Test ReHoParcels storage.
+@pytest.mark.skipif(
+    _check_afni() is False, reason="requires AFNI to be in PATH"
+)
+def test_ReHoParcels_comparison(tmp_path: Path) -> None:
+    """Test ReHoParcels implementation comparison.
 
     Parameters
     ----------
@@ -97,22 +91,29 @@ def test_reho_parcels_storage(tmp_path: Path) -> None:
 
     """
     with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        # Update workdir to current test's tmp_path
+        WorkDirManager().workdir = tmp_path
+
         # Initialize marker
-        reho_parcels_marker = ReHoParcels(parcellation=PARCELLATION)
-        # Initialize storage
-        reho_parcels_storage = SQLiteFeatureStorage(
-            tmp_path / "reho_parcels.sqlite"
+        junifer_marker = ReHoParcels(
+            parcellation="Schaefer100x7", using="junifer"
         )
-        # Generate meta
-        meta = {
-            "element": {"subject": "sub001"}
-        }  # only requires element key for storing
-        # Fit transform marker on data with storage
-        reho_parcels_marker.fit_transform(
-            input={"BOLD": {"path": "/tmp", "data": fmri_img, "meta": meta}},
-            storage=reho_parcels_storage,
+        # Fit transform marker on data
+        junifer_output = junifer_marker.fit_transform(element_data)
+        # Get BOLD output
+        junifer_output_bold = junifer_output["BOLD"]
+
+        # Initialize marker
+        afni_marker = ReHoParcels(parcellation="Schaefer100x7", using="afni")
+        # Fit transform marker on data
+        afni_output = afni_marker.fit_transform(element_data)
+        # Get BOLD output
+        afni_output_bold = afni_output["BOLD"]
+
+        # Check for Pearson correlation coefficient
+        r, _ = sp.stats.pearsonr(
+            junifer_output_bold["data"].flatten(),
+            afni_output_bold["data"].flatten(),
         )
+        assert r >= 0.2  # this is very bad, but they differ...