junifer 0.0.4.dev493__py3-none-any.whl → 0.0.4.dev530__py3-none-any.whl

junifer/markers/reho/reho_estimator.py

@@ -6,11 +6,10 @@
 
 
 import hashlib
-import subprocess
 from functools import lru_cache
 from itertools import product
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 import nibabel as nib
 import numpy as np
@@ -20,7 +19,7 @@ from scipy.stats import rankdata
 
 from ...pipeline import WorkDirManager
 from ...pipeline.singleton import singleton
-from ...utils import logger, raise_error
+from ...utils import logger, raise_error, run_ext_cmd
 
 
 if TYPE_CHECKING:
@@ -112,11 +111,6 @@ class ReHoEstimator:
         pathlib.Path
             The path to the ReHo map as NIfTI.
 
-        Raises
-        ------
-        RuntimeError
-            If the 3dReHo command fails due to some issue.
-
         Notes
         -----
         For more information on the publication, please check [1]_ , and for
@@ -174,30 +168,10 @@ class ReHoEstimator:
         else:
             reho_cmd.append(f"-nneigh {nneigh}")
         # Call 3dReHo
-        reho_cmd_str = " ".join(reho_cmd)
-        logger.info(f"3dReHo command to be executed: {reho_cmd_str}")
-        reho_process = subprocess.run(
-            reho_cmd_str,  # string needed with shell=True
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,  # needed for respecting $PATH
-            check=False,
-        )
-        if reho_process.returncode == 0:
-            logger.info(
-                "3dReHo succeeded with the following output: "
-                f"{reho_process.stdout}"
-            )
-        else:
-            raise_error(
-                msg="3dReHo failed with the following error: "
-                f"{reho_process.stdout}",
-                klass=RuntimeError,
-            )
+        run_ext_cmd(name="3dReHo", cmd=reho_cmd)
 
         # SHA256 for bypassing memmap
-        sha256_params = hashlib.sha256(bytes(reho_cmd_str, "utf-8"))
+        sha256_params = hashlib.sha256(bytes(" ".join(reho_cmd), "utf-8"))
         # Create element-scoped tempdir so that the ReHo map is
         # available later as get_coordinates and the like need it
         # in ReHoSpheres and the like to transform to other template
@@ -216,27 +190,7 @@ class ReHoEstimator:
             f"{reho_afni_out_path_prefix}+tlrc.BRIK",
         ]
         # Call 3dAFNItoNIFTI
-        convert_cmd_str = " ".join(convert_cmd)
-        logger.info(f"3dAFNItoNIFTI command to be executed: {convert_cmd_str}")
-        convert_process = subprocess.run(
-            convert_cmd_str,  # string needed with shell=True
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,  # needed for respecting $PATH
-            check=False,
-        )
-        if convert_process.returncode == 0:
-            logger.info(
-                "3dAFNItoNIFTI succeeded with the following output: "
-                f"{convert_process.stdout}"
-            )
-        else:
-            raise_error(
-                msg="3dAFNItoNIFTI failed with the following error: "
-                f"{convert_process.stdout}",
-                klass=RuntimeError,
-            )
+        run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_cmd)
 
         # Cleanup intermediate files
         for fname in self.temp_dir_path.glob("reho*"):  # type: ignore
@@ -244,9 +198,8 @@ class ReHoEstimator:
 
         # Load nifti
         output_data = nib.load(reho_afni_to_nifti_out_path)
-        # Stupid casting
-        output_data = cast("Nifti1Image", output_data)
-        return output_data, reho_afni_to_nifti_out_path
+
+        return output_data, reho_afni_to_nifti_out_path  # type: ignore
 
     def _compute_reho_python(
         self,

junifer/preprocess/ants/__init__.py

@@ -0,0 +1,4 @@
+"""Provide imports for ants sub-package."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL

junifer/preprocess/ants/ants_apply_transforms_warper.py

@@ -0,0 +1,224 @@
+"""Provide class for warping via ANTs antsApplyTransforms."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+import nibabel as nib
+import numpy as np
+
+from ...pipeline import WorkDirManager
+from ...utils import logger, raise_error, run_ext_cmd
+from ..base import BasePreprocessor
+
+
+if TYPE_CHECKING:
+    from nibabel import Nifti1Image
+
+
+class _AntsApplyTransformsWarper(BasePreprocessor):
+    """Class for warping NIfTI images via ANTs antsApplyTransforms.
+
+    Warps ANTs ``antsApplyTransforms``.
+
+    Parameters
+    ----------
+    reference : str
+        The data type to use as reference for warping.
+    on : str
+        The data type to use for warping.
+
+    Raises
+    ------
+    ValueError
+        If a list was passed for ``on``.
+
+    """
+
+    _EXT_DEPENDENCIES: ClassVar[
+        List[Dict[str, Union[str, bool, List[str]]]]
+    ] = [
+        {
+            "name": "ants",
+            "optional": False,
+            "commands": ["ResampleImage", "antsApplyTransforms"],
+        },
+    ]
+
+    def __init__(self, reference: str, on: str) -> None:
+        """Initialize the class."""
+        self.ref = reference
+        # Check only single data type is passed
+        if isinstance(on, list):
+            raise_error("Can only work on single data type, list was passed.")
+        self.on = on  # needed for the base validation to work
+        super().__init__(
+            on=self.on, required_data_types=[self.on, self.ref, "Warp"]
+        )
+
+    def get_valid_inputs(self) -> List[str]:
+        """Get valid data types for input.
+
+        Returns
+        -------
+        list of str
+            The list of data types that can be used as input for this
+            preprocessor.
+
+        """
+        # Constructed dynamically
+        return [self.on]
+
+    def get_output_type(self, input: List[str]) -> List[str]:
+        """Get output type.
+
+        Parameters
+        ----------
+        input : list of str
+            The input to the preprocessor. The list must contain the
+            available Junifer Data dictionary keys.
+
+        Returns
+        -------
+        list of str
+            The updated list of available Junifer Data object keys after
+            the pipeline step.
+
+        """
+        # Does not add any new keys
+        return input
+
+    def _run_apply_transforms(
+        self,
+        input_data: Dict,
+        ref_path: Path,
+        warp_path: Path,
+    ) -> Tuple["Nifti1Image", Path]:
+        """Run ``antsApplyTransforms``.
+
+        Parameters
+        ----------
+        input_data : dict
+            The input data.
+        ref_path : pathlib.Path
+            The path to the reference file.
+        warp_path : pathlib.Path
+            The path to the warp file.
+
+        Returns
+        -------
+        Niimg-like object
+            The warped input image.
+        pathlib.Path
+            The path to the resampled reference image.
+
+        """
+        # Get the min of the voxel sizes from input and use it as the
+        # resolution
+        resolution = np.min(input_data["data"].header.get_zooms()[:3])
+
+        # Create element-specific tempdir for storing post-warping assets
+        tempdir = WorkDirManager().get_element_tempdir(
+            prefix="applytransforms"
+        )
+
+        # Create a tempfile for resampled reference output
+        resample_image_out_path = tempdir / "reference_resampled.nii.gz"
+        # Set ResampleImage command
+        resample_image_cmd = [
+            "ResampleImage",
+            "3",  # image dimension
+            f"{ref_path.resolve()}",
+            f"{resample_image_out_path.resolve()}",
+            f"{resolution}x{resolution}x{resolution}",
+            "0",  # option for spacing and not size
+            "3 3",  # Lanczos windowed sinc
+        ]
+        # Call ResampleImage
+        run_ext_cmd(name="ResampleImage", cmd=resample_image_cmd)
+
+        # Create a tempfile for warped output
+        apply_transforms_out_path = tempdir / "input_warped.nii.gz"
+        # Set antsApplyTransforms command
+        apply_transforms_cmd = [
+            "antsApplyTransforms",
+            "-d 3",
+            "-e 3",
+            "-n LanczosWindowedSinc",
+            f"-i {input_data['path'].resolve()}",
+            # use resampled reference
+            f"-r {resample_image_out_path.resolve()}",
+            f"-t {warp_path.resolve()}",
+            f"-o {apply_transforms_out_path.resolve()}",
+        ]
+        # Call antsApplyTransforms
+        run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
+
+        # Load nifti
+        output_img = nib.load(apply_transforms_out_path)
+
+        return output_img, resample_image_out_path  # type: ignore
+
+    def preprocess(
+        self,
+        input: Dict[str, Any],
+        extra_input: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[str, Dict[str, Any]]:
+        """Preprocess.
+
+        Parameters
+        ----------
+        input : dict
+            A single input from the Junifer Data object in which to preprocess.
+        extra_input : dict, optional
+            The other fields in the Junifer Data object. Must include the
+            ``Warp`` and ``ref`` value's keys.
+
+        Returns
+        -------
+        str
+            The key to store the output in the Junifer Data object.
+        dict
+            The computed result as dictionary. This will be stored in the
+            Junifer Data object under the key ``data`` of the data type.
+
+        Raises
+        ------
+        ValueError
+            If ``extra_input`` is None.
+
+        """
+        logger.debug("Warping via ANTs using antsApplyTransforms")
+        # Check for extra inputs
+        if extra_input is None:
+            raise_error(
+                f"No extra input provided, requires `Warp` and `{self.ref}` "
+                "data types in particular."
+            )
+        # Retrieve data type info to warp
+        to_warp_input = input
+        # Retrieve data type info to use as reference
+        ref_input = extra_input[self.ref]
+        # Retrieve Warp data
+        warp = extra_input["Warp"]
+        # Replace original data with warped data and add resampled reference
+        # path
+        input["data"], input["reference_path"] = self._run_apply_transforms(
+            input_data=to_warp_input,
+            ref_path=ref_input["path"],
+            warp_path=warp["path"],
+        )
+        # Use reference input's space as warped input's space
+        input["space"] = ref_input["space"]
+        return self.on, input

junifer/preprocess/ants/tests/test_ants_apply_transforms_warper.py

@@ -0,0 +1,124 @@
+"""Provide tests for AntsApplyTransformsWarper."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import socket
+from pathlib import Path
+from typing import List
+
+import nibabel as nib
+import pytest
+
+from junifer.datagrabber import DMCC13Benchmark
+from junifer.datareader import DefaultDataReader
+from junifer.pipeline.utils import _check_ants
+from junifer.preprocess.ants.ants_apply_transforms_warper import (
+    _AntsApplyTransformsWarper,
+)
+
+
+def test_AntsApplyTransformsWarper_init() -> None:
+    """Test AntsApplyTransformsWarper init."""
+    ants_apply_transforms_warper = _AntsApplyTransformsWarper(
+        reference="T1w", on="BOLD"
+    )
+    assert ants_apply_transforms_warper.ref == "T1w"
+    assert ants_apply_transforms_warper.on == "BOLD"
+    assert ants_apply_transforms_warper._on == ["BOLD"]
+
+
+def test_AntsApplyTransformsWarper_get_valid_inputs() -> None:
+    """Test AntsApplyTransformsWarper get_valid_inputs."""
+    ants_apply_transforms_warper = _AntsApplyTransformsWarper(
+        reference="T1w", on="BOLD"
+    )
+    assert ants_apply_transforms_warper.get_valid_inputs() == ["BOLD"]
+
+
+@pytest.mark.parametrize(
+    "input_",
+    [
+        ["BOLD", "T1w", "Warp"],
+        ["BOLD", "T1w"],
+        ["BOLD"],
+    ],
+)
+def test_AntsApplyTransformsWarper_get_output_type(input_: List[str]) -> None:
+    """Test AntsApplyTransformsWarper get_output_type.
+
+    Parameters
+    ----------
+    input_ : list of str
+        The input data types.
+
+    """
+    ants_apply_transforms_warper = _AntsApplyTransformsWarper(
+        reference="T1w", on="BOLD"
+    )
+    assert ants_apply_transforms_warper.get_output_type(input_) == input_
+
+
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_AntsApplyTransformsWarper__run_apply_transform() -> None:
+    """Test AntsApplyTransformsWarper _run_apply_transform."""
+    with DMCC13Benchmark(
+        types=["BOLD", "T1w", "Warp"],
+        sessions=["wave1bas"],
+        tasks=["Rest"],
+        phase_encodings=["AP"],
+        runs=["1"],
+        native_t1w=True,
+    ) as dg:
+        # Read data
+        element_data = DefaultDataReader().fit_transform(
+            dg[("f9057kp", "wave1bas", "Rest", "AP", "1")]
+        )
+        # Preprocess data
+        warped_data, resampled_ref_path = _AntsApplyTransformsWarper(
+            reference="T1w", on="BOLD"
+        )._run_apply_transforms(
+            input_data=element_data["BOLD"],
+            ref_path=element_data["T1w"]["path"],
+            warp_path=element_data["Warp"]["path"],
+        )
+        assert isinstance(warped_data, nib.Nifti1Image)
+        assert isinstance(resampled_ref_path, Path)
+
+
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_AntsApplyTransformsWarper_preprocess() -> None:
+    """Test AntsApplyTransformsWarper preprocess."""
+    with DMCC13Benchmark(
+        types=["BOLD", "T1w", "Warp"],
+        sessions=["wave1bas"],
+        tasks=["Rest"],
+        phase_encodings=["AP"],
+        runs=["1"],
+        native_t1w=True,
+    ) as dg:
+        # Read data
+        element_data = DefaultDataReader().fit_transform(
+            dg[("f9057kp", "wave1bas", "Rest", "AP", "1")]
+        )
+        # Preprocess data
+        data_type, data = _AntsApplyTransformsWarper(
+            reference="T1w", on="BOLD"
+        ).preprocess(
+            input=element_data["BOLD"],
+            extra_input=element_data,
+        )
+        assert isinstance(data_type, str)
+        assert isinstance(data, dict)

junifer/preprocess/bold_warper.py

@@ -15,6 +15,7 @@ from typing import (
 
 from ..api.decorators import register_preprocessor
 from ..utils import logger, raise_error
+from .ants.ants_apply_transforms_warper import _AntsApplyTransformsWarper
 from .base import BasePreprocessor
 from .fsl.apply_warper import _ApplyWarper
 
@@ -35,8 +36,13 @@ class BOLDWarper(BasePreprocessor):
     ] = [
         {
             "name": "fsl",
-            "optional": False,
-            "commands": ["applywarp"],
+            "optional": True,
+            "commands": ["flirt", "applywarp"],
+        },
+        {
+            "name": "ants",
+            "optional": True,
+            "commands": ["ResampleImage", "antsApplyTransforms"],
         },
     ]
 
@@ -105,6 +111,8 @@ class BOLDWarper(BasePreprocessor):
         ------
         ValueError
             If ``extra_input`` is None.
+        RuntimeError
+            If warp / transformation file extension is not ".mat" or ".h5".
 
         """
         logger.debug("Warping BOLD using BOLDWarper")
@@ -114,11 +122,34 @@ class BOLDWarper(BasePreprocessor):
                 f"No extra input provided, requires `Warp` and `{self.ref}` "
                 "data types in particular."
             )
-        # Initialize ApplyWarper for computation
-        apply_warper = _ApplyWarper(reference=self.ref, on="BOLD")
-        # Replace original BOLD data with warped BOLD data
-        _, input = apply_warper.preprocess(
-            input=input,
-            extra_input=extra_input,
-        )
+        # Check for warp file type to use correct tool
+        warp_file_ext = extra_input["Warp"]["path"].suffix
+        if warp_file_ext == ".mat":
+            logger.debug("Using FSL with BOLDWarper")
+            # Initialize ApplyWarper for computation
+            apply_warper = _ApplyWarper(reference=self.ref, on="BOLD")
+            # Replace original BOLD data with warped BOLD data
+            _, input = apply_warper.preprocess(
+                input=input,
+                extra_input=extra_input,
+            )
+        elif warp_file_ext == ".h5":
+            logger.debug("Using ANTs with BOLDWarper")
+            # Initialize AntsApplyTransformsWarper for computation
+            ants_apply_transforms_warper = _AntsApplyTransformsWarper(
+                reference=self.ref, on="BOLD"
+            )
+            # Replace original BOLD data with warped BOLD data
+            _, input = ants_apply_transforms_warper.preprocess(
+                input=input,
+                extra_input=extra_input,
+            )
+        else:
+            raise_error(
+                msg=(
+                    "Unknown warp / transformation file extension: "
+                    f"{warp_file_ext}"
+                ),
+                klass=RuntimeError,
+            )
         return "BOLD", input

junifer/preprocess/fsl/apply_warper.py

@@ -3,7 +3,6 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import subprocess
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -14,14 +13,13 @@ from typing import (
     Optional,
     Tuple,
     Union,
-    cast,
 )
 
 import nibabel as nib
 import numpy as np
 
 from ...pipeline import WorkDirManager
-from ...utils import logger, raise_error
+from ...utils import logger, raise_error, run_ext_cmd
 from ..base import BasePreprocessor
 
 
@@ -54,7 +52,7 @@ class _ApplyWarper(BasePreprocessor):
         {
             "name": "fsl",
             "optional": False,
-            "commands": ["applywarp"],
+            "commands": ["flirt", "applywarp"],
         },
     ]
 
@@ -125,11 +123,6 @@ class _ApplyWarper(BasePreprocessor):
         pathlib.Path
             The path to the resampled reference image.
 
-        Raises
-        ------
-        RuntimeError
-            If FSL commands fail.
-
         """
         # Get the min of the voxel sizes from input and use it as the
         # resolution
@@ -150,29 +143,7 @@ class _ApplyWarper(BasePreprocessor):
             f"-out {flirt_out_path.resolve()}",
         ]
         # Call flirt
-        flirt_cmd_str = " ".join(flirt_cmd)
-        logger.info(f"flirt command to be executed: {flirt_cmd_str}")
-        flirt_process = subprocess.run(
-            flirt_cmd_str,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,  # needed for respecting $PATH
-            check=False,
-        )
-        if flirt_process.returncode == 0:
-            logger.info(
-                "flirt succeeded with the following output: "
-                f"{flirt_process.stdout}"
-            )
-        else:
-            raise_error(
-                msg="flirt failed with the following error: "
-                f"{flirt_process.stdout}",
-                klass=RuntimeError,
-            )
-
-        # TODO(synchon): Modify reference or not?
+        run_ext_cmd(name="flirt", cmd=flirt_cmd)
 
         # Create a tempfile for warped output
         applywarp_out_path = tempdir / "input_warped.nii.gz"
@@ -186,34 +157,12 @@ class _ApplyWarper(BasePreprocessor):
             f"-o {applywarp_out_path.resolve()}",
         ]
         # Call applywarp
-        applywarp_cmd_str = " ".join(applywarp_cmd)
-        logger.info(f"applywarp command to be executed: {applywarp_cmd_str}")
-        applywarp_process = subprocess.run(
-            applywarp_cmd_str,  # string needed with shell=True
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,  # needed for respecting $PATH
-            check=False,
-        )
-        if applywarp_process.returncode == 0:
-            logger.info(
-                "applywarp succeeded with the following output: "
-                f"{applywarp_process.stdout}"
-            )
-        else:
-            raise_error(
-                msg="applywarp failed with the following error: "
-                f"{applywarp_process.stdout}",
-                klass=RuntimeError,
-            )
+        run_ext_cmd(name="applywarp", cmd=applywarp_cmd)
 
         # Load nifti
         output_img = nib.load(applywarp_out_path)
 
-        # Stupid casting
-        output_img = cast("Nifti1Image", output_img)
-        return output_img, flirt_out_path
+        return output_img, flirt_out_path  # type: ignore
 
     def preprocess(
         self,