junifer 0.0.8.dev329__tar.gz → 0.0.8.dev339__tar.gz

{junifer-0.0.8.dev329/junifer.egg-info → junifer-0.0.8.dev339}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev329
+Version: 0.0.8.dev339
 Summary: JUelich NeuroImaging FEature extractoR
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>
 Maintainer-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>

junifer-0.0.8.dev339/docs/changes/newsfragments/530.change

@@ -0,0 +1 @@
+Use single precision in ``antsApplyTransforms`` (``--float 1``), halving its memory and giving float32 instead of float64 data, with differences below 0.002% of the data range by `Fede Raimondo`_

junifer-0.0.8.dev339/docs/changes/newsfragments/530.enh

@@ -0,0 +1 @@
+Warp the volumes of 4D data in chunks of ``preprocessing.warping.chunksize`` volumes (default 100) in :class:`.SpaceWarper`, as the memory used by ANTs and FSL grows with the number of volumes (e.g., about 53 GB to warp 1200 volumes to native space with ANTs) by `Fede Raimondo`_

junifer-0.0.8.dev339/docs/changes/newsfragments/530.enh.1

@@ -0,0 +1 @@
+Write the intermediate images (e.g., the warped, smoothed or filtered data) uncompressed in the temporary directory of the element, as they are read right away and deleted after the element is processed, so there is no need to spend time compressing and decompressing them, and run the FSL commands with ``FSLOUTPUTTYPE=NIFTI`` to write them uncompressed by `Fede Raimondo`_

junifer-0.0.8.dev339/docs/changes/newsfragments/533.enh

@@ -0,0 +1 @@
+Restrict the ALFF and fALFF computation of :class:`.ALFFParcels`, :class:`.ALFFSpheres` and :class:`.ALFFMaps` to the voxels in their ``masks`` (with ``-mask`` for AFNI's ``3dRSFC``), as for ReHo, reducing the memory and time (e.g., from 14.5 GB to 9.4 GB and from 7 to 1 minutes for 1200 volumes with AFNI), and do not write the bandpassed time series with ``3dRSFC`` (``-no_rs_out``), as only the parameters are used by `Fede Raimondo`_

junifer-0.0.8.dev339/docs/changes/newsfragments/533.enh.1

@@ -0,0 +1 @@
+Keep the data of :class:`.fMRIPrepConfoundRemover`, :class:`.TemporalFilter`, :class:`.TemporalSlicer` and :class:`.Smoothing` (with nilearn) in the saved file (memory-mapped) instead of in memory, as for the other preprocessors, releasing its memory during the next steps of the pipeline (e.g., 5 GB for 1200 volumes while running AFNI) by `Fede Raimondo`_

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/docs/using/configuring.rst

@@ -63,3 +63,9 @@ Available Configurations
      - ``preprocessing.dump.granularity``
      - "full" or "final"
      - Dump all pre-processing steps or just the final pre-processed data
+   * - ``JUNIFER_PREPROCESSING_WARPING_CHUNKSIZE``
+     - ``preprocessing.warping.chunksize``
+     - int
+     - | Number of volumes of 4D data to warp at once with
+       | :class:`.SpaceWarper` (default 100). The memory used by ANTs and FSL
+       | grows with the number of volumes, so smaller chunks use less memory

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.8.dev329'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev329')
+__version__ = version = '0.0.8.dev339'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev339')
 
-__commit_id__ = commit_id = 'g33802e12a'
+__commit_id__ = commit_id = 'gd12ff17f7'

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/api/res/fsl/run_fsl_docker.sh

@@ -34,6 +34,10 @@ echo "Docker args: ${docker_args[*]}" >&2
 echo "Corrected args for FSL: ${corrected_args[*]}" >&2
 
 cwd=$(pwd)
+# Pass the output type, as FSL writes it instead of the type of the extension
+if [ -n "${FSLOUTPUTTYPE}" ]; then
+    docker_args+=("-e FSLOUTPUTTYPE=${FSLOUTPUTTYPE}")
+fi
 cmd="docker run --rm ${docker_args[*]} -v ${cwd}:${cwd} -w ${cwd} brainlife/fsl ${corrected_args[*]}"
 echo "Running command: ${cmd}" >&2
 ${cmd}

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/maps/_ants_maps_warper.py

@@ -100,16 +100,17 @@ class ANTsMapsWarper:
             logger.debug("Using ANTs for maps transformation")
 
             # Save existing maps image to a tempfile
-            prewarp_maps_path = element_tempdir / "prewarp_maps.nii.gz"
+            prewarp_maps_path = element_tempdir / "prewarp_maps.nii"
             nib.save(maps_img, prewarp_maps_path)
 
             # Create a tempfile for warped output
-            warped_maps_path = element_tempdir / "maps_warped.nii.gz"
+            warped_maps_path = element_tempdir / "maps_warped.nii"
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 "-n LanczosWindowedSinc",
                 f"-i {prewarp_maps_path.resolve()}",
                 # use resampled reference
@@ -133,20 +134,21 @@ class ANTsMapsWarper:
                 extra_input=None,
             )
             # Save template to a tempfile
-            template_space_img_path = element_tempdir / f"{dst}_T1w.nii.gz"
+            template_space_img_path = element_tempdir / f"{dst}_T1w.nii"
             nib.save(template_space_img, template_space_img_path)
 
             # Save existing maps image to a tempfile
-            prewarp_maps_path = element_tempdir / "prewarp_maps.nii.gz"
+            prewarp_maps_path = element_tempdir / "prewarp_maps.nii"
             nib.save(maps_img, prewarp_maps_path)
 
             # Create a tempfile for warped output
-            warped_maps_path = element_tempdir / "maps_warped.nii.gz"
+            warped_maps_path = element_tempdir / "maps_warped.nii"
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 "-n LanczosWindowedSinc",
                 f"-i {prewarp_maps_path.resolve()}",
                 f"-r {template_space_img_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/maps/_fsl_maps_warper.py

@@ -66,13 +66,14 @@ class FSLMapsWarper:
         )
 
         # Save existing maps image to a tempfile
-        prewarp_maps_path = element_tempdir / "prewarp_maps.nii.gz"
+        prewarp_maps_path = element_tempdir / "prewarp_maps.nii"
         nib.save(maps_img, prewarp_maps_path)
 
         # Create a tempfile for warped output
-        warped_maps_path = element_tempdir / "maps_warped.nii.gz"
+        warped_maps_path = element_tempdir / "maps_warped.nii"
         # Set applywarp command
         applywarp_cmd = [
+            "FSLOUTPUTTYPE=NIFTI",
             "applywarp",
             "--interp=spline",
             f"-i {prewarp_maps_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/masks/_ants_mask_warper.py

@@ -121,16 +121,17 @@ class ANTsMaskWarper:
             logger.debug("Using ANTs for mask transformation")
 
             # Save existing mask image to a tempfile
-            prewarp_mask_path = element_tempdir / "prewarp_mask.nii.gz"
+            prewarp_mask_path = element_tempdir / "prewarp_mask.nii"
             nib.save(mask_img, prewarp_mask_path)
 
             # Create a tempfile for warped output
-            warped_mask_path = element_tempdir / "mask_warped.nii.gz"
+            warped_mask_path = element_tempdir / "mask_warped.nii"
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 "-n 'GenericLabel[NearestNeighbor]'",
                 f"-i {prewarp_mask_path.resolve()}",
                 # use resampled reference
@@ -154,20 +155,21 @@ class ANTsMaskWarper:
                 extra_input=None,
             )
             # Save template to a tempfile
-            template_space_img_path = element_tempdir / f"{dst}_T1w.nii.gz"
+            template_space_img_path = element_tempdir / f"{dst}_T1w.nii"
             nib.save(template_space_img, template_space_img_path)
 
             # Save existing mask image to a tempfile
-            prewarp_mask_path = element_tempdir / "prewarp_mask.nii.gz"
+            prewarp_mask_path = element_tempdir / "prewarp_mask.nii"
             nib.save(mask_img, prewarp_mask_path)
 
             # Create a tempfile for warped output
-            warped_mask_path = element_tempdir / "mask_warped.nii.gz"
+            warped_mask_path = element_tempdir / "mask_warped.nii"
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 f"-n {_get_interpolation_method(mask_img)}",
                 f"-i {prewarp_mask_path.resolve()}",
                 f"-r {template_space_img_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/masks/_fsl_mask_warper.py

@@ -87,13 +87,14 @@ class FSLMaskWarper:
         )
 
         # Save existing mask image to a tempfile
-        prewarp_mask_path = element_tempdir / "prewarp_mask.nii.gz"
+        prewarp_mask_path = element_tempdir / "prewarp_mask.nii"
         nib.save(mask_img, prewarp_mask_path)
 
         # Create a tempfile for warped output
-        warped_mask_path = element_tempdir / "mask_warped.nii.gz"
+        warped_mask_path = element_tempdir / "mask_warped.nii"
         # Set applywarp command
         applywarp_cmd = [
+            "FSLOUTPUTTYPE=NIFTI",
             "applywarp",
             f"--interp={_get_interpolation_method(mask_img)}",
             f"-i {prewarp_mask_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/parcellations/_ants_parcellation_warper.py

@@ -101,19 +101,20 @@ class ANTsParcellationWarper:
 
             # Save existing parcellation image to a tempfile
             prewarp_parcellation_path = (
-                element_tempdir / "prewarp_parcellation.nii.gz"
+                element_tempdir / "prewarp_parcellation.nii"
             )
             nib.save(parcellation_img, prewarp_parcellation_path)
 
             # Create a tempfile for warped output
             warped_parcellation_path = (
-                element_tempdir / "parcellation_warped.nii.gz"
+                element_tempdir / "parcellation_warped.nii"
             )
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 "-n 'GenericLabel[NearestNeighbor]'",
                 f"-i {prewarp_parcellation_path.resolve()}",
                 # use resampled reference
@@ -139,24 +140,25 @@ class ANTsParcellationWarper:
                 extra_input=None,
             )
             # Save template to a tempfile
-            template_space_img_path = element_tempdir / f"{dst}_T1w.nii.gz"
+            template_space_img_path = element_tempdir / f"{dst}_T1w.nii"
             nib.save(template_space_img, template_space_img_path)
 
             # Save existing parcellation image to a tempfile
             prewarp_parcellation_path = (
-                element_tempdir / "prewarp_parcellation.nii.gz"
+                element_tempdir / "prewarp_parcellation.nii"
             )
             nib.save(parcellation_img, prewarp_parcellation_path)
 
             # Create a tempfile for warped output
             warped_parcellation_path = (
-                element_tempdir / "parcellation_warped.nii.gz"
+                element_tempdir / "parcellation_warped.nii"
             )
             # Set antsApplyTransforms command
             apply_transforms_cmd = [
                 "antsApplyTransforms",
                 "-d 3",
                 "-e 3",
+                "--float 1",
                 "-n 'GenericLabel[NearestNeighbor]'",
                 f"-i {prewarp_parcellation_path.resolve()}",
                 f"-r {template_space_img_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/data/parcellations/_fsl_parcellation_warper.py

@@ -67,16 +67,15 @@ class FSLParcellationWarper:
 
         # Save existing parcellation image to a tempfile
         prewarp_parcellation_path = (
-            element_tempdir / "prewarp_parcellation.nii.gz"
+            element_tempdir / "prewarp_parcellation.nii"
         )
         nib.save(parcellation_img, prewarp_parcellation_path)
 
         # Create a tempfile for warped output
-        warped_parcellation_path = (
-            element_tempdir / "parcellation_warped.nii.gz"
-        )
+        warped_parcellation_path = element_tempdir / "parcellation_warped.nii"
         # Set applywarp command
         applywarp_cmd = [
+            "FSLOUTPUTTYPE=NIFTI",
             "applywarp",
             "--interp=nn",
             f"-i {prewarp_parcellation_path.resolve()}",

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/_afni_falff.py

@@ -57,6 +57,7 @@ class AFNIALFF(metaclass=Singleton):
         highpass: float,
         lowpass: float,
         tr: float | None,
+        mask_path: Path | None = None,
     ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF + fALFF map.
 
@@ -70,6 +71,10 @@ class AFNIALFF(metaclass=Singleton):
             Lowpass cutoff frequency.
         tr : positive float, optional
             The Repetition Time of the BOLD data.
+        mask_path : pathlib.Path, optional
+            Path to the mask to restrict the computation to. The voxels
+            outside the mask are set to 0. If None, all the voxels are used
+            (default None).
 
         Returns
         -------
@@ -90,18 +95,23 @@ class AFNIALFF(metaclass=Singleton):
             prefix="afni_lff"
         )
 
-        # Set 3dRSFC command
+        # Set 3dRSFC command; only the parameters are needed, not the
+        # bandpassed time series (-no_rs_out)
         lff_out_path_prefix = element_tempdir / "output"
         bp_cmd = [
             "3dRSFC",
             f"-prefix {lff_out_path_prefix.resolve()}",
             f"-input {input_path.resolve()}",
             f"-band {highpass} {lowpass}",
-            "-no_rsfa -nosat -nodetrend",
+            "-no_rsfa -nosat -nodetrend -no_rs_out",
         ]
         # Check tr
         if tr is not None:
             bp_cmd.append(f"-dt {tr}")
+        # Restrict the computation to the mask, which reduces the memory and
+        # time used by 3dRSFC
+        if mask_path is not None:
+            bp_cmd.append(f"-mask {mask_path.resolve()}")
         # Call 3dRSFC
         run_ext_cmd(name="3dRSFC", cmd=bp_cmd)
 

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/_junifer_falff.py

@@ -50,6 +50,7 @@ class JuniferALFF(metaclass=Singleton):
         highpass: float,
         lowpass: float,
         tr: float | None,
+        mask_path: Path | None = None,
     ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF + fALFF map.
 
@@ -63,6 +64,10 @@ class JuniferALFF(metaclass=Singleton):
             Lowpass cutoff frequency.
         tr : positive float, optional
             The Repetition Time of the BOLD data.
+        mask_path : pathlib.Path, optional
+            Path to the mask to restrict the computation to. The voxels
+            outside the mask are set to 0. If None, all the voxels are used
+            (default None).
 
         Returns
         -------
@@ -102,15 +107,22 @@ class JuniferALFF(metaclass=Singleton):
             f"nyquist = {fft_freqs[-1]}"
         )
 
-        # Process voxels in chunks to bound FFT memory
+        # Process voxels (only the ones in the mask, if any) in chunks to
+        # bound FFT memory
         flat = niimg_data.reshape(-1, n_timepoints)
-        numerator = np.empty(flat.shape[0])
-        denominator = np.empty(flat.shape[0])
+        if mask_path is not None:
+            mask_data = np.squeeze(np.asarray(nib.load(mask_path).dataobj))
+            voxels = np.flatnonzero(mask_data.reshape(-1) != 0)
+        else:
+            voxels = np.arange(flat.shape[0])
+        numerator = np.zeros(flat.shape[0])
+        denominator = np.zeros(flat.shape[0])
         chunk = 20_000
-        for start in range(0, flat.shape[0], chunk):
-            amp = np.abs(sp.fft.rfft(flat[start : start + chunk], axis=-1))
-            denominator[start : start + chunk] = amp @ weights
-            numerator[start : start + chunk] = amp @ band_weights
+        for start in range(0, len(voxels), chunk):
+            t_voxels = voxels[start : start + chunk]
+            amp = np.abs(sp.fft.rfft(flat[t_voxels], axis=-1))
+            denominator[t_voxels] = amp @ weights
+            numerator[t_voxels] = amp @ band_weights
         spatial_shape = niimg_data.shape[:-1]
         numerator = numerator.reshape(spatial_shape)
         denominator = denominator.reshape(spatial_shape)
@@ -137,8 +149,8 @@ class JuniferALFF(metaclass=Singleton):
         element_tempdir = WorkDirManager().get_element_tempdir(
             prefix="junifer_lff"
         )
-        output_alff_path = element_tempdir / "output_alff.nii.gz"
-        output_falff_path = element_tempdir / "output_falff.nii.gz"
+        output_alff_path = element_tempdir / "output_alff.nii"
+        output_falff_path = element_tempdir / "output_falff.nii"
         # Save computed data to file
         nib.save(alff_data, output_alff_path)
         nib.save(falff_data, output_falff_path)

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/falff_base.py

@@ -17,11 +17,13 @@ from typing import (
 
 from pydantic import BeforeValidator, PositiveFloat
 
+from ...data import get_data
 from ...datagrabber import DataType
 from ...storage import StorageType
 from ...typing import ConditionalDependencies, MarkerInOutMappings
 from ...utils import ensure_list_or_none
 from ..base import BaseMarker, logger
+from ..utils import _save_mask
 from ._afni_falff import AFNIALFF
 from ._junifer_falff import JuniferALFF
 
@@ -66,8 +68,10 @@ class ALFFBase(BaseMarker):
         The parameters to pass to the aggregation function.
         See :func:`.get_aggfunc_by_name` for options (default None).
     masks : str, dict, list of them or None, optional
-        The specification of the masks to apply to regions before extracting
-        signals. Check :ref:`Using Masks <using_masks>` for more details.
+        The specification of the masks to apply. The ALFF and fALFF
+        computation is restricted to the voxels in the mask, and the mask is
+        also applied to regions before extracting signals. Check
+        :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
     name : str or None, optional
         The name of the marker.
@@ -115,6 +119,7 @@ class ALFFBase(BaseMarker):
     def _compute(
         self,
         input_data: dict[str, Any],
+        extra_input: dict[str, Any] | None = None,
     ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF and fALFF.
 
@@ -123,7 +128,8 @@ class ALFFBase(BaseMarker):
         input_data : dict
             The input to the marker.
         extra_input : dict, optional
-            The other fields in the pipeline data object (default None).
+            The other fields in the pipeline data object. Used to compute
+            the mask in the space of ``input_data`` (default None).
 
         Returns
         -------
@@ -144,12 +150,26 @@ class ALFFBase(BaseMarker):
             estimator = AFNIALFF()
         elif self.using == "junifer":
             estimator = JuniferALFF()
+        # Get mask in the space of the input data
+        mask_path = None
+        if self.masks is not None:
+            logger.debug(f"Masking with {self.masks}")
+            mask_path = _save_mask(
+                get_data(
+                    kind="mask",
+                    names=self.masks,
+                    target_data=input_data,
+                    extra_input=extra_input,
+                ),
+                prefix="alff_mask",
+            )
         # Compute ALFF + fALFF
         alff, falff, alff_path, falff_path = estimator.compute(  # type: ignore
             input_path=input_data["path"],
             highpass=self.highpass,
             lowpass=self.lowpass,
             tr=self.tr,
+            mask_path=mask_path,
         )
 
         # If the input data space is native already, the original path should

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/falff_maps.py

@@ -92,7 +92,7 @@ class ALFFMaps(ALFFBase):
 
         # Compute ALFF + fALFF
         alff_output, falff_output, alff_output_path, falff_output_path = (
-            self._compute(input_data=input)
+            self._compute(input_data=input, extra_input=extra_input)
         )
 
         # Perform aggregation on ALFF + fALFF

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/falff_parcels.py

@@ -104,7 +104,7 @@ class ALFFParcels(ALFFBase):
 
         # Compute ALFF + fALFF
         alff_output, falff_output, alff_output_path, falff_output_path = (
-            self._compute(input_data=input)
+            self._compute(input_data=input, extra_input=extra_input)
         )
 
         # Perform aggregation on ALFF + fALFF

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/falff/falff_spheres.py

@@ -113,7 +113,7 @@ class ALFFSpheres(ALFFBase):
 
         # Compute ALFF + fALFF
         alff_output, falff_output, alff_output_path, falff_output_path = (
-            self._compute(input_data=input)
+            self._compute(input_data=input, extra_input=extra_input)
         )
 
         # Perform aggregation on ALFF / fALFF

junifer-0.0.8.dev339/junifer/markers/falff/tests/test_falff_mask.py

@@ -0,0 +1,99 @@
+"""Provide tests for the ALFF and fALFF computation with masks."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose, assert_array_equal
+
+from junifer.markers.falff._afni_falff import AFNIALFF
+from junifer.markers.falff._junifer_falff import JuniferALFF
+from junifer.pipeline import WorkDirManager
+from junifer.pipeline.utils import _check_afni
+
+
+def _save(data: np.ndarray, path: Path, tr: float = 2.0) -> Path:
+    """Save data as NIfTI, with the TR in the header for 4D data."""
+    img = nib.Nifti1Image(data, np.eye(4))
+    if data.ndim == 4:
+        img.header.set_zooms((1.0, 1.0, 1.0, tr))
+    nib.save(img, path)
+    return path
+
+
+def _data(tmp_path: Path) -> tuple[Path, Path, np.ndarray]:
+    """Create BOLD data and a mask of half of the voxels."""
+    data = np.random.default_rng(0).normal(size=(6, 6, 6, 100)) + 100
+    bold_path = _save(data.astype(np.float32), tmp_path / "bold.nii")
+    mask = np.zeros((6, 6, 6), dtype=np.uint8)
+    mask[3:] = 1
+    mask_path = _save(mask, tmp_path / "mask.nii")
+    return bold_path, mask_path, mask.astype(bool)
+
+
+@pytest.mark.parametrize(
+    "estimator",
+    [
+        JuniferALFF,
+        pytest.param(
+            AFNIALFF,
+            marks=pytest.mark.skipif(
+                _check_afni() is False, reason="requires AFNI to be in PATH"
+            ),
+        ),
+    ],
+)
+def test_ALFF_mask(
+    estimator: type[JuniferALFF | AFNIALFF], tmp_path: Path
+) -> None:
+    """Test the ALFF and fALFF computation is restricted to the mask.
+
+    The values are computed for each voxel, so inside the mask they are the
+    same as without mask, and outside the mask they are 0.
+
+    Parameters
+    ----------
+    estimator : JuniferALFF or AFNIALFF
+        The ALFF estimator to test.
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    WorkDirManager().workdir = tmp_path
+    bold_path, mask_path, mask = _data(tmp_path)
+    kwargs = {"highpass": 0.01, "lowpass": 0.1, "tr": 2.0}
+    masked = estimator().compute(bold_path, mask_path=mask_path, **kwargs)
+    unmasked = estimator().compute(bold_path, **kwargs)
+    for i_map in range(2):  # ALFF and fALFF
+        t_masked = masked[i_map].get_fdata()
+        t_unmasked = unmasked[i_map].get_fdata()
+        assert_array_equal(t_masked[~mask], 0)
+        assert (t_masked[mask] > 0).all()
+        assert_allclose(t_masked[mask], t_unmasked[mask], rtol=1e-6)
+
+
+@pytest.mark.skipif(
+    _check_afni() is False, reason="requires AFNI to be in PATH"
+)
+def test_AFNIALFF_no_time_series(tmp_path: Path) -> None:
+    """Test 3dRSFC does not output the bandpassed time series.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    WorkDirManager().workdir = tmp_path
+    bold_path, mask_path, _ = _data(tmp_path)
+    alff_path = AFNIALFF().compute(
+        bold_path, highpass=0.01, lowpass=0.1, tr=2.0, mask_path=mask_path
+    )[2]
+    # Only the parameters (ALFF, fALFF and mALFF) are in the output directory
+    outputs = {x.name for x in alff_path.parent.iterdir()}
+    assert not any("_LFF+" in x for x in outputs)
+    assert any("_ALFF+" in x for x in outputs)

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/reho/_junifer_reho.py

@@ -204,7 +204,7 @@ class JuniferReHo(metaclass=Singleton):
         element_tempdir = WorkDirManager().get_element_tempdir(
             prefix="junifer_reho"
         )
-        output_path = element_tempdir / "output.nii.gz"
+        output_path = element_tempdir / "output.nii"
         # Save computed data to file
         nib.save(output_data, output_path)
 

{junifer-0.0.8.dev329 → junifer-0.0.8.dev339}/junifer/markers/reho/reho_base.py

@@ -3,7 +3,6 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import hashlib
 from enum import StrEnum
 from pathlib import Path
 from typing import (
@@ -13,17 +12,15 @@ from typing import (
     ClassVar,
 )
 
-import nibabel as nib
-import numpy as np
 from pydantic import BeforeValidator
 
 from ...data import get_data
 from ...datagrabber import DataType
-from ...pipeline import WorkDirManager
 from ...storage import StorageType
 from ...typing import ConditionalDependencies, MarkerInOutMappings
 from ...utils import ensure_list_or_none
 from ..base import BaseMarker, logger
+from ..utils import _save_mask
 from ._afni_reho import AFNIReHo
 from ._junifer_reho import JuniferReHo
 
@@ -199,7 +196,8 @@ class ReHoBase(BaseMarker):
                     names=self.masks,
                     target_data=input_data,
                     extra_input=extra_input,
-                )
+                ),
+                prefix="reho_mask",
             )
         # Compute reho
         reho_map, reho_map_path = estimator.compute(  # type: ignore
@@ -217,38 +215,3 @@ class ReHoBase(BaseMarker):
             return reho_map, input_data["path"]
 
         return reho_map, reho_map_path
-
-
-def _save_mask(mask_img: "Nifti1Image") -> Path:
-    """Save mask to the working directory, named by its content.
-
-    The same mask always gets the same path, so that the cached ReHo
-    computation can be reused by markers using the same mask.
-
-    Parameters
-    ----------
-    mask_img : Niimg-like object
-        The mask to save.
-
-    Returns
-    -------
-    pathlib.Path
-        The path to the saved mask.
-
-    """
-    mask_data = np.squeeze(np.asarray(mask_img.dataobj)) != 0
-    digest = hashlib.sha256()
-    digest.update(str(mask_data.shape).encode())
-    digest.update(np.packbits(mask_data).tobytes())
-    digest.update(mask_img.affine.tobytes())
-    mask_path = (
-        WorkDirManager().workdir / f"reho_mask_{digest.hexdigest()[:16]}.nii"
-    )
-    if not mask_path.exists():
-        nib.save(
-            nib.Nifti1Image(
-                mask_data.astype(np.uint8), mask_img.affine, mask_img.header
-            ),
-            mask_path,
-        )
-    return mask_path