junifer 0.0.4.dev733__py3-none-any.whl → 0.0.4.dev781__py3-none-any.whl

junifer/markers/falff/tests/test_falff_parcels.py

@@ -18,7 +18,7 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-PARCELLATION = "Schaefer100x7"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
 def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
@@ -59,7 +59,7 @@ def test_ALFFParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             output_bold_data = output_bold["data"]
             # Assert BOLD output data dimension
             assert output_bold_data.ndim == 2
-            assert output_bold_data.shape == (1, 100)
+            assert output_bold_data.shape == (1, 16)
 
             # Reset log capture
             caplog.clear()
@@ -123,4 +123,4 @@ def test_ALFFParcels_comparison(tmp_path: Path, fractional: bool) -> None:
             junifer_output_bold["data"][0],
             afni_output_bold["data"][0],
         )
-        assert r > 0.99
+        assert r > 0.97

junifer/markers/falff/tests/test_falff_spheres.py

@@ -82,14 +82,14 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
     "fractional", [True, False], ids=["fractional", "non-fractional"]
 )
 def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
-    """Test ALFFSpheres using afni.
+    """Test ALFFSpheres implementation comparison.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
-         The path to the test directory.
+        The path to the test directory.
     fractional : bool
-         Whether to compute fractional ALFF or not.
+        Whether to compute fractional ALFF or not.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:

junifer/markers/functional_connectivity/tests/test_crossparcellation_functional_connectivity.py

@@ -2,14 +2,17 @@
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
 import pytest
-from nilearn import image
 
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import CrossParcellationFC
+from junifer.pipeline import WorkDirManager
+from junifer.pipeline.utils import _check_ants
 from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
@@ -18,32 +21,53 @@ parcellation_one = "Schaefer100x17"
 parcellation_two = "Schaefer200x17"
 
 
-def test_compute() -> None:
-    """Test CrossParcellationFC compute()."""
+def test_init() -> None:
+    """Test CrossParcellationFC init()."""
+    with pytest.raises(ValueError, match="must be different"):
+        CrossParcellationFC(
+            parcellation_one="a",
+            parcellation_two="a",
+            correlation_method="pearson",
+        )
 
-    with SPMAuditoryTestingDataGrabber() as dg:
-        out = dg["sub001"]
-        niimg = image.load_img(str(out["BOLD"]["path"].absolute()))
-        input_dict = {
-            "BOLD": {
-                "data": niimg,
-                "path": out["BOLD"]["path"],
-                "meta": {"element": "sub001"},
-                "space": "MNI",
-            }
-        }
 
+def test_get_output_type() -> None:
+    """Test CrossParcellationFC get_output_type()."""
+    crossparcellation = CrossParcellationFC(
+        parcellation_one=parcellation_one, parcellation_two=parcellation_two
+    )
+    assert "matrix" == crossparcellation.get_output_type("BOLD")
+
+
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
+def test_compute(tmp_path: Path) -> None:
+    """Test CrossParcellationFC compute().
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        WorkDirManager().workdir = tmp_path
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
             correlation_method="spearman",
         )
-        out = crossparcellation.compute(input_dict["BOLD"])
+        out = crossparcellation.compute(element_data["BOLD"])
         assert out["data"].shape == (200, 100)
         assert len(out["col_names"]) == 100
         assert len(out["row_names"]) == 200
 
 
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
 def test_store(tmp_path: Path) -> None:
     """Test CrossParcellationFC store().
 
@@ -53,43 +77,20 @@ def test_store(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-
     with SPMAuditoryTestingDataGrabber() as dg:
-        input_dict = dg["sub001"]
-        niimg = image.load_img(str(input_dict["BOLD"]["path"].absolute()))
-
-        input_dict["BOLD"]["data"] = niimg
-
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        WorkDirManager().workdir = tmp_path
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
             correlation_method="spearman",
         )
-        uri = tmp_path / "test_crossparcellation.sqlite"
-        storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-        crossparcellation.fit_transform(input_dict, storage=storage)
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_crossparcellation.sqlite", upsert="ignore"
+        )
+        # Fit transform marker on data with storage
+        crossparcellation.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
             x["name"] == "BOLD_CrossParcellationFC" for x in features.values()
         )
-
-
-def test_get_output_type() -> None:
-    """Test CrossParcellationFC get_output_type()."""
-
-    crossparcellation = CrossParcellationFC(
-        parcellation_one=parcellation_one, parcellation_two=parcellation_two
-    )
-    input_ = "BOLD"
-    output = crossparcellation.get_output_type(input_)
-    assert output == "matrix"
-
-
-def test_init_() -> None:
-    """Test CrossParcellationFC init()."""
-    with pytest.raises(ValueError, match="must be different"):
-        CrossParcellationFC(
-            parcellation_one="a",
-            parcellation_two="a",
-            correlation_method="pearson",
-        )

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,42 +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": {}, "space": "MNI"}}
-    )
-
-    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, "space": "MNI"}}
-    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,57 +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": {}, "space": "MNI"}}
-    )
-
-    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, "space": "MNI"}}
-    )
-
-    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, "space": "MNI"}}
-    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,74 +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": {}, "space": "MNI"}}
-    )
-
-    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, "space": "MNI"})
-
-    # 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, "space": "MNI"}}
-    )
-
-    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, "space": "MNI"}}
-    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()
+        )