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

junifer/markers/parcel_aggregation.py

@@ -63,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]],
@@ -96,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:
@@ -174,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
         -----
@@ -253,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/reho_base.py

@@ -62,6 +62,12 @@ class ReHoBase(BaseMarker):
         },
     ]
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "reho": "vector",
+        },
+    }
+
     def __init__(
         self,
         using: str,
@@ -76,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

@@ -125,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")
@@ -145,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

@@ -140,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:
 
-            * ``data`` : the actual computed values as a 1D numpy.ndarray
-            * ``col_names`` : the column labels for the spheres 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 spheres")
@@ -160,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,
@@ -169,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

@@ -68,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,
@@ -103,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],
@@ -183,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
         -----
@@ -241,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/temporal_snr_base.py

@@ -39,6 +39,12 @@ class TemporalSNRBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "tsnr": "vector",
+        },
+    }
+
     def __init__(
         self,
         agg_method: str = "mean",
@@ -61,33 +67,6 @@ class TemporalSNRBase(BaseMarker):
             klass=NotImplementedError,
         )
 
-    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: Dict[str, Any],
@@ -107,11 +86,14 @@ class TemporalSNRBase(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. The following keys will be
-            included in the dictionary:
+            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:
+
+            * ``tsnr`` : dictionary with the following keys:
 
-            * ``data`` : the computed values as a ``numpy.ndarray``
-            * ``col_names`` : the column labels for the computed values as list
+              - ``data`` : computed tSNR as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         # Calculate voxelwise temporal signal-to-noise ratio in an image
@@ -129,4 +111,10 @@ class TemporalSNRBase(BaseMarker):
             mask_img=mask_img,
         )
         # Perform necessary aggregation and return
-        return self.aggregate(input=input, extra_input=extra_input)
+        return {
+            "tsnr": {
+                **self.aggregate(input=input, extra_input=extra_input)[
+                    "aggregation"
+                ]
+            }
+        }

junifer/markers/temporal_snr/temporal_snr_parcels.py

@@ -77,16 +77,16 @@ class TemporalSNRParcels(TemporalSNRBase):
             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`` : ROI-wise temporal SNR as a ``numpy.ndarray``
-            * ``col_names`` : the ROI labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        parcel_aggregation = ParcelAggregation(
+        return ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after parcel aggregation
-        return parcel_aggregation.compute(input=input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/temporal_snr_spheres.py

@@ -92,11 +92,13 @@ class TemporalSNRSpheres(TemporalSNRBase):
             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`` : VOI-wise temporal SNR as a ``numpy.ndarray``
-            * ``col_names`` : the VOI labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        sphere_aggregation = SphereAggregation(
+        return SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -104,6 +106,4 @@ class TemporalSNRSpheres(TemporalSNRBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after sphere aggregation
-        return sphere_aggregation.compute(input=input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -20,11 +20,13 @@ def test_TemporalSNRParcels_computation() -> None:
             parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_parcels = marker.fit_transform(element_data)
-        tsnr_parcels_bold = tsnr_parcels["BOLD"]
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
 
         assert "data" in tsnr_parcels_bold
         assert "col_names" in tsnr_parcels_bold
@@ -51,5 +53,6 @@ def test_TemporalSNRParcels_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRParcels_tsnr"
+            for x in features.values()
         )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -20,11 +20,13 @@ def test_TemporalSNRSpheres_computation() -> None:
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_spheres = marker.fit_transform(element_data)
-        tsnr_spheres_bold = tsnr_spheres["BOLD"]
+        tsnr_spheres_bold = tsnr_spheres["BOLD"]["tsnr"]
 
         assert "data" in tsnr_spheres_bold
         assert "col_names" in tsnr_spheres_bold
@@ -49,7 +51,8 @@ def test_TemporalSNRSpheres_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRSpheres_tsnr"
+            for x in features.values()
         )