junifer 0.0.3.dev186__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -6,10 +6,10 @@
 
 from pathlib import Path
 
-from nilearn import datasets, image
-
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCParcels
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
 def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
@@ -21,40 +21,35 @@ def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    # Check empirical correlation method parameters
-    efc = EdgeCentricFCParcels(
-        parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-        cor_method_params={"empirical": True},
-    )
-    all_out = efc.fit_transform({"BOLD": {"data": fmri_img, "meta": {}}})
-
-    out = all_out["BOLD"]
-
-    # for 16 ROIs we should get (16 * (16 -1) / 2) edges in the ETS
-    n_edges = int(16 * (16 - 1) / 2)
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == n_edges
-    assert out["data"].shape[1] == n_edges
-    assert len(set(out["row_names"])) == n_edges
-    assert len(set(out["col_names"])) == n_edges
-
-    # check correct output
-    assert efc.get_output_type("BOLD") == "matrix"
-
-    uri = tmp_path / "test_fc_parcellation.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {"element": {"subject": "test"}, "dependencies": {"numpy"}}
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = efc.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_EdgeCentricFCParcels" for x in features.values()
-    )
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = EdgeCentricFCParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+            cor_method_params={"empirical": True},
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        edge_fc = marker.fit_transform(element_data)
+        edge_fc_bold = edge_fc["BOLD"]
+
+        # For 16 ROIs we should get (16 * (16 -1) / 2) edges in the ETS
+        n_edges = int(16 * (16 - 1) / 2)
+        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 len(set(edge_fc_bold["row_names"])) == n_edges
+        assert len(set(edge_fc_bold["col_names"])) == n_edges
+
+        # Store
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_edge_fc_parcels.sqlite", upsert="ignore"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_EdgeCentricFCParcels" for x in features.values()
+        )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_spheres.py

@@ -6,10 +6,10 @@
 
 from pathlib import Path
 
-from nilearn import datasets, image
-
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCSpheres
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
 def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
@@ -21,53 +21,41 @@ def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    efc = EdgeCentricFCSpheres(
-        coords="DMNBuckner", radius=5.0, cor_method="correlation"
-    )
-    all_out = efc.fit_transform({"BOLD": {"data": fmri_img, "meta": {}}})
-
-    out = all_out["BOLD"]
-
-    # There are six DMNBuckner coordinates, so
-    # for 6 ROIs we should get (6 * (6 -1) / 2) edges in the ETS
-    n_edges = int(6 * (6 - 1) / 2)
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == n_edges
-    assert out["data"].shape[1] == n_edges
-    assert len(set(out["row_names"])) == n_edges
-    assert len(set(out["col_names"])) == n_edges
-
-    # check correct output
-    assert efc.get_output_type("BOLD") == "matrix"
-
-    # Check empirical correlation method parameters
-    efc = EdgeCentricFCSpheres(
-        coords="DMNBuckner",
-        radius=5.0,
-        cor_method="correlation",
-        cor_method_params={"empirical": True},
-    )
-
-    meta = {
-        "element": {"subject": "sub001"},
-        "dependencies": {"nilearn"},
-    }
-    all_out = efc.fit_transform({"BOLD": {"data": fmri_img, "meta": meta}})
-
-    uri = tmp_path / "test_fc_parcellation.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {"element": {"subject": "test"}, "dependencies": {"numpy"}}
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = efc.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_EdgeCentricFCSpheres" for x in features.values()
-    )
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = EdgeCentricFCSpheres(
+            coords="DMNBuckner", radius=5.0, cor_method="correlation"
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        edge_fc = marker.fit_transform(element_data)
+        edge_fc_bold = edge_fc["BOLD"]
+
+        # There are six DMNBuckner coordinates, so
+        # for 6 ROIs we should get (6 * (6 -1) / 2) edges in the ETS
+        n_edges = int(6 * (6 - 1) / 2)
+        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 == (n_edges, n_edges)
+        assert len(set(edge_fc_bold["row_names"])) == n_edges
+        assert len(set(edge_fc_bold["col_names"])) == n_edges
+
+        # Check empirical correlation method parameters
+        marker = EdgeCentricFCSpheres(
+            coords="DMNBuckner",
+            radius=5.0,
+            cor_method="correlation",
+            cor_method_params={"empirical": True},
+        )
+        # Store
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_edge_fc_spheres.sqlite", upsert="ignore"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_EdgeCentricFCSpheres" for x in features.values()
+        )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_parcels.py

@@ -2,20 +2,22 @@
 
 # Authors: Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
-from nilearn import datasets, image
 from nilearn.connectome import ConnectivityMeasure
 from nilearn.maskers import NiftiLabelsMasker
-from numpy.testing import assert_array_almost_equal, assert_array_equal
+from numpy.testing import assert_array_almost_equal
 
+from junifer.data import get_parcellation
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import (
     FunctionalConnectivityParcels,
 )
-from junifer.markers.parcel_aggregation import ParcelAggregation
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
 def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
@@ -27,70 +29,60 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    fc = FunctionalConnectivityParcels(parcellation="Schaefer100x7")
-    all_out = fc.fit_transform({"BOLD": {"data": fmri_img, "meta": {}}})
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 100
-    assert out["data"].shape[1] == 100
-    assert len(set(out["row_names"])) == 100
-    assert len(set(out["col_names"])) == 100
-
-    # get the timeseries using pa
-    pa = ParcelAggregation(
-        parcellation="Schaefer100x7", method="mean", on="BOLD"
-    )
-    meta = {
-        "element": {"subject": "sub001"},
-        "dependencies": {"nilearn"},
-    }
-    ts = pa.compute({"data": fmri_img, "meta": meta})
-
-    # compare with nilearn
-    # Get the testing parcellation (for nilearn)
-    parcellation = datasets.fetch_atlas_schaefer_2018(
-        n_rois=100, yeo_networks=7, resolution_mm=2
-    )
-    masker = NiftiLabelsMasker(
-        labels_img=parcellation["maps"], standardize=False
-    )
-    ts_ni = masker.fit_transform(fmri_img)
-
-    # check the TS are almost equal
-    assert_array_equal(ts_ni, ts["data"])
-
-    # Check that FC are almost equal
-    cm = ConnectivityMeasure(kind="covariance")
-    out_ni = cm.fit_transform([ts_ni])[0]
-    assert_array_almost_equal(out_ni, out["data"], decimal=3)
-
-    # check correct output
-    assert fc.get_output_type("BOLD") == "matrix"
-
-    # Check empirical correlation method parameters
-    fc = FunctionalConnectivityParcels(
-        parcellation="Schaefer100x7", cor_method_params={"empirical": True}
-    )
-
-    all_out = fc.fit_transform({"BOLD": {"data": fmri_img, "meta": meta}})
-
-    uri = tmp_path / "test_fc_parcellation.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {"element": {"subject": "test"}, "dependencies": {"numpy"}}
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = fc.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_FunctionalConnectivityParcels"
-        for x in features.values()
-    )
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = FunctionalConnectivityParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        fc = marker.fit_transform(element_data)
+        fc_bold = fc["BOLD"]
+
+        assert "data" in fc_bold
+        assert "row_names" in fc_bold
+        assert "col_names" in fc_bold
+        assert fc_bold["data"].shape == (16, 16)
+        assert len(set(fc_bold["row_names"])) == 16
+        assert len(set(fc_bold["col_names"])) == 16
+
+        # Compare with nilearn
+        # Load testing parcellation for the target data
+        testing_parcellation, _ = get_parcellation(
+            parcellation=["TianxS1x3TxMNInonlinear2009cAsym"],
+            target_data=element_data["BOLD"],
+        )
+        # Extract timeseries
+        nifti_labels_masker = NiftiLabelsMasker(
+            labels_img=testing_parcellation, standardize=False
+        )
+        extracted_timeseries = nifti_labels_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        # Compute the connectivity measure
+        connectivity_measure = ConnectivityMeasure(
+            kind="covariance"
+        ).fit_transform([extracted_timeseries])[0]
+
+        # Check that FC are almost equal
+        assert_array_almost_equal(
+            connectivity_measure, fc_bold["data"], decimal=3
+        )
+
+        # Check empirical correlation method parameters
+        marker = FunctionalConnectivityParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+            cor_method_params={"empirical": True},
+        )
+        # Store
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_fc_parcels.sqlite", upsert="ignore"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_FunctionalConnectivityParcels"
+            for x in features.values()
+        )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -3,21 +3,24 @@
 # Authors: Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
 #          Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
 import pytest
-from nilearn import datasets, image
 from nilearn.connectome import ConnectivityMeasure
+from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_almost_equal
 from sklearn.covariance import EmpiricalCovariance
 
+from junifer.data import get_coordinates
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import (
     FunctionalConnectivitySpheres,
 )
-from junifer.markers.sphere_aggregation import SphereAggregation
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
 def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
@@ -29,54 +32,57 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    fc = FunctionalConnectivitySpheres(
-        coords="DMNBuckner", radius=5.0, cor_method="correlation"
-    )
-    all_out = fc.fit_transform({"BOLD": {"data": fmri_img, "meta": {}}})
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 6
-    assert out["data"].shape[1] == 6
-    assert len(set(out["row_names"])) == 6
-    assert len(set(out["col_names"])) == 6
-
-    # get the timeseries using sa
-    sa = SphereAggregation(
-        coords="DMNBuckner", radius=5.0, method="mean", on="BOLD"
-    )
-    ts = sa.compute({"data": fmri_img, "meta": {}})
-
-    # Check that FC are almost equal when using nileran
-    cm = ConnectivityMeasure(kind="correlation")
-    out_ni = cm.fit_transform([ts["data"]])[0]
-    assert_array_almost_equal(out_ni, out["data"], decimal=3)
-
-    # check correct output
-    assert fc.get_output_type("BOLD") == "matrix"
-
-    uri = tmp_path / "test_fc_parcel.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {
-        "element": {"subject": "test"},
-        "dependencies": {"numpy", "nilearn"},
-    }
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = fc.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_FunctionalConnectivitySpheres"
-        for x in features.values()
-    )
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = FunctionalConnectivitySpheres(
+            coords="DMNBuckner", radius=5.0, cor_method="correlation"
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        fc = marker.fit_transform(element_data)
+        fc_bold = fc["BOLD"]
+
+        assert "data" in fc_bold
+        assert "row_names" in fc_bold
+        assert "col_names" in fc_bold
+        assert fc_bold["data"].shape == (6, 6)
+        assert len(set(fc_bold["row_names"])) == 6
+        assert len(set(fc_bold["col_names"])) == 6
+
+        # Compare with nilearn
+        # Load testing coordinates for the target data
+        testing_coords, _ = get_coordinates(
+            coords="DMNBuckner", target_data=element_data["BOLD"]
+        )
+        # Extract timeseries
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=5.0
+        )
+        extracted_timeseries = nifti_spheres_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        # Compute the connectivity measure
+        connectivity_measure = ConnectivityMeasure(
+            kind="correlation"
+        ).fit_transform([extracted_timeseries])[0]
+
+        # Check that FC are almost equal
+        assert_array_almost_equal(
+            connectivity_measure, fc_bold["data"], decimal=3
+        )
+
+        # Store
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_fc_spheres.sqlite", upsert="ignore"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_FunctionalConnectivitySpheres"
+            for x in features.values()
+        )
 
 
 def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
@@ -88,41 +94,49 @@ def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    fc = FunctionalConnectivitySpheres(
-        coords="DMNBuckner",
-        radius=5.0,
-        cor_method="correlation",
-        cor_method_params={"empirical": True},
-    )
-    all_out = fc.fit_transform({"BOLD": {"data": fmri_img, "meta": {}}})
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 6
-    assert out["data"].shape[1] == 6
-    assert len(set(out["row_names"])) == 6
-    assert len(set(out["col_names"])) == 6
-
-    # get the timeseries using sa
-    sa = SphereAggregation(
-        coords="DMNBuckner", radius=5.0, method="mean", on="BOLD"
-    )
-    ts = sa.compute({"data": fmri_img})
-
-    # Check that FC are almost equal when using nileran
-    cm = ConnectivityMeasure(
-        cov_estimator=EmpiricalCovariance(), kind="correlation"  # type: ignore
-    )
-    out_ni = cm.fit_transform([ts["data"]])[0]
-    assert_array_almost_equal(out_ni, out["data"], decimal=3)
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = FunctionalConnectivitySpheres(
+            coords="DMNBuckner",
+            radius=5.0,
+            cor_method="correlation",
+            cor_method_params={"empirical": True},
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "matrix"
+
+        # Fit-transform the data
+        fc = marker.fit_transform(element_data)
+        fc_bold = fc["BOLD"]
+
+        assert "data" in fc_bold
+        assert "row_names" in fc_bold
+        assert "col_names" in fc_bold
+        assert fc_bold["data"].shape == (6, 6)
+        assert len(set(fc_bold["row_names"])) == 6
+        assert len(set(fc_bold["col_names"])) == 6
+
+        # Compare with nilearn
+        # Load testing coordinates for the target data
+        testing_coords, _ = get_coordinates(
+            coords="DMNBuckner", target_data=element_data["BOLD"]
+        )
+        # Extract timeseries
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=5.0
+        )
+        extracted_timeseries = nifti_spheres_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        # Compute the connectivity measure
+        connectivity_measure = ConnectivityMeasure(
+            cov_estimator=EmpiricalCovariance(), kind="correlation"  # type: ignore
+        ).fit_transform([extracted_timeseries])[0]
+
+        # Check that FC are almost equal
+        assert_array_almost_equal(
+            connectivity_measure, fc_bold["data"], decimal=3
+        )
 
 
 def test_FunctionalConnectivitySpheres_error() -> None: