junifer 0.0.8.dev339__tar.gz → 0.0.8.dev346__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev339
+Version: 0.0.8.dev346
 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.dev346/docs/changes/newsfragments/534.enh

@@ -0,0 +1 @@
+Read only the signals of the voxels of the spheres, in chunks of ``markers.spheres.chunksize`` volumes (default 100), in :class:`.JuniferNiftiSpheresMasker`, instead of loading the whole 4D data, reducing the memory used by the sphere-based markers (e.g., :class:`.SphereAggregation` and :class:`.FunctionalConnectivitySpheres`) on BOLD data, with the same results, and do not change the input data when it has NaN values by `Fede Raimondo`_

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

@@ -69,3 +69,10 @@ Available Configurations
      - | 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_MARKERS_SPHERES_CHUNKSIZE``
+     - ``markers.spheres.chunksize``
+     - int
+     - | Number of volumes of 4D data to read at once to extract the signals
+       | of spheres (e.g., :class:`.SphereAggregation`) (default 100). Only
+       | the signals of the voxels of the spheres are kept, so the whole data
+       | is never in memory, and smaller chunks use less memory

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/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.dev339'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev339')
+__version__ = version = '0.0.8.dev346'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev346')
 
-__commit_id__ = commit_id = 'gd12ff17f7'
+__commit_id__ = commit_id = 'g936d23c84'

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer/external/nilearn/junifer_nifti_spheres_masker.py

@@ -15,7 +15,7 @@ from nilearn.maskers.base_masker import filter_and_extract
 from sklearn import neighbors
 from sklearn.utils.validation import check_is_fitted
 
-from ...utils import raise_error, warn_with_log
+from ...utils import config, raise_error, warn_with_log
 
 
 if TYPE_CHECKING:
@@ -24,6 +24,7 @@ if TYPE_CHECKING:
     from nibabel import Nifti1Image, Nifti2Image
     from numpy.typing import ArrayLike, DTypeLike
     from pandas import DataFrame
+    from scipy.sparse import lil_matrix
 
 
 __all__ = ["JuniferNiftiSpheresMasker"]
@@ -62,14 +63,40 @@ __all__ = ["JuniferNiftiSpheresMasker"]
 # DAMAGE.
 
 
-def _apply_mask_and_get_affinity(
+def _get_chunk_size() -> int:
+    """Get the number of volumes to read at once.
+
+    Returns
+    -------
+    int
+        The value of ``markers.spheres.chunksize`` (default 100).
+
+    Raises
+    ------
+    ValueError
+        If ``markers.spheres.chunksize`` is not a positive integer.
+
+    """
+    chunk_size = config.get("markers.spheres.chunksize", 100)
+    if (
+        isinstance(chunk_size, bool)
+        or not isinstance(chunk_size, int)
+        or chunk_size < 1
+    ):
+        raise_error(
+            "`markers.spheres.chunksize` must be a positive integer, "
+            f"but is {chunk_size}"
+        )
+    return chunk_size
+
+
+def _get_sphere_voxels(
     seeds, niimg, radius, allow_overlap, mask_img=None
-):
-    """Apply mask and get affinity matrix for given seeds.
+) -> tuple[np.ndarray, "lil_matrix"]:
+    """Get the voxels of the spheres at given seed locations.
 
-    Utility function to get only the rows which are occupied by sphere at
-    given seed locations and the provided radius. Rows are in target_affine and
-    target_shape space.
+    The voxels only depend on the geometry (and the mask), so the data of
+    ``niimg`` is not read.
 
     Parameters
     ----------
@@ -79,8 +106,6 @@ def _apply_mask_and_get_affinity(
     niimg : 3D/4D Niimg-like object
         See :ref:`extracting_data`.
         Images to process.
-        If a 3D niimg is provided, a singleton dimension will be added to
-        the output to represent the single scan in the niimg.
     radius : float
         Indicates, in millimeters, the radius for the sphere around the seed.
     allow_overlap : boolean
@@ -92,9 +117,9 @@ def _apply_mask_and_get_affinity(
 
     Returns
     -------
-    X : 2D numpy.ndarray
-        Signal for each brain voxel in the (masked) niimgs.
-        shape: (number of scans, number of voxels)
+    voxels : 1D numpy.ndarray
+        The flat (C order) index in ``niimg`` of each voxel (column of ``A``):
+        the voxels in the mask or all the voxels if there is no mask.
     A : scipy.sparse.lil_matrix
         Contains the boolean indices for each sphere.
         shape: (number of seeds, number of voxels)
@@ -102,54 +127,38 @@ def _apply_mask_and_get_affinity(
     Raises
     ------
     ValueError
-        If ``niimg`` and ``mask_img`` are both provided or
+        If ``niimg`` and ``mask_img`` are both not provided or
         if overlap is detected between spheres.
 
-    Warns
-    -----
-    RuntimeWarning
-        If the provided images contain NaN, they will be converted to zeroes.
-
     """
     seeds = list(seeds)
-
     # Compute world coordinates of all in-mask voxels.
     if niimg is None:
+        if mask_img is None:
+            raise_error("Either a niimg or a mask_img must be provided.")
         mask, affine = masking.load_mask_img(mask_img)
+        shape = mask.shape
         # Get coordinate for all voxels inside of mask
         mask_coords = np.asarray(np.nonzero(mask)).T.tolist()
-        X = None
-
     elif mask_img is not None:
         affine = niimg.affine
+        shape = niimg.shape[:3]
         mask_img = check_niimg_3d(mask_img)
         mask_img = image.resample_img(
             mask_img,
             target_affine=affine,
-            target_shape=niimg.shape[:3],
+            target_shape=shape,
             interpolation="nearest",
         )
         mask, _ = masking.load_mask_img(mask_img)
         mask_coords = list(zip(*np.where(mask != 0), strict=False))
-
-        X = masking.apply_mask_fmri(niimg, mask_img)
-
-    elif niimg is not None:
-        affine = niimg.affine
-        if np.isnan(np.sum(safe_get_data(niimg))):
-            warn_with_log(
-                "The imgs you have fed into fit_transform() contains NaN "
-                "values which will be converted to zeroes."
-            )
-            X = safe_get_data(niimg, True).reshape([-1, niimg.shape[3]]).T
-        else:
-            X = safe_get_data(niimg).reshape([-1, niimg.shape[3]]).T
-
-        mask_coords = list(np.ndindex(niimg.shape[:3]))
-
     else:
-        raise_error("Either a niimg or a mask_img must be provided.")
-
+        affine = niimg.affine
+        shape = niimg.shape[:3]
+        mask_coords = list(np.ndindex(shape))
+    voxels = np.ravel_multi_index(
+        tuple(np.asarray(mask_coords, dtype=int).reshape(-1, 3).T), shape
+    )
     # For each seed, get coordinates of nearest voxel
     nearests = []
     for sx, sy, sz in seeds:
@@ -190,6 +199,132 @@ def _apply_mask_and_get_affinity(
     if (not allow_overlap) and np.any(A.sum(axis=0) >= 2):
         raise_error("Overlap detected between spheres")
 
+    return voxels, A
+
+
+def _read_signals(niimg, voxels, masked) -> np.ndarray:
+    """Read the signals of some voxels, a few volumes at a time.
+
+    The data is read in chunks of ``markers.spheres.chunksize`` volumes and
+    only the signals of ``voxels`` are kept, so the whole data is never in
+    memory. The values are the same as extracting the signals from the whole
+    data with :func:`nilearn.masking.apply_mask_fmri` (``masked``) or
+    :func:`nilearn._utils.niimg.safe_get_data` (not ``masked``).
+
+    Parameters
+    ----------
+    niimg : 4D Niimg-like object
+        The image to read.
+    voxels : 1D numpy.ndarray
+        The flat (C order) indices of the voxels to read.
+    masked : bool
+        Whether the voxels are the ones of a mask: as
+        :func:`nilearn.masking.apply_mask_fmri` does, the signals are then
+        float32 if the data is not floating point, and the non-finite values
+        are set to 0. Otherwise, the signals keep the data type of the image
+        and the non-finite values are set to 0 only if the image has NaN
+        values, with a warning.
+
+    Returns
+    -------
+    numpy.ndarray of shape (number of scans, number of voxels)
+        The signals of the voxels.
+
+    """
+    n_scans = niimg.shape[3]
+    chunk_size = _get_chunk_size()
+    signals = None
+    has_nan = False
+    for start in range(0, n_scans, chunk_size):
+        chunk = np.asanyarray(niimg.dataobj[..., start : start + chunk_size])
+        if not masked and not has_nan:
+            has_nan = bool(np.isnan(np.sum(chunk)))
+        chunk = chunk.reshape(-1, chunk.shape[-1])[voxels].T
+        if masked and chunk.dtype.kind != "f":
+            chunk = chunk.astype(np.float32)
+        if signals is None:
+            signals = np.empty((n_scans, len(voxels)), dtype=chunk.dtype)
+        signals[start : start + chunk.shape[0]] = chunk
+    if masked or has_nan:
+        if has_nan:
+            warn_with_log(
+                "The imgs you have fed into fit_transform() contains NaN "
+                "values which will be converted to zeroes."
+            )
+        signals[~np.isfinite(signals)] = 0
+    return signals
+
+
+def _apply_mask_and_get_affinity(
+    seeds, niimg, radius, allow_overlap, mask_img=None
+):
+    """Apply mask and get affinity matrix for given seeds.
+
+    Utility function to get only the rows which are occupied by sphere at
+    given seed locations and the provided radius. Rows are in target_affine and
+    target_shape space.
+
+    Parameters
+    ----------
+    seeds : List of triplets of coordinates in native space
+        Seed definitions. List of coordinates of the seeds in the same space
+        as target_affine.
+    niimg : 3D/4D Niimg-like object
+        See :ref:`extracting_data`.
+        Images to process.
+        If a 3D niimg is provided, a singleton dimension will be added to
+        the output to represent the single scan in the niimg.
+    radius : float
+        Indicates, in millimeters, the radius for the sphere around the seed.
+    allow_overlap : boolean
+        If False, a ValueError is raised if VOIs overlap
+    mask_img : Niimg-like object, optional
+        Mask to apply to regions before extracting signals. If niimg is None,
+        mask_img is used as a reference space in which the spheres 'indices are
+        placed.
+
+    Returns
+    -------
+    X : 2D numpy.ndarray
+        Signal for each brain voxel in the (masked) niimgs.
+        shape: (number of scans, number of voxels)
+    A : scipy.sparse.lil_matrix
+        Contains the boolean indices for each sphere.
+        shape: (number of seeds, number of voxels)
+
+    Raises
+    ------
+    ValueError
+        If ``niimg`` and ``mask_img`` are both provided or
+        if overlap is detected between spheres.
+
+    Warns
+    -----
+    RuntimeWarning
+        If the provided images contain NaN, they will be converted to zeroes.
+
+    """
+    _, A = _get_sphere_voxels(
+        seeds, niimg, radius, allow_overlap, mask_img=mask_img
+    )
+    X = None
+    if niimg is not None and mask_img is not None:
+        mask_img = image.resample_img(
+            check_niimg_3d(mask_img),
+            target_affine=niimg.affine,
+            target_shape=niimg.shape[:3],
+            interpolation="nearest",
+        )
+        X = masking.apply_mask_fmri(niimg, mask_img)
+    elif niimg is not None:
+        if np.isnan(np.sum(safe_get_data(niimg))):
+            warn_with_log(
+                "The imgs you have fed into fit_transform() contains NaN "
+                "values which will be converted to zeroes."
+            )
+            X = safe_get_data(niimg, True).reshape([-1, niimg.shape[3]]).T
+        else:
+            X = safe_get_data(niimg).reshape([-1, niimg.shape[3]]).T
     return X, A
 
 
@@ -198,16 +333,17 @@ def _iter_signals_from_spheres(
 ):
     """Iterate over spheres.
 
+    Only the signals of the voxels of the spheres are read, a few volumes at
+    a time (see :func:`_read_signals`), so the whole data is never in memory.
+
     Parameters
     ----------
     seeds : :obj:`list` of triplets of coordinates in native space
         Seed definitions. List of coordinates of the seeds in the same space
         as the images (typically MNI or TAL).
-    niimg : 3D/4D Niimg-like object
+    niimg : 4D Niimg-like object
         See :ref:`extracting_data`.
         Images to process.
-        If a 3D niimg is provided, a singleton dimension will be added to
-        the output to represent the single scan in the niimg.
     radius: float
         Indicates, in millimeters, the radius for the sphere around the seed.
     allow_overlap: boolean
@@ -218,11 +354,17 @@ def _iter_signals_from_spheres(
         Mask to apply to regions before extracting signals.
 
     """
-    X, A = _apply_mask_and_get_affinity(
+    voxels, A = _get_sphere_voxels(
         seeds, niimg, radius, allow_overlap, mask_img=mask_img
     )
-    for row in A.rows:
-        yield X[:, row]
+    rows = [np.asarray(row, dtype=int) for row in A.rows]
+    # The voxels of any sphere, and their position in the signals read
+    used = np.unique(np.concatenate([np.zeros(0, dtype=int), *rows]))
+    position = np.full(len(voxels), -1, dtype=int)
+    position[used] = np.arange(len(used))
+    signals = _read_signals(niimg, voxels[used], masked=mask_img is not None)
+    for row in rows:
+        yield signals[:, position[row]]
 
 
 class _JuniferExtractionFunctor:
@@ -321,6 +463,11 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
     * it allows to pass any callable as the ``agg_func`` parameter.
     * empty spheres do not create an error. Instead, ``agg_func`` is applied to
       an empty array and the result is passed.
+    * only the signals of the voxels of the spheres are read, a few volumes at
+      a time (``markers.spheres.chunksize``), so the whole data is never in
+      memory.
+    * ``reports`` is False by default, as the data for the reports (e.g., the
+      middle volume of the resampled images) needs the whole data in memory.
 
     Parameters
     ----------
@@ -359,6 +506,9 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
         self.agg_func = agg_func
         # nilearn's default (False) is deprecated, use the new equivalent
         kwargs.setdefault("standardize", None)
+        # The reports are not used, and computing their data at fit time
+        # loads (and resamples) the whole data
+        kwargs.setdefault("reports", False)
         super().__init__(
             seeds=seeds,
             radius=radius,

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer/external/nilearn/tests/test_junifer_nifti_spheres_masker.py

@@ -3,6 +3,8 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from pathlib import Path
+
 import nibabel
 import numpy as np
 import pytest
@@ -12,6 +14,12 @@ from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_equal
 
 from junifer.external.nilearn import JuniferNiftiSpheresMasker
+from junifer.external.nilearn.junifer_nifti_spheres_masker import (
+    _apply_mask_and_get_affinity,
+    _get_sphere_voxels,
+    _iter_signals_from_spheres,
+)
+from junifer.testing import config_override
 
 
 # New BSD License
@@ -397,3 +405,213 @@ def test_junifer_and_nilearn_mean_agg_are_equal(
     # Checks
     assert junifer_output.shape == nilearn_output.shape
     np.testing.assert_almost_equal(junifer_output, nilearn_output)
+
+
+def _spheres_data(
+    tmp_path: Path, dtype: str = "float32", with_nan: bool = True
+) -> tuple[nibabel.Nifti1Image, nibabel.Nifti1Image, list]:
+    """Create a file-backed 4D image, a mask and seeds for the spheres."""
+    rng = np.random.default_rng(42)
+    affine = np.diag([3.0, 3.0, 3.0, 1.0])
+    affine[:3, 3] = -30
+    data = rng.normal(100, 10, size=(21, 21, 21, 23))
+    if with_nan:
+        data[10, 10, 10, 3] = np.nan
+    nibabel.save(
+        nibabel.Nifti1Image(data.astype(dtype), affine), tmp_path / "data.nii"
+    )
+    mask = np.zeros((21, 21, 21), dtype="int8")
+    mask[4:17, 3:18, 5:16] = 1
+    mask_img = nibabel.Nifti1Image(mask, affine)
+    # The last seed is outside the image, so its sphere is empty
+    seeds = [(0, 0, 0), (12, -9, 6), (-24, 24, 24), (100, 100, 100)]
+    return nibabel.load(tmp_path / "data.nii"), mask_img, seeds
+
+
+@pytest.mark.parametrize("chunk_size", [1, 5, 23, 100])
+@pytest.mark.parametrize("masked", [True, False])
+@pytest.mark.parametrize(
+    "dtype, with_nan",
+    [
+        ("float32", True),
+        ("float32", False),
+        ("float64", True),
+        ("int16", False),
+    ],
+)
+def test_iter_signals_from_spheres_chunks(
+    tmp_path: Path, chunk_size: int, masked: bool, dtype: str, with_nan: bool
+) -> None:
+    """Test the signals of the spheres read in chunks of volumes.
+
+    They are the same as the ones extracted from the whole data.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    chunk_size : int
+        The parametrized number of volumes to read at once.
+    masked : bool
+        The parametrized use of a mask.
+    dtype : str
+        The parametrized data type.
+    with_nan : bool
+        The parametrized presence of a NaN value in the data.
+
+    """
+    img, mask_img, seeds = _spheres_data(tmp_path, dtype, with_nan)
+    mask_img = mask_img if masked else None
+    X, A = _apply_mask_and_get_affinity(
+        seeds, img, radius=4.0, allow_overlap=True, mask_img=mask_img
+    )
+    with config_override("markers.spheres.chunksize", chunk_size):
+        signals = list(
+            _iter_signals_from_spheres(
+                seeds, img, radius=4.0, allow_overlap=True, mask_img=mask_img
+            )
+        )
+    assert len(signals) == len(seeds)
+    assert signals[-1].shape == (23, 0)
+    for row, t_signals in zip(A.rows, signals, strict=True):
+        assert t_signals.dtype == X.dtype
+        assert_array_equal(t_signals, X[:, row])
+
+
+def test_JuniferNiftiSpheresMasker_input_unchanged(tmp_path: Path) -> None:
+    """Test the masker does not change the input data.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    img, _, seeds = _spheres_data(tmp_path)
+    data = np.asarray(img.dataobj).copy()
+    in_memory = nibabel.Nifti1Image(data.copy(), img.affine)
+    with pytest.warns(RuntimeWarning, match="NaN values"):
+        JuniferNiftiSpheresMasker(
+            seeds=seeds, radius=4.0, allow_overlap=True
+        ).fit_transform(in_memory)
+    # The NaN is still there
+    assert_array_equal(np.asarray(in_memory.dataobj), data)
+
+
+@pytest.mark.parametrize("chunk_size", [0, -1, 1.5, True, "10"])
+def test_JuniferNiftiSpheresMasker_chunk_size_error(
+    tmp_path: Path, chunk_size: object
+) -> None:
+    """Test the masker with an invalid number of volumes to read at once.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    chunk_size : object
+        The parametrized invalid number of volumes.
+
+    """
+    img, _, seeds = _spheres_data(tmp_path)
+    with config_override("markers.spheres.chunksize", chunk_size):
+        with pytest.raises(ValueError, match="must be a positive integer"):
+            JuniferNiftiSpheresMasker(seeds=seeds, radius=4.0).fit_transform(
+                img
+            )
+
+
+def test_JuniferNiftiSpheresMasker_reports() -> None:
+    """Test the reports are disabled by default, as they load the data."""
+    assert JuniferNiftiSpheresMasker(seeds=[(1, 1, 1)]).reports is False
+    masker = JuniferNiftiSpheresMasker(seeds=[(1, 1, 1)], reports=True)
+    assert masker.reports is True
+
+
+def test_get_sphere_voxels_mask_only(tmp_path: Path) -> None:
+    """Test the voxels of the spheres with only a mask, without an image.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    img, mask_img, seeds = _spheres_data(tmp_path)
+    voxels, A = _get_sphere_voxels(
+        seeds, img, radius=4.0, allow_overlap=True, mask_img=mask_img
+    )
+    mask_voxels, mask_A = _get_sphere_voxels(
+        seeds, None, radius=4.0, allow_overlap=True, mask_img=mask_img
+    )
+    assert_array_equal(mask_voxels, voxels)
+    assert mask_A.rows.tolist() == A.rows.tolist()
+    # No signals without an image
+    X, _ = _apply_mask_and_get_affinity(
+        seeds, None, radius=4.0, allow_overlap=True, mask_img=mask_img
+    )
+    assert X is None
+    with pytest.raises(ValueError, match="Either a niimg or a mask_img"):
+        _get_sphere_voxels(seeds, None, radius=4.0, allow_overlap=True)
+
+
+@pytest.mark.parametrize("dtype", ["auto", "float64"])
+def test_JuniferNiftiSpheresMasker_dtype(tmp_path: Path, dtype: str) -> None:
+    """Test the data type of the signals is the same as with nilearn.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    dtype : str
+        The parametrized data type of the extraction.
+
+    """
+    img, _, seeds = _spheres_data(tmp_path, "float32", with_nan=False)
+    junifer_signals = JuniferNiftiSpheresMasker(
+        seeds=seeds[:3], radius=4.0, allow_overlap=True, dtype=dtype
+    ).fit_transform(img)
+    nilearn_signals = NiftiSpheresMasker(
+        seeds=seeds[:3], radius=4.0, allow_overlap=True, dtype=dtype
+    ).fit_transform(img)
+    assert junifer_signals.dtype == nilearn_signals.dtype
+    np.testing.assert_allclose(junifer_signals, nilearn_signals, rtol=1e-6)
+
+
+@pytest.mark.parametrize("chunk_size", [5, 100])
+@pytest.mark.parametrize("masked", [True, False])
+@pytest.mark.parametrize("with_nan", [True, False])
+def test_junifer_and_nilearn_spheres_are_equal(
+    tmp_path: Path, chunk_size: int, masked: bool, with_nan: bool
+) -> None:
+    """Test the signals of the spheres are the same as with nilearn.
+
+    The signals are read in chunks of volumes from a file-backed image.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    chunk_size : int
+        The parametrized number of volumes to read at once.
+    masked : bool
+        The parametrized use of a mask.
+    with_nan : bool
+        The parametrized presence of a NaN value in the data.
+
+    """
+    img, mask_img, seeds = _spheres_data(tmp_path, with_nan=with_nan)
+    # Only the seeds with voxels in the mask, as nilearn fails for empty
+    # spheres
+    params = {
+        "seeds": seeds[:2],
+        "radius": 4.0,
+        "allow_overlap": True,
+        "mask_img": mask_img if masked else None,
+    }
+    with config_override("markers.spheres.chunksize", chunk_size):
+        junifer_signals = JuniferNiftiSpheresMasker(**params).fit_transform(
+            img
+        )
+    nilearn_signals = NiftiSpheresMasker(**params).fit_transform(img)
+    assert junifer_signals.dtype == nilearn_signals.dtype
+    np.testing.assert_allclose(junifer_signals, nilearn_signals, rtol=1e-6)

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer/markers/maps_aggregation.py

@@ -194,6 +194,8 @@ class MapsAggregation(BaseMarker):
             mask_img=mask_img,
             resampling_target=None,
             standardize=None,
+            # Not used, and computing their data at fit time reads the data
+            reports=False,
         )
         # Mask the input data and extract data
         # nilearn maskers return 1D arrays for 3D images, keep 2D

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer/markers/parcel_aggregation.py

@@ -220,7 +220,9 @@ class ParcelAggregation(BaseMarker):
         # tailored to the input image, so no target affine is needed (it
         # would make nilearn crop and copy the input image)
         logger.debug("Masking")
-        masker = NiftiMasker(parcellation_bin, standardize=None)
+        # No reports, as they are not used and computing their data at fit
+        # time reads the data
+        masker = NiftiMasker(parcellation_bin, standardize=None, reports=False)
         # Mask the input data and the parcellation
         # nilearn maskers return 1D arrays for 3D images, keep 2D
         data = np.atleast_2d(masker.fit_transform(t_input_img))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev339
+Version: 0.0.8.dev346
 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 → junifer-0.0.8.dev346}/junifer.egg-info/SOURCES.txt

@@ -157,6 +157,7 @@ docs/changes/newsfragments/530.enh.1
 docs/changes/newsfragments/531.enh
 docs/changes/newsfragments/533.enh
 docs/changes/newsfragments/533.enh.1
+docs/changes/newsfragments/534.enh
 docs/extending/confounds_format.rst
 docs/extending/coordinates.rst
 docs/extending/data_dump_asset.rst

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer.egg-info/scm_file_list.json

@@ -141,6 +141,7 @@
     "docs/changes/newsfragments/531.enh",
     "docs/changes/newsfragments/533.enh",
     "docs/changes/newsfragments/533.enh.1",
+    "docs/changes/newsfragments/534.enh",
     "docs/conf.py",
     "docs/contribution.rst",
     "docs/extending/confounds_format.rst",

{junifer-0.0.8.dev339 → junifer-0.0.8.dev346}/junifer.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "0.0.7",
-  "distance": 339,
-  "node": "gd12ff17f7d2d27a6d19b9984c848cbc330517746",
+  "distance": 346,
+  "node": "g936d23c84af77f42851ae98deb7080b16556b831",
   "dirty": false,
   "branch": "main",
   "node_date": "2026-10-19"