junifer 0.0.4.dev493__py3-none-any.whl → 0.0.4.dev530__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.4.dev493'
-__version_tuple__ = version_tuple = (0, 0, 4, 'dev493')
+__version__ = version = '0.0.4.dev530'
+__version_tuple__ = version_tuple = (0, 0, 4, 'dev530')

junifer/api/res/ants/ResampleImage

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+run_ants_docker.sh ResampleImage "$@"

junifer/data/coordinates.py

@@ -4,7 +4,6 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import subprocess
 import typing
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -14,7 +13,7 @@ import pandas as pd
 from numpy.typing import ArrayLike
 
 from ..pipeline import WorkDirManager
-from ..utils.logging import logger, raise_error, warn_with_log
+from ..utils import logger, raise_error, run_ext_cmd, warn_with_log
 
 
 # Path to the VOIs
@@ -231,6 +230,8 @@ def get_coordinates(
 
     Raises
     ------
+    RuntimeError
+        If warp / transformation file extension is not ".mat" or ".h5".
     ValueError
         If ``extra_input`` is None when ``target_data``'s space is native.
 
@@ -251,12 +252,6 @@ def get_coordinates(
         # Create component-scoped tempdir
         tempdir = WorkDirManager().get_tempdir(prefix="coordinates")
 
-        # Save existing coordinates to a component-scoped tempfile
-        pretransform_coordinates_path = (
-            tempdir / "pretransform_coordinates.txt"
-        )
-        np.savetxt(pretransform_coordinates_path, seeds)
-
         # Create element-scoped tempdir so that transformed coordinates is
         # available later as numpy stores file path reference for
         # loading on computation
@@ -264,48 +259,92 @@ def get_coordinates(
             prefix="coordinates"
         )
 
-        # Create an element-scoped tempfile for transformed coordinates output
-        img2imgcoord_out_path = element_tempdir / "coordinates_transformed.txt"
-        # Set img2imgcoord command
-        img2imgcoord_cmd = [
-            "cat",
-            f"{pretransform_coordinates_path.resolve()}",
-            "| img2imgcoord -mm",
-            f"-src {target_data['path'].resolve()}",
-            f"-dest {target_data['reference_path'].resolve()}",
-            f"-warp {extra_input['Warp']['path'].resolve()}",
-            f"> {img2imgcoord_out_path.resolve()};",
-            f"sed -i 1d {img2imgcoord_out_path.resolve()}",
-        ]
-        # Call img2imgcoord
-        img2imgcoord_cmd_str = " ".join(img2imgcoord_cmd)
-        logger.info(
-            f"img2imgcoord command to be executed: {img2imgcoord_cmd_str}"
-        )
-        img2imgcoord_process = subprocess.run(
-            img2imgcoord_cmd_str,  # string needed with shell=True
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,  # needed for respecting $PATH
-            check=False,
-        )
-        # Check for success or failure
-        if img2imgcoord_process.returncode == 0:
-            logger.info(
-                "img2imgcoord succeeded with the following output: "
-                f"{img2imgcoord_process.stdout}"
+        # Check for warp file type to use correct tool
+        warp_file_ext = extra_input["Warp"]["path"].suffix
+        if warp_file_ext == ".mat":
+            # Save existing coordinates to a component-scoped tempfile
+            pretransform_coordinates_path = (
+                tempdir / "pretransform_coordinates.txt"
+            )
+            np.savetxt(pretransform_coordinates_path, seeds)
+
+            # Create an element-scoped tempfile for transformed coordinates
+            # output
+            transformed_coords_path = (
+                element_tempdir / "coordinates_transformed.txt"
+            )
+
+            logger.debug("Using FSL for coordinates transformation")
+            # Set img2imgcoord command
+            img2imgcoord_cmd = [
+                "cat",
+                f"{pretransform_coordinates_path.resolve()}",
+                "| img2imgcoord -mm",
+                f"-src {target_data['path'].resolve()}",
+                f"-dest {target_data['reference_path'].resolve()}",
+                f"-warp {extra_input['Warp']['path'].resolve()}",
+                f"> {transformed_coords_path.resolve()};",
+                f"sed -i 1d {transformed_coords_path.resolve()}",
+            ]
+            # Call img2imgcoord
+            run_ext_cmd(name="img2imgcoord", cmd=img2imgcoord_cmd)
+
+            # Load coordinates
+            seeds = np.loadtxt(transformed_coords_path)
+
+        elif warp_file_ext == ".h5":
+            # Save existing coordinates to a component-scoped tempfile
+            pretransform_coordinates_path = (
+                tempdir / "pretransform_coordinates.csv"
+            )
+            np.savetxt(
+                pretransform_coordinates_path,
+                seeds,
+                delimiter=",",
+                # Add header while saving to make ANTs work
+                header="x,y,z",
             )
+
+            # Create an element-scoped tempfile for transformed coordinates
+            # output
+            transformed_coords_path = (
+                element_tempdir / "coordinates_transformed.csv"
+            )
+
+            logger.debug("Using ANTs for coordinates transformation")
+            # 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
+            seeds = np.loadtxt(
+                # Skip header when reading
+                transformed_coords_path,
+                delimiter=",",
+                skiprows=1,
+            )
+
         else:
             raise_error(
-                msg="img2imgcoord failed with the following error: "
-                f"{img2imgcoord_process.stdout}",
+                msg=(
+                    "Unknown warp / transformation file extension: "
+                    f"{warp_file_ext}"
+                ),
                 klass=RuntimeError,
             )
 
-        # Load coordinates
-        seeds = np.loadtxt(img2imgcoord_out_path)
-
         # Delete tempdir
         WorkDirManager().delete_tempdir(tempdir)
 

junifer/data/masks.py

@@ -1,9 +1,9 @@
 """Provide functions for masks."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import subprocess
 import typing
 from pathlib import Path
 from typing import (
@@ -29,7 +29,7 @@ from nilearn.masking import (
 )
 
 from ..pipeline import WorkDirManager
-from ..utils.logging import logger, raise_error
+from ..utils import logger, raise_error, run_ext_cmd
 from .utils import closest_resolution
 
 
@@ -199,7 +199,8 @@ def get_mask(  # noqa: C901
     ------
     RuntimeError
         If masks are in different spaces and they need to be intersected /
-        unionized.
+        unionized or
+        if warp / transformation file extension is not ".mat" or ".h5".
     ValueError
         If extra key is provided in addition to mask name in ``masks`` or
         if no mask is provided or
@@ -364,50 +365,58 @@ def get_mask(  # noqa: C901
         element_tempdir = WorkDirManager().get_element_tempdir(prefix="masks")
 
         # Create an element-scoped tempfile for warped output
-        applywarp_out_path = element_tempdir / "mask_warped.nii.gz"
-        # Set applywarp command
-        applywarp_cmd = [
-            "applywarp",
-            "--interp=nn",
-            f"-i {prewarp_mask_path.resolve()}",
-            # use resampled reference
-            f"-r {target_data['reference_path'].resolve()}",
-            f"-w {extra_input['Warp']['path'].resolve()}",
-            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,
-        )
-        # Check for success or failure
-        if applywarp_process.returncode == 0:
-            logger.info(
-                "applywarp succeeded with the following output: "
-                f"{applywarp_process.stdout}"
-            )
+        warped_mask_path = element_tempdir / "mask_warped.nii.gz"
+
+        # 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 for mask warping")
+            # Set applywarp command
+            applywarp_cmd = [
+                "applywarp",
+                "--interp=nn",
+                f"-i {prewarp_mask_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-w {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_mask_path.resolve()}",
+            ]
+            # Call applywarp
+            run_ext_cmd(name="applywarp", cmd=applywarp_cmd)
+
+        elif warp_file_ext == ".h5":
+            logger.debug("Using ANTs for mask warping")
+            # Set antsApplyTransforms command
+            apply_transforms_cmd = [
+                "antsApplyTransforms",
+                "-d 3",
+                "-e 3",
+                "-n 'GenericLabel[NearestNeighbor]'",
+                f"-i {prewarp_mask_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-t {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_mask_path.resolve()}",
+            ]
+            # Call antsApplyTransforms
+            run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
+
         else:
             raise_error(
-                msg="applywarp failed with the following error: "
-                f"{applywarp_process.stdout}",
+                msg=(
+                    "Unknown warp / transformation file extension: "
+                    f"{warp_file_ext}"
+                ),
                 klass=RuntimeError,
             )
 
         # Load nifti
-        mask_img = nib.load(applywarp_out_path)
+        mask_img = nib.load(warped_mask_path)
 
         # Delete tempdir
         WorkDirManager().delete_tempdir(tempdir)
 
-    # Type-cast to remove errors
-    mask_img = typing.cast("Nifti1Image", mask_img)
-    return mask_img
+    return mask_img  # type: ignore
 
 
 def load_mask(

junifer/data/parcellations.py

@@ -7,7 +7,6 @@
 
 import io
 import shutil
-import subprocess
 import tarfile
 import tempfile
 import typing
@@ -23,7 +22,7 @@ from nilearn import datasets, image
 from requests.exceptions import ConnectionError, HTTPError, ReadTimeout
 
 from ..pipeline import WorkDirManager
-from ..utils.logging import logger, raise_error, warn_with_log
+from ..utils import logger, raise_error, run_ext_cmd, warn_with_log
 from .utils import closest_resolution
 
 
@@ -231,7 +230,8 @@ def get_parcellation(
     Raises
     ------
     RuntimeError
-        If parcellations are in different spaces and they need to be merged.
+        If parcellations are in different spaces and they need to be merged or
+        if warp / transformation file extension is not ".mat" or ".h5".
     ValueError
         If ``extra_input`` is None when ``target_data``'s space is native.
 
@@ -302,55 +302,61 @@ def get_parcellation(
         element_tempdir = WorkDirManager().get_element_tempdir(
             prefix="parcellations"
         )
-
         # Create an element-scoped tempfile for warped output
-        applywarp_out_path = element_tempdir / "parcellation_warped.nii.gz"
-        # Set applywarp command
-        applywarp_cmd = [
-            "applywarp",
-            "--interp=nn",
-            f"-i {prewarp_parcellation_path.resolve()}",
-            # use resampled reference
-            f"-r {target_data['reference_path'].resolve()}",
-            f"-w {extra_input['Warp']['path'].resolve()}",
-            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,
+        warped_parcellation_path = (
+            element_tempdir / "parcellation_warped.nii.gz"
         )
-        # Check for success or failure
-        if applywarp_process.returncode == 0:
-            logger.info(
-                "applywarp succeeded with the following output: "
-                f"{applywarp_process.stdout}"
-            )
+
+        # 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 for parcellation warping")
+            # Set applywarp command
+            applywarp_cmd = [
+                "applywarp",
+                "--interp=nn",
+                f"-i {prewarp_parcellation_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-w {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_parcellation_path.resolve()}",
+            ]
+            # Call applywarp
+            run_ext_cmd(name="applywarp", cmd=applywarp_cmd)
+
+        elif warp_file_ext == ".h5":
+            logger.debug("Using ANTs for parcellation warping")
+            # Set antsApplyTransforms command
+            apply_transforms_cmd = [
+                "antsApplyTransforms",
+                "-d 3",
+                "-e 3",
+                "-n 'GenericLabel[NearestNeighbor]'",
+                f"-i {prewarp_parcellation_path.resolve()}",
+                # use resampled reference
+                f"-r {target_data['reference_path'].resolve()}",
+                f"-t {extra_input['Warp']['path'].resolve()}",
+                f"-o {warped_parcellation_path.resolve()}",
+            ]
+            # Call antsApplyTransforms
+            run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
+
         else:
             raise_error(
-                msg="applywarp failed with the following error: "
-                f"{applywarp_process.stdout}",
+                msg=(
+                    "Unknown warp / transformation file extension: "
+                    f"{warp_file_ext}"
+                ),
                 klass=RuntimeError,
             )
 
         # Load nifti
-        resampled_parcellation_img = nib.load(applywarp_out_path)
+        resampled_parcellation_img = nib.load(warped_parcellation_path)
 
         # Delete tempdir
         WorkDirManager().delete_tempdir(tempdir)
 
-        # Stupid casting
-        resampled_parcellation_img = typing.cast(
-            "Nifti1Image", resampled_parcellation_img
-        )
-
-    return resampled_parcellation_img, labels
+    return resampled_parcellation_img, labels  # type: ignore
 
 
 def load_parcellation(

junifer/markers/falff/falff_estimator.py

@@ -4,11 +4,10 @@
 #          Federico Raimondo <f.raimondo@fz-juelich.de>
 # License: AGPL
 
-import subprocess
 import typing
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
 
 import nibabel as nib
 import numpy as np
@@ -17,7 +16,7 @@ from scipy.fft import fft, fftfreq
 
 from ...pipeline import WorkDirManager
 from ...pipeline.singleton import singleton
-from ...utils import logger, raise_error
+from ...utils import logger, run_ext_cmd
 
 
 if TYPE_CHECKING:
@@ -54,42 +53,6 @@ class ALFFEstimator:
         if self.temp_dir_path is not None:
             WorkDirManager().delete_tempdir(self.temp_dir_path)
 
-    @staticmethod
-    def _run_afni_cmd(cmd: str) -> None:
-        """Run AFNI command.
-
-        Parameters
-        ----------
-        cmd : str
-            AFNI command to be executed.
-
-        Raises
-        ------
-        RuntimeError
-            If AFNI command fails.
-
-        """
-        logger.info(f"AFNI command to be executed: {cmd}")
-        process = subprocess.run(
-            cmd,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,
-            check=False,
-        )
-        if process.returncode == 0:
-            logger.info(
-                "AFNI command succeeded with the following output: "
-                f"{process.stdout}"
-            )
-        else:
-            raise_error(
-                msg="AFNI command failed with the following error: "
-                f"{process.stdout}",
-                klass=RuntimeError,
-            )
-
     def _compute_alff_afni(
         self,
         data: Union["Nifti1Image", "Nifti2Image"],
@@ -121,11 +84,6 @@ class ALFFEstimator:
         pathlib.Path
             The path to the fALFF map as NIfTI.
 
-        Raises
-        ------
-        RuntimeError
-            If the AFNI commands fails due to some issues.
-
         """
         # Note: self.temp_dir_path is sure to exist before proceeding, so
         #       types checks are ignored further on.
@@ -150,31 +108,36 @@ class ALFFEstimator:
             self.temp_dir_path / "temp_falff"  # type: ignore
         )
 
-        bp_cmd = (
-            "3dRSFC "
-            f"-prefix {falff_afni_out_path_prefix.resolve()} "
-            f"-input {nifti_in_file_path.resolve()} "
-            f"-band {highpass} {lowpass} "
-            "-no_rsfa -nosat -nodetrend "
-        )
+        # Set 3dRSFC command
+        bp_cmd = [
+            "3dRSFC",
+            f"-prefix {falff_afni_out_path_prefix.resolve()}",
+            f"-input {nifti_in_file_path.resolve()}",
+            f"-band {highpass} {lowpass}",
+            "-no_rsfa -nosat -nodetrend",
+        ]
         if tr is not None:
-            bp_cmd += f"-dt {tr} "
-        self._run_afni_cmd(bp_cmd)
-
-        # Convert afni's output to nifti
-        convert_cmd = (
-            "3dAFNItoNIFTI "
-            f"-prefix {alff_fname.resolve()} "
-            f"{falff_afni_out_path_prefix}_ALFF+tlrc.BRIK "
-        )
-        self._run_afni_cmd(convert_cmd)
-
-        convert_cmd = (
-            "3dAFNItoNIFTI "
-            f"-prefix {falff_fname.resolve()} "
-            f"{falff_afni_out_path_prefix}_fALFF+tlrc.BRIK "
-        )
-        self._run_afni_cmd(convert_cmd)
+            bp_cmd.append(f"-dt {tr}")
+        # Call 3dRSFC
+        run_ext_cmd(name="3dRSFC", cmd=bp_cmd)
+
+        # Convert alff output to nifti
+        convert_alff_cmd = [
+            "3dAFNItoNIFTI",
+            f"-prefix {alff_fname.resolve()}",
+            f"{falff_afni_out_path_prefix}_ALFF+tlrc.BRIK",
+        ]
+        # Call 3dAFNItoNIFTI
+        run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_alff_cmd)
+
+        # Convert falff output to nifti
+        convert_falff_cmd = [
+            "3dAFNItoNIFTI",
+            f"-prefix {falff_fname.resolve()}",
+            f"{falff_afni_out_path_prefix}_fALFF+tlrc.BRIK",
+        ]
+        # Call 3dAFNItoNIFTI
+        run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_falff_cmd)
 
         # Cleanup intermediate files
         for fname in self.temp_dir_path.glob("temp_*"):  # type: ignore
@@ -183,10 +146,8 @@ class ALFFEstimator:
         # Load niftis
         alff_img = nib.load(alff_fname)
         falff_img = nib.load(falff_fname)
-        # Cast image type
-        alff_img = cast("Nifti1Image", alff_img)
-        falff_img = cast("Nifti1Image", falff_img)
-        return alff_img, falff_img, alff_fname, falff_fname
+
+        return alff_img, falff_img, alff_fname, falff_fname  # type: ignore
 
     def _compute_alff_python(
         self,