cellfinder 1.1.3__tar.gz → 1.2.0__tar.gz

{cellfinder-1.1.3 → cellfinder-1.2.0}/.github/workflows/test_and_deploy.yml

@@ -42,12 +42,14 @@ jobs:
         # Run all supported Python versions on linux
         os: [ubuntu-latest]
         python-version: ["3.9", "3.10"]
-        # Include one windows, one macos run
+        # Include one windows, one macos run each for M1 (latest) and Intel (13)
         include:
-        - os: macos-latest
-          python-version: "3.10"
-        - os: windows-latest
-          python-version: "3.10"
+          - os: macos-13
+            python-version: "3.10"
+          - os: macos-latest
+            python-version: "3.10"
+          - os: windows-latest
+            python-version: "3.10"
 
     steps:
       # Cache the tensorflow model so we don't have to remake it every time
@@ -55,7 +57,7 @@ jobs:
         uses: actions/cache@v3
         with:
           path: "~/.cellfinder"
-          key: models-${{ hashFiles('~/.cellfinder/**') }}
+          key: models-${{ hashFiles('~/.brainglobe/**') }}
       # Setup pyqt libraries
       - name: Setup qtpy libraries
         uses: tlambert03/setup-qt-libs@v1
@@ -65,11 +67,13 @@ jobs:
       - uses: neuroinformatics-unit/actions/test@v2
         with:
           python-version: ${{ matrix.python-version }}
+          secret-codecov-token: ${{ secrets.CODECOV_TOKEN }}
           use-xvfb: true
 
   test_numba_disabled:
     needs: [linting, manifest]
     name: Run tests with numba disabled
+    timeout-minutes: 60
     runs-on: ubuntu-latest
     env:
        NUMBA_DISABLE_JIT: "1"
@@ -79,7 +83,7 @@ jobs:
         uses: actions/cache@v3
         with:
           path: "~/.cellfinder"
-          key: models-${{ hashFiles('~/.cellfinder/**') }}
+          key: models-${{ hashFiles('~/.brainglobe/**') }}
       # Setup pyqt libraries
       - name: Setup qtpy libraries
         uses: tlambert03/setup-qt-libs@v1
@@ -89,6 +93,7 @@ jobs:
       - uses: neuroinformatics-unit/actions/test@v2
         with:
           python-version: "3.10"
+          secret-codecov-token: ${{ secrets.CODECOV_TOKEN }}
           codecov-flags: "numba"
 
   # Run brainglobe-workflows brainmapper-CLI tests to check for
@@ -96,13 +101,14 @@ jobs:
   test_brainmapper_cli:
     needs: [linting, manifest]
     name: Run brainmapper tests to check for breakages
+    timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
       - name: Cache tensorflow model
         uses: actions/cache@v3
         with:
           path: "~/.cellfinder"
-          key: models-${{ hashFiles('~/.cellfinder/**') }}
+          key: models-${{ hashFiles('~/.brainglobe/**') }}
 
       - name: Checkout brainglobe-workflows
         uses: actions/checkout@v3

{cellfinder-1.1.3 → cellfinder-1.2.0}/.github/workflows/test_include_guard.yaml

@@ -35,7 +35,12 @@ jobs:
             import cellfinder.core
             import cellfinder.napari
 
-      - name: Uninstall tensorflow
+      - name: Uninstall tensorflow-macos on Mac M1
+        if: matrix.os == 'macos-latest'
+        run: python -m pip uninstall -y tensorflow-macos
+
+      - name: Uninstall tensorflow on Ubuntu
+        if: matrix.os == 'ubuntu-latest'
         run: python -m pip uninstall -y tensorflow
 
       - name: Test (broken) import

{cellfinder-1.1.3 → cellfinder-1.2.0}/.gitignore

@@ -130,11 +130,6 @@ mprofile*.dat
 
 *.DS_Store
 
-# asv
-.asv
-benchmarks/results
-benchmarks/html
-benchmarks/env
 
 # OS
 .DS_Store

{cellfinder-1.1.3 → cellfinder-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cellfinder
-Version: 1.1.3
+Version: 1.2.0
 Summary: Automated 3D cell detection in large microscopy images
 Author-email: "Adam Tyson, Christian Niedworok, Charly Rousseau" <code@adamltyson.com>
 License: BSD-3-Clause
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: brainglobe-utils>=0.4.2
+Requires-Dist: brainglobe-utils>=0.5.0
 Requires-Dist: brainglobe-napari-io>=0.3.4
 Requires-Dist: dask[array]
 Requires-Dist: fancylog>=0.0.7
@@ -54,17 +54,17 @@ Requires-Dist: napari[pyqt5]; extra == "napari"
 Requires-Dist: pooch>=1; extra == "napari"
 Requires-Dist: qtpy; extra == "napari"
 
-[![Python Version](https://img.shields.io/pypi/pyversions/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![PyPI](https://img.shields.io/pypi/v/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![Downloads](https://pepy.tech/badge/cellfinder-core)](https://pepy.tech/project/cellfinder)
-[![Wheel](https://img.shields.io/pypi/wheel/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![Development Status](https://img.shields.io/pypi/status/cellfinder-core.svg)](https://github.com/brainglobe/cellfinder)
+[![Python Version](https://img.shields.io/pypi/pyversions/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![PyPI](https://img.shields.io/pypi/v/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![Downloads](https://pepy.tech/badge/cellfinder)](https://pepy.tech/project/cellfinder)
+[![Wheel](https://img.shields.io/pypi/wheel/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![Development Status](https://img.shields.io/pypi/status/cellfinder.svg)](https://github.com/brainglobe/cellfinder)
 [![Tests](https://img.shields.io/github/actions/workflow/status/brainglobe/cellfinder/test_and_deploy.yml?branch=main)](https://github.com/brainglobe/cellfinder/actions)
-[![codecov](https://codecov.io/gh/brainglobe/cellfinder-core/branch/main/graph/badge.svg?token=nx1lhNI7ox)](https://codecov.io/gh/brainglobe/cellfinder)
+[![codecov](https://codecov.io/gh/brainglobe/cellfinder/branch/main/graph/badge.svg?token=nx1lhNI7ox)](https://codecov.io/gh/brainglobe/cellfinder)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
-[![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://brainglobe.info/developers/index.html)
+[![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://brainglobe.info/community/developers/index.html)
 [![Twitter](https://img.shields.io/twitter/follow/brain_globe?style=social)](https://twitter.com/brain_globe)
 
 # cellfinder

{cellfinder-1.1.3 → cellfinder-1.2.0}/README.md

@@ -1,14 +1,14 @@
-[![Python Version](https://img.shields.io/pypi/pyversions/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![PyPI](https://img.shields.io/pypi/v/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![Downloads](https://pepy.tech/badge/cellfinder-core)](https://pepy.tech/project/cellfinder)
-[![Wheel](https://img.shields.io/pypi/wheel/cellfinder-core.svg)](https://pypi.org/project/cellfinder)
-[![Development Status](https://img.shields.io/pypi/status/cellfinder-core.svg)](https://github.com/brainglobe/cellfinder)
+[![Python Version](https://img.shields.io/pypi/pyversions/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![PyPI](https://img.shields.io/pypi/v/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![Downloads](https://pepy.tech/badge/cellfinder)](https://pepy.tech/project/cellfinder)
+[![Wheel](https://img.shields.io/pypi/wheel/cellfinder.svg)](https://pypi.org/project/cellfinder)
+[![Development Status](https://img.shields.io/pypi/status/cellfinder.svg)](https://github.com/brainglobe/cellfinder)
 [![Tests](https://img.shields.io/github/actions/workflow/status/brainglobe/cellfinder/test_and_deploy.yml?branch=main)](https://github.com/brainglobe/cellfinder/actions)
-[![codecov](https://codecov.io/gh/brainglobe/cellfinder-core/branch/main/graph/badge.svg?token=nx1lhNI7ox)](https://codecov.io/gh/brainglobe/cellfinder)
+[![codecov](https://codecov.io/gh/brainglobe/cellfinder/branch/main/graph/badge.svg?token=nx1lhNI7ox)](https://codecov.io/gh/brainglobe/cellfinder)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
-[![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://brainglobe.info/developers/index.html)
+[![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://brainglobe.info/community/developers/index.html)
 [![Twitter](https://img.shields.io/twitter/follow/brain_globe?style=social)](https://twitter.com/brain_globe)
 
 # cellfinder

{cellfinder-1.1.3 → cellfinder-1.2.0}/cellfinder/__init__.py

@@ -1,4 +1,5 @@
 from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
 
 try:
     __version__ = version("cellfinder")
@@ -22,3 +23,5 @@ except PackageNotFoundError as e:
 
 __author__ = "Adam Tyson, Christian Niedworok, Charly Rousseau"
 __license__ = "BSD-3-Clause"
+
+DEFAULT_CELLFINDER_DIRECTORY = Path.home() / ".brainglobe" / "cellfinder"

{cellfinder-1.1.3 → cellfinder-1.2.0}/cellfinder/core/detect/detect.py

@@ -22,6 +22,7 @@ from typing import Callable, List, Optional, Sequence, Tuple, TypeVar
 import numpy as np
 from brainglobe_utils.cells.cells import Cell
 from brainglobe_utils.general.system import get_num_processes
+from numba import set_num_threads
 
 from cellfinder.core import logger, types
 from cellfinder.core.detect.filters.plane import TileProcessor
@@ -157,6 +158,13 @@ def main(
         )
     n_processes = get_num_processes(min_free_cpu_cores=n_free_cpus)
     n_ball_procs = max(n_processes - 1, 1)
+
+    # we parallelize 2d filtering, which typically lags behind the 3d
+    # processing so for n_ball_procs 2d filtering threads, ball_z_size will
+    # typically be in use while the others stall waiting for 3d processing
+    # so we can use those for other things, such as numba threading
+    set_num_threads(max(n_ball_procs - int(ball_z_size), 1))
+
     start_time = datetime.now()
 
     (
@@ -236,7 +244,10 @@ def main(
         # then 3D filtering has finished. As batches of planes are filtered
         # by the 3D filter, it releases the locks of subsequent 2D filter
         # processes.
-        cells = mp_3d_filter.process(async_results, locks, callback=callback)
+        mp_3d_filter.process(async_results, locks, callback=callback)
+
+        # it's now done filtering, get results with pool
+        cells = mp_3d_filter.get_results(worker_pool)
 
     time_elapsed = datetime.now() - start_time
     logger.debug(

cellfinder-1.2.0/cellfinder/core/detect/filters/volume/ball_filter.py

@@ -0,0 +1,417 @@
+from functools import lru_cache
+
+import numpy as np
+from numba import njit, objmode, prange
+from numba.core import types
+from numba.experimental import jitclass
+
+from cellfinder.core.tools.array_operations import bin_mean_3d
+from cellfinder.core.tools.geometry import make_sphere
+
+DEBUG = False
+
+uint32_3d_type = types.uint32[:, :, :]
+bool_3d_type = types.bool_[:, :, :]
+float_3d_type = types.float64[:, :, :]
+
+
+@lru_cache(maxsize=50)
+def get_kernel(ball_xy_size: int, ball_z_size: int) -> np.ndarray:
+    # Create a spherical kernel.
+    #
+    # This is done by:
+    # 1. Generating a binary sphere at a resolution *upscale_factor* larger
+    #    than desired.
+    # 2. Downscaling the binary sphere to get a 'fuzzy' sphere at the
+    #    original intended scale
+    upscale_factor: int = 7
+    upscaled_kernel_shape = (
+        upscale_factor * ball_xy_size,
+        upscale_factor * ball_xy_size,
+        upscale_factor * ball_z_size,
+    )
+    upscaled_ball_centre_position = (
+        np.floor(upscaled_kernel_shape[0] / 2),
+        np.floor(upscaled_kernel_shape[1] / 2),
+        np.floor(upscaled_kernel_shape[2] / 2),
+    )
+    upscaled_ball_radius = upscaled_kernel_shape[0] / 2.0
+
+    sphere_kernel = make_sphere(
+        upscaled_kernel_shape,
+        upscaled_ball_radius,
+        upscaled_ball_centre_position,
+    )
+    sphere_kernel = sphere_kernel.astype(np.float64)
+    kernel = bin_mean_3d(
+        sphere_kernel,
+        bin_height=upscale_factor,
+        bin_width=upscale_factor,
+        bin_depth=upscale_factor,
+    )
+
+    assert (
+        kernel.shape[2] == ball_z_size
+    ), "Kernel z dimension should be {}, got {}".format(
+        ball_z_size, kernel.shape[2]
+    )
+
+    return kernel
+
+
+# volume indices/size is 64 bit for very large brains(!)
+spec = [
+    ("ball_xy_size", types.uint32),
+    ("ball_z_size", types.uint32),
+    ("tile_step_width", types.uint64),
+    ("tile_step_height", types.uint64),
+    ("THRESHOLD_VALUE", types.uint32),
+    ("SOMA_CENTRE_VALUE", types.uint32),
+    ("overlap_fraction", types.float64),
+    ("overlap_threshold", types.float64),
+    ("middle_z_idx", types.uint32),
+    ("_num_z_added", types.uint32),
+    ("kernel", float_3d_type),
+    ("volume", uint32_3d_type),
+    ("inside_brain_tiles", bool_3d_type),
+]
+
+
+@jitclass(spec=spec)
+class BallFilter:
+    """
+    A 3D ball filter.
+
+    This runs a spherical kernel across the (x, y) dimensions
+    of a *ball_z_size* stack of planes, and marks pixels in the middle
+    plane of the stack that have a high enough intensity within the
+    spherical kernel.
+    """
+
+    def __init__(
+        self,
+        plane_width: int,
+        plane_height: int,
+        ball_xy_size: int,
+        ball_z_size: int,
+        overlap_fraction: float,
+        tile_step_width: int,
+        tile_step_height: int,
+        threshold_value: int,
+        soma_centre_value: int,
+    ):
+        """
+        Parameters
+        ----------
+        plane_width, plane_height :
+            Width/height of the planes.
+        ball_xy_size :
+            Diameter of the spherical kernel in the x/y dimensions.
+        ball_z_size :
+            Diameter of the spherical kernel in the z dimension.
+            Equal to the number of planes that stacked to filter
+            the central plane of the stack.
+        overlap_fraction :
+            The fraction of pixels within the spherical kernel that
+            have to be over *threshold_value* for a pixel to be marked
+            as having a high intensity.
+        tile_step_width, tile_step_height :
+            Width/height of individual tiles in the mask generated by
+            2D filtering.
+        threshold_value :
+            Value above which an individual pixel is considered to have
+            a high intensity.
+        soma_centre_value :
+            Value used to mark pixels with a high enough intensity.
+        """
+        self.ball_xy_size = ball_xy_size
+        self.ball_z_size = ball_z_size
+        self.overlap_fraction = overlap_fraction
+        self.tile_step_width = tile_step_width
+        self.tile_step_height = tile_step_height
+
+        self.THRESHOLD_VALUE = threshold_value
+        self.SOMA_CENTRE_VALUE = soma_centre_value
+
+        # getting kernel is not jitted
+        with objmode(kernel=float_3d_type):
+            kernel = get_kernel(ball_xy_size, ball_z_size)
+        self.kernel = kernel
+
+        self.overlap_threshold = np.sum(self.overlap_fraction * self.kernel)
+
+        # Stores the current planes that are being filtered
+        # first axis is z for faster rotating the z-axis
+        self.volume = np.empty(
+            (ball_z_size, plane_width, plane_height),
+            dtype=np.uint32,
+        )
+        # Index of the middle plane in the volume
+        self.middle_z_idx = int(np.floor(ball_z_size / 2))
+        self._num_z_added = 0
+
+        # first axis is z
+        self.inside_brain_tiles = np.empty(
+            (
+                ball_z_size,
+                int(np.ceil(plane_width / tile_step_width)),
+                int(np.ceil(plane_height / tile_step_height)),
+            ),
+            dtype=np.bool_,
+        )
+
+    @property
+    def ready(self) -> bool:
+        """
+        Return `True` if enough planes have been appended to run the filter.
+        """
+        return self._num_z_added >= self.ball_z_size
+
+    def append(self, plane: np.ndarray, mask: np.ndarray) -> None:
+        """
+        Add a new 2D plane to the filter.
+        """
+        if DEBUG:
+            assert [e for e in plane.shape[:2]] == [
+                e for e in self.volume.shape[1:]
+            ], 'plane shape mismatch, expected "{}", got "{}"'.format(
+                [e for e in self.volume.shape[1:]],
+                [e for e in plane.shape[:2]],
+            )
+            assert [e for e in mask.shape[:2]] == [
+                e for e in self.inside_brain_tiles.shape[1:]
+            ], 'mask shape mismatch, expected"{}", got {}"'.format(
+                [e for e in self.inside_brain_tiles.shape[1:]],
+                [e for e in mask.shape[:2]],
+            )
+
+        if self.ready:
+            # Shift everything down by one to make way for the new plane
+            # this is faster than np.roll, especially with z-axis first
+            self.volume[:-1, :, :] = self.volume[1:, :, :]
+            self.inside_brain_tiles[:-1, :, :] = self.inside_brain_tiles[
+                1:, :, :
+            ]
+
+        # index for *next* slice is num we added *so far* until max
+        idx = min(self._num_z_added, self.ball_z_size - 1)
+        self._num_z_added += 1
+
+        # Add the new plane to the top of volume and inside_brain_tiles
+        self.volume[idx, :, :] = plane
+        self.inside_brain_tiles[idx, :, :] = mask
+
+    def get_middle_plane(self) -> np.ndarray:
+        """
+        Get the plane in the middle of self.volume.
+        """
+        return self.volume[self.middle_z_idx, :, :].copy()
+
+    def walk(self, parallel: bool = False) -> None:
+        # **don't** pass parallel as keyword arg - numba struggles with it
+        # Highly optimised because most time critical
+        ball_radius = self.ball_xy_size // 2
+        # Get extents of image that are covered by tiles
+        tile_mask_covered_img_width = (
+            self.inside_brain_tiles.shape[1] * self.tile_step_width
+        )
+        tile_mask_covered_img_height = (
+            self.inside_brain_tiles.shape[2] * self.tile_step_height
+        )
+        # Get maximum offsets for the ball
+        max_width = tile_mask_covered_img_width - self.ball_xy_size
+        max_height = tile_mask_covered_img_height - self.ball_xy_size
+
+        # we have to pass the raw volume so walk doesn't use its edits as it
+        # processes the volume. self.volume is the one edited in place
+        input_volume = self.volume.copy()
+
+        if parallel:
+            _walk_parallel(
+                max_height,
+                max_width,
+                self.tile_step_width,
+                self.tile_step_height,
+                self.inside_brain_tiles,
+                input_volume,
+                self.volume,
+                self.kernel,
+                ball_radius,
+                self.middle_z_idx,
+                self.overlap_threshold,
+                self.THRESHOLD_VALUE,
+                self.SOMA_CENTRE_VALUE,
+            )
+        else:
+            _walk_single(
+                max_height,
+                max_width,
+                self.tile_step_width,
+                self.tile_step_height,
+                self.inside_brain_tiles,
+                input_volume,
+                self.volume,
+                self.kernel,
+                ball_radius,
+                self.middle_z_idx,
+                self.overlap_threshold,
+                self.THRESHOLD_VALUE,
+                self.SOMA_CENTRE_VALUE,
+            )
+
+
+@njit(cache=True)
+def _cube_overlaps(
+    volume: np.ndarray,
+    x_start: int,
+    x_end: int,
+    y_start: int,
+    y_end: int,
+    overlap_threshold: float,
+    threshold_value: int,
+    kernel: np.ndarray,
+) -> bool:  # Highly optimised because most time critical
+    """
+    For each pixel in cube in volume that is greater than THRESHOLD_VALUE, sum
+    up the corresponding pixels in *kernel*. If the total is less than
+    overlap_threshold, return False, otherwise return True.
+
+    Halfway through scanning the z-planes, if the total overlap is
+    less than 0.4 * overlap_threshold, this will return False early
+    without scanning the second half of the z-planes.
+
+    Parameters
+    ----------
+    volume :
+        3D array.
+    x_start, x_end, y_start, y_end :
+        The start and end indices in volume that form the cube. End is
+        exclusive
+    overlap_threshold :
+        Threshold above which to return True.
+    threshold_value :
+        Value above which a pixel is marked as being part of a cell.
+    kernel :
+        3D array, with the same shape as *cube* in the volume.
+    """
+    current_overlap_value = 0.0
+
+    middle = np.floor(volume.shape[0] / 2) + 1
+    halfway_overlap_thresh = (
+        overlap_threshold * 0.4
+    )  # FIXME: do not hard code value
+
+    for z in range(volume.shape[0]):
+        # TODO: OPTIMISE: step from middle to outer boundaries to check
+        # more data first
+        #
+        # If halfway through the array, and the overlap value isn't more than
+        # 0.4 * the overlap threshold, return
+        if z == middle and current_overlap_value < halfway_overlap_thresh:
+            return False  # DEBUG: optimisation attempt
+
+        for y in range(y_start, y_end):
+            for x in range(x_start, x_end):
+                # includes self.SOMA_CENTRE_VALUE
+                if volume[z, x, y] >= threshold_value:
+                    # x/y must be shifted in kernel because we x/y is relative
+                    # to the full volume, so shift it to relative to the cube
+                    current_overlap_value += kernel[
+                        x - x_start, y - y_start, z
+                    ]
+
+    return current_overlap_value > overlap_threshold
+
+
+@njit
+def _is_tile_to_check(
+    x: int,
+    y: int,
+    middle_z: int,
+    tile_step_width: int,
+    tile_step_height: int,
+    inside_brain_tiles: np.ndarray,
+) -> bool:  # Highly optimised because most time critical
+    """
+    Check if the tile containing pixel (x, y) is a tile that needs checking.
+    """
+    x_in_mask = x // tile_step_width  # TEST: test bounds (-1 range)
+    y_in_mask = y // tile_step_height  # TEST: test bounds (-1 range)
+    return inside_brain_tiles[middle_z, x_in_mask, y_in_mask]
+
+
+def _walk_base(
+    max_height: int,
+    max_width: int,
+    tile_step_width: int,
+    tile_step_height: int,
+    inside_brain_tiles: np.ndarray,
+    input_volume: np.ndarray,
+    volume: np.ndarray,
+    kernel: np.ndarray,
+    ball_radius: int,
+    middle_z: int,
+    overlap_threshold: float,
+    threshold_value: int,
+    soma_centre_value: int,
+) -> None:
+    """
+    Scan through *volume*, and mark pixels where there are enough surrounding
+    pixels with high enough intensity.
+
+    The surrounding area is defined by the *kernel*.
+
+    Parameters
+    ----------
+    max_height, max_width :
+        Maximum offsets for the ball filter.
+    inside_brain_tiles :
+        3d array containing information on whether a tile is
+        inside the brain or not. Tiles outside the brain are skipped.
+    input_volume :
+        3D array containing the plane-filtered data passed to the function
+        before walking. volume is edited in place, so this is the original
+        volume to prevent the changes for some cubes affective other cubes
+        during a single walk call.
+    volume :
+        3D array containing the plane-filtered data - edited in place.
+    kernel :
+        3D array
+    ball_radius :
+        Radius of the ball in the xy plane.
+    soma_centre_value :
+        Value that is used to mark pixels in *volume*.
+
+    Notes
+    -----
+    Warning: modifies volume in place!
+    """
+    for y in prange(max_height):
+        for x in prange(max_width):
+            ball_centre_x = x + ball_radius
+            ball_centre_y = y + ball_radius
+            if _is_tile_to_check(
+                ball_centre_x,
+                ball_centre_y,
+                middle_z,
+                tile_step_width,
+                tile_step_height,
+                inside_brain_tiles,
+            ):
+                if _cube_overlaps(
+                    input_volume,
+                    x,
+                    x + kernel.shape[0],
+                    y,
+                    y + kernel.shape[1],
+                    overlap_threshold,
+                    threshold_value,
+                    kernel,
+                ):
+                    volume[middle_z, ball_centre_x, ball_centre_y] = (
+                        soma_centre_value
+                    )
+
+
+_walk_parallel = njit(parallel=True)(_walk_base)
+_walk_single = njit(parallel=False)(_walk_base)