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

junifer/markers/parcel_aggregation.py

@@ -17,6 +17,9 @@ from ..utils import logger, raise_error, warn_with_log
 from .base import BaseMarker
 
 
+__all__ = ["ParcelAggregation"]
+
+
 @register_marker
 class ParcelAggregation(BaseMarker):
     """Class for parcel aggregation.
@@ -60,6 +63,36 @@ 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]],
@@ -93,61 +126,6 @@ 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:
@@ -171,8 +149,10 @@ 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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         Warns
         -----
@@ -195,7 +175,9 @@ class ParcelAggregation(BaseMarker):
         )
 
         # Get binarized parcellation image for masking
-        parcellation_bin = math_img("img != 0", img=parcellation_img)
+        parcellation_bin = math_img(
+            "np.squeeze(img) != 0", img=parcellation_img
+        )
 
         # Load mask
         if self.masks is not None:
@@ -206,7 +188,7 @@ class ParcelAggregation(BaseMarker):
             )
             # Get "logical and" version of parcellation and mask
             parcellation_bin = math_img(
-                "np.logical_and(img, mask)",
+                "np.logical_and(img, np.squeeze(mask))",
                 img=parcellation_bin,
                 mask=mask_img,
             )
@@ -248,5 +230,9 @@ class ParcelAggregation(BaseMarker):
                     "available."
                 )
         # Format the output
-        out = {"data": out_values, "col_names": labels}
-        return out
+        return {
+            "aggregation": {
+                "data": out_values,
+                "col_names": labels,
+            },
+        }

junifer/markers/reho/__init__.py

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

junifer/markers/reho/_afni_reho.py

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

junifer/markers/reho/_junifer_reho.py

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

junifer/markers/reho/reho_base.py

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

junifer/markers/reho/reho_spheres.py

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

junifer/markers/reho/tests/test_reho_parcels.py

@@ -42,6 +42,11 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
                 parcellation="TianxS1x3TxMNInonlinear2009cAsym",
                 using="junifer",
             )
+            # Check correct output
+            assert "vector" == marker.get_output_type(
+                input_type="BOLD", output_feature="reho"
+            )
+
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
@@ -49,7 +54,7 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            output_bold = output["BOLD"]
+            output_bold = output["BOLD"]["reho"]
             # Assert BOLD output keys
             assert "data" in output_bold
             assert "col_names" in output_bold
@@ -102,14 +107,14 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
         # Get BOLD output
-        junifer_output_bold = junifer_output["BOLD"]
+        junifer_output_bold = junifer_output["BOLD"]["reho"]
 
         # Initialize marker
         afni_marker = ReHoParcels(parcellation="Schaefer100x7", using="afni")
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
-        afni_output_bold = afni_output["BOLD"]
+        afni_output_bold = afni_output["BOLD"]["reho"]
 
         # Check for Pearson correlation coefficient
         r, _ = sp.stats.pearsonr(

junifer/markers/reho/tests/test_reho_spheres.py

@@ -40,6 +40,11 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             marker = ReHoSpheres(
                 coords=COORDINATES, using="junifer", radius=10.0
             )
+            # Check correct output
+            assert "vector" == marker.get_output_type(
+                input_type="BOLD", output_feature="reho"
+            )
+
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
@@ -47,7 +52,7 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            output_bold = output["BOLD"]
+            output_bold = output["BOLD"]["reho"]
             # Assert BOLD output keys
             assert "data" in output_bold
             assert "col_names" in output_bold
@@ -99,7 +104,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
         # Get BOLD output
-        junifer_output_bold = junifer_output["BOLD"]
+        junifer_output_bold = junifer_output["BOLD"]["reho"]
 
         # Initialize marker
         afni_marker = ReHoSpheres(
@@ -110,7 +115,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
-        afni_output_bold = afni_output["BOLD"]
+        afni_output_bold = afni_output["BOLD"]["reho"]
 
         # Check for Pearson correlation coefficient
         r, _ = sp.stats.pearsonr(

junifer/markers/sphere_aggregation.py

@@ -14,6 +14,9 @@ from ..utils import logger, raise_error, warn_with_log
 from .base import BaseMarker
 
 
+__all__ = ["SphereAggregation"]
+
+
 @register_marker
 class SphereAggregation(BaseMarker):
     """Class for sphere aggregation.
@@ -65,6 +68,36 @@ class SphereAggregation(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,
         coords: str,
@@ -100,61 +133,6 @@ class SphereAggregation(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],
@@ -180,8 +158,10 @@ class SphereAggregation(BaseMarker):
             to the user or stored in the storage by calling the store method
             with this as a parameter. The dictionary has the following keys:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         Warns
         -----
@@ -238,5 +218,9 @@ class SphereAggregation(BaseMarker):
                     "available."
                 )
         # Format the output
-        out = {"data": out_values, "col_names": labels}
-        return out
+        return {
+            "aggregation": {
+                "data": out_values,
+                "col_names": labels,
+            },
+        }

junifer/markers/temporal_snr/__init__.py

@@ -5,3 +5,6 @@
 
 from .temporal_snr_parcels import TemporalSNRParcels
 from .temporal_snr_spheres import TemporalSNRSpheres
+
+
+__all__ = ["TemporalSNRParcels", "TemporalSNRSpheres"]