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

junifer/markers/functional_connectivity/tests/test_functional_connectivity_parcels.py

@@ -6,13 +6,10 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
 
-import pytest
 from nilearn.connectome import ConnectivityMeasure
 from nilearn.maskers import NiftiLabelsMasker
 from numpy.testing import assert_array_almost_equal
-from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
 from junifer.data import get_parcellation
 from junifer.datareader import DefaultDataReader
@@ -23,51 +20,26 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-if TYPE_CHECKING:
-    from sklearn.base import BaseEstimator
-
-
-@pytest.mark.parametrize(
-    "conn_method_params, cov_estimator",
-    [
-        ({"empirical": False}, LedoitWolf(store_precision=False)),
-        ({"empirical": True}, EmpiricalCovariance(store_precision=False)),
-    ],
-)
-def test_FunctionalConnectivityParcels(
-    tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-    cov_estimator: Type["BaseEstimator"],
-) -> None:
+def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
     """Test FunctionalConnectivityParcels.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    conn_method_params : dict
-        The parametrized parameters to connectivity measure method.
-    cov_estimator : estimator object
-        The parametrized covariance estimator.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
-        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        # Setup marker
         marker = FunctionalConnectivityParcels(
-            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-            conn_method="correlation",
-            conn_method_params=conn_method_params,
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert "matrix" == marker.get_output_type(
-            input_type="BOLD", output_feature="functional_connectivity"
-        )
+        assert marker.get_output_type("BOLD") == "matrix"
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]["functional_connectivity"]
+        fc_bold = fc["BOLD"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -91,7 +63,7 @@ def test_FunctionalConnectivityParcels(
         )
         # Compute the connectivity measure
         connectivity_measure = ConnectivityMeasure(
-            cov_estimator=cov_estimator, kind="correlation"  # type: ignore
+            kind="covariance"
         ).fit_transform([extracted_timeseries])[0]
 
         # Check that FC are almost equal
@@ -99,6 +71,11 @@ def test_FunctionalConnectivityParcels(
             connectivity_measure, fc_bold["data"], decimal=3
         )
 
+        # Check empirical correlation method parameters
+        marker = FunctionalConnectivityParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+            cor_method_params={"empirical": True},
+        )
         # Store
         storage = SQLiteFeatureStorage(
             uri=tmp_path / "test_fc_parcels.sqlite", upsert="ignore"
@@ -106,7 +83,6 @@ def test_FunctionalConnectivityParcels(
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"]
-            == "BOLD_FunctionalConnectivityParcels_functional_connectivity"
+            x["name"] == "BOLD_FunctionalConnectivityParcels"
             for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -7,13 +7,12 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
 
 import pytest
 from nilearn.connectome import ConnectivityMeasure
 from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_almost_equal
-from sklearn.covariance import EmpiricalCovariance, LedoitWolf
+from sklearn.covariance import EmpiricalCovariance
 
 from junifer.data import get_coordinates
 from junifer.datareader import DefaultDataReader
@@ -24,52 +23,26 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-if TYPE_CHECKING:
-    from sklearn.base import BaseEstimator
-
-
-@pytest.mark.parametrize(
-    "conn_method_params, cov_estimator",
-    [
-        ({"empirical": False}, LedoitWolf(store_precision=False)),
-        ({"empirical": True}, EmpiricalCovariance(store_precision=False)),
-    ],
-)
-def test_FunctionalConnectivitySpheres(
-    tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-    cov_estimator: Type["BaseEstimator"],
-) -> None:
+def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
     """Test FunctionalConnectivitySpheres.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    conn_method_params : dict
-        The parametrized parameters to connectivity measure method.
-    cov_estimator : estimator object
-        The parametrized covariance estimator.
 
     """
     with SPMAuditoryTestingDataGrabber() as dg:
-        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
-        # Setup marker
         marker = FunctionalConnectivitySpheres(
-            coords="DMNBuckner",
-            radius=5.0,
-            conn_method="correlation",
-            conn_method_params=conn_method_params,
+            coords="DMNBuckner", radius=5.0, cor_method="correlation"
         )
         # Check correct output
-        assert "matrix" == marker.get_output_type(
-            input_type="BOLD", output_feature="functional_connectivity"
-        )
+        assert marker.get_output_type("BOLD") == "matrix"
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]["functional_connectivity"]
+        fc_bold = fc["BOLD"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -92,7 +65,7 @@ def test_FunctionalConnectivitySpheres(
         )
         # Compute the connectivity measure
         connectivity_measure = ConnectivityMeasure(
-            cov_estimator=cov_estimator, kind="correlation"  # type: ignore
+            kind="correlation"
         ).fit_transform([extracted_timeseries])[0]
 
         # Check that FC are almost equal
@@ -107,15 +80,68 @@ def test_FunctionalConnectivitySpheres(
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"]
-            == "BOLD_FunctionalConnectivitySpheres_functional_connectivity"
+            x["name"] == "BOLD_FunctionalConnectivitySpheres"
             for x in features.values()
         )
 
 
+def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
+    """Test FunctionalConnectivitySpheres with empirical covariance.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = FunctionalConnectivitySpheres(
+            coords="DMNBuckner",
+            radius=5.0,
+            cor_method="correlation",
+            cor_method_params={"empirical": True},
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        fc = marker.fit_transform(element_data)
+        fc_bold = fc["BOLD"]
+
+        assert "data" in fc_bold
+        assert "row_names" in fc_bold
+        assert "col_names" in fc_bold
+        assert fc_bold["data"].shape == (6, 6)
+        assert len(set(fc_bold["row_names"])) == 6
+        assert len(set(fc_bold["col_names"])) == 6
+
+        # Compare with nilearn
+        # Load testing coordinates for the target data
+        testing_coords, _ = get_coordinates(
+            coords="DMNBuckner", target_data=element_data["BOLD"]
+        )
+        # Extract timeseries
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=5.0
+        )
+        extracted_timeseries = nifti_spheres_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        # Compute the connectivity measure
+        connectivity_measure = ConnectivityMeasure(
+            cov_estimator=EmpiricalCovariance(), kind="correlation"  # type: ignore
+        ).fit_transform([extracted_timeseries])[0]
+
+        # Check that FC are almost equal
+        assert_array_almost_equal(
+            connectivity_measure, fc_bold["data"], decimal=3
+        )
+
+
 def test_FunctionalConnectivitySpheres_error() -> None:
     """Test FunctionalConnectivitySpheres errors."""
     with pytest.raises(ValueError, match="radius should be > 0"):
         FunctionalConnectivitySpheres(
-            coords="DMNBuckner", radius=-0.1, conn_method="correlation"
+            coords="DMNBuckner", radius=-0.1, cor_method="correlation"
         )

junifer/markers/parcel_aggregation.py

@@ -17,9 +17,6 @@ from ..utils import logger, raise_error, warn_with_log
 from .base import BaseMarker
 
 
-__all__ = ["ParcelAggregation"]
-
-
 @register_marker
 class ParcelAggregation(BaseMarker):
     """Class for parcel aggregation.
@@ -63,36 +60,6 @@ class ParcelAggregation(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "numpy"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "T1w": {
-            "aggregation": "vector",
-        },
-        "T2w": {
-            "aggregation": "vector",
-        },
-        "BOLD": {
-            "aggregation": "timeseries",
-        },
-        "VBM_GM": {
-            "aggregation": "vector",
-        },
-        "VBM_WM": {
-            "aggregation": "vector",
-        },
-        "VBM_CSF": {
-            "aggregation": "vector",
-        },
-        "fALFF": {
-            "aggregation": "vector",
-        },
-        "GCOR": {
-            "aggregation": "vector",
-        },
-        "LCOR": {
-            "aggregation": "vector",
-        },
-    }
-
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -126,6 +93,61 @@ class ParcelAggregation(BaseMarker):
         self.time_method = time_method
         self.time_method_params = time_method_params or {}
 
+    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 [
+            "T1w",
+            "T2w",
+            "BOLD",
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]
+
+    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.
+
+        Raises
+        ------
+        ValueError
+            If the ``input_type`` is invalid.
+
+        """
+
+        if input_type in [
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]:
+            return "vector"
+        elif input_type == "BOLD":
+            return "timeseries"
+        else:
+            raise_error(f"Unknown input kind for {input_type}")
+
     def compute(
         self, input: Dict[str, Any], extra_input: Optional[Dict] = None
     ) -> Dict:
@@ -149,10 +171,8 @@ class ParcelAggregation(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:
 
-            * ``aggregation`` : 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
 
         Warns
         -----
@@ -175,9 +195,7 @@ class ParcelAggregation(BaseMarker):
         )
 
         # Get binarized parcellation image for masking
-        parcellation_bin = math_img(
-            "np.squeeze(img) != 0", img=parcellation_img
-        )
+        parcellation_bin = math_img("img != 0", img=parcellation_img)
 
         # Load mask
         if self.masks is not None:
@@ -188,7 +206,7 @@ class ParcelAggregation(BaseMarker):
             )
             # Get "logical and" version of parcellation and mask
             parcellation_bin = math_img(
-                "np.logical_and(img, np.squeeze(mask))",
+                "np.logical_and(img, mask)",
                 img=parcellation_bin,
                 mask=mask_img,
             )
@@ -230,9 +248,5 @@ class ParcelAggregation(BaseMarker):
                     "available."
                 )
         # Format the output
-        return {
-            "aggregation": {
-                "data": out_values,
-                "col_names": labels,
-            },
-        }
+        out = {"data": out_values, "col_names": labels}
+        return out

junifer/markers/reho/__init__.py

@@ -5,6 +5,3 @@
 
 from .reho_parcels import ReHoParcels
 from .reho_spheres import ReHoSpheres
-
-
-__all__ = ["ReHoParcels", "ReHoSpheres"]

junifer/markers/reho/_afni_reho.py

@@ -26,9 +26,6 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
 
-__all__ = ["AFNIReHo"]
-
-
 @singleton
 class AFNIReHo:
     """Class for computing ReHo using AFNI.
@@ -75,7 +72,7 @@ class AFNIReHo:
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             * 7 : for facewise neighbours only
-            * 19 : for face- and edge-wise neighbours
+            * 19 : for face- and edge-wise nieghbours
             * 27 : for face-, edge-, and node-wise neighbors
 
             (default 27).
@@ -181,7 +178,7 @@ class AFNIReHo:
         convert_cmd = [
             "3dAFNItoNIFTI",
             f"-prefix {reho_afni_to_nifti_out_path.resolve()}",
-            f"{reho_out_path_prefix}+orig.BRIK",
+            f"{reho_out_path_prefix}+tlrc.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_cmd)

junifer/markers/reho/_junifer_reho.py

@@ -28,9 +28,6 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
 
-__all__ = ["JuniferReHo"]
-
-
 @singleton
 class JuniferReHo:
     """Class for computing ReHo using junifer.
@@ -63,7 +60,7 @@ class JuniferReHo:
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             * 7 : for facewise neighbours only
-            * 19 : for face- and edge-wise neighbours
+            * 19 : for face- and edge-wise nieghbours
             * 27 : for face-, edge-, and node-wise neighbors
             * 125 : for 5x5 cuboidal volume
 

junifer/markers/reho/reho_base.py

@@ -26,8 +26,6 @@ from ._junifer_reho import JuniferReHo
 if TYPE_CHECKING:
     from nibabel import Nifti1Image
 
-__all__ = ["ReHoBase"]
-
 
 class ReHoBase(BaseMarker):
     """Base class for regional homogeneity computation.
@@ -62,12 +60,6 @@ class ReHoBase(BaseMarker):
         },
     ]
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "reho": "vector",
-        },
-    }
-
     def __init__(
         self,
         using: str,
@@ -82,6 +74,33 @@ class ReHoBase(BaseMarker):
         self.using = using
         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],

junifer/markers/reho/reho_parcels.py

@@ -14,9 +14,6 @@ from ..parcel_aggregation import ParcelAggregation
 from .reho_base import ReHoBase
 
 
-__all__ = ["ReHoParcels"]
-
-
 @register_marker
 class ReHoParcels(ReHoBase):
     """Class for regional homogeneity on parcels.
@@ -40,7 +37,7 @@ class ReHoParcels(ReHoBase):
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             - 7 : for facewise neighbours only
-            - 19 : for face- and edge-wise neighbours
+            - 19 : for face- and edge-wise nieghbours
             - 27 : for face-, edge-, and node-wise neighbors
 
         * ``neigh_rad`` : positive float, optional
@@ -70,7 +67,7 @@ class ReHoParcels(ReHoBase):
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             * 7 : for facewise neighbours only
-            * 19 : for face- and edge-wise neighbours
+            * 19 : for face- and edge-wise nieghbours
             * 27 : for face-, edge-, and node-wise neighbors
             * 125 : for 5x5 cuboidal volume
 
@@ -125,14 +122,11 @@ class ReHoParcels(ReHoBase):
         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:
 
-            * ``reho`` : 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 1D numpy.ndarray
+            * ``col_names`` : the column labels for the parcels as a list
 
         """
         logger.info("Calculating ReHo for parcels")
@@ -148,27 +142,22 @@ class ReHoParcels(ReHoBase):
         else:
             reho_map, reho_file_path = self._compute(input_data=input)
 
-        # Perform aggregation on reho map
-        aggregation_input = dict(input.items())
-        aggregation_input["data"] = reho_map
-        aggregation_input["path"] = reho_file_path
+        # Initialize parcel aggregation
         parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(
-            input=aggregation_input,
+        )
+        # Perform aggregation on reho map
+        parcel_aggregation_input = dict(input.items())
+        parcel_aggregation_input["data"] = reho_map
+        parcel_aggregation_input["path"] = reho_file_path
+        output = parcel_aggregation.compute(
+            input=parcel_aggregation_input,
             extra_input=extra_input,
         )
-
-        return {
-            "reho": {
-                # Only use the first row and expand row dimension
-                "data": parcel_aggregation["aggregation"]["data"][0][
-                    np.newaxis, :
-                ],
-                "col_names": parcel_aggregation["aggregation"]["col_names"],
-            }
-        }
+        # Only use the first row and expand row dimension
+        output["data"] = output["data"][0][np.newaxis, :]
+        return output

junifer/markers/reho/reho_spheres.py

@@ -14,9 +14,6 @@ from ..sphere_aggregation import SphereAggregation
 from .reho_base import ReHoBase
 
 
-__all__ = ["ReHoSpheres"]
-
-
 @register_marker
 class ReHoSpheres(ReHoBase):
     """Class for regional homogeneity on spheres.
@@ -51,7 +48,7 @@ class ReHoSpheres(ReHoBase):
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             - 7 : for facewise neighbours only
-            - 19 : for face- and edge-wise neighbours
+            - 19 : for face- and edge-wise nieghbours
             - 27 : for face-, edge-, and node-wise neighbors
 
         * ``neigh_rad`` : positive float, optional
@@ -81,7 +78,7 @@ class ReHoSpheres(ReHoBase):
             Number of voxels in the neighbourhood, inclusive. Can be:
 
             * 7 : for facewise neighbours only
-            * 19 : for face- and edge-wise neighbours
+            * 19 : for face- and edge-wise nieghbours
             * 27 : for face-, edge-, and node-wise neighbors
             * 125 : for 5x5 cuboidal volume
 
@@ -140,14 +137,11 @@ class ReHoSpheres(ReHoBase):
         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:
-
-            * ``reho`` : dictionary with the following keys:
+            The computed result as dictionary. The dictionary has the following
+            keys:
 
-              - ``data`` : ROI values as ``numpy.ndarray``
-              - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a 1D numpy.ndarray
+            * ``col_names`` : the column labels for the spheres as a list
 
         """
         logger.info("Calculating ReHo for spheres")
@@ -163,10 +157,7 @@ class ReHoSpheres(ReHoBase):
         else:
             reho_map, reho_file_path = self._compute(input_data=input)
 
-        # Perform aggregation on reho map
-        aggregation_input = dict(input.items())
-        aggregation_input["data"] = reho_map
-        aggregation_input["path"] = reho_file_path
+        # Initialize sphere aggregation
         sphere_aggregation = SphereAggregation(
             coords=self.coords,
             radius=self.radius,
@@ -175,14 +166,14 @@ class ReHoSpheres(ReHoBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input=aggregation_input, extra_input=extra_input)
-
-        return {
-            "reho": {
-                # Only use the first row and expand row dimension
-                "data": sphere_aggregation["aggregation"]["data"][0][
-                    np.newaxis, :
-                ],
-                "col_names": sphere_aggregation["aggregation"]["col_names"],
-            }
-        }
+        )
+        # Perform aggregation on reho map
+        sphere_aggregation_input = dict(input.items())
+        sphere_aggregation_input["data"] = reho_map
+        sphere_aggregation_input["path"] = reho_file_path
+        output = sphere_aggregation.compute(
+            input=sphere_aggregation_input, extra_input=extra_input
+        )
+        # Only use the first row and expand row dimension
+        output["data"] = output["data"][0][np.newaxis, :]
+        return output