junifer 0.0.5.dev98__py3-none-any.whl → 0.0.5.dev131__py3-none-any.whl

junifer/datagrabber/aomic/tests/test_piop2.py

@@ -18,123 +18,67 @@ URI = "https://gin.g-node.org/juaml/datalad-example-aomicpiop2"
 
 
 @pytest.mark.parametrize(
-    "tasks",
-    [None, "restingstate"],
+    "type_, nested_types, tasks",
+    [
+        ("BOLD", ["confounds", "mask"], None),
+        ("BOLD", ["confounds", "mask"], ["restingstate"]),
+        ("BOLD", ["confounds", "mask"], ["restingstate", "stopsignal"]),
+        ("BOLD", ["confounds", "mask"], ["workingmemory", "stopsignal"]),
+        ("BOLD", ["confounds", "mask"], ["workingmemory"]),
+        ("T1w", ["mask"], None),
+        ("VBM_CSF", None, None),
+        ("VBM_GM", None, None),
+        ("VBM_WM", None, None),
+        ("DWI", None, None),
+        ("FreeSurfer", None, None),
+    ],
 )
-def test_DataladAOMICPIOP2(tasks: Optional[str]) -> None:
+def test_DataladAOMICPIOP2(
+    type_: str,
+    nested_types: Optional[List[str]],
+    tasks: Optional[List[str]],
+) -> None:
     """Test DataladAOMICPIOP2 DataGrabber.
 
     Parameters
     ----------
-    tasks : str or None
+    type_ : str
+        The parametrized type.
+    nested_types : list of str or None
+        The parametrized nested types.
+    tasks : list of str or None
         The parametrized task values.
 
     """
-    dg = DataladAOMICPIOP2(tasks=tasks)
+    dg = DataladAOMICPIOP2(types=type_, tasks=tasks)
     # Set URI to Gin
     dg.uri = URI
 
     with dg:
+        # Get all elements
         all_elements = dg.get_elements()
-
-        if tasks == "restingstate":
-            for el in all_elements:
-                assert el[1] == "restingstate"
-
+        # Get test element
         test_element = all_elements[0]
-        sub, task = test_element
+        # Get test element data
         out = dg[test_element]
-
-        # asserts type "BOLD"
-        assert "BOLD" in out
-
-        new_task = f"{task}_acq-seq"
-        assert (
-            out["BOLD"]["path"].name == f"{sub}_task-{new_task}_"
-            "space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz"
-        )
-
-        assert out["BOLD"]["path"].exists()
-        assert out["BOLD"]["path"].is_file()
-
-        # asserts type BOLD.confounds
-        assert "confounds" in out["BOLD"]
-
-        assert (
-            out["BOLD"]["confounds"]["path"].name == f"{sub}_task-{new_task}_"
-            "desc-confounds_regressors.tsv"
-        )
-
-        assert out["BOLD"]["confounds"]["path"].exists()
-        assert out["BOLD"]["confounds"]["path"].is_file()
-
-        # assert BOLD.mask
-        assert out["BOLD"]["mask"]["path"].exists()
-
-        # asserts type "T1w"
-        assert "T1w" in out
-
-        assert (
-            out["T1w"]["path"].name == f"{sub}_space-MNI152NLin2009cAsym_"
-            "desc-preproc_T1w.nii.gz"
-        )
-
-        assert out["T1w"]["path"].exists()
-        assert out["T1w"]["path"].is_file()
-
-        # asserts T1w.mask
-        assert out["T1w"]["mask"]["path"].exists()
-
-        # asserts type "VBM_CSF"
-        assert "VBM_CSF" in out
-
-        assert (
-            out["VBM_CSF"]["path"].name
-            == f"{sub}_space-MNI152NLin2009cAsym_label-"
-            "CSF_probseg.nii.gz"
-        )
-
-        assert out["VBM_CSF"]["path"].exists()
-        assert out["VBM_CSF"]["path"].is_file()
-
-        # asserts type "VBM_GM"
-        assert "VBM_GM" in out
-
-        assert (
-            out["VBM_GM"]["path"].name
-            == f"{sub}_space-MNI152NLin2009cAsym_label-"
-            "GM_probseg.nii.gz"
-        )
-
-        assert out["VBM_GM"]["path"].exists()
-        assert out["VBM_GM"]["path"].is_file()
-
-        # asserts type "VBM_WM"
-        assert "VBM_WM" in out
-
-        assert (
-            out["VBM_WM"]["path"].name
-            == f"{sub}_space-MNI152NLin2009cAsym_label-"
-            "WM_probseg.nii.gz"
-        )
-
-        assert out["VBM_WM"]["path"].exists()
-        assert out["VBM_WM"]["path"].is_file()
-
-        # asserts type "DWI"
-        assert "DWI" in out
-
-        assert out["DWI"]["path"].name == f"{sub}_desc-preproc_dwi.nii.gz"
-
-        assert out["DWI"]["path"].exists()
-        assert out["DWI"]["path"].is_file()
-
-        # asserts meta
-        assert "meta" in out["BOLD"]
-        meta = out["BOLD"]["meta"]
+        # Assert data type
+        assert type_ in out
+        # Check task name if BOLD
+        if type_ == "BOLD" and tasks is not None:
+            assert test_element[1] in out[type_]["path"].name
+        assert out[type_]["path"].exists()
+        assert out[type_]["path"].is_file()
+        # Asserts data type metadata
+        assert "meta" in out[type_]
+        meta = out[type_]["meta"]
         assert "element" in meta
         assert "subject" in meta["element"]
-        assert sub == meta["element"]["subject"]
+        assert test_element[0] == meta["element"]["subject"]
+        # Assert nested data type if not None
+        if nested_types is not None:
+            for nested_type in nested_types:
+                assert out[type_][nested_type]["path"].exists()
+                assert out[type_][nested_type]["path"].is_file()
 
 
 @pytest.mark.parametrize(

junifer/datagrabber/pattern.py

@@ -6,6 +6,7 @@
 # License: AGPL
 
 import re
+from copy import deepcopy
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -364,7 +365,7 @@ class PatternDataGrabber(BaseDataGrabber):
             # Data type dictionary
             t_pattern = self.patterns[t_type]
             # Copy data type dictionary in output
-            out[t_type] = t_pattern.copy()
+            out[t_type] = deepcopy(t_pattern)
             # Iterate to check for nested "types" like mask
             for k, v in t_pattern.items():
                 # Resolve pattern for base data type

junifer/datagrabber/utils.py

@@ -53,6 +53,17 @@ PATTERNS_SCHEMA = {
         "mandatory": ["pattern"],
         "optional": {},
     },
+    "FreeSurfer": {
+        "mandatory": ["pattern"],
+        "optional": {
+            "aseg": {"mandatory": ["pattern"], "optional": []},
+            "norm": {"mandatory": ["pattern"], "optional": []},
+            "lh_white": {"mandatory": ["pattern"], "optional": []},
+            "rh_white": {"mandatory": ["pattern"], "optional": []},
+            "lh_pial": {"mandatory": ["pattern"], "optional": []},
+            "rh_pial": {"mandatory": ["pattern"], "optional": []},
+        },
+    },
 }
 
 

junifer/datareader/default.py

@@ -103,8 +103,8 @@ class DefaultDataReader(PipelineStepMixin, UpdateMetaMixin):
             params = {}
         # For each type of data, try to read it
         for type_key, type_val in input.items():
-            # Skip Warp data type
-            if type_key == "Warp":
+            # Skip Warp and FreeSurfer data type
+            if type_key in ["Warp", "FreeSurfer"]:
                 continue
 
             # Check for malformed datagrabber specification

junifer/external/BrainPrint/brainprint/__init__.py

@@ -0,0 +1,4 @@
+from ._version import __version__  # noqa: F401
+from .brainprint import compute_asymmetry, compute_brainprint  # noqa: F401
+from .surfaces import surf_to_vtk  # noqa: F401
+from .utils._config import sys_info  # noqa: F401

junifer/external/BrainPrint/brainprint/_version.py

@@ -0,0 +1,3 @@
+"""Version number."""
+
+__version__ = "0.4.0"

junifer/external/BrainPrint/brainprint/asymmetry.py

@@ -0,0 +1,91 @@
+"""
+Contains asymmetry estimation functionality.
+"""
+from typing import Dict
+
+import numpy as np
+from lapy import shapedna
+
+
+def compute_asymmetry(
+    eigenvalues, distance: str = "euc", skip_cortex: bool = False
+) -> Dict[str, float]:
+    """
+    Compute lateral shape distances from BrainPrint analysis results.
+
+    Parameters
+    ----------
+    eigenvalues : _type_
+        BrainPrint analysis results.
+    distance : str, optional
+        ShapeDNA distance, by default "euc".
+    skip_cortex : bool, optional
+        Whether to skip white matter and pial surfaces, by default False.
+
+    Returns
+    -------
+    Dict[str, float]
+        {left_label}_{right_label}, distance.
+    """
+    # Define structures
+
+    # combined and individual aseg labels:
+    # - Left  Striatum: left  Caudate + Putamen + Accumbens
+    # - Right Striatum: right Caudate + Putamen + Accumbens
+    # - CorpusCallosum: 5 subregions combined
+    # - Cerebellum: brainstem + (left+right) cerebellum WM and GM
+    # - Ventricles: (left+right) lat.vent + inf.lat.vent + choroidplexus + 3rdVent + CSF
+    # - Lateral-Ventricle: lat.vent + inf.lat.vent + choroidplexus
+    # - 3rd-Ventricle: 3rd-Ventricle + CSF
+
+    structures_left_right = [
+        ("Left-Striatum", "Right-Striatum"),
+        ("Left-Lateral-Ventricle", "Right-Lateral-Ventricle"),
+        (
+            "Left-Cerebellum-White-Matter",
+            "Right-Cerebellum-White-Matter",
+        ),
+        ("Left-Cerebellum-Cortex", "Right-Cerebellum-Cortex"),
+        ("Left-Thalamus-Proper", "Right-Thalamus-Proper"),
+        ("Left-Caudate", "Right-Caudate"),
+        ("Left-Putamen", "Right-Putamen"),
+        ("Left-Pallidum", "Right-Pallidum"),
+        ("Left-Hippocampus", "Right-Hippocampus"),
+        ("Left-Amygdala", "Right-Amygdala"),
+        ("Left-Accumbens-area", "Right-Accumbens-area"),
+        ("Left-VentralDC", "Right-VentralDC"),
+    ]
+
+    cortex_2d_left_right = [
+        ("lh-white-2d", "rh-white-2d"),
+        ("lh-pial-2d", "rh-pial-2d"),
+    ]
+
+    structures = structures_left_right
+    if not skip_cortex:
+        structures += cortex_2d_left_right
+
+    distances = dict()
+    for left_label, right_label in structures:
+        left_eigenvalues, right_eigenvalues = (
+            eigenvalues[left_label][2:],
+            eigenvalues[right_label][2:],
+        )
+        has_nan = np.isnan(left_eigenvalues).any() or np.isnan(right_eigenvalues).any()
+        key = f"{left_label}_{right_label}"
+        if has_nan:
+            message = (
+                "NaNs found for {left_label} or {right_label}, "
+                "skipping asymmetry computation...".format(
+                    left_label=left_label, right_label=right_label
+                )
+            )
+            print(message)
+            distances[key] = np.nan
+        else:
+            distances[key] = shapedna.compute_distance(
+                left_eigenvalues,
+                right_eigenvalues,
+                dist=distance,
+            )
+    return distances