cellfinder 1.3.3__tar.gz → 1.4.0a0__tar.gz

{cellfinder-1.3.3 → cellfinder-1.4.0a0}/.github/workflows/test_and_deploy.yml

@@ -38,11 +38,14 @@ jobs:
   test:
     needs: [linting, manifest]
     name: Run package tests
-    timeout-minutes: 60
+    timeout-minutes: 120
     runs-on: ${{ matrix.os }}
     env:
       KERAS_BACKEND: torch
       CELLFINDER_TEST_DEVICE: cpu
+      # pooch cache dir
+      BRAINGLOBE_TEST_DATA_DIR: "~/.pooch_cache"
+
     strategy:
       matrix:
         # Run all supported Python versions on linux
@@ -56,6 +59,14 @@ jobs:
             python-version: "3.12"
 
     steps:
+      - uses: actions/checkout@v4
+      - name: Cache pooch data
+        uses: actions/cache@v4
+        with:
+          path: "~/.pooch_cache"
+          # hash on conftest in case url changes
+          key: ${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/pooch_registry.txt') }}
+      # Cache the tensorflow model so we don't have to remake it every time
       - name: Cache brainglobe directory
         uses: actions/cache@v3
         with:
@@ -78,12 +89,16 @@ jobs:
   test_numba_disabled:
     needs: [linting, manifest]
     name: Run tests with numba disabled
-    timeout-minutes: 60
+    timeout-minutes: 120
     runs-on: ubuntu-latest
     env:
-       NUMBA_DISABLE_JIT: "1"
+      NUMBA_DISABLE_JIT: "1"
+      PYTORCH_JIT: "0"
+      # pooch cache dir
+      BRAINGLOBE_TEST_DATA_DIR: "~/.pooch_cache"
 
     steps:
+      - uses: actions/checkout@v4
       - name: Cache brainglobe directory
         uses: actions/cache@v3
         with:
@@ -91,6 +106,13 @@ jobs:
             ~/.brainglobe
             !~/.brainglobe/atlas.tar.gz
           key: brainglobe
+
+      - name: Cache pooch data
+        uses: actions/cache@v4
+        with:
+          path: "~/.pooch_cache"
+          key: ${{ runner.os }}-3.10-${{ hashFiles('**/pooch_registry.txt') }}
+
       # Setup pyqt libraries
       - name: Setup qtpy libraries
         uses: tlambert03/setup-qt-libs@v1
@@ -108,7 +130,7 @@ jobs:
   test_brainmapper_cli:
     needs: [linting, manifest]
     name: Run brainmapper tests to check for breakages
-    timeout-minutes: 60
+    timeout-minutes: 120
     runs-on: ubuntu-latest
     env:
       KERAS_BACKEND: torch

{cellfinder-1.3.3 → cellfinder-1.4.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cellfinder
-Version: 1.3.3
+Version: 1.4.0a0
 Summary: Automated 3D cell detection in large microscopy images
 Author-email: "Adam Tyson, Christian Niedworok, Charly Rousseau" <code@adamltyson.com>
 License: BSD-3-Clause
@@ -33,7 +33,7 @@ Requires-Dist: numpy
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: keras==3.5.0
-Requires-Dist: torch>=2.1.0
+Requires-Dist: torch!=2.4,>=2.1.0
 Requires-Dist: tifffile
 Requires-Dist: tqdm
 Provides-Extra: dev
@@ -46,6 +46,7 @@ Requires-Dist: pytest-qt; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: tox; extra == "dev"
+Requires-Dist: pooch>=1; extra == "dev"
 Provides-Extra: napari
 Requires-Dist: brainglobe-napari-io; extra == "napari"
 Requires-Dist: magicgui; extra == "napari"

{cellfinder-1.3.3 → cellfinder-1.4.0a0}/cellfinder/core/classify/classify.py

@@ -30,7 +30,7 @@ def main(
     max_workers: int = 3,
     *,
     callback: Optional[Callable[[int], None]] = None,
-) -> List:
+) -> List[Cell]:
     """
     Parameters
     ----------

cellfinder-1.4.0a0/cellfinder/core/detect/detect.py

@@ -0,0 +1,236 @@
+"""
+Detection is run in three steps:
+
+1. 2D filtering
+2. 3D filtering
+3. Structure detection
+
+In steps 1. and 2. filters are applied, and any bright points detected
+post-filter are marked. To avoid using a separate mask array to mark the
+bright points, the input data is clipped to [0, (max_val - 2)]
+(max_val is the maximum value that the image data type can store), and:
+- (max_val - 1) is used to mark bright points during 2D filtering
+- (max_val) is used to mark bright points during 3D filtering
+"""
+
+import dataclasses
+from datetime import datetime
+from typing import Callable, List, Optional, Tuple
+
+import numpy as np
+import torch
+from brainglobe_utils.cells.cells import Cell
+
+from cellfinder.core import logger, types
+from cellfinder.core.detect.filters.plane import TileProcessor
+from cellfinder.core.detect.filters.setup_filters import DetectionSettings
+from cellfinder.core.detect.filters.volume.volume_filter import VolumeFilter
+from cellfinder.core.tools.tools import inference_wrapper
+
+
+@inference_wrapper
+def main(
+    signal_array: types.array,
+    start_plane: int = 0,
+    end_plane: int = -1,
+    voxel_sizes: Tuple[float, float, float] = (5, 2, 2),
+    soma_diameter: float = 16,
+    max_cluster_size: float = 100_000,
+    ball_xy_size: float = 6,
+    ball_z_size: float = 15,
+    ball_overlap_fraction: float = 0.6,
+    soma_spread_factor: float = 1.4,
+    n_free_cpus: int = 2,
+    log_sigma_size: float = 0.2,
+    n_sds_above_mean_thresh: float = 10,
+    outlier_keep: bool = False,
+    artifact_keep: bool = False,
+    save_planes: bool = False,
+    plane_directory: Optional[str] = None,
+    batch_size: Optional[int] = None,
+    torch_device: str = "cpu",
+    use_scipy: bool = True,
+    split_ball_xy_size: int = 3,
+    split_ball_z_size: int = 3,
+    split_ball_overlap_fraction: float = 0.8,
+    split_soma_diameter: int = 7,
+    *,
+    callback: Optional[Callable[[int], None]] = None,
+) -> List[Cell]:
+    """
+    Perform cell candidate detection on a 3D signal array.
+
+    Parameters
+    ----------
+    signal_array : numpy.ndarray
+        3D array representing the signal data.
+
+    start_plane : int
+        Index of the starting plane for detection.
+
+    end_plane : int
+        Index of the ending plane for detection.
+
+    voxel_sizes : Tuple[float, float, float]
+        Tuple of voxel sizes in each dimension (z, y, x).
+
+    soma_diameter : float
+        Diameter of the soma in physical units.
+
+    max_cluster_size : float
+        Maximum size of a cluster in physical units.
+
+    ball_xy_size : float
+        Size of the XY ball used for filtering in physical units.
+
+    ball_z_size : float
+        Size of the Z ball used for filtering in physical units.
+
+    ball_overlap_fraction : float
+        Fraction of overlap allowed between balls.
+
+    soma_spread_factor : float
+        Spread factor for soma size.
+
+    n_free_cpus : int
+        Number of free CPU cores available for parallel processing.
+
+    log_sigma_size : float
+        Size of the sigma for the log filter.
+
+    n_sds_above_mean_thresh : float
+        Number of standard deviations above the mean threshold.
+
+    outlier_keep : bool, optional
+        Whether to keep outliers during detection. Defaults to False.
+
+    artifact_keep : bool, optional
+        Whether to keep artifacts during detection. Defaults to False.
+
+    save_planes : bool, optional
+        Whether to save the planes during detection. Defaults to False.
+
+    plane_directory : str, optional
+        Directory path to save the planes. Defaults to None.
+
+    batch_size : int, optional
+        The number of planes to process in each batch. Defaults to 1.
+        For CPU, there's no benefit for a larger batch size. Only a memory
+        usage increase. For CUDA, the larger the batch size the better the
+        performance. Until it fills up the GPU memory - after which it
+        becomes slower.
+
+    torch_device : str, optional
+        The device on which to run the computation. By default, it's "cpu".
+        To run on a gpu, specify the PyTorch device name, such as "cuda" to
+        run on the first GPU.
+
+    callback : Callable[int], optional
+        A callback function that is called every time a plane has finished
+        being processed. Called with the plane number that has finished.
+
+    Returns
+    -------
+    List[Cell]
+        List of detected cells.
+    """
+    start_time = datetime.now()
+    if batch_size is None:
+        if torch_device == "cpu":
+            batch_size = 4
+        else:
+            batch_size = 1
+
+    if not np.issubdtype(signal_array.dtype, np.number):
+        raise TypeError(
+            "signal_array must be a numpy datatype, but has datatype "
+            f"{signal_array.dtype}"
+        )
+
+    if signal_array.ndim != 3:
+        raise ValueError("Input data must be 3D")
+
+    if end_plane < 0:
+        end_plane = len(signal_array)
+    end_plane = min(len(signal_array), end_plane)
+
+    torch_device = torch_device.lower()
+    batch_size = max(batch_size, 1)
+    # brainmapper can pass them in as str
+    voxel_sizes = list(map(float, voxel_sizes))
+
+    settings = DetectionSettings(
+        plane_shape=signal_array.shape[1:],
+        plane_original_np_dtype=signal_array.dtype,
+        voxel_sizes=voxel_sizes,
+        soma_spread_factor=soma_spread_factor,
+        soma_diameter_um=soma_diameter,
+        max_cluster_size_um3=max_cluster_size,
+        ball_xy_size_um=ball_xy_size,
+        ball_z_size_um=ball_z_size,
+        start_plane=start_plane,
+        end_plane=end_plane,
+        n_free_cpus=n_free_cpus,
+        ball_overlap_fraction=ball_overlap_fraction,
+        log_sigma_size=log_sigma_size,
+        n_sds_above_mean_thresh=n_sds_above_mean_thresh,
+        outlier_keep=outlier_keep,
+        artifact_keep=artifact_keep,
+        save_planes=save_planes,
+        plane_directory=plane_directory,
+        batch_size=batch_size,
+        torch_device=torch_device,
+    )
+
+    # replicate the settings specific to splitting, before we access anything
+    # of the original settings, causing cached properties
+    kwargs = dataclasses.asdict(settings)
+    kwargs["ball_z_size_um"] = split_ball_z_size * settings.z_pixel_size
+    kwargs["ball_xy_size_um"] = (
+        split_ball_xy_size * settings.in_plane_pixel_size
+    )
+    kwargs["ball_overlap_fraction"] = split_ball_overlap_fraction
+    kwargs["soma_diameter_um"] = (
+        split_soma_diameter * settings.in_plane_pixel_size
+    )
+    # always run on cpu because copying to gpu overhead is likely slower than
+    # any benefit for detection on smallish volumes
+    kwargs["torch_device"] = "cpu"
+    # for splitting, we only do 3d filtering. Its input is a zero volume
+    # with cell voxels marked with threshold_value. So just use float32
+    # for input because the filters will also use float(32). So there will
+    # not be need to convert the input a different dtype before passing to
+    # the filters.
+    kwargs["plane_original_np_dtype"] = np.float32
+    splitting_settings = DetectionSettings(**kwargs)
+
+    # Create 3D analysis filter
+    mp_3d_filter = VolumeFilter(settings=settings)
+
+    # Create 2D analysis filter
+    mp_tile_processor = TileProcessor(
+        plane_shape=settings.plane_shape,
+        clipping_value=settings.clipping_value,
+        threshold_value=settings.threshold_value,
+        n_sds_above_mean_thresh=n_sds_above_mean_thresh,
+        log_sigma_size=log_sigma_size,
+        soma_diameter=settings.soma_diameter,
+        torch_device=torch_device,
+        dtype=settings.filtering_dtype.__name__,
+        use_scipy=use_scipy,
+    )
+
+    orig_n_threads = torch.get_num_threads()
+    torch.set_num_threads(settings.n_torch_comp_threads)
+
+    # process the data
+    mp_3d_filter.process(mp_tile_processor, signal_array, callback=callback)
+    cells = mp_3d_filter.get_results(splitting_settings)
+
+    torch.set_num_threads(orig_n_threads)
+
+    time_elapsed = datetime.now() - start_time
+    s = f"Detection complete. Found {len(cells)} cells in {time_elapsed}"
+    logger.debug(s)
+    print(s)
+    return cells

cellfinder-1.4.0a0/cellfinder/core/detect/filters/plane/classical_filter.py

@@ -0,0 +1,347 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from scipy.ndimage import gaussian_filter, laplace
+from scipy.signal import medfilt2d
+
+
+@torch.jit.script
+def normalize(
+    filtered_planes: torch.Tensor,
+    flip: bool,
+    max_value: float = 1.0,
+) -> None:
+    """
+    Normalizes the 3d tensor so each z-plane is independently scaled to be
+    in the [0, max_value] range. If `flip` is `True`, the sign of the tensor
+    values are flipped before any processing.
+
+    It is done to filtered_planes inplace.
+    """
+    num_z = filtered_planes.shape[0]
+    filtered_planes_1d = filtered_planes.view(num_z, -1)
+
+    if flip:
+        filtered_planes_1d.mul_(-1)
+
+    planes_min = torch.min(filtered_planes_1d, dim=1, keepdim=True)[0]
+    filtered_planes_1d.sub_(planes_min)
+    # take max after subtraction
+    planes_max = torch.max(filtered_planes_1d, dim=1, keepdim=True)[0]
+    # if min = max = zero, divide by 1 - it'll stay zero
+    planes_max[planes_max == 0] = 1
+    filtered_planes_1d.div_(planes_max)
+
+    if max_value != 1.0:
+        # To leave room to label in the 3d detection.
+        filtered_planes_1d.mul_(max_value)
+
+
+@torch.jit.script
+def filter_for_peaks(
+    planes: torch.Tensor,
+    med_kernel: torch.Tensor,
+    gauss_kernel: torch.Tensor,
+    gauss_kernel_size: int,
+    lap_kernel: torch.Tensor,
+    device: str,
+    clipping_value: float,
+) -> torch.Tensor:
+    """
+    Takes the 3d z-stack and returns a new z-stack where the peaks are
+    highlighted.
+
+    It applies a median filter -> gaussian filter -> laplacian filter.
+    """
+    filtered_planes = planes.unsqueeze(1)  # ZYX -> ZCYX input, C=channels
+
+    # ------------------ median filter ------------------
+    # extracts patches to compute median over for each pixel
+    # We go from ZCYX -> ZCYX, C=1 to C=9 with C containing the elements around
+    # each Z,X,Y voxel over which we compute the median
+    # Zero padding is ok here
+    filtered_planes = F.conv2d(filtered_planes, med_kernel, padding="same")
+    # we're going back to ZCYX=Z1YX by taking median of patches in C dim
+    filtered_planes = filtered_planes.median(dim=1, keepdim=True)[0]
+
+    # ------------------ gaussian filter ------------------
+    # normalize the input data to 0-1 range. Otherwise, if the values are
+    # large, we'd need a float64 so conv result is accurate
+    normalize(filtered_planes, flip=False)
+
+    # we need to do reflection padding around the tensor for parity with scipy
+    # gaussian filtering. Scipy does reflection in a manner typically called
+    # symmetric: (dcba|abcd|dcba). Torch does it like this: (dcb|abcd|cba). So
+    # we manually do symmetric padding below
+    pad = gauss_kernel_size // 2
+    padding_mode = "reflect"
+    # if data is too small for reflect, just use constant border value
+    if pad >= filtered_planes.shape[-1] or pad >= filtered_planes.shape[-2]:
+        padding_mode = "replicate"
+    filtered_planes = F.pad(filtered_planes, (pad,) * 4, padding_mode, 0.0)
+    # We reflected torch style, so copy/shift everything by one to be symmetric
+    filtered_planes[:, :, :pad, :] = filtered_planes[
+        :, :, 1 : pad + 1, :
+    ].clone()
+    filtered_planes[:, :, -pad:, :] = filtered_planes[
+        :, :, -pad - 1 : -1, :
+    ].clone()
+    filtered_planes[:, :, :, :pad] = filtered_planes[
+        :, :, :, 1 : pad + 1
+    ].clone()
+    filtered_planes[:, :, :, -pad:] = filtered_planes[
+        :, :, :, -pad - 1 : -1
+    ].clone()
+
+    # We apply the 1D gaussian filter twice, once for Y and once for X. The
+    # filter shape passed in is 11K1 or 111K, depending on device. Where
+    # K=filter size
+    # see https://discuss.pytorch.org/t/performance-issue-for-conv2d-with-1d-
+    # filter-along-a-dim/201734/2 for the reason for the moveaxis depending
+    # on the device
+    if device == "cpu":
+        # kernel shape is 11K1. First do Y (second to last axis)
+        filtered_planes = F.conv2d(
+            filtered_planes, gauss_kernel, padding="valid"
+        )
+        # To do X, exchange X,Y axis, filter, change back. On CPU, Y (second
+        # to last) axis is faster.
+        filtered_planes = F.conv2d(
+            filtered_planes.moveaxis(-1, -2), gauss_kernel, padding="valid"
+        ).moveaxis(-1, -2)
+    else:
+        # kernel shape is 111K
+        # First do Y (second to last axis). Exchange X,Y axis, filter, change
+        # back. On CUDA, X (last) axis is faster.
+        filtered_planes = F.conv2d(
+            filtered_planes.moveaxis(-1, -2), gauss_kernel, padding="valid"
+        ).moveaxis(-1, -2)
+        # now do X, last axis
+        filtered_planes = F.conv2d(
+            filtered_planes, gauss_kernel, padding="valid"
+        )
+
+    # ------------------ laplacian filter ------------------
+    # it's a 2d filter. Need to pad using symmetric for scipy parity. But,
+    # torch doesn't have it, and we used a kernel of size 3, so for padding of
+    # 1, replicate == symmetric. That's enough for parity with past scipy. If
+    # we change kernel size in the future, we may have to do as above
+    padding = lap_kernel.shape[-1] // 2
+    filtered_planes = F.pad(filtered_planes, (padding,) * 4, "replicate")
+    filtered_planes = F.conv2d(filtered_planes, lap_kernel, padding="valid")
+
+    # we don't need the channel axis
+    filtered_planes = filtered_planes[:, 0, :, :]
+
+    # scale back to full scale, filtered values are negative so flip
+    normalize(filtered_planes, flip=True, max_value=clipping_value)
+    return filtered_planes
+
+
+class PeakEnhancer:
+    """
+    A class that filters each plane in a z-stack such that peaks are
+    visualized.
+
+    It uses a series of 2D filters of median -> gaussian ->
+    laplacian. Then normalizes each plane to be between [0, clipping_value].
+
+    Parameters
+    ----------
+    torch_device: str
+        The device on which the data and processing occurs on. Can be e.g.
+        "cpu", "cuda" etc. Any data passed to the filter must be on this
+        device. Returned data will also be on this device.
+    dtype : torch.dtype
+        The data-type of the input planes and the type to use internally.
+        E.g. `torch.float32`.
+    clipping_value : int
+        The value such that after normalizing, the max value will be this
+        clipping_value.
+    laplace_gaussian_sigma : float
+        Size of the sigma for the gaussian filter.
+    use_scipy : bool
+        If running on the CPU whether to use the scipy filters or the same
+        pytorch filters used on CUDA. Scipy filters can be faster.
+    """
+
+    # binary kernel that generates square patches for each pixel so we can find
+    # the median around the pixel
+    med_kernel: torch.Tensor
+
+    # gaussian 1D kernel with kernel/weight shape 11K1 or 111K, depending
+    # on device. Where K=filter size
+    gauss_kernel: torch.Tensor
+
+    # 2D laplacian kernel with kernel/weight shape KxK. Where
+    # K=filter size
+    lap_kernel: torch.Tensor
+
+    # the value such that after normalizing, the max value will be this
+    # clipping_value
+    clipping_value: float
+
+    # sigma value for gaussian filter
+    laplace_gaussian_sigma: float
+
+    # the torch device to run on. E.g. cpu/cuda.
+    torch_device: str
+
+    # when running on CPU whether to use pytorch or scipy for filters
+    use_scipy: bool
+
+    median_filter_size: int = 3
+    """
+    The median filter size in x/y direction.
+
+    **Must** be odd.
+    """
+
+    def __init__(
+        self,
+        torch_device: str,
+        dtype: torch.dtype,
+        clipping_value: float,
+        laplace_gaussian_sigma: float,
+        use_scipy: bool,
+    ):
+        super().__init__()
+        self.torch_device = torch_device.lower()
+        self.clipping_value = clipping_value
+        self.laplace_gaussian_sigma = laplace_gaussian_sigma
+        self.use_scipy = use_scipy
+
+        # all these kernels are odd in size
+        self.med_kernel = self._get_median_kernel(torch_device, dtype)
+        self.gauss_kernel = self._get_gaussian_kernel(
+            torch_device, dtype, laplace_gaussian_sigma
+        )
+        self.lap_kernel = self._get_laplacian_kernel(torch_device, dtype)
+
+    @property
+    def gaussian_filter_size(self) -> int:
+        """
+        The gaussian filter 1d size.
+
+        It is odd.
+        """
+        return 2 * int(round(4 * self.laplace_gaussian_sigma)) + 1
+
+    def _get_median_kernel(
+        self, torch_device: str, dtype: torch.dtype
+    ) -> torch.Tensor:
+        """
+        Gets a median patch generator kernel, already on the correct
+        device.
+
+        Based on how kornia does it for median filtering.
+        """
+        # must be odd kernel
+        kernel_n = self.median_filter_size
+        if not (kernel_n % 2):
+            raise ValueError("The median filter size must be odd")
+
+        # extract patches to compute median over for each pixel. When passing
+        # input we go from ZCYX -> ZCYX, C=1 to C=9 and containing the elements
+        # around each Z,X,Y over which we can then compute the median
+        window_range = kernel_n * kernel_n  # e.g. 3x3
+        kernel = torch.zeros(
+            (window_range, window_range), device=torch_device, dtype=dtype
+        )
+        idx = torch.arange(window_range, device=torch_device)
+        # diagonal of e.g. 9x9 is 1
+        kernel[idx, idx] = 1.0
+        # out channels, in channels, n*y, n*x. The kernel collects all the 3x3
+        # elements around a pixel, using a binary mask for each element, as a
+        # separate channel. So we go from 1 to 9 channels in the output
+        kernel = kernel.view(window_range, 1, kernel_n, kernel_n)
+
+        return kernel
+
+    def _get_gaussian_kernel(
+        self,
+        torch_device: str,
+        dtype: torch.dtype,
+        laplace_gaussian_sigma: float,
+    ) -> torch.Tensor:
+        """Gets the 1D gaussian kernel used to filter the data."""
+        # we do 2 1D filters, once on each y, x dim.
+        # shape of kernel will be 11K1 with dims Z, C, Y, X. C=1, Z is expanded
+        # to number of z during filtering.
+        kernel_size = self.gaussian_filter_size
+
+        # to get the values of a 1D gaussian kernel, we pass a single impulse
+        # data through the filter, which recovers the filter values. We do this
+        # because scipy doesn't make their kernel available in public API and
+        # we want parity with scipy filtering
+        impulse = np.zeros(kernel_size)
+        # the impulse needs to be to the left of center
+        impulse[kernel_size // 2] = 1
+        kernel = gaussian_filter(
+            impulse, laplace_gaussian_sigma, mode="constant", cval=0
+        )
+        # kernel should be fully symmetric
+        assert kernel[0] == kernel[-1]
+        gauss_kernel = torch.from_numpy(kernel).type(dtype).to(torch_device)
+
+        # default shape is (y, x) with y axis filtered only - we transpose
+        # input to filter on x
+        gauss_kernel = gauss_kernel.view(1, 1, -1, 1)
+
+        # see https://discuss.pytorch.org/t/performance-issue-for-conv2d-
+        # with-1d-filter-along-a-dim/201734. Conv2d is faster on a specific dim
+        # for 1D filters depending on CPU/CUDA. See also filter_for_peaks
+        # on CPU, we only do conv2d on the (1st) dim
+        if torch_device != "cpu":
+            # on CUDA, we only filter on the x dim, flipping input to filter y
+            gauss_kernel = gauss_kernel.view(1, 1, 1, -1)
+
+        return gauss_kernel
+
+    def _get_laplacian_kernel(
+        self, torch_device: str, dtype: torch.dtype
+    ) -> torch.Tensor:
+        """Gets a 2d laplacian kernel, based on scipy's laplace."""
+        # for parity with scipy, scipy computes the laplacian with default
+        # parameters and kernel size 3 using filter coefficients [1, -2, 1].
+        # Each filtered pixel is the sum of the filter around the pixel
+        # vertically and horizontally. We can do it in 2d at once with
+        # coefficients below (faster than 2x1D for such small filter)
+        return torch.as_tensor(
+            [[0, 1, 0], [1, -4, 1], [0, 1, 0]],
+            dtype=dtype,
+            device=torch_device,
+        ).view(1, 1, 3, 3)
+
+    def enhance_peaks(self, planes: torch.Tensor) -> torch.Tensor:
+        """
+        Applies the filtering and normalization to the 3d z-stack (not inplace)
+        and returns the filtered z-stack.
+        """
+        if self.torch_device == "cpu" and self.use_scipy:
+            filtered_planes = planes.clone()
+            for i in range(planes.shape[0]):
+                img = planes[i, :, :].numpy()
+                img = medfilt2d(img)
+                img = gaussian_filter(img, self.laplace_gaussian_sigma)
+                img = laplace(img)
+                filtered_planes[i, :, :] = torch.from_numpy(img)
+
+            # laplace makes values negative so flip
+            normalize(
+                filtered_planes,
+                flip=True,
+                max_value=self.clipping_value,
+            )
+            return filtered_planes
+
+        filtered_planes = filter_for_peaks(
+            planes,
+            self.med_kernel,
+            self.gauss_kernel,
+            self.gaussian_filter_size,
+            self.lap_kernel,
+            self.torch_device,
+            self.clipping_value,
+        )
+        return filtered_planes