junifer 0.0.5.dev183__py3-none-any.whl → 0.0.5.dev208__py3-none-any.whl

junifer/markers/complexity/tests/test_multiscale_entropy_auc.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test MultiscaleEntropyAUC get_output_type()."""
-    marker = MultiscaleEntropyAUC(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == MultiscaleEntropyAUC(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_perm_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test PermEntropy get_output_type()."""
-    marker = PermEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == PermEntropy(parcellation=PARCELLATION).get_output_type(
+        input_type="BOLD", output_feature="complexity"
+    )
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_range_entropy.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropy get_output_type()."""
-    marker = RangeEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == RangeEntropy(parcellation=PARCELLATION).get_output_type(
+        input_type="BOLD", output_feature="complexity"
+    )
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_range_entropy_auc.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropyAUC get_output_type()."""
-    marker = RangeEntropyAUC(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == RangeEntropyAUC(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_sample_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test SampleEntropy get_output_type()."""
-    marker = SampleEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == SampleEntropy(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_weighted_perm_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test WeightedPermEntropy get_output_type()."""
-    marker = WeightedPermEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == WeightedPermEntropy(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/ets_rss.py

@@ -47,6 +47,12 @@ 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]],
@@ -61,33 +67,6 @@ 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],
@@ -109,8 +88,9 @@ class RSSETSMarker(BaseMarker):
         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:
 
             * ``data`` : the actual computed values as a numpy.ndarray
             * ``col_names`` : the column labels for the computed values as list
@@ -124,20 +104,22 @@ class RSSETSMarker(BaseMarker):
 
         """
         logger.debug("Calculating root sum of squares of edgewise timeseries.")
-        # Initialize a ParcelAggregation
-        parcel_aggregation = ParcelAggregation(
+        # Perform aggregation
+        aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-        )
-        # 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
+        ).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"],
+            }
+        }

junifer/markers/falff/falff_base.py

@@ -37,8 +37,6 @@ class ALFFBase(BaseMarker):
 
     Parameters
     ----------
-    fractional : bool
-        Whether to compute fractional ALFF.
     highpass : positive float
         Highpass cutoff frequency.
     lowpass : positive float
@@ -85,9 +83,15 @@ 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,
@@ -110,45 +114,12 @@ 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", Path]:
+    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF and fALFF.
 
         Parameters
@@ -161,9 +132,13 @@ class ALFFBase(BaseMarker):
         Returns
         -------
         Niimg-like object
-            The ALFF / fALFF as NIfTI.
+            The ALFF as NIfTI.
+        Niimg-like object
+            The fALFF as NIfTI.
+        pathlib.Path
+            The path to the ALFF as NIfTI.
         pathlib.Path
-            The path to the ALFF / fALFF as NIfTI.
+            The path to the fALFF as NIfTI.
 
         """
         logger.debug("Calculating ALFF and fALFF")
@@ -186,11 +161,7 @@ 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" 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
+        if input_data["space"] == "native":
+            return alff, falff, input_data["path"], input_data["path"]
         else:
-            return alff, alff_path
+            return alff, falff, alff_path, falff_path

junifer/markers/falff/falff_parcels.py

@@ -26,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:
 
@@ -73,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,
@@ -85,7 +82,6 @@ class ALFFParcels(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -114,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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``alff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
+
+            * ``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

@@ -26,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:
 
@@ -80,7 +78,6 @@ class ALFFSpheres(ALFFBase):
     def __init__(
         self,
         coords: str,
-        fractional: bool,
         using: str,
         radius: Optional[float] = None,
         allow_overlap: bool = False,
@@ -94,7 +91,6 @@ class ALFFSpheres(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -125,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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``alff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
+
+            * ``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