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

junifer/datareader/default.py

@@ -5,7 +5,7 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 import nibabel as nib
 import pandas as pd
@@ -15,6 +15,9 @@ from ..pipeline import PipelineStepMixin, UpdateMetaMixin
 from ..utils.logging import logger, warn_with_log
 
 
+__all__ = ["DefaultDataReader"]
+
+
 # Map each file extension to a type
 _extensions = {
     ".nii": "NIFTI",
@@ -102,57 +105,106 @@ class DefaultDataReader(PipelineStepMixin, UpdateMetaMixin):
         if params is None:
             params = {}
         # For each type of data, try to read it
-        for type_ in input.keys():
-            # Skip Warp data type
-            if type_ == "Warp":
+        for type_key, type_val in input.items():
+            # Skip Warp and FreeSurfer data type
+            if type_key in ["Warp", "FreeSurfer"]:
                 continue
 
             # Check for malformed datagrabber specification
-            if "path" not in input[type_]:
+            if "path" not in type_val:
                 warn_with_log(
-                    f"Input type {type_} does not provide a path. Skipping."
+                    f"Input type {type_key} does not provide a path. Skipping."
                 )
                 continue
 
-            # Retrieve actual path
-            t_path = input[type_]["path"]
-            # Retrieve loading params for the data type
-            t_params = params.get(type_, {})
-
-            # Convert str to Path
-            if not isinstance(t_path, Path):
-                t_path = Path(t_path)
-                out[type_]["path"] = t_path
-
-            logger.info(f"Reading {type_} from {t_path.as_posix()}")
-            # Initialize variable for file data
-            fread = None
-            # Lowercase path
-            fname = t_path.name.lower()
-            # Loop through extensions to find the correct one
-            for ext, ftype in _extensions.items():
-                if fname.endswith(ext):
-                    logger.info(f"{type_} is type {ftype}")
-                    # Retrieve reader function
-                    reader_func = _readers[ftype]["func"]
-                    # Retrieve reader function params
-                    reader_params = _readers[ftype]["params"]
-                    # Update reader function params
-                    if reader_params is not None:
-                        t_params.update(reader_params)
-                    logger.debug(f"Calling {reader_func} with {t_params}")
+            # Iterate to check for nested "types" like mask;
+            # need to copy to avoid runtime error for changing dict size
+            for k, v in type_val.copy().items():
+                # Read data for base data type
+                if k == "path":
+                    # Convert str to Path
+                    if not isinstance(v, Path):
+                        v = Path(v)
+                    # Update path
+                    out[type_key]["path"] = v
+                    logger.info(f"Reading {type_key} from {v.absolute()!s}")
+                    # Retrieve loading params for the data type
+                    t_params = params.get(type_key, {})
                     # Read data
-                    fread = reader_func(t_path, **t_params)
-                    break
-            # If no file data is found due to unknown extension
-            if fread is None:
-                logger.info(
-                    f"Unknown file type {t_path.as_posix()}, skipping reading"
-                )
+                    out[type_key]["data"] = _read_data(
+                        data_type=type_key, path=v, read_params=t_params
+                    )
+                # Read data for nested data type
+                if isinstance(v, dict) and "path" in v:
+                    # Set path
+                    nested_path = v["path"]
+                    # Convert str to Path
+                    if not isinstance(nested_path, Path):
+                        nested_path = Path(nested_path)
+                    # Update path
+                    out[type_key][k]["path"] = nested_path
+                    # Set nested type key for easier access
+                    nested_type = f"{type_key}.{k}"
+                    logger.info(
+                        f"Reading {nested_type} from "
+                        f"{nested_path.absolute()!s}"
+                    )
+                    # Retrieve loading params for the nested data type
+                    nested_params = params.get(nested_type, {})
+                    # Read data
+                    out[type_key][k]["data"] = _read_data(
+                        data_type=nested_type,
+                        path=nested_path,
+                        read_params=nested_params,
+                    )
 
-            # Set file data for output
-            out[type_]["data"] = fread
             # Update metadata for step
-            self.update_meta(out[type_], "datareader")
+            self.update_meta(out[type_key], "datareader")
 
         return out
+
+
+def _read_data(
+    data_type: str, path: Path, read_params: Dict
+) -> Union[nib.Nifti1Image, pd.DataFrame, None]:
+    """Read data for data type.
+
+    Parameters
+    ----------
+    data_type : str
+        The data type being read.
+    path : pathlib.Path
+        The path to read data from.
+    read_params : dict
+        Parameters for reader function.
+
+    Returns
+    -------
+    nibabel.Nifti1Image or pandas.DataFrame or pandas.TextFileReader or None
+        The data loaded in memory if file type is known else None.
+
+    """
+    # Initialize variable for file data
+    fread = None
+    # Lowercase path
+    fname = path.name.lower()
+    # Loop through extensions to find the correct one
+    for ext, ftype in _extensions.items():
+        if fname.endswith(ext):
+            logger.info(f"{data_type} is of type {ftype}")
+            # Retrieve reader function
+            reader_func = _readers[ftype]["func"]
+            # Retrieve reader function params
+            reader_params = _readers[ftype]["params"]
+            # Update reader function params
+            if reader_params is not None:
+                read_params.update(reader_params)
+            logger.debug(f"Calling {reader_func!s} with {read_params}")
+            # Read data
+            fread = reader_func(path, **read_params)
+            break
+    # If no file data is found due to unknown extension
+    if fread is None:
+        logger.info(f"Unknown file type {path.absolute()!s}, skipping reading")
+
+    return fread

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