junifer 0.0.8.dev335__tar.gz → 0.0.8.dev339__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev335
+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/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.dev335 → 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.dev335'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev335')
+__version__ = version = '0.0.8.dev339'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev339')
 
-__commit_id__ = commit_id = 'g611612030'
+__commit_id__ = commit_id = 'gd12ff17f7'

{junifer-0.0.8.dev335 → 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.dev335 → 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)

{junifer-0.0.8.dev335 → 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.dev335 → 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.dev335 → 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.dev335 → 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.dev335 → 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

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/markers/tests/test_marker_utils.py

@@ -6,10 +6,14 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from pathlib import Path
+
+import nibabel as nib
 import numpy as np
 import pytest
 
-from junifer.markers.utils import _ets
+from junifer.markers.utils import _ets, _save_mask
+from junifer.pipeline import WorkDirManager
 
 
 def test_ets() -> None:
@@ -48,3 +52,38 @@ def test_ets_incorrect_label_list() -> None:
         ValueError, match="List of roi names does not correspond"
     ):
         _ets(bold_ts, roi_labels)
+
+
+def test_save_mask(tmp_path: Path) -> None:
+    """Test saving masks in the element directory, named by their content.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    data = np.zeros((3, 4, 5), dtype=np.int8)
+    data[1, 1:3, 2:4] = 1
+    mask = nib.Nifti1Image(data, np.eye(4))
+    path = _save_mask(mask, prefix="test_mask")
+    # In the element directory, with the voxels in the mask
+    assert path.parent == workdir_mgr.elementdir
+    assert path.name.startswith("test_mask_")
+    assert np.array_equal(np.asarray(nib.load(path).dataobj), data)
+    # The same mask (another image) has the same path, a different one not
+    assert (
+        _save_mask(nib.Nifti1Image(data.copy(), np.eye(4)), prefix="test_mask")
+        == path
+    )
+    other = data.copy()
+    other[0, 0, 0] = 1
+    assert (
+        _save_mask(nib.Nifti1Image(other, np.eye(4)), prefix="test_mask")
+        != path
+    )
+    # Deleted with the element directory
+    workdir_mgr.cleanup_elementdir()
+    assert not path.exists()

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/markers/utils.py

@@ -8,18 +8,62 @@
 #          Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 # License: AGPL
 
+import hashlib
 import zlib
 from collections.abc import Callable
+from pathlib import Path
 from typing import Any
 
+import nibabel as nib
 import numpy as np
 import pandas as pd
 from nibabel.spatialimages import SpatialImage
 from scipy.stats import zscore
 
+from ..pipeline import WorkDirManager
 from ..utils import raise_error
 
 
+def _save_mask(mask_img: SpatialImage, prefix: str) -> Path:
+    """Save mask to the element directory, named by its content.
+
+    The same mask always gets the same path within an element, so that the
+    cached computations (e.g., ReHo or ALFF) can be reused by markers using
+    the same mask. The element directory is deleted after the element is
+    processed.
+
+    Parameters
+    ----------
+    mask_img : Niimg-like object
+        The mask to save.
+    prefix : str
+        The prefix of the file name.
+
+    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().get_elementdir()
+        / f"{prefix}_{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
+
+
 def _has_data(data: np.ndarray) -> np.ndarray:
     """Get the columns with data.
 

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/pipeline/tests/test_workdir_manager.py

@@ -95,6 +95,30 @@ def test_workdir_manager_cleanup_elementdir(
     assert workdir_mgr.elementdir is None
 
 
+def test_workdir_manager_get_elementdir(tmp_path: Path) -> None:
+    """Test WorkDirManager gets the element directory correctly.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    assert workdir_mgr.elementdir is None
+    # Created on the first call, and the same afterwards
+    elementdir = workdir_mgr.get_elementdir()
+    assert elementdir.is_dir()
+    assert elementdir.parent == tmp_path
+    assert workdir_mgr.get_elementdir() == elementdir
+    # The element temporary directories are in it
+    assert workdir_mgr.get_element_tempdir().parent == elementdir
+    workdir_mgr.cleanup_elementdir()
+    assert not elementdir.exists()
+    assert workdir_mgr.elementdir is None
+
+
 def test_workdir_manager_get_and_delete_tempdir(tmp_path: Path) -> None:
     """Test WorkDirManager gets and deletes temporary directories correctly.
 

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/pipeline/workdir_manager.py

@@ -128,6 +128,26 @@ class WorkDirManager(metaclass=Singleton):
         """Get element directory."""
         return self._elementdir  # type: ignore
 
+    def get_elementdir(self) -> Path:
+        """Get the element directory, creating it if needed.
+
+        This directory should be available only for the lifetime of an
+        element.
+
+        Returns
+        -------
+        pathlib.Path
+            The path to the element directory.
+
+        """
+        if self._elementdir is None:
+            logger.debug(
+                "Setting up element directory under "
+                f"{self._workdir.resolve()!s}"  # type: ignore
+            )
+            self._elementdir = Path(tempfile.mkdtemp(dir=self._workdir))
+        return self._elementdir
+
     def get_element_tempdir(
         self, prefix: str | None = None, suffix: str | None = None
     ) -> Path:
@@ -151,22 +171,12 @@ class WorkDirManager(metaclass=Singleton):
             The path to the temporary directory.
 
         """
-        # Create element directory if not created already
-        if self._elementdir is None:
-            logger.debug(
-                "Setting up element directory under "
-                f"{self._workdir.resolve()!s}"  # type: ignore
-            )
-            self._elementdir = Path(tempfile.mkdtemp(dir=self._workdir))
-
+        elementdir = self.get_elementdir()
         logger.debug(
-            "Creating element temporary directory at "
-            f"{self._elementdir.resolve()!s}"
+            f"Creating element temporary directory at {elementdir.resolve()!s}"
         )
         return Path(
-            tempfile.mkdtemp(
-                dir=self._elementdir, prefix=prefix, suffix=suffix
-            )
+            tempfile.mkdtemp(dir=elementdir, prefix=prefix, suffix=suffix)
         )
 
     def delete_element_tempdir(self, tempdir: Path) -> None:

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/preprocess/_temporal_filter.py

@@ -201,8 +201,10 @@ class TemporalFilter(BasePreprocessor):
             {
                 # Update path to sync with "data"
                 "path": filtered_data_path,
-                # Update data
-                "data": cleaned_img,
+                # Update data, loaded from the file to not keep the
+                # in-memory image (memory-mapped, as the file is not
+                # compressed)
+                "data": nib.load(filtered_data_path),
             }
         )
 

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/preprocess/_temporal_slicer.py

@@ -159,8 +159,10 @@ class TemporalSlicer(BasePreprocessor):
             {
                 # Update path to sync with "data"
                 "path": sliced_img_path,
-                # Update data
-                "data": sliced_img,
+                # Update data, loaded from the file to not keep the
+                # in-memory image (memory-mapped, as the file is not
+                # compressed)
+                "data": nib.load(sliced_img_path),
             }
         )
 

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/preprocess/confounds/fmriprep_confound_remover.py

@@ -694,8 +694,10 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             {
                 # Update path to sync with "data"
                 "path": deconfounded_img_path,
-                # Update data
-                "data": cleaned_img,
+                # Update data, loaded from the file to not keep the
+                # in-memory image (memory-mapped, as the file is not
+                # compressed)
+                "data": nib.load(deconfounded_img_path),
             }
         )
 

{junifer-0.0.8.dev335 → junifer-0.0.8.dev339}/junifer/preprocess/confounds/tests/test_fmriprep_confound_remover.py

@@ -5,6 +5,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import nibabel as nib
 import numpy as np
 import pandas as pd
 import pytest
@@ -498,6 +499,9 @@ def test_fMRIPrepConfoundRemover_fit_transform() -> None:
         # Fit-transform
         output = confound_remover.fit_transform(element_data)
         output_img = output["BOLD"]["data"]
+        # The data is loaded from the saved file, not kept in memory
+        assert nib.is_proxy(output_img.dataobj)
+        assert output_img.get_filename() == str(output["BOLD"]["path"])
         output_bold = output_img.get_fdata()
         output_tr = output_img.header.get_zooms()[3]
 
@@ -554,6 +558,9 @@ def test_fMRIPrepConfoundRemover_fit_transform_masks() -> None:
         # Fit-transform
         output = confound_remover.fit_transform(element_data)
         output_img = output["BOLD"]["data"]
+        # The data is loaded from the saved file, not kept in memory
+        assert nib.is_proxy(output_img.dataobj)
+        assert output_img.get_filename() == str(output["BOLD"]["path"])
         output_bold = output_img.get_fdata()
         output_tr = output_img.header.get_zooms()[3]