junifer 0.0.6.dev175__py3-none-any.whl → 0.0.6.dev201__py3-none-any.whl

junifer/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.6.dev175'
-__version_tuple__ = version_tuple = (0, 0, 6, 'dev175')
+__version__ = version = '0.0.6.dev201'
+__version_tuple__ = version_tuple = (0, 0, 6, 'dev201')

junifer/data/__init__.pyi

@@ -1,41 +1,27 @@
 __all__ = [
-    "list_coordinates",
-    "load_coordinates",
-    "register_coordinates",
-    "get_coordinates",
-    "list_parcellations",
-    "load_parcellation",
-    "register_parcellation",
-    "merge_parcellations",
-    "get_parcellation",
-    "list_masks",
-    "load_mask",
-    "register_mask",
-    "get_mask",
+    "CoordinatesRegistry",
+    "ParcellationRegistry",
+    "MaskRegistry",
+    "get_data",
+    "list_data",
+    "load_data",
+    "register_data",
+    "deregister_data",
     "get_template",
     "get_xfm",
     "utils",
 ]
 
-from .coordinates import (
-    list_coordinates,
-    load_coordinates,
-    register_coordinates,
-    get_coordinates,
-)
-from .parcellations import (
-    list_parcellations,
-    load_parcellation,
-    register_parcellation,
-    merge_parcellations,
-    get_parcellation,
-)
+from .coordinates import CoordinatesRegistry
+from .parcellations import ParcellationRegistry
+from .masks import MaskRegistry
 
-from .masks import (
-    list_masks,
-    load_mask,
-    register_mask,
-    get_mask,
+from ._dispatch import (
+    get_data,
+    list_data,
+    load_data,
+    register_data,
+    deregister_data,
 )
 
 from .template_spaces import get_template, get_xfm

junifer/data/_dispatch.py

@@ -0,0 +1,251 @@
+"""Provide dispatch functions for pipeline data registries."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from numpy.typing import ArrayLike
+
+from ..utils import raise_error
+from .coordinates import CoordinatesRegistry
+from .masks import MaskRegistry
+from .parcellations import ParcellationRegistry
+
+
+if TYPE_CHECKING:
+    from nibabel.nifti1 import Nifti1Image
+
+
+__all__ = [
+    "get_data",
+    "list_data",
+    "load_data",
+    "register_data",
+    "deregister_data",
+]
+
+
+def get_data(
+    kind: str,
+    names: Union[
+        str,  # coordinates, parcellation, mask
+        List[str],  # parcellation, mask
+        Dict,  # mask
+        List[Dict],  # mask
+    ],
+    target_data: Dict[str, Any],
+    extra_input: Optional[Dict[str, Any]] = None,
+) -> Union[
+    Tuple[ArrayLike, List[str]],  # coordinates
+    Tuple["Nifti1Image", List[str]],  # parcellation
+    "Nifti1Image",  # mask
+]:
+    """Get tailored ``kind`` for ``target_data``.
+
+    Parameters
+    ----------
+    kind : {"coordinates", "parcellation", "mask"}
+        Kind of data to fetch and apply.
+    names : str or dict or list of str / dict
+        The registered name(s) of the data.
+    target_data : dict
+        The corresponding item of the data object to which the data
+        will be applied.
+    extra_input : dict, optional
+        The other fields in the data object. Useful for accessing other
+        data types that need to be used in the computation of data
+        (default None).
+
+    Returns
+    -------
+    tuple of numpy.ndarray, list of str; \
+    tuple of nibabel.nifti1.Nifti1Image, list of str; \
+    nibabel.nifti1.Nifti1Image
+
+    Raises
+    ------
+    ValueError
+        If ``kind`` is invalid value.
+
+    """
+
+    if kind == "coordinates":
+        return CoordinatesRegistry().get(
+            coords=names,
+            target_data=target_data,
+            extra_input=extra_input,
+        )
+    elif kind == "parcellation":
+        return ParcellationRegistry().get(
+            parcellations=names,
+            target_data=target_data,
+            extra_input=extra_input,
+        )
+    elif kind == "mask":
+        return MaskRegistry().get(
+            masks=names,
+            target_data=target_data,
+            extra_input=extra_input,
+        )
+    else:
+        raise_error(f"Unknown data kind: {kind}")
+
+
+def list_data(kind: str) -> List[str]:
+    """List available data for ``kind``.
+
+    Parameters
+    ----------
+    kind : {"coordinates", "parcellation", "mask"}
+        Kind of data registry to list.
+
+    Returns
+    -------
+    list of str
+        Available data for the registry.
+
+    Raises
+    ------
+    ValueError
+        If ``kind`` is invalid value.
+
+    """
+
+    if kind == "coordinates":
+        return CoordinatesRegistry().list
+    elif kind == "parcellation":
+        return ParcellationRegistry().list
+    elif kind == "mask":
+        return MaskRegistry().list
+    else:
+        raise_error(f"Unknown data kind: {kind}")
+
+
+def load_data(
+    kind: str,
+    name: str,
+    **kwargs,
+) -> Union[
+    Tuple[ArrayLike, List[str], str],  # coordinates
+    Tuple[Optional["Nifti1Image"], List[str], Path, str],  # parcellation
+    Tuple[
+        Optional[Union["Nifti1Image", Callable]], Optional[Path], str
+    ],  # mask
+]:
+    """Load ``kind`` named ``name``.
+
+    Parameters
+    ----------
+    kind : {"coordinates", "parcellation", "mask"}
+        Kind of data to load.
+    name : str
+        The registered name of the data.
+    **kwargs
+        Keyword arguments are passed to respective registry class method.
+
+    Returns
+    -------
+    tuple of numpy.ndarray, list of str, str; \
+    tuple of nibabel.nifti1.Nifti1Image or None, \
+    list of str, pathlib.Path, str; \
+    tuple of nibabel.nifti1.Nifti1Image or callable or None, \
+    pathlib.Path or None, str
+
+    Raises
+    ------
+    ValueError
+        If ``kind`` is invalid value.
+
+    """
+
+    if kind == "coordinates":
+        return CoordinatesRegistry().load(name=name)
+    elif kind == "parcellation":
+        return ParcellationRegistry().load(name=name, **kwargs)
+    elif kind == "mask":
+        return MaskRegistry().load(name=name, **kwargs)
+    else:
+        raise_error(f"Unknown data kind: {kind}")
+
+
+def register_data(
+    kind: str,
+    name: str,
+    space: str,
+    overwrite: bool = False,
+    **kwargs,
+) -> None:
+    """Register ``name`` under ``kind``.
+
+    Parameters
+    ----------
+    kind : {"coordinates", "parcellation", "mask"}
+        Kind of data to register.
+    name : str
+        The name to register.
+    space : str
+        The template space of the data.
+    overwrite : bool, optional
+        If True, overwrite an existing data with the same name.
+    **kwargs
+        Keyword arguments are passed to respective registry class method.
+
+    Raises
+    ------
+    ValueError
+        If ``kind`` is invalid value.
+
+    """
+
+    if kind == "coordinates":
+        return CoordinatesRegistry().register(
+            name=name, space=space, overwrite=overwrite, **kwargs
+        )
+    elif kind == "parcellation":
+        return ParcellationRegistry().register(
+            name=name, space=space, overwrite=overwrite, **kwargs
+        )
+    elif kind == "mask":
+        return MaskRegistry().load(
+            name=name, space=space, overwrite=overwrite, **kwargs
+        )
+    else:
+        raise_error(f"Unknown data kind: {kind}")
+
+
+def deregister_data(kind: str, name: str) -> None:
+    """De-register ``name`` from ``kind``.
+
+    Parameters
+    ----------
+    kind : {"coordinates", "parcellation", "mask"}
+        Kind of data to register.
+    name : str
+        The name to de-register.
+
+    Raises
+    ------
+    ValueError
+        If ``kind`` is invalid value.
+
+    """
+
+    if kind == "coordinates":
+        return CoordinatesRegistry().deregister(name=name)
+    elif kind == "parcellation":
+        return ParcellationRegistry().register(name=name)
+    elif kind == "mask":
+        return MaskRegistry().load(name=name)
+    else:
+        raise_error(f"Unknown data kind: {kind}")

junifer/data/coordinates/__init__.py

@@ -0,0 +1,9 @@
+"""Coordinates."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import lazy_loader as lazy
+
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/data/coordinates/__init__.pyi

@@ -0,0 +1,5 @@
+__all__ = [
+    "CoordinatesRegistry",
+]
+
+from ._coordinates import CoordinatesRegistry

junifer/data/coordinates/_ants_coordinates_warper.py

@@ -0,0 +1,96 @@
+"""Provide class for coordinates space warping via ANTs."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from typing import Any, Dict
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from ...pipeline import WorkDirManager
+from ...utils import logger, run_ext_cmd
+
+
+__all__ = ["ANTsCoordinatesWarper"]
+
+
+class ANTsCoordinatesWarper:
+    """Class for coordinates space warping via ANTs.
+
+    This class uses ANTs ``antsApplyTransformsToPoints`` for transformation.
+
+    """
+
+    def warp(
+        self,
+        seeds: ArrayLike,
+        target_data: Dict[str, Any],
+        extra_input: Dict[str, Any],
+    ) -> ArrayLike:
+        """Warp ``seeds`` to correct space.
+
+        Parameters
+        ----------
+        seeds : array-like
+            The coordinates to transform.
+        target_data : dict
+            The corresponding item of the data object to which the coordinates
+            will be applied.
+        extra_input : dict, optional
+            The other fields in the data object. Useful for accessing other
+            data kinds that needs to be used in the computation of coordinates
+            (default None).
+
+        Returns
+        -------
+        numpy.ndarray
+            The transformed coordinates.
+
+        """
+        logger.debug("Using ANTs for coordinates transformation")
+
+        # Create element-specific tempdir for storing post-warping assets
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="ants_coordinates_warper"
+        )
+
+        # Save existing coordinates to a tempfile
+        pretransform_coordinates_path = (
+            element_tempdir / "pretransform_coordinates.txt"
+        )
+        np.savetxt(
+            pretransform_coordinates_path,
+            seeds,
+            delimiter=",",
+            # Add header while saving to make ANTs work
+            header="x,y,z",
+        )
+
+        # Create a tempfile for transformed coordinates output
+        transformed_coords_path = (
+            element_tempdir / "coordinates_transformed.txt"
+        )
+        # Set antsApplyTransformsToPoints command
+        apply_transforms_to_points_cmd = [
+            "antsApplyTransformsToPoints",
+            "-d 3",
+            "-p 1",
+            "-f 0",
+            f"-i {pretransform_coordinates_path.resolve()}",
+            f"-o {transformed_coords_path.resolve()}",
+            f"-t {extra_input['Warp']['path'].resolve()};",
+        ]
+        # Call antsApplyTransformsToPoints
+        run_ext_cmd(
+            name="antsApplyTransformsToPoints",
+            cmd=apply_transforms_to_points_cmd,
+        )
+
+        # Load coordinates
+        return np.loadtxt(
+            # Skip header when reading
+            transformed_coords_path,
+            delimiter=",",
+            skiprows=1,
+        )