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

junifer/data/template_spaces.py

@@ -0,0 +1,190 @@
+"""Provide functions for template spaces."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+import httpx
+import nibabel as nib
+import numpy as np
+from templateflow import api as tflow
+
+from ..utils import logger, raise_error
+from .utils import closest_resolution
+
+
+def get_xfm(
+    src: str, dst: str, xfms_dir: Union[str, Path, None] = None
+) -> Path:  # pragma: no cover
+    """Fetch warp files to convert from ``src`` to ``dst``.
+
+    Parameters
+    ----------
+    src : str
+        The template space to transform from.
+    dst : str
+        The template space to transform to.
+    xfms_dir : str or pathlib.Path, optional
+        Path where the retrieved transformation files are stored.
+        The default location is "$HOME/junifer/data/xfms" (default None).
+
+    Returns
+    -------
+    pathlib.Path
+        The path to the transformation file.
+
+    Raises
+    ------
+    RuntimeError
+        If there is a problem fetching files.
+
+    """
+    if xfms_dir is None:
+        xfms_dir = Path().home() / "junifer" / "data" / "xfms"
+        logger.debug(f"Creating xfm directory at: {xfms_dir.resolve()}")
+        # Create default junifer data directory if not present
+        xfms_dir.mkdir(exist_ok=True, parents=True)
+    # Convert str to Path
+    elif not isinstance(xfms_dir, Path):
+        xfms_dir = Path(xfms_dir)
+
+    # Set local file prefix
+    xfm_file_prefix = f"{src}_to_{dst}"
+    # Set local file dir
+    xfm_file_dir = xfms_dir / xfm_file_prefix
+    # Create local directory if not present
+    xfm_file_dir.mkdir(exist_ok=True, parents=True)
+    # Set file name with extension
+    xfm_file = f"{src}_to_{dst}_Composite.h5"
+    # Set local file path
+    xfm_file_path = xfm_file_dir / xfm_file
+    # Check if the file exists
+    if xfm_file_path.exists():
+        logger.info(
+            f"Found existing xfm file for {src} to {dst} at "
+            f"{xfm_file_path.resolve()}"
+        )
+        return xfm_file_path
+
+    # Set URL
+    url = (
+        "https://gin.g-node.org/juaml/human-template-xfms/raw/main/xfms/"
+        f"{xfm_file_prefix}/{xfm_file}"
+    )
+    # Create the file before proceeding
+    xfm_file_path.touch()
+
+    logger.info(f"Downloading xfm file for {src} to {dst} from {url}")
+    # Steam response
+    with httpx.stream("GET", url) as resp:
+        try:
+            resp.raise_for_status()
+        except httpx.HTTPError as exc:
+            raise_error(
+                f"Error response {exc.response.status_code} while "
+                f"requesting {exc.request.url!r}",
+                klass=RuntimeError,
+            )
+        else:
+            with open(xfm_file_path, "ab") as f:
+                for chunk in resp.iter_bytes():
+                    f.write(chunk)
+
+    return xfm_file_path
+
+
+def get_template(
+    space: str,
+    target_data: Dict[str, Any],
+    extra_input: Optional[Dict[str, Any]] = None,
+    template_type: str = "T1w",
+) -> nib.Nifti1Image:
+    """Get template for the space, tailored for the target image.
+
+    Parameters
+    ----------
+    space : str
+        The name of the template space.
+    target_data : dict
+        The corresponding item of the data object for which the template space
+        will be loaded.
+    extra_input : dict, optional
+        The other fields in the data object. Useful for accessing other data
+        types (default None).
+    template_type : {"T1w", "brain", "gm", "wm", "csf"}, optional
+        The template type to retrieve (default "T1w").
+
+    Returns
+    -------
+    Nifti1Image
+        The template image.
+
+    Raises
+    ------
+    ValueError
+        If ``space`` or ``template_type`` is invalid.
+    RuntimeError
+        If required template is not found.
+
+    """
+    # Check for invalid space; early check to raise proper error
+    if space not in tflow.templates():
+        raise_error(f"Unknown template space: {space}")
+
+    # Check for template type
+    if template_type not in ["T1w", "brain", "gm", "wm", "csf"]:
+        raise_error(f"Unknown template type: {template_type}")
+
+    # Get the min of the voxels sizes and use it as the resolution
+    target_img = target_data["data"]
+    resolution = np.min(target_img.header.get_zooms()[:3]).astype(int)
+
+    # Fetch available resolutions for the template
+    available_resolutions = [
+        int(min(val["zooms"]))
+        for val in tflow.get_metadata(space)["res"].values()
+    ]
+    # Use the closest resolution if desired resolution is not found
+    resolution = closest_resolution(resolution, available_resolutions)
+
+    logger.info(f"Downloading template {space} in resolution {resolution}")
+    # Retrieve template
+    try:
+        suffix = None
+        desc = None
+        label = None
+        if template_type == "T1w":
+            suffix = template_type
+            desc = None
+            label = None
+        elif template_type == "brain":
+            suffix = "mask"
+            desc = "brain"
+            label = None
+        elif template_type in ["gm", "wm", "csf"]:
+            suffix = "probseg"
+            desc = None
+            label = template_type.upper()
+        # Set kwargs for fetching
+        kwargs = {
+            "suffix": suffix,
+            "desc": desc,
+            "label": label,
+        }
+        template_path = tflow.get(
+            space,
+            raise_empty=True,
+            resolution=resolution,
+            extension="nii.gz",
+            **kwargs,
+        )
+    except Exception:  # noqa: BLE001
+        raise_error(
+            f"Template {space} ({template_type}) with resolution {resolution} "
+            "not found",
+            klass=RuntimeError,
+        )
+    else:
+        return nib.load(template_path)  # type: ignore

junifer/data/tests/test_coordinates.py

@@ -8,10 +8,13 @@ import pytest
 from numpy.testing import assert_array_equal
 
 from junifer.data.coordinates import (
+    get_coordinates,
     list_coordinates,
     load_coordinates,
     register_coordinates,
 )
+from junifer.datareader import DefaultDataReader
+from junifer.testing.datagrabbers import OasisVBMTestingDataGrabber
 
 
 def test_register_coordinates_built_in_check() -> None:
@@ -21,6 +24,7 @@ def test_register_coordinates_built_in_check() -> None:
             name="DMNBuckner",
             coordinates=np.zeros(2),
             voi_names=["1", "2"],
+            space="MNI",
             overwrite=True,
         )
 
@@ -31,6 +35,7 @@ def test_register_coordinates_overwrite() -> None:
         name="MyList",
         coordinates=np.zeros((2, 3)),
         voi_names=["roi1", "roi2"],
+        space="MNI",
         overwrite=True,
     )
     with pytest.raises(ValueError, match=r"already registered"):
@@ -38,27 +43,31 @@ def test_register_coordinates_overwrite() -> None:
             name="MyList",
             coordinates=np.ones((2, 3)),
             voi_names=["roi2", "roi3"],
+            space="MNI",
         )
 
     register_coordinates(
         name="MyList",
         coordinates=np.ones((2, 3)),
         voi_names=["roi2", "roi3"],
+        space="MNI",
         overwrite=True,
     )
 
-    coord, names = load_coordinates("MyList")
+    coord, names, space = load_coordinates("MyList")
     assert_array_equal(coord, np.ones((2, 3)))
     assert names == ["roi2", "roi3"]
+    assert space == "MNI"
 
 
 def test_register_coordinates_valid_input() -> None:
     """Test coordinates registration check for valid input."""
-    with pytest.raises(ValueError, match=r"numpy.ndarray"):
+    with pytest.raises(TypeError, match=r"numpy.ndarray"):
         register_coordinates(
             name="MyList",
             coordinates=[1, 2],
             voi_names=["roi1", "roi2"],
+            space="MNI",
             overwrite=True,
         )
     with pytest.raises(ValueError, match=r"2D array"):
@@ -66,6 +75,7 @@ def test_register_coordinates_valid_input() -> None:
             name="MyList",
             coordinates=np.zeros((2, 3, 4)),
             voi_names=["roi1", "roi2"],
+            space="MNI",
             overwrite=True,
         )
 
@@ -74,6 +84,7 @@ def test_register_coordinates_valid_input() -> None:
             name="MyList",
             coordinates=np.zeros((2, 4)),
             voi_names=["roi1", "roi2"],
+            space="MNI",
             overwrite=True,
         )
     with pytest.raises(ValueError, match=r"voi_names"):
@@ -81,6 +92,7 @@ def test_register_coordinates_valid_input() -> None:
             name="MyList",
             coordinates=np.zeros((2, 3)),
             voi_names=["roi1", "roi2", "roi3"],
+            space="MNI",
             overwrite=True,
         )
 
@@ -96,12 +108,31 @@ def test_list_coordinates() -> None:
 
 def test_load_coordinates() -> None:
     """Test loading coordinates from file."""
-    coord, names = load_coordinates("DMNBuckner")
+    coord, names, space = load_coordinates("DMNBuckner")
     assert coord.shape == (6, 3)  # type: ignore
     assert names == ["PCC", "MPFC", "lAG", "rAG", "lHF", "rHF"]
+    assert space == "MNI"
 
 
 def test_load_coordinates_nonexisting() -> None:
     """Test loading coordinates that not exist."""
     with pytest.raises(ValueError, match=r"not found"):
         load_coordinates("NonExisting")
+
+
+def test_get_coordinates() -> None:
+    """Test tailored coordinates fetch."""
+    reader = DefaultDataReader()
+    with OasisVBMTestingDataGrabber() as dg:
+        element = dg["sub-01"]
+        element_data = reader.fit_transform(element)
+        vbm_gm = element_data["VBM_GM"]
+        # Get tailored coordinates
+        tailored_coords, tailored_labels = get_coordinates(
+            coords="DMNBuckner", target_data=vbm_gm
+        )
+        # Get raw coordinates
+        raw_coords, raw_labels, _ = load_coordinates("DMNBuckner")
+        # Both tailored and raw should be same for now
+        assert_array_equal(tailored_coords, raw_coords)
+        assert tailored_labels == raw_labels

junifer/data/tests/test_data_utils.py

@@ -36,6 +36,7 @@ def test_closest_resolution(
         The valid resolutions.
     expected: float
         The expected result.
+
     """
     assert closest_resolution(resolution, valid_resolutions) == expected
     assert (