junifer 0.0.8.dev253__tar.gz → 0.0.8.dev257__tar.gz

{junifer-0.0.8.dev253/junifer.egg-info → junifer-0.0.8.dev257}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev253
+Version: 0.0.8.dev257
 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.dev257/docs/changes/newsfragments/514.bugfix

@@ -0,0 +1 @@
+Fix ReHo computation with ``using="junifer"`` including neighbours outside the mask, checking the wrong centre voxel for ``nneigh=125``, setting voxels outside the mask to 1 instead of 0, skipping voxels at the edges of the volume and setting fully tied neighbourhoods to 1 instead of 0, so that it matches AFNI's ``3dReHo`` by `Fede Raimondo`_

junifer-0.0.8.dev257/docs/changes/newsfragments/514.bugfix.1

@@ -0,0 +1 @@
+Use the ``masks`` parameter of :class:`.ReHoMaps`, :class:`.ReHoParcels` and :class:`.ReHoSpheres` to restrict the ReHo computation for both ``using="junifer"`` and ``using="afni"``, instead of an MNI152 brain mask resampled to the input data (wrong for native space) only for ``using="junifer"``. Without ``masks``, both use the voxels with non-zero time series, so that both implementations give the same results by `Fede Raimondo`_

junifer-0.0.8.dev257/docs/changes/newsfragments/514.enh

@@ -0,0 +1 @@
+Vectorize ReHo computation with ``using="junifer"``, making it about 5 times faster by `Fede Raimondo`_

{junifer-0.0.8.dev253 → junifer-0.0.8.dev257}/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.dev253'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev253')
+__version__ = version = '0.0.8.dev257'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev257')
 
-__commit_id__ = commit_id = 'gad12935a9'
+__commit_id__ = commit_id = 'g19ea0a56d'

{junifer-0.0.8.dev253 → junifer-0.0.8.dev257}/junifer/markers/reho/_afni_reho.py

@@ -55,6 +55,7 @@ class AFNIReHo(metaclass=Singleton):
         self,
         input_path: Path,
         nneigh: int = 27,
+        mask_path: Path | None = None,
         neigh_rad: float | None = None,
         neigh_x: float | None = None,
         neigh_y: float | None = None,
@@ -78,6 +79,9 @@ class AFNIReHo(metaclass=Singleton):
             * 27 : for face-, edge-, and node-wise neighbors
 
             (default 27).
+        mask_path : pathlib.Path or None, optional
+            Path to the mask to restrict the computation to, passed to
+            ``3dReHo`` as ``-mask``. If None, no mask is used (default None).
         neigh_rad : positive float, optional
             The radius of a desired neighbourhood (default None).
         neigh_x : positive float, optional
@@ -143,6 +147,8 @@ class AFNIReHo(metaclass=Singleton):
             f"-prefix {reho_out_path_prefix.resolve()}",
             f"-inset {input_path.resolve()}",
         ]
+        if mask_path is not None:
+            reho_cmd.append(f"-mask {mask_path.resolve()}")
         # Check ellipsoidal / cuboidal volume arguments
         if neigh_rad:
             reho_cmd.append(f"-neigh_RAD {neigh_rad}")

junifer-0.0.8.dev257/junifer/markers/reho/_junifer_reho.py

@@ -0,0 +1,272 @@
+"""Provide class for computing regional homogeneity (ReHo) using junifer."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from functools import lru_cache
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    ClassVar,
+)
+
+import nibabel as nib
+import numpy as np
+import scipy as sp
+from nilearn import image as nimg
+
+from ...pipeline import WorkDirManager
+from ...typing import Dependencies
+from ...utils import raise_error
+from ...utils.singleton import Singleton
+from ..base import logger
+
+
+if TYPE_CHECKING:
+    from nibabel.nifti1 import Nifti1Image
+
+
+__all__ = ["JuniferReHo"]
+
+
+class JuniferReHo(metaclass=Singleton):
+    """Class for computing ReHo using junifer.
+
+    It's designed as a singleton with caching for efficient computation.
+
+    """
+
+    _DEPENDENCIES: ClassVar[Dependencies] = {"numpy", "nilearn", "scipy"}
+
+    def __del__(self) -> None:
+        """Terminate the class."""
+        # Clear the computation cache
+        logger.debug("Clearing cache for ReHo computation via junifer")
+        self.compute.cache_clear()
+
+    @lru_cache(maxsize=None, typed=True)
+    def compute(
+        self,
+        input_path: Path,
+        nneigh: int = 27,
+        mask_path: Path | None = None,
+    ) -> tuple["Nifti1Image", Path]:
+        """Compute ReHo map.
+
+        Parameters
+        ----------
+        input_path : pathlib.Path
+            Path to the input data.
+        nneigh : {7, 19, 27, 125}, optional
+            Number of voxels in the neighbourhood, inclusive. Can be:
+
+            * 7 : for facewise neighbours only
+            * 19 : for face- and edge-wise neighbours
+            * 27 : for face-, edge-, and node-wise neighbors
+            * 125 : for 5x5 cuboidal volume
+
+            (default 27).
+        mask_path : pathlib.Path or None, optional
+            Path to the mask to restrict the computation to. Voxels outside
+            the mask are excluded from every neighbourhood and set to 0 in
+            the output. If None, voxels with non-zero time series are used,
+            same as AFNI's ``3dReHo`` without ``-mask`` (default None).
+
+        Returns
+        -------
+        Niimg-like object
+            The ReHo map as NIfTI.
+        pathlib.Path
+            The path to the ReHo map as NIfTI.
+
+        Raises
+        ------
+        ValueError
+            If ``nneigh`` is invalid.
+
+        """
+        valid_nneigh = (7, 19, 27, 125)
+        if nneigh not in valid_nneigh:
+            raise_error(
+                f"Invalid value for `nneigh`, should be one of: {valid_nneigh}"
+            )
+
+        logger.debug("Creating cache for ReHo computation via junifer")
+
+        # Get scan data
+        niimg = nib.load(input_path)
+        niimg_data = niimg.get_fdata(caching="unchanged")
+        # Get scan dimensions
+        n_x, n_y, n_z, n_t = niimg_data.shape
+
+        # Get mask as bool array
+        if mask_path is not None:
+            logical_mask = np.squeeze(nib.load(mask_path).get_fdata()) != 0
+        else:
+            # Same as AFNI's 3dReHo without -mask
+            logical_mask = np.sum(np.abs(niimg_data), axis=-1) > 1e-6
+
+        # Get rank of every voxel across time series and tied rank correction
+        # for every voxel
+        ranks_niimg_data, tied_rank_corrections = _rank_with_ties(niimg_data)
+        del niimg_data
+
+        # Create mask cluster and set start and end indices
+        if nneigh in (7, 19, 27):
+            mask_cluster = np.ones((3, 3, 3))
+
+            if nneigh == 7:
+                mask_cluster[0, 0, 0] = 0
+                mask_cluster[0, 1, 0] = 0
+                mask_cluster[0, 2, 0] = 0
+                mask_cluster[0, 0, 1] = 0
+                mask_cluster[0, 2, 1] = 0
+                mask_cluster[0, 0, 2] = 0
+                mask_cluster[0, 1, 2] = 0
+                mask_cluster[0, 2, 2] = 0
+                mask_cluster[1, 0, 0] = 0
+                mask_cluster[1, 2, 0] = 0
+                mask_cluster[1, 0, 2] = 0
+                mask_cluster[1, 2, 2] = 0
+                mask_cluster[2, 0, 0] = 0
+                mask_cluster[2, 1, 0] = 0
+                mask_cluster[2, 2, 0] = 0
+                mask_cluster[2, 0, 1] = 0
+                mask_cluster[2, 2, 1] = 0
+                mask_cluster[2, 0, 2] = 0
+                mask_cluster[2, 1, 2] = 0
+                mask_cluster[2, 2, 2] = 0
+
+            elif nneigh == 19:
+                mask_cluster[0, 0, 0] = 0
+                mask_cluster[0, 2, 0] = 0
+                mask_cluster[2, 0, 0] = 0
+                mask_cluster[2, 2, 0] = 0
+                mask_cluster[0, 0, 2] = 0
+                mask_cluster[0, 2, 2] = 0
+                mask_cluster[2, 0, 2] = 0
+                mask_cluster[2, 2, 2] = 0
+
+        elif nneigh == 125:
+            mask_cluster = np.ones((5, 5, 5))
+
+        # Exclude voxels outside the mask from every neighbourhood
+        ranks_niimg_data[~logical_mask] = 0
+        tied_rank_corrections[~logical_mask] = 0
+        # Sum over the neighbourhood of every voxel: number of voxels in the
+        # mask, ranks per timepoint and tied rank corrections; at the edges
+        # of the volume, only the neighbours within it are used
+        n_neighbours = sp.ndimage.correlate(
+            logical_mask.astype(np.float64),
+            mask_cluster,
+            mode="constant",
+        )
+        neighbourhood_rank_sums = sp.ndimage.correlate(
+            ranks_niimg_data,
+            mask_cluster[..., np.newaxis],
+            mode="constant",
+        )
+        del ranks_niimg_data
+        neighbourhood_tied_rank_corrections = sp.ndimage.correlate(
+            tied_rank_corrections,
+            mask_cluster,
+            mode="constant",
+        )
+        # Calculate Kendall's coefficient of concordance (KCC)
+        np.square(neighbourhood_rank_sums, out=neighbourhood_rank_sums)
+        numerator = (12 * np.sum(neighbourhood_rank_sums, axis=-1)) - (
+            3 * n_neighbours**2 * n_t * (n_t + 1) ** 2
+        )
+        del neighbourhood_rank_sums
+        denominator = (n_neighbours**2 * n_t * (n_t**2 - 1)) - (
+            n_neighbours * neighbourhood_tied_rank_corrections
+        )
+        # If all the time series in the neighbourhood are fully tied, the
+        # denominator is 0 and KCC is set to 0, same as AFNI's 3dReHo
+        with np.errstate(divide="ignore", invalid="ignore"):
+            kcc = np.where(denominator == 0, 0.0, numerator / denominator)
+
+        # Initialize 3D array to store reho map; voxels outside the mask stay
+        # at 0, same as AFNI's 3dReHo
+        reho_map = np.zeros((n_x, n_y, n_z), dtype=np.float32)
+        reho_map[logical_mask] = kcc[logical_mask]
+
+        # Create new image like target image
+        output_data = nimg.new_img_like(
+            ref_niimg=niimg,
+            data=reho_map,
+            copy_header=False,
+        )
+
+        # Create element-scoped tempdir so that the ReHo map is
+        # available later as nibabel stores file path reference for
+        # loading on computation
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="junifer_reho"
+        )
+        output_path = element_tempdir / "output.nii.gz"
+        # Save computed data to file
+        nib.save(output_data, output_path)
+
+        return output_data, output_path  # type: ignore
+
+
+def _rank_with_ties(data: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Rank data along the last axis and compute tied rank corrections.
+
+    Equivalent to ``scipy.stats.rankdata(data, axis=-1)`` (tied values get
+    their average rank and NaN propagates to the whole time series), but
+    sorting only once.
+
+    Parameters
+    ----------
+    data : numpy.ndarray
+        The data to rank along the last axis.
+
+    Returns
+    -------
+    numpy.ndarray
+        The ranks of ``data`` along the last axis.
+    numpy.ndarray
+        The tied rank correction, the sum of ``t^3 - t`` over the groups of
+        ``t`` tied values, for every element along the last axis.
+
+    """
+    n = data.shape[-1]
+    sort_idx = np.argsort(data, axis=-1, kind="stable")
+    sorted_data = np.take_along_axis(data, sort_idx, axis=-1)
+    positions = np.arange(1, n + 1)
+    # Mark the first and last sample of every tie group in sorted order
+    is_first = np.ones(data.shape, dtype=bool)
+    is_first[..., 1:] = sorted_data[..., 1:] != sorted_data[..., :-1]
+    del sorted_data
+    is_last = np.ones(data.shape, dtype=bool)
+    is_last[..., :-1] = is_first[..., 1:]
+    # Min and max rank of the tie group of every sample in sorted order
+    min_ranks = np.maximum.accumulate(
+        np.where(is_first, positions, 0), axis=-1
+    )
+    del is_first
+    max_ranks = np.flip(
+        np.minimum.accumulate(
+            np.flip(np.where(is_last, positions, n + 1), axis=-1), axis=-1
+        ),
+        axis=-1,
+    )
+    del is_last
+    # Every sample belongs to a tie group of size t = max - min + 1, and
+    # summing t^2 - 1 over the samples is the same as summing t^3 - t over
+    # the tie groups
+    tie_sizes = max_ranks - min_ranks + 1
+    tied_rank_corrections = np.sum(tie_sizes**2 - 1, axis=-1).astype(
+        np.float64
+    )
+    del tie_sizes
+    # Tied values get their average rank; put back in the original order
+    ranks = np.empty(data.shape, dtype=np.float64)
+    np.put_along_axis(ranks, sort_idx, (min_ranks + max_ranks) / 2, axis=-1)
+    # Propagate NaN to the whole time series, same as scipy.stats.rankdata
+    has_nan = np.isnan(data).any(axis=-1)
+    ranks[has_nan] = np.nan
+    tied_rank_corrections[has_nan] = np.nan
+    return ranks, tied_rank_corrections

{junifer-0.0.8.dev253 → junifer-0.0.8.dev257}/junifer/markers/reho/reho_base.py

@@ -3,6 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import hashlib
 from enum import Enum
 from pathlib import Path
 from typing import (
@@ -12,9 +13,13 @@ 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
@@ -98,8 +103,10 @@ class ReHoBase(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 ReHo 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.
@@ -136,6 +143,7 @@ class ReHoBase(BaseMarker):
     def _compute(
         self,
         input_data: dict[str, Any],
+        extra_input: dict[str, Any] | None = None,
         **reho_params: Any,
     ) -> tuple["Nifti1Image", Path]:
         """Compute voxel-wise ReHo.
@@ -151,6 +159,9 @@ class ReHoBase(BaseMarker):
         ----------
         input_data : dict
             The BOLD data as dictionary.
+        extra_input : dict, optional
+            The other fields in the pipeline data object. Used to compute
+            the mask in the space of ``input_data`` (default None).
         **reho_params : dict
             Extra keyword arguments for ReHo.
 
@@ -178,9 +189,22 @@ class ReHoBase(BaseMarker):
             estimator = AFNIReHo()
         elif self.using == "junifer":
             estimator = JuniferReHo()
+        # 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,
+                )
+            )
         # Compute reho
         reho_map, reho_map_path = estimator.compute(  # type: ignore
             input_path=input_data["path"],
+            mask_path=mask_path,
             **reho_params,
         )
 
@@ -193,3 +217,38 @@ 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.dev253 → junifer-0.0.8.dev257}/junifer/markers/reho/reho_maps.py

@@ -116,10 +116,12 @@ class ReHoMaps(ReHoBase):
         # transformation to native space.
         if self.reho_params is not None:
             reho_map, reho_file_path = self._compute(
-                input_data=input, **self.reho_params
+                input_data=input, extra_input=extra_input, **self.reho_params
             )
         else:
-            reho_map, reho_file_path = self._compute(input_data=input)
+            reho_map, reho_file_path = self._compute(
+                input_data=input, extra_input=extra_input
+            )
 
         # Perform aggregation on reho map
         aggregation_input = dict(input.items())

{junifer-0.0.8.dev253 → junifer-0.0.8.dev257}/junifer/markers/reho/reho_parcels.py

@@ -125,10 +125,12 @@ class ReHoParcels(ReHoBase):
         # transformation to native space.
         if self.reho_params is not None:
             reho_map, reho_file_path = self._compute(
-                input_data=input, **self.reho_params
+                input_data=input, extra_input=extra_input, **self.reho_params
             )
         else:
-            reho_map, reho_file_path = self._compute(input_data=input)
+            reho_map, reho_file_path = self._compute(
+                input_data=input, extra_input=extra_input
+            )
 
         # Perform aggregation on reho map
         aggregation_input = dict(input.items())

{junifer-0.0.8.dev253 → junifer-0.0.8.dev257}/junifer/markers/reho/reho_spheres.py

@@ -134,10 +134,12 @@ class ReHoSpheres(ReHoBase):
         # transformation to native space.
         if self.reho_params is not None:
             reho_map, reho_file_path = self._compute(
-                input_data=input, **self.reho_params
+                input_data=input, extra_input=extra_input, **self.reho_params
             )
         else:
-            reho_map, reho_file_path = self._compute(input_data=input)
+            reho_map, reho_file_path = self._compute(
+                input_data=input, extra_input=extra_input
+            )
 
         # Perform aggregation on reho map
         aggregation_input = dict(input.items())

junifer-0.0.8.dev257/junifer/markers/reho/tests/test_junifer_reho.py

@@ -0,0 +1,178 @@
+"""Provide tests for ReHo computation using junifer."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pytest
+import scipy as sp
+from numpy.testing import assert_allclose, assert_array_equal
+
+from junifer.markers.reho._afni_reho import AFNIReHo
+from junifer.markers.reho._junifer_reho import JuniferReHo, _rank_with_ties
+from junifer.pipeline import WorkDirManager
+from junifer.pipeline.utils import _check_afni
+
+
+def _tied_rank_corrections(ranks: np.ndarray) -> np.ndarray:
+    """Compute tied rank corrections one time series at a time."""
+    out = np.zeros(ranks.shape[:-1])
+    for idx in np.ndindex(ranks.shape[:-1]):
+        _, tie_count = np.unique(ranks[idx], return_counts=True)
+        out[idx] = np.sum(tie_count**3 - tie_count)
+    return out
+
+
+@pytest.mark.parametrize(
+    "shape, scale",
+    [
+        ((4, 3, 2, 50), 3),  # many ties
+        ((3, 3, 3, 30), 100),  # few ties
+        ((2, 2, 2, 10), 0),  # all values tied
+    ],
+)
+def test_rank_with_ties(shape: tuple[int, ...], scale: float) -> None:
+    """Test ranking with ties against scipy.
+
+    Parameters
+    ----------
+    shape : tuple of int
+        The shape of the data.
+    scale : float
+        The scale of the data before rounding.
+
+    """
+    data = np.round(np.random.default_rng(0).normal(size=shape) * scale)
+    ranks, tied_rank_corrections = _rank_with_ties(data)
+    expected_ranks = sp.stats.rankdata(data, axis=-1)
+    assert_array_equal(ranks, expected_ranks)
+    assert_array_equal(
+        tied_rank_corrections, _tied_rank_corrections(expected_ranks)
+    )
+
+
+def test_rank_with_ties_nan() -> None:
+    """Test NaN propagates to the whole time series."""
+    data = np.array([[1.0, np.nan, 2.0], [1.0, 3.0, 2.0]])
+    ranks, tied_rank_corrections = _rank_with_ties(data)
+    assert np.isnan(ranks[0]).all()
+    assert np.isnan(tied_rank_corrections[0])
+    assert_array_equal(ranks[1], [1, 3, 2])
+    assert tied_rank_corrections[1] == 0
+
+
+def _save(data: np.ndarray, path: Path) -> Path:
+    """Save data as NIfTI."""
+    nib.save(nib.Nifti1Image(data, np.eye(4)), path)
+    return path
+
+
+def test_JuniferReHo_nan(tmp_path: Path) -> None:
+    """Test NaN time series do not give valid ReHo values.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    WorkDirManager().workdir = tmp_path
+    data = np.random.default_rng(0).normal(size=(7, 7, 7, 20))
+    data[3, 3, 3, 5] = np.nan
+    bold_path = _save(data.astype(np.float32), tmp_path / "bold_nan.nii")
+    mask_path = _save(np.ones((7, 7, 7), dtype=np.uint8), tmp_path / "m.nii")
+
+    # With a mask including the NaN voxel, every neighbourhood with it is NaN
+    reho = JuniferReHo().compute(bold_path, mask_path=mask_path)[0]
+    reho = reho.get_fdata()
+    assert np.isnan(reho[2:5, 2:5, 2:5]).all()
+    reho[2:5, 2:5, 2:5] = 0
+    assert np.isfinite(reho).all()
+
+    # Without mask, the NaN voxel is excluded as AFNI's 3dReHo does
+    reho = JuniferReHo().compute(bold_path)[0].get_fdata()
+    assert np.isfinite(reho).all()
+    assert reho[3, 3, 3] == 0
+
+
+def test_JuniferReHo_mask(tmp_path: Path) -> None:
+    """Test ReHo is restricted to the mask.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    WorkDirManager().workdir = tmp_path
+    data = np.random.default_rng(0).normal(size=(7, 7, 7, 20))
+    bold_path = _save(data.astype(np.float32), tmp_path / "bold.nii")
+    mask = np.ones((7, 7, 7), dtype=np.uint8)
+    mask[:3] = 0
+    mask_path = _save(mask, tmp_path / "mask.nii")
+
+    masked = JuniferReHo().compute(bold_path, mask_path=mask_path)[0]
+    masked = masked.get_fdata()
+    unmasked = JuniferReHo().compute(bold_path)[0].get_fdata()
+    # Outside the mask is 0
+    assert (masked[:3] == 0).all()
+    # Next to the mask boundary, neighbours outside the mask are excluded
+    assert not np.allclose(masked[3, 1:-1, 1:-1], unmasked[3, 1:-1, 1:-1])
+    # Far from the mask boundary, nothing changes
+    assert_array_equal(masked[4:-1, 1:-1, 1:-1], unmasked[4:-1, 1:-1, 1:-1])
+
+
+@pytest.mark.external
+@pytest.mark.skipif(
+    _check_afni() is False, reason="requires AFNI to be in PATH"
+)
+@pytest.mark.parametrize("nneigh", [7, 19, 27])
+@pytest.mark.parametrize("use_mask", [False, True])
+def test_JuniferReHo_vs_AFNI(
+    tmp_path: Path, nneigh: int, use_mask: bool
+) -> None:
+    """Test junifer and AFNI give the same ReHo map.
+
+    The data covers the edges of the volume, fully tied neighbourhoods (the
+    denominator of KCC is 0), voxels with all-zero time series and ties.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    nneigh : int
+        The number of voxels in the neighbourhood.
+    use_mask : bool
+        Whether to use a mask.
+
+    """
+    WorkDirManager().workdir = tmp_path
+    data = np.round(
+        np.random.default_rng(0).normal(size=(9, 8, 7, 25)) * 3
+    ).astype(np.float32)
+    # Constant time series: fully tied neighbourhoods
+    data[:4, :4, :4] = 5
+    # All-zero time series: outside AFNI's implicit mask
+    data[6:, 5:, 4:] = 0
+    bold_path = _save(data, tmp_path / "bold.nii")
+    mask_path = None
+    if use_mask:
+        mask = np.ones(data.shape[:3], dtype=np.uint8)
+        mask[:, :, 0] = 0
+        mask[4, 4, 3] = 0
+        mask_path = _save(mask, tmp_path / "mask.nii")
+
+    junifer_reho = JuniferReHo().compute(
+        bold_path, nneigh=nneigh, mask_path=mask_path
+    )[0]
+    afni_reho = AFNIReHo().compute(
+        bold_path, nneigh=nneigh, mask_path=mask_path
+    )[0]
+    assert_allclose(
+        junifer_reho.get_fdata(),
+        np.squeeze(afni_reho.get_fdata()),
+        atol=1e-6,
+    )