junifer 0.0.4.dev829__py3-none-any.whl → 0.0.5__py3-none-any.whl

junifer/markers/falff/falff_parcels.py

@@ -14,6 +14,9 @@ from ..parcel_aggregation import ParcelAggregation
 from .falff_base import ALFFBase
 
 
+__all__ = ["ALFFParcels"]
+
+
 @register_marker
 class ALFFParcels(ALFFBase):
     """Class for ALFF / fALFF on parcels.
@@ -23,8 +26,6 @@ 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:
 
@@ -70,7 +71,6 @@ class ALFFParcels(ALFFBase):
     def __init__(
         self,
         parcellation: Union[str, List[str]],
-        fractional: bool,
         using: str,
         highpass: float = 0.01,
         lowpass: float = 0.1,
@@ -82,7 +82,6 @@ class ALFFParcels(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -111,33 +110,63 @@ class ALFFParcels(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            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
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``falff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         logger.info("Calculating ALFF / fALFF for parcels")
 
-        # 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,
+        # Compute ALFF + fALFF
+        alff_output, falff_output, alff_output_path, falff_output_path = (
+            self._compute(input_data=input)
         )
 
-        return output
+        # 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"
+                ],
+            },
+        }

junifer/markers/falff/falff_spheres.py

@@ -14,6 +14,9 @@ from ..sphere_aggregation import SphereAggregation
 from .falff_base import ALFFBase
 
 
+__all__ = ["ALFFSpheres"]
+
+
 @register_marker
 class ALFFSpheres(ALFFBase):
     """Class for computing ALFF / fALFF on spheres.
@@ -23,8 +26,6 @@ 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:
 
@@ -77,7 +78,6 @@ class ALFFSpheres(ALFFBase):
     def __init__(
         self,
         coords: str,
-        fractional: bool,
         using: str,
         radius: Optional[float] = None,
         allow_overlap: bool = False,
@@ -91,7 +91,6 @@ class ALFFSpheres(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -122,35 +121,67 @@ class ALFFSpheres(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            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
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``falff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         logger.info("Calculating ALFF / fALFF for spheres")
 
-        # 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
-        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,
+        # Compute ALFF + fALFF
+        alff_output, falff_output, alff_output_path, falff_output_path = (
+            self._compute(input_data=input)
         )
 
-        return output
+        # 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"
+                ],
+            },
+        }

junifer/markers/falff/tests/test_falff_parcels.py

@@ -21,6 +21,28 @@ 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.
 
@@ -41,7 +63,6 @@ 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
@@ -51,15 +72,16 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # 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
+            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_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()
@@ -77,18 +99,13 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-@pytest.mark.parametrize(
-    "fractional", [True, False], ids=["fractional", "non-fractional"]
-)
-def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
+def test_ALFFParcels_comparison(tmp_path: Path) -> 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:
@@ -99,7 +116,6 @@ def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         junifer_marker = ALFFParcels(
             parcellation=PARCELLATION,
-            fractional=fractional,
             using="junifer",
         )
         # Fit transform marker on data
@@ -110,7 +126,6 @@ def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         afni_marker = ALFFParcels(
             parcellation=PARCELLATION,
-            fractional=fractional,
             using="afni",
         )
         # Fit transform marker on data
@@ -118,9 +133,10 @@ def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]
 
-        # Check for Pearson correlation coefficient
-        r, _ = sp.stats.pearsonr(
-            junifer_output_bold["data"][0],
-            afni_output_bold["data"][0],
-        )
-        assert r > 0.97
+        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

junifer/markers/falff/tests/test_falff_spheres.py

@@ -21,6 +21,28 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 COORDINATES = "DMNBuckner"
 
 
+@pytest.mark.parametrize(
+    "feature",
+    [
+        "alff",
+        "falff",
+    ],
+)
+def test_ALFFSpheres_get_output_type(feature: str) -> None:
+    """Test ALFFSpheres get_output_type().
+
+    Parameters
+    ----------
+    feature : str
+        The parametrized feature name.
+
+    """
+    assert "vector" == ALFFSpheres(
+        coords=COORDINATES,
+        using="junifer",
+    ).get_output_type(input_type="BOLD", output_feature=feature)
+
+
 def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
     """Test ALFFSpheres.
 
@@ -41,7 +63,6 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Initialize marker
             marker = ALFFSpheres(
                 coords=COORDINATES,
-                fractional=False,
                 using="junifer",
                 radius=5.0,
             )
@@ -52,15 +73,16 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # 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
+            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_data = output_bold["data"]
-            # Assert BOLD output data dimension
-            assert output_bold_data.ndim == 2
-            assert output_bold_data.shape == (1, 6)
+                output_bold_data = output_bold["data"]
+                # Assert BOLD output data dimension
+                assert output_bold_data.ndim == 2
+                assert output_bold_data.shape == (1, 6)
 
             # Reset log capture
             caplog.clear()
@@ -78,18 +100,13 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-@pytest.mark.parametrize(
-    "fractional", [True, False], ids=["fractional", "non-fractional"]
-)
-def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
+def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
     """Test ALFFSpheres 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:
@@ -100,7 +117,6 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         junifer_marker = ALFFSpheres(
             coords=COORDINATES,
-            fractional=fractional,
             using="junifer",
             radius=5.0,
         )
@@ -112,7 +128,6 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         afni_marker = ALFFSpheres(
             coords=COORDINATES,
-            fractional=fractional,
             using="afni",
             radius=5.0,
         )
@@ -121,9 +136,10 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]
 
-        # Check for Pearson correlation coefficient
-        r, _ = sp.stats.pearsonr(
-            junifer_output_bold["data"][0],
-            afni_output_bold["data"][0],
-        )
-        assert r > 0.99
+        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.99

junifer/markers/functional_connectivity/__init__.py

@@ -8,3 +8,12 @@ from .functional_connectivity_spheres import FunctionalConnectivitySpheres
 from .crossparcellation_functional_connectivity import CrossParcellationFC
 from .edge_functional_connectivity_parcels import EdgeCentricFCParcels
 from .edge_functional_connectivity_spheres import EdgeCentricFCSpheres
+
+
+__all__ = [
+    "FunctionalConnectivityParcels",
+    "FunctionalConnectivitySpheres",
+    "CrossParcellationFC",
+    "EdgeCentricFCParcels",
+    "EdgeCentricFCSpheres",
+]

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -15,6 +15,9 @@ from ..parcel_aggregation import ParcelAggregation
 from ..utils import _correlate_dataframes
 
 
+__all__ = ["CrossParcellationFC"]
+
+
 @register_marker
 class CrossParcellationFC(BaseMarker):
     """Class for calculating parcel-wise correlations with 2 parcellations.
@@ -25,29 +28,42 @@ class CrossParcellationFC(BaseMarker):
         The name of the first parcellation.
     parcellation_two : str
         The name of the second parcellation.
-    aggregation_method : str, optional
-        The aggregation method (default "mean").
-    correlation_method : str, optional
+    agg_method : str, optional
+        The method to perform aggregation using.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
+    agg_method_params : dict, optional
+        Parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options
+        (default None).
+    corr_method : str, optional
         Any method that can be passed to
-        :any:`pandas.DataFrame.corr` (default "pearson").
+        :meth:`pandas.DataFrame.corr` (default "pearson").
     masks : str, dict or list of dict or str, optional
         The specification of the masks to apply to regions before extracting
         signals. Check :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
     name : str, optional
-        The name of the marker. If None, will use the class name
-        (default None).
+        The name of the marker. If None, will use
+        ``BOLD_CrossParcellationFC`` (default None).
 
     """
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "functional_connectivity": "matrix",
+        },
+    }
+
     def __init__(
         self,
         parcellation_one: str,
         parcellation_two: str,
-        aggregation_method: str = "mean",
-        correlation_method: str = "pearson",
+        agg_method: str = "mean",
+        agg_method_params: Optional[Dict] = None,
+        corr_method: str = "pearson",
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -57,38 +73,12 @@ class CrossParcellationFC(BaseMarker):
             )
         self.parcellation_one = parcellation_one
         self.parcellation_two = parcellation_two
-        self.aggregation_method = aggregation_method
-        self.correlation_method = correlation_method
+        self.agg_method = agg_method
+        self.agg_method_params = agg_method_params
+        self.corr_method = corr_method
         self.masks = masks
         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 "matrix"
-
     def compute(
         self,
         input: Dict[str, Any],
@@ -115,10 +105,14 @@ class CrossParcellationFC(BaseMarker):
             to the user or stored in the storage by calling the store method
             with this as a parameter. The dictionary has the following keys:
 
-            * ``data`` : the correlation values between the two parcellations
-              as a numpy.ndarray
-            * ``col_names`` : the ROIs for first parcellation as a list
-            * ``row_names`` : the ROIs for second parcellation as a list
+            * ``functional_connectivity`` : dictionary with the following keys:
+
+              - ``data`` : correlation between the two parcellations as
+                           ``numpy.ndarray``
+              - ``col_names`` : ROI labels for first parcellation as list of
+                                str
+              - ``row_names`` : ROI labels for second parcellation as list of
+                                str
 
         """
         logger.debug(
@@ -126,31 +120,40 @@ class CrossParcellationFC(BaseMarker):
             f" {self.parcellation_one} and "
             f"{self.parcellation_two} parcellations."
         )
-        # Initialize a ParcelAggregation
-        parcellation_one_dict = ParcelAggregation(
+        # Perform aggregation using two parcellations
+        aggregation_parcellation_one = ParcelAggregation(
             parcellation=self.parcellation_one,
-            method=self.aggregation_method,
+            method=self.agg_method,
+            method_params=self.agg_method_params,
             masks=self.masks,
+            on="BOLD",
         ).compute(input, extra_input=extra_input)
-        parcellation_two_dict = ParcelAggregation(
+        aggregation_parcellation_two = ParcelAggregation(
             parcellation=self.parcellation_two,
-            method=self.aggregation_method,
+            method=self.agg_method,
+            method_params=self.agg_method_params,
             masks=self.masks,
+            on="BOLD",
         ).compute(input, extra_input=extra_input)
 
-        parcellated_ts_one = parcellation_one_dict["data"]
-        parcellated_ts_two = parcellation_two_dict["data"]
-        # columns should be named after parcellation 1
-        # rows should be named after parcellation 2
-
-        result = _correlate_dataframes(
-            pd.DataFrame(parcellated_ts_one),
-            pd.DataFrame(parcellated_ts_two),
-            method=self.correlation_method,
-        ).values
-
         return {
-            "data": result,
-            "col_names": parcellation_one_dict["col_names"],
-            "row_names": parcellation_two_dict["col_names"],
+            "functional_connectivity": {
+                "data": _correlate_dataframes(
+                    pd.DataFrame(
+                        aggregation_parcellation_one["aggregation"]["data"]
+                    ),
+                    pd.DataFrame(
+                        aggregation_parcellation_two["aggregation"]["data"]
+                    ),
+                    method=self.corr_method,
+                ).values,
+                # Columns should be named after parcellation 1
+                "col_names": aggregation_parcellation_one["aggregation"][
+                    "col_names"
+                ],
+                # Rows should be named after parcellation 2
+                "row_names": aggregation_parcellation_two["aggregation"][
+                    "col_names"
+                ],
+            },
         }