junifer 0.0.5.dev240__py3-none-any.whl → 0.0.6__py3-none-any.whl

junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -5,11 +5,12 @@
 
 
 from abc import abstractmethod
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Any, ClassVar, Optional, Union
 
 from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
 from ...external.nilearn import JuniferConnectivityMeasure
+from ...typing import Dependencies, MarkerInOutMappings
 from ...utils import raise_error
 from ..base import BaseMarker
 
@@ -51,9 +52,9 @@ class FunctionalConnectivityBase(BaseMarker):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "scikit-learn"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn", "scikit-learn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "functional_connectivity": "matrix",
         },
@@ -62,10 +63,10 @@ class FunctionalConnectivityBase(BaseMarker):
     def __init__(
         self,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_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,
+        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
@@ -82,9 +83,9 @@ class FunctionalConnectivityBase(BaseMarker):
     @abstractmethod
     def aggregate(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
+        input: dict[str, Any],
+        extra_input: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         """Perform aggregation."""
         raise_error(
             msg="Concrete classes need to implement aggregate().",
@@ -93,9 +94,9 @@ class FunctionalConnectivityBase(BaseMarker):
 
     def compute(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict] = None,
-    ) -> Dict:
+        input: dict[str, Any],
+        extra_input: Optional[dict] = None,
+    ) -> dict:
         """Compute.
 
         Parameters

junifer/markers/functional_connectivity/functional_connectivity_parcels.py

@@ -5,7 +5,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ..parcel_aggregation import ParcelAggregation
@@ -23,7 +23,7 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
     ----------
     parcellation : str or list of str
         The name(s) of the parcellation(s) to use.
-        See :func:`.list_parcellations` for options.
+        See :func:`.list_data` for options.
     agg_method : str, optional
         The method to perform aggregation using.
         See :func:`.get_aggfunc_by_name` for options
@@ -55,12 +55,12 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
 
     def __init__(
         self,
-        parcellation: Union[str, List[str]],
+        parcellation: Union[str, list[str]],
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_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,
+        conn_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.parcellation = parcellation
@@ -74,8 +74,8 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
         )
 
     def aggregate(
-        self, input: Dict[str, Any], extra_input: Optional[Dict] = None
-    ) -> Dict:
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
         """Perform parcel aggregation.
 
         Parameters

junifer/markers/functional_connectivity/functional_connectivity_spheres.py

@@ -5,7 +5,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ..sphere_aggregation import SphereAggregation
@@ -24,7 +24,7 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
     ----------
     coords : str
         The name of the coordinates list to use.
-        See :func:`.list_coordinates` for options.
+        See :func:`.list_data` 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.
@@ -68,10 +68,10 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         radius: Optional[float] = None,
         allow_overlap: bool = False,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_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,
+        conn_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.coords = coords
@@ -89,8 +89,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         )
 
     def aggregate(
-        self, input: Dict[str, Any], extra_input: Optional[Dict] = None
-    ) -> Dict:
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
         """Perform sphere aggregation.
 
         Parameters

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -5,7 +5,6 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict
 
 import pytest
 
@@ -24,7 +23,7 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 )
 def test_EdgeCentricFCParcels(
     tmp_path: Path,
-    conn_method_params: Dict[str, bool],
+    conn_method_params: dict[str, bool],
 ) -> None:
     """Test EdgeCentricFCParcels.
 

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_spheres.py

@@ -5,7 +5,6 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict
 
 import pytest
 
@@ -24,7 +23,7 @@ from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 )
 def test_EdgeCentricFCSpheres(
     tmp_path: Path,
-    conn_method_params: Dict[str, bool],
+    conn_method_params: dict[str, bool],
 ) -> None:
     """Test EdgeCentricFCSpheres.
 

junifer/markers/functional_connectivity/tests/test_functional_connectivity_parcels.py

@@ -6,7 +6,7 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING
 
 import pytest
 from nilearn.connectome import ConnectivityMeasure
@@ -14,7 +14,7 @@ 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.data import ParcellationRegistry
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import (
     FunctionalConnectivityParcels,
@@ -36,8 +36,8 @@ if TYPE_CHECKING:
 )
 def test_FunctionalConnectivityParcels(
     tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-    cov_estimator: Type["BaseEstimator"],
+    conn_method_params: dict[str, bool],
+    cov_estimator: type["BaseEstimator"],
 ) -> None:
     """Test FunctionalConnectivityParcels.
 
@@ -78,8 +78,8 @@ def test_FunctionalConnectivityParcels(
 
         # Compare with nilearn
         # Load testing parcellation for the target data
-        testing_parcellation, _ = get_parcellation(
-            parcellation=["TianxS1x3TxMNInonlinear2009cAsym"],
+        testing_parcellation, _ = ParcellationRegistry().get(
+            parcellations=["TianxS1x3TxMNInonlinear2009cAsym"],
             target_data=element_data["BOLD"],
         )
         # Extract timeseries

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -7,7 +7,7 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING
 
 import pytest
 from nilearn.connectome import ConnectivityMeasure
@@ -15,7 +15,7 @@ from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_almost_equal
 from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
-from junifer.data import get_coordinates
+from junifer.data import CoordinatesRegistry
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import (
     FunctionalConnectivitySpheres,
@@ -37,8 +37,8 @@ if TYPE_CHECKING:
 )
 def test_FunctionalConnectivitySpheres(
     tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-    cov_estimator: Type["BaseEstimator"],
+    conn_method_params: dict[str, bool],
+    cov_estimator: type["BaseEstimator"],
 ) -> None:
     """Test FunctionalConnectivitySpheres.
 
@@ -80,7 +80,7 @@ def test_FunctionalConnectivitySpheres(
 
         # Compare with nilearn
         # Load testing coordinates for the target data
-        testing_coords, _ = get_coordinates(
+        testing_coords, _ = CoordinatesRegistry().get(
             coords="DMNBuckner", target_data=element_data["BOLD"]
         )
         # Extract timeseries

junifer/markers/parcel_aggregation.py

@@ -4,15 +4,16 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Any, ClassVar, Optional, Union
 
 import numpy as np
 from nilearn.image import math_img
 from nilearn.maskers import NiftiMasker
 
 from ..api.decorators import register_marker
-from ..data import get_mask, get_parcellation
+from ..data import get_data
 from ..stats import get_aggfunc_by_name
+from ..typing import Dependencies, MarkerInOutMappings
 from ..utils import logger, raise_error, warn_with_log
 from .base import BaseMarker
 
@@ -27,8 +28,8 @@ class ParcelAggregation(BaseMarker):
     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_data` for options.
     method : str
         The method to perform aggregation using. Check valid options in
         :func:`.get_aggfunc_by_name`.
@@ -61,9 +62,9 @@ class ParcelAggregation(BaseMarker):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "numpy"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn", "numpy"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "T1w": {
             "aggregation": "vector",
         },
@@ -95,13 +96,13 @@ class ParcelAggregation(BaseMarker):
 
     def __init__(
         self,
-        parcellation: Union[str, List[str]],
+        parcellation: Union[str, list[str]],
         method: str,
-        method_params: Optional[Dict[str, Any]] = None,
+        method_params: Optional[dict[str, Any]] = None,
         time_method: Optional[str] = None,
-        time_method_params: Optional[Dict[str, Any]] = None,
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
-        on: Union[List[str], str, None] = None,
+        time_method_params: Optional[dict[str, Any]] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
+        on: Union[list[str], str, None] = None,
         name: Optional[str] = None,
     ) -> None:
         if not isinstance(parcellation, list):
@@ -127,8 +128,8 @@ class ParcelAggregation(BaseMarker):
         self.time_method_params = time_method_params or {}
 
     def compute(
-        self, input: Dict[str, Any], extra_input: Optional[Dict] = None
-    ) -> Dict:
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
         """Compute.
 
         Parameters
@@ -168,8 +169,9 @@ class ParcelAggregation(BaseMarker):
         )
 
         # Get parcellation tailored to target image
-        parcellation_img, labels = get_parcellation(
-            parcellation=self.parcellation,
+        parcellation_img, labels = get_data(
+            kind="parcellation",
+            names=self.parcellation,
             target_data=input,
             extra_input=extra_input,
         )
@@ -183,8 +185,11 @@ class ParcelAggregation(BaseMarker):
         if self.masks is not None:
             logger.debug(f"Masking with {self.masks}")
             # Get tailored mask
-            mask_img = get_mask(
-                masks=self.masks, target_data=input, extra_input=extra_input
+            mask_img = get_data(
+                kind="mask",
+                names=self.masks,
+                target_data=input,
+                extra_input=extra_input,
             )
             # Get "logical and" version of parcellation and mask
             parcellation_bin = math_img(

junifer/markers/reho/__init__.py

@@ -3,8 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from .reho_parcels import ReHoParcels
-from .reho_spheres import ReHoSpheres
+import lazy_loader as lazy
 
 
-__all__ = ["ReHoParcels", "ReHoSpheres"]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/markers/reho/__init__.pyi

@@ -0,0 +1,4 @@
+__all__ = ["ReHoParcels", "ReHoSpheres"]
+
+from .reho_parcels import ReHoParcels
+from .reho_spheres import ReHoSpheres

junifer/markers/reho/_afni_reho.py

@@ -8,29 +8,25 @@ from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Tuple,
-    Union,
 )
 
 import nibabel as nib
 
 from ...pipeline import WorkDirManager
-from ...pipeline.singleton import singleton
+from ...typing import ExternalDependencies
 from ...utils import logger, run_ext_cmd
+from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["AFNIReHo"]
 
 
-@singleton
-class AFNIReHo:
+class AFNIReHo(metaclass=Singleton):
     """Class for computing ReHo using AFNI.
 
     This class uses AFNI's 3dReHo to compute ReHo. It's designed as a singleton
@@ -38,7 +34,7 @@ class AFNIReHo:
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "afni",
             "commands": ["3dReHo", "3dAFNItoNIFTI"],
@@ -54,7 +50,7 @@ class AFNIReHo:
     @lru_cache(maxsize=None, typed=True)
     def compute(
         self,
-        data: "Nifti1Image",
+        input_path: Path,
         nneigh: int = 27,
         neigh_rad: Optional[float] = None,
         neigh_x: Optional[float] = None,
@@ -64,13 +60,13 @@ class AFNIReHo:
         box_x: Optional[int] = None,
         box_y: Optional[int] = None,
         box_z: Optional[int] = None,
-    ) -> Tuple["Nifti1Image", Path]:
+    ) -> tuple["Nifti1Image", Path]:
         """Compute ReHo map.
 
         Parameters
         ----------
-        data : 4D Niimg-like object
-            Images to process.
+        input_path : pathlib.Path
+            Path to the input data.
         nneigh : {7, 19, 27}, optional
             Number of voxels in the neighbourhood, inclusive. Can be:
 
@@ -132,19 +128,17 @@ class AFNIReHo:
         """
         logger.debug("Creating cache for ReHo computation via AFNI")
 
-        # Create component-scoped tempdir
-        tempdir = WorkDirManager().get_tempdir(prefix="afni_reho")
-
-        # Save target data to a component-scoped tempfile
-        nifti_in_file_path = tempdir / "input.nii"  # needs to be .nii
-        nib.save(data, nifti_in_file_path)
+        # Create element-scoped tempdir
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="afni_reho"
+        )
 
         # Set 3dReHo command
-        reho_out_path_prefix = tempdir / "reho"
+        reho_out_path_prefix = element_tempdir / "output"
         reho_cmd = [
             "3dReHo",
             f"-prefix {reho_out_path_prefix.resolve()}",
-            f"-inset {nifti_in_file_path.resolve()}",
+            f"-inset {input_path.resolve()}",
         ]
         # Check ellipsoidal / cuboidal volume arguments
         if neigh_rad:
@@ -168,28 +162,28 @@ class AFNIReHo:
         # Call 3dReHo
         run_ext_cmd(name="3dReHo", cmd=reho_cmd)
 
-        # Create element-scoped tempdir so that the ReHo map is
-        # available later as nibabel stores file path reference for
-        # loading on computation
-        element_tempdir = WorkDirManager().get_element_tempdir(
-            prefix="afni_reho"
-        )
+        # Read header to get output suffix
+        niimg = nib.load(input_path)
+        header = niimg.header
+        sform_code = header.get_sform(coded=True)[1]
+        if sform_code == 4:
+            output_suffix = "tlrc"
+        else:
+            output_suffix = "orig"
+
         # Convert afni to nifti
-        reho_afni_to_nifti_out_path = (
+        reho_nifti_out_path = (
             element_tempdir / "output.nii"  # needs to be .nii
         )
         convert_cmd = [
             "3dAFNItoNIFTI",
-            f"-prefix {reho_afni_to_nifti_out_path.resolve()}",
-            f"{reho_out_path_prefix}+orig.BRIK",
+            f"-prefix {reho_nifti_out_path.resolve()}",
+            f"{reho_out_path_prefix}+{output_suffix}.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_cmd)
 
         # Load nifti
-        output_data = nib.load(reho_afni_to_nifti_out_path)
-
-        # Delete tempdir
-        WorkDirManager().delete_tempdir(tempdir)
+        output_data = nib.load(reho_nifti_out_path)
 
-        return output_data, reho_afni_to_nifti_out_path  # type: ignore
+        return output_data, reho_nifti_out_path

junifer/markers/reho/_junifer_reho.py

@@ -9,8 +9,6 @@ from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     ClassVar,
-    Set,
-    Tuple,
 )
 
 import nibabel as nib
@@ -20,26 +18,26 @@ from nilearn import image as nimg
 from nilearn import masking as nmask
 
 from ...pipeline import WorkDirManager
-from ...pipeline.singleton import singleton
+from ...typing import Dependencies
 from ...utils import logger, raise_error
+from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["JuniferReHo"]
 
 
-@singleton
-class JuniferReHo:
+class JuniferReHo(metaclass=Singleton):
     """Class for computing ReHo using junifer.
 
     It's designed as a singleton with caching for efficient computation.
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"numpy", "nilearn", "scipy"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"numpy", "nilearn", "scipy"}
 
     def __del__(self) -> None:
         """Terminate the class."""
@@ -50,15 +48,15 @@ class JuniferReHo:
     @lru_cache(maxsize=None, typed=True)
     def compute(
         self,
-        data: "Nifti1Image",
+        input_path: Path,
         nneigh: int = 27,
-    ) -> Tuple["Nifti1Image", Path]:
+    ) -> tuple["Nifti1Image", Path]:
         """Compute ReHo map.
 
         Parameters
         ----------
-        data : 4D Niimg-like object
-            Images to process.
+        input_path : pathlib.Path
+            Path to the input data.
         nneigh : {7, 19, 27, 125}, optional
             Number of voxels in the neighbourhood, inclusive. Can be:
 
@@ -91,7 +89,8 @@ class JuniferReHo:
         logger.debug("Creating cache for ReHo computation via junifer")
 
         # Get scan data
-        niimg_data = data.get_fdata()
+        niimg = nib.load(input_path)
+        niimg_data = niimg.get_fdata().copy()
         # Get scan dimensions
         n_x, n_y, n_z, _ = niimg_data.shape
 
@@ -121,7 +120,7 @@ class JuniferReHo:
         # after #299 is merged
         # Calculate whole brain mask
         mni152_whole_brain_mask = nmask.compute_brain_mask(
-            target_img=data,
+            target_img=niimg,
             threshold=0.5,
             mask_type="whole-brain",
         )
@@ -229,7 +228,7 @@ class JuniferReHo:
 
         # Create new image like target image
         output_data = nimg.new_img_like(
-            ref_niimg=data,
+            ref_niimg=niimg,
             data=reho_map,
             copy_header=False,
         )

junifer/markers/reho/reho_base.py

@@ -9,14 +9,10 @@ from typing import (
     TYPE_CHECKING,
     Any,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Tuple,
-    Type,
-    Union,
 )
 
+from ...typing import ConditionalDependencies, MarkerInOutMappings
 from ...utils import logger, raise_error
 from ..base import BaseMarker
 from ._afni_reho import AFNIReHo
@@ -24,7 +20,7 @@ from ._junifer_reho import JuniferReHo
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 __all__ = ["ReHoBase"]
 
@@ -51,7 +47,7 @@ class ReHoBase(BaseMarker):
 
     """
 
-    _CONDITIONAL_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, Type]]]] = [
+    _CONDITIONAL_DEPENDENCIES: ClassVar[ConditionalDependencies] = [
         {
             "using": "afni",
             "depends_on": AFNIReHo,
@@ -62,7 +58,7 @@ class ReHoBase(BaseMarker):
         },
     ]
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "reho": "vector",
         },
@@ -84,9 +80,9 @@ class ReHoBase(BaseMarker):
 
     def _compute(
         self,
-        input_data: Dict[str, Any],
+        input_data: dict[str, Any],
         **reho_params: Any,
-    ) -> Tuple["Nifti1Image", Path]:
+    ) -> tuple["Nifti1Image", Path]:
         """Compute voxel-wise ReHo.
 
         Calculates Kendall's W per voxel using neighborhood voxels.
@@ -129,7 +125,7 @@ class ReHoBase(BaseMarker):
             estimator = JuniferReHo()
         # Compute reho
         reho_map, reho_map_path = estimator.compute(  # type: ignore
-            data=input_data["data"],
+            input_path=input_data["path"],
             **reho_params,
         )