junifer 0.0.5.dev202__py3-none-any.whl → 0.0.5.dev219__py3-none-any.whl

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -28,18 +28,24 @@ 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).
 
     """
 
@@ -55,8 +61,9 @@ class CrossParcellationFC(BaseMarker):
         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:
@@ -66,8 +73,9 @@ 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)
 
@@ -115,13 +123,17 @@ class CrossParcellationFC(BaseMarker):
         # 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)
         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)
 
         return {
@@ -133,11 +145,15 @@ class CrossParcellationFC(BaseMarker):
                     pd.DataFrame(
                         aggregation_parcellation_two["aggregation"]["data"]
                     ),
-                    method=self.correlation_method,
+                    method=self.corr_method,
                 ).values,
                 # Columns should be named after parcellation 1
-                "col_names": aggregation_parcellation_one["col_names"],
+                "col_names": aggregation_parcellation_one["aggregation"][
+                    "col_names"
+                ],
                 # Rows should be named after parcellation 2
-                "row_names": aggregation_parcellation_two["col_names"],
+                "row_names": aggregation_parcellation_two["aggregation"][
+                    "col_names"
+                ],
             },
         }

junifer/markers/functional_connectivity/edge_functional_connectivity_parcels.py

@@ -22,36 +22,40 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
     Parameters
     ----------
     parcellation : str or list of str
-        The name(s) of the parcellation(s). Check valid options by calling
-        :func:`.list_parcellations`.
+        The name(s) of the parcellation(s) to use.
+        See :func:`.list_parcellations` for options.
     agg_method : str, optional
-        The method to perform aggregation of BOLD time series.
-        Check valid options in :func:`.get_aggfunc_by_name`
+        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. Check valid options in
-        :func:`.get_aggfunc_by_name` (default None).
-    cor_method : str, optional
-        The method to perform correlation. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure`
-        (default "covariance").
-    cor_method_params : dict, optional
-        Parameters to pass to the correlation function. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
+        Parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options
+        (default None).
+    conn_method : str, optional
+        The method to perform connectivity measure using.
+        See :class:`.JuniferConnectivityMeasure` for options
+        (default "correlation").
+    conn_method_params : dict, optional
+        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+        If None, ``{"empirical": True}`` will be used, which would mean
+        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
+        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
+        desired, ``{"empirical": False}`` should be passed
+        (default None).
     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_EdgeCentricFCParcels`` (default None).
 
     References
     ----------
     .. [1] Jo et al. (2021)
-            Subject identification using
-            edge-centric functional connectivity
-            doi: https://doi.org/10.1016/j.neuroimage.2021.118204
+           Subject identification using edge-centric functional connectivity.
+           https://doi.org/10.1016/j.neuroimage.2021.118204
 
     """
 
@@ -60,8 +64,8 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         parcellation: Union[str, List[str]],
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -69,8 +73,8 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            cor_method=cor_method,
-            cor_method_params=cor_method_params,
+            conn_method=conn_method,
+            conn_method_params=conn_method_params,
             masks=masks,
             name=name,
         )

junifer/markers/functional_connectivity/edge_functional_connectivity_spheres.py

@@ -22,42 +22,48 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
     Parameters
     ----------
     coords : str
-        The name of the coordinates list to use. See
-        :func:`.list_coordinates` for options.
-    radius : float, optional
-        The radius of the sphere in mm. If None, the signal will be extracted
-        from a single voxel. See :class:`nilearn.maskers.NiftiSpheresMasker`
-        for more information (default None).
+        The name of the coordinates list to use.
+        See :func:`.list_coordinates` for options.
+    radius : positive float, optional
+        The radius of the sphere around each coordinates in millimetres.
+        If None, the signal will be extracted from a single voxel.
+        See :class:`.JuniferNiftiSpheresMasker` for more information
+        (default None).
     allow_overlap : bool, optional
         Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default is False).
+        the spheres overlap (default False).
     agg_method : str, optional
-        The aggregation method to use.
-        See :func:`.get_aggfunc_by_name` for more information
-        (default None).
+        The method to perform aggregation using.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
     agg_method_params : dict, optional
-        The parameters to pass to the aggregation method (default None).
-    cor_method : str, optional
-        The method to perform correlation using. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default "covariance").
-    cor_method_params : dict, optional
-        Parameters to pass to the correlation function. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
+        Parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options
+        (default None).
+    conn_method : str, optional
+        The method to perform connectivity measure using.
+        See :class:`.JuniferConnectivityMeasure` for options
+        (default "correlation").
+    conn_method_params : dict, optional
+        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+        If None, ``{"empirical": True}`` will be used, which would mean
+        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
+        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
+        desired, ``{"empirical": False}`` should be passed
+        (default None).
     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. By default, it will use
-        KIND_EdgeCentricFCSpheres where KIND is the kind of data it
-        was applied to (default None).
+        The name of the marker. If None, will use
+        ``BOLD_EdgeCentricFCSpheres`` (default None).
 
     References
     ----------
     .. [1] Jo et al. (2021)
-            Subject identification using
-            edge-centric functional connectivity
-            doi: https://doi.org/10.1016/j.neuroimage.2021.118204
+           Subject identification using edge-centric functional connectivity.
+           https://doi.org/10.1016/j.neuroimage.2021.118204
 
     """
 
@@ -68,8 +74,8 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         allow_overlap: bool = False,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -81,8 +87,8 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            cor_method=cor_method,
-            cor_method_params=cor_method_params,
+            conn_method=conn_method,
+            conn_method_params=conn_method_params,
             masks=masks,
             name=name,
         )

junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -7,9 +7,9 @@
 from abc import abstractmethod
 from typing import Any, ClassVar, Dict, List, Optional, Set, Union
 
-from nilearn.connectome import ConnectivityMeasure
-from sklearn.covariance import EmpiricalCovariance
+from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
+from ...external.nilearn import JuniferConnectivityMeasure
 from ...utils import raise_error
 from ..base import BaseMarker
 
@@ -23,25 +23,31 @@ class FunctionalConnectivityBase(BaseMarker):
     Parameters
     ----------
     agg_method : str, optional
-        The method to perform aggregation using. Check valid options in
-        :func:`.get_aggfunc_by_name` (default "mean").
+        The method to perform aggregation using.
+        Check valid options in :func:`.get_aggfunc_by_name`
+        (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function. Check valid options in
-        :func:`.get_aggfunc_by_name` (default None).
-    cor_method : str, optional
-        The method to perform correlation using. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure`
-        (default "covariance").
-    cor_method_params : dict, optional
-        Parameters to pass to the correlation function. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
+        Parameters to pass to the aggregation function.
+        Check valid options in :func:`.get_aggfunc_by_name`
+        (default None).
+    conn_method : str, optional
+        The method to perform connectivity measure using.
+        Check valid options in :class:`.JuniferConnectivityMeasure`
+        (default "correlation").
+    conn_method_params : dict, optional
+        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+        If None, ``{"empirical": True}`` will be used, which would mean
+        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
+        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
+        desired, ``{"empirical": False}`` should be passed
+        (default None).
     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_<class_name>``
+        (default None).
 
     """
 
@@ -57,19 +63,18 @@ class FunctionalConnectivityBase(BaseMarker):
         self,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.agg_method = agg_method
         self.agg_method_params = agg_method_params
-        self.cor_method = cor_method
-        self.cor_method_params = cor_method_params or {}
-
-        # default to nilearn behavior
-        self.cor_method_params["empirical"] = self.cor_method_params.get(
-            "empirical", False
+        self.conn_method = conn_method
+        self.conn_method_params = conn_method_params or {}
+        # Reverse of nilearn behavior
+        self.conn_method_params["empirical"] = self.conn_method_params.get(
+            "empirical", True
         )
         self.masks = masks
         super().__init__(on="BOLD", name=name)
@@ -121,14 +126,21 @@ class FunctionalConnectivityBase(BaseMarker):
         """
         # Perform necessary aggregation
         aggregation = self.aggregate(input, extra_input=extra_input)
-        # Compute correlation
-        if self.cor_method_params["empirical"]:
-            connectivity = ConnectivityMeasure(
-                cov_estimator=EmpiricalCovariance(),  # type: ignore
-                kind=self.cor_method,
-            )
+        # Set covariance estimator
+        if self.conn_method_params["empirical"]:
+            cov_estimator = EmpiricalCovariance(store_precision=False)
         else:
-            connectivity = ConnectivityMeasure(kind=self.cor_method)
+            cov_estimator = LedoitWolf(store_precision=False)
+        # Compute correlation
+        connectivity = JuniferConnectivityMeasure(
+            cov_estimator=cov_estimator,
+            kind=self.conn_method,
+            **{
+                k: v
+                for k, v in self.conn_method_params.items()
+                if k != "empirical"
+            },
+        )
         # Create dictionary for output
         return {
             "functional_connectivity": {

junifer/markers/functional_connectivity/functional_connectivity_parcels.py

@@ -22,28 +22,34 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
     Parameters
     ----------
     parcellation : str or list of str
-        The name(s) of the parcellation(s). Check valid options by calling
-        :func:`.list_parcellations`.
+        The name(s) of the parcellation(s) to use.
+        See :func:`.list_parcellations` for options.
     agg_method : str, optional
-        The method to perform aggregation using. Check valid options in
-        :func:`.get_aggfunc_by_name` (default "mean").
+        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. Check valid options in
-        :func:`.get_aggfunc_by_name` (default None).
-    cor_method : str, optional
-        The method to perform correlation using. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure`
-        (default "covariance").
-    cor_method_params : dict, optional
-        Parameters to pass to the correlation function. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
+        Parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options
+        (default None).
+    conn_method : str, optional
+        The method to perform connectivity measure using.
+        See :class:`.JuniferConnectivityMeasure` for options
+        (default "correlation").
+    conn_method_params : dict, optional
+        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+        If None, ``{"empirical": True}`` will be used, which would mean
+        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
+        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
+        desired, ``{"empirical": False}`` should be passed
+        (default None).
     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_FunctionalConnectivityParcels`` (default None).
 
     """
 
@@ -52,8 +58,8 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
         parcellation: Union[str, List[str]],
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -61,8 +67,8 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            cor_method=cor_method,
-            cor_method_params=cor_method_params,
+            conn_method=conn_method,
+            conn_method_params=conn_method_params,
             masks=masks,
             name=name,
         )

junifer/markers/functional_connectivity/functional_connectivity_spheres.py

@@ -23,35 +23,42 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
     Parameters
     ----------
     coords : str
-        The name of the coordinates list to use. See
-        :func:`.list_coordinates` for options.
-    radius : float, optional
-        The radius of the sphere in mm. If None, the signal will be extracted
-        from a single voxel. See :class:`nilearn.maskers.NiftiSpheresMasker`
-        for more information (default None).
+        The name of the coordinates list to use.
+        See :func:`.list_coordinates` for options.
+    radius : positive float, optional
+        The radius of the sphere around each coordinates in millimetres.
+        If None, the signal will be extracted from a single voxel.
+        See :class:`.JuniferNiftiSpheresMasker` for more information
+        (default None).
     allow_overlap : bool, optional
         Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default is False).
+        the spheres overlap (default False).
     agg_method : str, optional
-        The aggregation method to use.
-        See :func:`.get_aggfunc_by_name` for more information
-        (default None).
+        The method to perform aggregation using.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
     agg_method_params : dict, optional
-        The parameters to pass to the aggregation method (default None).
-    cor_method : str, optional
-        The method to perform correlation using. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default "covariance").
-    cor_method_params : dict, optional
-        Parameters to pass to the correlation function. Check valid options in
-        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
+        Parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options
+        (default None).
+    conn_method : str, optional
+        The method to perform connectivity measure using.
+        See :class:`.JuniferConnectivityMeasure` for options
+        (default "correlation").
+    conn_method_params : dict, optional
+        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+        If None, ``{"empirical": True}`` will be used, which would mean
+        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
+        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
+        desired, ``{"empirical": False}`` should be passed
+        (default None).
     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. By default, it will use
-        KIND_FunctionalConnectivitySpheres where KIND is the kind of data it
-        was applied to (default None).
+        The name of the marker. If None, will use
+        ``BOLD_FunctionalConnectivitySpheres`` (default None).
 
     """
 
@@ -62,8 +69,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         allow_overlap: bool = False,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -75,8 +82,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            cor_method=cor_method,
-            cor_method_params=cor_method_params,
+            conn_method=conn_method,
+            conn_method_params=conn_method_params,
             masks=masks,
             name=name,
         )

junifer/markers/functional_connectivity/tests/test_crossparcellation_functional_connectivity.py

@@ -27,7 +27,7 @@ def test_init() -> None:
         CrossParcellationFC(
             parcellation_one="a",
             parcellation_two="a",
-            correlation_method="pearson",
+            corr_method="pearson",
         )
 
 
@@ -58,7 +58,7 @@ def test_compute(tmp_path: Path) -> None:
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
-            correlation_method="spearman",
+            corr_method="spearman",
         )
         out = crossparcellation.compute(element_data["BOLD"])[
             "functional_connectivity"
@@ -86,7 +86,7 @@ def test_store(tmp_path: Path) -> None:
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
-            correlation_method="spearman",
+            corr_method="spearman",
         )
         storage = SQLiteFeatureStorage(
             uri=tmp_path / "test_crossparcellation.sqlite", upsert="ignore"

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -5,6 +5,9 @@
 # License: AGPL
 
 from pathlib import Path
+from typing import Dict
+
+import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCParcels
@@ -12,20 +15,35 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    "conn_method_params",
+    [
+        {"empirical": False},
+        {"empirical": True},
+    ],
+)
+def test_EdgeCentricFCParcels(
+    tmp_path: Path,
+    conn_method_params: Dict[str, bool],
+) -> None:
     """Test EdgeCentricFCParcels.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    conn_method_params : dict
+        The parametrized parameters to connectivity measure method.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
+        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        # Setup marker
         marker = EdgeCentricFCParcels(
             parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-            cor_method_params={"empirical": True},
+            conn_method="correlation",
+            conn_method_params=conn_method_params,
         )
         # Check correct output
         assert "matrix" == marker.get_output_type(
@@ -41,8 +59,7 @@ def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
         assert "data" in edge_fc_bold
         assert "row_names" in edge_fc_bold
         assert "col_names" in edge_fc_bold
-        assert edge_fc_bold["data"].shape[0] == n_edges
-        assert edge_fc_bold["data"].shape[1] == n_edges
+        assert edge_fc_bold["data"].shape == (n_edges, n_edges)
         assert len(set(edge_fc_bold["row_names"])) == n_edges
         assert len(set(edge_fc_bold["col_names"])) == n_edges