junifer 0.0.5__py3-none-any.whl → 0.0.5.dev11__py3-none-any.whl

junifer/markers/complexity/tests/test_weighted_perm_entropy.py

@@ -13,7 +13,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import WeightedPermEntropy  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -24,9 +23,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test WeightedPermEntropy compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -39,19 +35,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test WeightedPermEntropy get_output_type()."""
-    assert "vector" == WeightedPermEntropy(
-        parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="complexity")
+    marker = WeightedPermEntropy(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test WeightedPermEntropy store().
 

junifer/markers/complexity/weighted_perm_entropy.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["WeightedPermEntropy"]
-
-
 @register_marker
 class WeightedPermEntropy(ComplexityBase):
     """Class for weighted permutation entropy of a time series.

junifer/markers/ets_rss.py

@@ -17,9 +17,6 @@ from .parcel_aggregation import ParcelAggregation
 from .utils import _ets
 
 
-__all__ = ["RSSETSMarker"]
-
-
 @register_marker
 class RSSETSMarker(BaseMarker):
     """Class for root sum of squares of edgewise timeseries.
@@ -47,12 +44,6 @@ class RSSETSMarker(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "rss_ets": "timeseries",
-        },
-    }
-
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -67,6 +58,33 @@ class RSSETSMarker(BaseMarker):
         self.masks = masks
         super().__init__(name=name)
 
+    def get_valid_inputs(self) -> List[str]:
+        """Get valid data types for input.
+
+        Returns
+        -------
+        list of str
+            The list of data types that can be used as input for this marker.
+
+        """
+        return ["BOLD"]
+
+    def get_output_type(self, input_type: str) -> str:
+        """Get output type.
+
+        Parameters
+        ----------
+        input_type : str
+            The data type input to the marker.
+
+        Returns
+        -------
+        str
+            The storage type output by the marker.
+
+        """
+        return "timeseries"
+
     def compute(
         self,
         input: Dict[str, Any],
@@ -88,9 +106,8 @@ class RSSETSMarker(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. This will be either returned
-            to the user or stored in the storage by calling the store method
-            with this as a parameter. The dictionary has the following keys:
+            The computed result as dictionary. The dictionary has the following
+            keys:
 
             * ``data`` : the actual computed values as a numpy.ndarray
             * ``col_names`` : the column labels for the computed values as list
@@ -104,22 +121,20 @@ class RSSETSMarker(BaseMarker):
 
         """
         logger.debug("Calculating root sum of squares of edgewise timeseries.")
-        # Perform aggregation
-        aggregation = ParcelAggregation(
+        # Initialize a ParcelAggregation
+        parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-        ).compute(input=input, extra_input=extra_input)
-        # Compute edgewise timeseries
-        edge_ts, _ = _ets(aggregation["aggregation"]["data"])
-        # Compute the RSS of edgewise timeseries
-        rss = np.sum(edge_ts**2, 1) ** 0.5
-
-        return {
-            "rss_ets": {
-                # Make it 2D
-                "data": rss[:, np.newaxis],
-                "col_names": ["root_sum_of_squares_ets"],
-            }
-        }
+        )
+        # Compute the parcel aggregation
+        out = parcel_aggregation.compute(input=input, extra_input=extra_input)
+        edge_ts, _ = _ets(out["data"])
+        # Compute the RSS
+        out["data"] = np.sum(edge_ts**2, 1) ** 0.5
+        # Make it 2D
+        out["data"] = out["data"][:, np.newaxis]
+        # Set correct column label
+        out["col_names"] = ["root_sum_of_squares_ets"]
+        return out

junifer/markers/falff/__init__.py

@@ -5,6 +5,3 @@
 
 from .falff_parcels import ALFFParcels
 from .falff_spheres import ALFFSpheres
-
-
-__all__ = ["ALFFParcels", "ALFFSpheres"]

junifer/markers/falff/_afni_falff.py

@@ -26,9 +26,6 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
 
-__all__ = ["AFNIALFF"]
-
-
 @singleton
 class AFNIALFF:
     """Class for computing ALFF using AFNI.
@@ -124,7 +121,7 @@ class AFNIALFF:
         convert_alff_cmd = [
             "3dAFNItoNIFTI",
             f"-prefix {alff_afni_to_nifti_out_path.resolve()}",
-            f"{alff_falff_out_path_prefix}_ALFF+orig.BRIK",
+            f"{alff_falff_out_path_prefix}_ALFF+tlrc.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_alff_cmd)
@@ -136,7 +133,7 @@ class AFNIALFF:
         convert_falff_cmd = [
             "3dAFNItoNIFTI",
             f"-prefix {falff_afni_to_nifti_out_path.resolve()}",
-            f"{alff_falff_out_path_prefix}_fALFF+orig.BRIK",
+            f"{alff_falff_out_path_prefix}_fALFF+tlrc.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_falff_cmd)

junifer/markers/falff/_junifer_falff.py

@@ -27,9 +27,6 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
 
-__all__ = ["JuniferALFF"]
-
-
 @singleton
 class JuniferALFF:
     """Class for computing ALFF using junifer.

junifer/markers/falff/falff_base.py

@@ -29,14 +29,13 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
 
-__all__ = ["ALFFBase"]
-
-
 class ALFFBase(BaseMarker):
     """Base class for (fractional) Amplitude Low Frequency Fluctuation.
 
     Parameters
     ----------
+    fractional : bool
+        Whether to compute fractional ALFF.
     highpass : positive float
         Highpass cutoff frequency.
     lowpass : positive float
@@ -83,15 +82,9 @@ class ALFFBase(BaseMarker):
         },
     ]
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "alff": "vector",
-            "falff": "vector",
-        },
-    }
-
     def __init__(
         self,
+        fractional: bool,
         highpass: float,
         lowpass: float,
         using: str,
@@ -114,12 +107,45 @@ class ALFFBase(BaseMarker):
             )
         self.using = using
         self.tr = tr
+        self.fractional = fractional
+
+        # Create a name based on the class name if none is provided
+        if name is None:
+            suffix = "_fractional" if fractional else ""
+            name = f"{self.__class__.__name__}{suffix}"
         super().__init__(on="BOLD", name=name)
 
+    def get_valid_inputs(self) -> List[str]:
+        """Get valid data types for input.
+
+        Returns
+        -------
+        list of str
+            The list of data types that can be used as input for this marker.
+
+        """
+        return ["BOLD"]
+
+    def get_output_type(self, input_type: str) -> str:
+        """Get output type.
+
+        Parameters
+        ----------
+        input_type : str
+            The data type input to the marker.
+
+        Returns
+        -------
+        str
+            The storage type output by the marker.
+
+        """
+        return "vector"
+
     def _compute(
         self,
         input_data: Dict[str, Any],
-    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
+    ) -> Tuple["Nifti1Image", Path]:
         """Compute ALFF and fALFF.
 
         Parameters
@@ -132,13 +158,9 @@ class ALFFBase(BaseMarker):
         Returns
         -------
         Niimg-like object
-            The ALFF as NIfTI.
-        Niimg-like object
-            The fALFF as NIfTI.
-        pathlib.Path
-            The path to the ALFF as NIfTI.
+            The ALFF / fALFF as NIfTI.
         pathlib.Path
-            The path to the fALFF as NIfTI.
+            The path to the ALFF / fALFF as NIfTI.
 
         """
         logger.debug("Calculating ALFF and fALFF")
@@ -161,7 +183,11 @@ class ALFFBase(BaseMarker):
         # parcellation / coordinates to native space, else the
         # path should be passed for use later if required.
         # TODO(synchon): will be taken care in #292
-        if input_data["space"] == "native":
-            return alff, falff, input_data["path"], input_data["path"]
+        if input_data["space"] == "native" and self.fractional:
+            return falff, input_data["path"]
+        elif input_data["space"] == "native" and not self.fractional:
+            return alff, input_data["path"]
+        elif input_data["space"] != "native" and self.fractional:
+            return falff, falff_path
         else:
-            return alff, falff, alff_path, falff_path
+            return alff, alff_path

junifer/markers/falff/falff_parcels.py

@@ -14,9 +14,6 @@ from ..parcel_aggregation import ParcelAggregation
 from .falff_base import ALFFBase
 
 
-__all__ = ["ALFFParcels"]
-
-
 @register_marker
 class ALFFParcels(ALFFBase):
     """Class for ALFF / fALFF on parcels.
@@ -26,6 +23,8 @@ class ALFFParcels(ALFFBase):
     parcellation : str or list of str
         The name(s) of the parcellation(s). Check valid options by calling
         :func:`.list_parcellations`.
+    fractional : bool
+        Whether to compute fractional ALFF.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -71,6 +70,7 @@ class ALFFParcels(ALFFBase):
     def __init__(
         self,
         parcellation: Union[str, List[str]],
+        fractional: bool,
         using: str,
         highpass: float = 0.01,
         lowpass: float = 0.1,
@@ -82,6 +82,7 @@ class ALFFParcels(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
+            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -110,63 +111,33 @@ class ALFFParcels(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. This will be either returned
-            to the user or stored in the storage by calling the store method
-            with this as a parameter. The dictionary has the following keys:
-
-            * ``alff`` : dictionary with the following keys:
-
-              - ``data`` : ROI values as ``numpy.ndarray``
-              - ``col_names`` : ROI labels as list of str
+            The computed result as dictionary. The dictionary has the following
+            keys:
 
-            * ``falff`` : dictionary with the following keys:
-
-              - ``data`` : ROI values as ``numpy.ndarray``
-              - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a numpy.ndarray
+            * ``col_names`` : the column labels for the computed values as list
 
         """
         logger.info("Calculating ALFF / fALFF for parcels")
 
-        # Compute ALFF + fALFF
-        alff_output, falff_output, alff_output_path, falff_output_path = (
-            self._compute(input_data=input)
+        # Compute ALFF / fALFF
+        output_data, output_file_path = self._compute(input_data=input)
+
+        # Initialize parcel aggregation
+        parcel_aggregation = ParcelAggregation(
+            parcellation=self.parcellation,
+            method=self.agg_method,
+            method_params=self.agg_method_params,
+            masks=self.masks,
+            on="BOLD",
+        )
+        # Perform aggregation on ALFF / fALFF
+        parcel_aggregation_input = dict(input.items())
+        parcel_aggregation_input["data"] = output_data
+        parcel_aggregation_input["path"] = output_file_path
+        output = parcel_aggregation.compute(
+            input=parcel_aggregation_input,
+            extra_input=extra_input,
         )
 
-        # Perform aggregation on ALFF + fALFF
-        aggregation_alff_input = dict(input.items())
-        aggregation_falff_input = dict(input.items())
-        aggregation_alff_input["data"] = alff_output
-        aggregation_falff_input["data"] = falff_output
-        aggregation_alff_input["path"] = alff_output_path
-        aggregation_falff_input["path"] = falff_output_path
-
-        return {
-            "alff": {
-                **ParcelAggregation(
-                    parcellation=self.parcellation,
-                    method=self.agg_method,
-                    method_params=self.agg_method_params,
-                    masks=self.masks,
-                    on="BOLD",
-                ).compute(
-                    input=aggregation_alff_input,
-                    extra_input=extra_input,
-                )[
-                    "aggregation"
-                ],
-            },
-            "falff": {
-                **ParcelAggregation(
-                    parcellation=self.parcellation,
-                    method=self.agg_method,
-                    method_params=self.agg_method_params,
-                    masks=self.masks,
-                    on="BOLD",
-                ).compute(
-                    input=aggregation_falff_input,
-                    extra_input=extra_input,
-                )[
-                    "aggregation"
-                ],
-            },
-        }
+        return output

junifer/markers/falff/falff_spheres.py

@@ -14,9 +14,6 @@ from ..sphere_aggregation import SphereAggregation
 from .falff_base import ALFFBase
 
 
-__all__ = ["ALFFSpheres"]
-
-
 @register_marker
 class ALFFSpheres(ALFFBase):
     """Class for computing ALFF / fALFF on spheres.
@@ -26,6 +23,8 @@ class ALFFSpheres(ALFFBase):
     coords : str
         The name of the coordinates list to use. See
         :func:`.list_coordinates` for options.
+    fractional : bool
+        Whether to compute fractional ALFF.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -78,6 +77,7 @@ class ALFFSpheres(ALFFBase):
     def __init__(
         self,
         coords: str,
+        fractional: bool,
         using: str,
         radius: Optional[float] = None,
         allow_overlap: bool = False,
@@ -91,6 +91,7 @@ class ALFFSpheres(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
+            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -121,67 +122,35 @@ class ALFFSpheres(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. This will be either returned
-            to the user or stored in the storage by calling the store method
-            with this as a parameter. The dictionary has the following keys:
-
-            * ``alff`` : dictionary with the following keys:
-
-              - ``data`` : ROI values as ``numpy.ndarray``
-              - ``col_names`` : ROI labels as list of str
+            The computed result as dictionary. The dictionary has the following
+            keys:
 
-            * ``falff`` : dictionary with the following keys:
-
-              - ``data`` : ROI values as ``numpy.ndarray``
-              - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a numpy.ndarray
+            * ``col_names`` : the column labels for the computed values as list
 
         """
         logger.info("Calculating ALFF / fALFF for spheres")
 
-        # Compute ALFF + fALFF
-        alff_output, falff_output, alff_output_path, falff_output_path = (
-            self._compute(input_data=input)
+        # Compute ALFF / fALFF
+        output_data, output_file_path = self._compute(input_data=input)
+
+        # Initialize sphere aggregation
+        sphere_aggregation = SphereAggregation(
+            coords=self.coords,
+            radius=self.radius,
+            allow_overlap=self.allow_overlap,
+            method=self.agg_method,
+            method_params=self.agg_method_params,
+            masks=self.masks,
+            on="BOLD",
         )
-
         # Perform aggregation on ALFF / fALFF
-        aggregation_alff_input = dict(input.items())
-        aggregation_falff_input = dict(input.items())
-        aggregation_alff_input["data"] = alff_output
-        aggregation_falff_input["data"] = falff_output
-        aggregation_alff_input["path"] = alff_output_path
-        aggregation_falff_input["path"] = falff_output_path
-
-        return {
-            "alff": {
-                **SphereAggregation(
-                    coords=self.coords,
-                    radius=self.radius,
-                    allow_overlap=self.allow_overlap,
-                    method=self.agg_method,
-                    method_params=self.agg_method_params,
-                    masks=self.masks,
-                    on="BOLD",
-                ).compute(
-                    input=aggregation_alff_input,
-                    extra_input=extra_input,
-                )[
-                    "aggregation"
-                ],
-            },
-            "falff": {
-                **SphereAggregation(
-                    coords=self.coords,
-                    radius=self.radius,
-                    allow_overlap=self.allow_overlap,
-                    method=self.agg_method,
-                    method_params=self.agg_method_params,
-                    masks=self.masks,
-                    on="BOLD",
-                ).compute(
-                    input=aggregation_falff_input,
-                    extra_input=extra_input,
-                )[
-                    "aggregation"
-                ],
-            },
-        }
+        sphere_aggregation_input = dict(input.items())
+        sphere_aggregation_input["data"] = output_data
+        sphere_aggregation_input["path"] = output_file_path
+        output = sphere_aggregation.compute(
+            input=sphere_aggregation_input,
+            extra_input=extra_input,
+        )
+
+        return output

junifer/markers/falff/tests/test_falff_parcels.py

@@ -21,28 +21,6 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.parametrize(
-    "feature",
-    [
-        "alff",
-        "falff",
-    ],
-)
-def test_ALFFParcels_get_output_type(feature: str) -> None:
-    """Test ALFFParcels get_output_type().
-
-    Parameters
-    ----------
-    feature : str
-        The parametrized feature name.
-
-    """
-    assert "vector" == ALFFParcels(
-        parcellation=PARCELLATION,
-        using="junifer",
-    ).get_output_type(input_type="BOLD", output_feature=feature)
-
-
 def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
     """Test ALFFParcels.
 
@@ -63,6 +41,7 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Initialize marker
             marker = ALFFParcels(
                 parcellation=PARCELLATION,
+                fractional=False,
                 using="junifer",
             )
             # Fit transform marker on data
@@ -72,16 +51,15 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            for feature in output["BOLD"].keys():
-                output_bold = output["BOLD"][feature]
-                # Assert BOLD output keys
-                assert "data" in output_bold
-                assert "col_names" in output_bold
+            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 output_bold_data.shape == (1, 16)
+            output_bold_data = output_bold["data"]
+            # Assert BOLD output data dimension
+            assert output_bold_data.ndim == 2
+            assert output_bold_data.shape == (1, 16)
 
             # Reset log capture
             caplog.clear()
@@ -99,13 +77,18 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_ALFFParcels_comparison(tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    "fractional", [True, False], ids=["fractional", "non-fractional"]
+)
+def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
     """Test ALFFParcels implementation comparison.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    fractional : bool
+        Whether to compute fractional ALFF or not.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
@@ -116,6 +99,7 @@ def test_ALFFParcels_comparison(tmp_path: Path) -> None:
         # Initialize marker
         junifer_marker = ALFFParcels(
             parcellation=PARCELLATION,
+            fractional=fractional,
             using="junifer",
         )
         # Fit transform marker on data
@@ -126,6 +110,7 @@ def test_ALFFParcels_comparison(tmp_path: Path) -> None:
         # Initialize marker
         afni_marker = ALFFParcels(
             parcellation=PARCELLATION,
+            fractional=fractional,
             using="afni",
         )
         # Fit transform marker on data
@@ -133,10 +118,9 @@ def test_ALFFParcels_comparison(tmp_path: Path) -> None:
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]
 
-        for feature in afni_output_bold.keys():
-            # Check for Pearson correlation coefficient
-            r, _ = sp.stats.pearsonr(
-                junifer_output_bold[feature]["data"][0],
-                afni_output_bold[feature]["data"][0],
-            )
-            assert r > 0.97
+        # Check for Pearson correlation coefficient
+        r, _ = sp.stats.pearsonr(
+            junifer_output_bold["data"][0],
+            afni_output_bold["data"][0],
+        )
+        assert r > 0.97