cellfinder 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

cellfinder/core/classify/classify.py

@@ -19,8 +19,8 @@ def main(
     signal_array: types.array,
     background_array: types.array,
     n_free_cpus: int,
-    voxel_sizes: Tuple[int, int, int],
-    network_voxel_sizes: Tuple[int, int, int],
+    voxel_sizes: Tuple[float, float, float],
+    network_voxel_sizes: Tuple[float, float, float],
     batch_size: int,
     cube_height: int,
     cube_width: int,
@@ -29,12 +29,58 @@ def main(
     model_weights: Optional[os.PathLike],
     network_depth: depth_type,
     max_workers: int = 3,
+    pin_memory: bool = False,
     *,
     callback: Optional[Callable[[int], None]] = None,
 ) -> List[Cell]:
     """
     Parameters
     ----------
+
+    points: List of Cell objects
+        The potential cells to classify.
+    signal_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    background_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    n_free_cpus : int
+        How many CPU cores to leave free.
+    voxel_sizes : 3-tuple of floats
+        Size of your voxels in the z, y, and x dimensions.
+    network_voxel_sizes : 3-tuple of floats
+        Size of the pre-trained network's voxels in the z, y, and x dimensions.
+    batch_size : int
+        How many potential cells to classify at one time. The GPU/CPU
+        memory must be able to contain at once this many data cubes for
+        the models. For performance-critical applications, tune to maximize
+        memory usage without running out. Check your GPU/CPU memory to verify
+        it's not full.
+    cube_height: int
+        The height of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_width: int
+        The width of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_depth: int
+        The depth of the data cube centered on the cell used for
+        classification. Defaults to `20`.
+    trained_model : Optional[Path]
+        Trained model file path (home directory (default) -> pretrained
+        weights).
+    model_weights : Optional[Path]
+        Model weights path (home directory (default) -> pretrained
+        weights).
+    network_depth: str
+        The network depth to use during classification. Defaults to `"50"`.
+    max_workers: int
+        The number of sub-processes to use for data loading / processing.
+        Defaults to 8.
+    pin_memory: bool
+        Pins data to be sent to the GPU to the CPU memory. This allows faster
+        GPU data speeds, but can only be used if the data used by the GPU can
+        stay in the CPU RAM while the GPU uses it. I.e. there's enough RAM.
+        Otherwise, if there's a risk of the RAM being paged, it shouldn't be
+        used. Defaults to False.
     callback : Callable[int], optional
         A callback function that is called during classification. Called with
         the batch number once that batch has been classified.

cellfinder/core/detect/detect.py

@@ -49,10 +49,11 @@ def main(
     plane_directory: Optional[str] = None,
     batch_size: Optional[int] = None,
     torch_device: Optional[str] = None,
-    split_ball_xy_size: int = 3,
-    split_ball_z_size: int = 3,
+    pin_memory: bool = False,
+    split_ball_xy_size: float = 6,
+    split_ball_z_size: float = 15,
     split_ball_overlap_fraction: float = 0.8,
-    split_soma_diameter: int = 7,
+    n_splitting_iter: int = 10,
     *,
     callback: Optional[Callable[[int], None]] = None,
 ) -> List[Cell]:
@@ -61,69 +62,80 @@ def main(
 
     Parameters
     ----------
-    signal_array : numpy.ndarray
-        3D array representing the signal data.
-
+    signal_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
     start_plane : int
-        Index of the starting plane for detection.
-
+        First plane index to process (inclusive, to process a subset of the
+        data).
     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).
-
+        Last plane index to process (exclusive, to process a subset of the
+        data).
+    voxel_sizes : 3-tuple of floats
+        Size of your voxels in the z, y, and x dimensions (microns).
     soma_diameter : float
-        Diameter of the soma in physical units.
-
+        The expected in-plane (xy) soma diameter (microns).
     max_cluster_size : float
-        Maximum size of a cluster in physical units.
-
+        Largest detected cell cluster (in cubic um) where splitting
+        should be attempted. Clusters above this size will be labeled
+        as artifacts.
     ball_xy_size : float
-        Size of the XY ball used for filtering in physical units.
-
+        3d filter's in-plane (xy) filter ball size (microns).
     ball_z_size : float
-        Size of the Z ball used for filtering in physical units.
-
+        3d filter's axial (z) filter ball size (microns).
     ball_overlap_fraction : float
-        Fraction of overlap allowed between balls.
-
+        3d filter's fraction of the ball filter needed to be filled by
+        foreground voxels, centered on a voxel, to retain the voxel.
     soma_spread_factor : float
-        Spread factor for soma size.
-
+        Cell spread factor for determining the largest cell volume before
+        splitting up cell clusters. Structures with spherical volume of
+        diameter `soma_spread_factor * soma_diameter` or less will not be
+        split.
     n_free_cpus : int
-        Number of free CPU cores available for parallel processing.
-
+        How many CPU cores to leave free.
     log_sigma_size : float
-        Size of the sigma for the log filter.
-
+        Gaussian filter width (as a fraction of soma diameter) used during
+        2d in-plane Laplacian of Gaussian filtering.
     n_sds_above_mean_thresh : float
-        Number of standard deviations above the mean threshold.
-
+        Intensity threshold (the number of standard deviations above
+        the mean) of the filtered 2d planes used to mark pixels as
+        foreground or background.
     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.
-
+    batch_size: int
+        The number of planes of the original data volume to process at
+        once. The GPU/CPU memory must be able to contain this many planes
+        for all the filters. For performance-critical applications, tune to
+        maximize memory usage without running out. Check your GPU/CPU memory
+        to verify it's not full.
     torch_device : str, optional
         The device on which to run the computation. If not specified (None),
         "cuda" will be used if a GPU is available, otherwise "cpu".
         You can also manually specify "cuda" or "cpu".
-
+    pin_memory: bool
+        Pins data to be sent to the GPU to the CPU memory. This allows faster
+        GPU data speeds, but can only be used if the data used by the GPU can
+        stay in the CPU RAM while the GPU uses it. I.e. there's enough RAM.
+        Otherwise, if there's a risk of the RAM being paged, it shouldn't be
+        used. Defaults to False.
+    split_ball_xy_size: float
+        Similar to `ball_xy_size`, except the value to use for the 3d
+        filter during cluster splitting.
+    split_ball_z_size: float
+        Similar to `ball_z_size`, except the value to use for the 3d filter
+        during cluster splitting.
+    split_ball_overlap_fraction: float
+        Similar to `ball_overlap_fraction`, except the value to use for the
+        3d filter during cluster splitting.
+    n_splitting_iter: int
+        The number of iterations to run the 3d filtering on a cluster. Each
+        iteration reduces the cluster size by the voxels not retained in
+        the previous iteration.
     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.
@@ -131,7 +143,7 @@ def main(
     Returns
     -------
     List[Cell]
-        List of detected cells.
+        List of detected cell candidates.
     """
     start_time = datetime.now()
     if torch_device is None:
@@ -187,19 +199,16 @@ def main(
         plane_directory=plane_directory,
         batch_size=batch_size,
         torch_device=torch_device,
+        pin_memory=pin_memory,
+        n_splitting_iter=n_splitting_iter,
     )
 
     # 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_z_size_um"] = split_ball_z_size
+    kwargs["ball_xy_size_um"] = split_ball_xy_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"

cellfinder/core/detect/filters/plane/plane_filter.py

@@ -39,7 +39,7 @@ class TileProcessor:
         Number of standard deviations above the mean threshold to use for
         determining whether a voxel is bright.
     log_sigma_size : float
-        Size of the sigma for the gaussian filter.
+        Size of the Gaussian sigma for the Laplacian of Gaussian filtering.
     soma_diameter : float
         Diameter of the soma in voxels.
     torch_device: str

cellfinder/core/detect/filters/setup_filters.py

@@ -80,23 +80,28 @@ class DetectionSettings:
 
     voxel_sizes: Tuple[float, float, float] = (1.0, 1.0, 1.0)
     """
-    Tuple of voxel sizes in each dimension (z, y, x). We use this to convert
-    from `um` to pixel sizes.
+    Tuple of voxel sizes (microns) in each dimension (z, y, x). We use this
+    to convert from `um` to pixel sizes.
     """
 
     soma_spread_factor: float = 1.4
-    """Spread factor for soma size - how much it may stretch in the images."""
+    """
+    Cell spread factor for determining the largest cell volume before
+    splitting up cell clusters. Structures with spherical volume of
+    diameter `soma_spread_factor * soma_diameter` or less will not be
+    split.
+    """
 
     soma_diameter_um: float = 16
     """
-    Diameter of a typical soma in um. Bright areas larger than this will be
-    split.
+    Diameter of a typical soma in-plane (xy) in microns.
     """
 
     max_cluster_size_um3: float = 100_000
     """
-    Maximum size of a cluster (bright area) that will be processed, in um.
-    Larger bright areas are skipped as artifacts.
+    Largest detected cell cluster (in cubic um) where splitting
+    should be attempted. Clusters above this size will be labeled
+    as artifacts.
     """
 
     ball_xy_size_um: float = 6
@@ -116,17 +121,21 @@ class DetectionSettings:
 
     ball_overlap_fraction: float = 0.6
     """
-    Fraction of overlap between a bright area and the spherical kernel,
-    for the area to be considered a single ball.
+    Fraction of the 3d ball filter needed to be filled by foreground voxels,
+    centered on a voxel, to retain the voxel.
     """
 
     log_sigma_size: float = 0.2
-    """Size of the sigma for the 2d Gaussian filter."""
+    """
+    Gaussian filter width (as a fraction of soma diameter) used during
+    2d in-plane Laplacian of Gaussian filtering.
+    """
 
     n_sds_above_mean_thresh: float = 10
     """
-    Number of standard deviations above the mean intensity to use for a
-    threshold to define bright areas. Below it, it's not considered bright.
+    Intensity threshold (the number of standard deviations above
+    the mean) of the filtered 2d planes used to mark pixels as
+    foreground or background.
     """
 
     outlier_keep: bool = False
@@ -180,6 +189,14 @@ class DetectionSettings:
     to run on the first GPU.
     """
 
+    pin_memory: bool = False
+    """
+    Pins data to be sent to the GPU to the CPU memory. This allows faster GPU
+    data speeds, but can only be used if the data used by the GPU can stay in
+    the CPU RAM while the GPU uses it. I.e. there's enough RAM. Otherwise, if
+    there's a risk of the RAM being paged, it shouldn't be used.
+    """
+
     n_free_cpus: int = 2
     """
     Number of free CPU cores to keep available and not use during parallel
@@ -191,6 +208,8 @@ class DetectionSettings:
     """
     During the structure splitting phase we iteratively shrink the bright areas
     and re-filter with the 3d filter. This is the number of iterations to do.
+    Each iteration reduces the cluster size by the voxels not retained in the
+    previous iteration.
 
     This is a maximum because we also stop if there are no more structures left
     during any iteration.

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

@@ -78,11 +78,11 @@ class BallFilter:
     ----------
     plane_height, plane_width : int
         Height/width of the planes.
-    ball_xy_size : int
-        Diameter of the spherical kernel in the x/y dimensions.
-    ball_z_size : int
-        Diameter of the spherical kernel in the z dimension.
-        Equal to the number of planes stacked to filter
+    ball_xy_size : float
+        Diameter of the spherical kernel (in microns) in the x/y dimensions.
+    ball_z_size : float
+        Diameter of the spherical kernel in the z dimension in microns.
+        Determines the number of planes stacked to filter
         the central plane of the stack.
     overlap_fraction : float
         The fraction of pixels within the spherical kernel that

cellfinder/core/detect/filters/volume/structure_splitting.py

@@ -1,3 +1,4 @@
+from copy import copy
 from typing import List, Tuple, Type
 
 import numpy as np
@@ -224,6 +225,7 @@ def split_cells(
             where M is the number of individual cells and each centre is
             represented by its x, y, and z coordinates.
     """
+    settings = copy(settings)
     # these points are in x, y, z order columnwise, in absolute pixels
     orig_centre = get_structure_centre(cell_points)
 

cellfinder/core/detect/filters/volume/volume_filter.py

@@ -140,7 +140,7 @@ class VolumeFilter:
             tensor = torch.empty(
                 (batch_size, *self.settings.plane_shape),
                 dtype=torch_dtype,
-                pin_memory=not cpu,
+                pin_memory=not cpu and self.settings.pin_memory,
                 device="cpu",
             )
 

cellfinder/core/main.py

@@ -1,34 +1,33 @@
 import os
 from typing import Callable, List, Optional, Tuple
 
-import numpy as np
 from brainglobe_utils.cells.cells import Cell
 
-from cellfinder.core import logger
+from cellfinder.core import logger, types
 from cellfinder.core.download.download import model_type
 from cellfinder.core.train.train_yaml import depth_type
 
 
 def main(
-    signal_array: np.ndarray,
-    background_array: np.ndarray,
-    voxel_sizes: Tuple[int, int, int],
+    signal_array: types.array,
+    background_array: types.array,
+    voxel_sizes: Tuple[float, float, float],
     start_plane: int = 0,
     end_plane: int = -1,
     trained_model: Optional[os.PathLike] = None,
     model_weights: Optional[os.PathLike] = None,
     model: model_type = "resnet50_tv",
-    batch_size: int = 64,
+    classification_batch_size: int = 64,
     n_free_cpus: int = 2,
-    network_voxel_sizes: Tuple[int, int, int] = (5, 1, 1),
-    soma_diameter: int = 16,
-    ball_xy_size: int = 6,
-    ball_z_size: int = 15,
+    network_voxel_sizes: Tuple[float, float, float] = (5, 1, 1),
+    soma_diameter: float = 16,
+    ball_xy_size: float = 6,
+    ball_z_size: float = 15,
     ball_overlap_fraction: float = 0.6,
     log_sigma_size: float = 0.2,
     n_sds_above_mean_thresh: float = 10,
     soma_spread_factor: float = 1.4,
-    max_cluster_size: int = 100000,
+    max_cluster_size: float = 100000,
     cube_width: int = 50,
     cube_height: int = 50,
     cube_depth: int = 20,
@@ -36,8 +35,13 @@ def main(
     skip_detection: bool = False,
     skip_classification: bool = False,
     detected_cells: List[Cell] = None,
-    classification_batch_size: Optional[int] = None,
+    detection_batch_size: Optional[int] = None,
     torch_device: Optional[str] = None,
+    pin_memory: bool = False,
+    split_ball_xy_size: float = 6,
+    split_ball_z_size: float = 15,
+    split_ball_overlap_fraction: float = 0.8,
+    n_splitting_iter: int = 10,
     *,
     detect_callback: Optional[Callable[[int], None]] = None,
     classify_callback: Optional[Callable[[int], None]] = None,
@@ -46,6 +50,111 @@ def main(
     """
     Parameters
     ----------
+    signal_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    background_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    voxel_sizes : 3-tuple of floats
+        Size of your voxels in the z, y, and x dimensions (microns).
+    start_plane : int
+        First plane index to process (inclusive, to process a subset of the
+        data).
+    end_plane : int
+        Last plane index to process (exclusive, to process a subset of the
+        data).
+    trained_model : Optional[Path]
+        Trained model file path (home directory (default) -> pretrained
+        weights).
+    model_weights : Optional[Path]
+        Model weights path (home directory (default) -> pretrained
+        weights).
+    model: str
+        Type of model to use. Defaults to `"resnet50_tv"`.
+    classification_batch_size : int
+        How many potential cells to classify at one time. The GPU/CPU
+        memory must be able to contain at once this many data cubes for
+        the models. For performance-critical applications, tune to maximize
+        memory usage without running out. Check your GPU/CPU memory to verify
+        it's not full.
+    n_free_cpus : int
+        How many CPU cores to leave free.
+    network_voxel_sizes : 3-tuple of floats
+        Size of the pre-trained network's voxels (microns) in the z, y, and x
+        dimensions.
+    soma_diameter : float
+        The expected in-plane (xy) soma diameter (microns).
+    ball_xy_size : float
+        3d filter's in-plane (xy) filter ball size (microns).
+    ball_z_size : float
+        3d filter's axial (z) filter ball size (microns).
+    ball_overlap_fraction : float
+        3d filter's fraction of the ball filter needed to be filled by
+        foreground voxels, centered on a voxel, to retain the voxel.
+    log_sigma_size : float
+        Gaussian filter width (as a fraction of soma diameter) used during
+        2d in-plane Laplacian of Gaussian filtering.
+    n_sds_above_mean_thresh : float
+        Intensity threshold (the number of standard deviations above
+        the mean) of the filtered 2d planes used to mark pixels as
+        foreground or background.
+    soma_spread_factor : float
+        Cell spread factor for determining the largest cell volume before
+        splitting up cell clusters. Structures with spherical volume of
+        diameter `soma_spread_factor * soma_diameter` or less will not be
+        split.
+    max_cluster_size : float
+        Largest detected cell cluster (in cubic um) where splitting
+        should be attempted. Clusters above this size will be labeled
+        as artifacts.
+    cube_width: int
+        The width of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_height: int
+        The height of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_depth: int
+        The depth of the data cube centered on the cell used for
+        classification. Defaults to `20`.
+    network_depth: str
+        The network depth to use during classification. Defaults to `"50"`.
+    skip_detection : bool
+        If selected, the detection step is skipped and instead we get the
+        detected cells from the cell layer below (from a previous
+        detection run or import).
+    skip_classification : bool
+        If selected, the classification step is skipped and all cells from
+        the detection stage are added.
+    detected_cells: Optional list of Cell objects.
+        If specified, the cells to use during classification.
+    detection_batch_size: int
+        The number of planes of the original data volume to process at
+        once. The GPU/CPU memory must be able to contain this many planes
+        for all the filters. For performance-critical applications, tune
+        to maximize memory usage without running out. Check your GPU/CPU
+        memory to verify it's not full.
+    torch_device : str, optional
+        The device on which to run the computation. If not specified (None),
+        "cuda" will be used if a GPU is available, otherwise "cpu".
+        You can also manually specify "cuda" or "cpu".
+    pin_memory: bool
+        Pins data to be sent to the GPU to the CPU memory. This allows faster
+        GPU data speeds, but can only be used if the data used by the GPU can
+        stay in the CPU RAM while the GPU uses it. I.e. there's enough RAM.
+        Otherwise, if there's a risk of the RAM being paged, it shouldn't be
+        used. Defaults to False.
+    split_ball_xy_size: float
+        Similar to `ball_xy_size`, except the value to use for the 3d
+        filter during cluster splitting.
+    split_ball_z_size: float
+        Similar to `ball_z_size`, except the value to use for the 3d filter
+        during cluster splitting.
+    split_ball_overlap_fraction: float
+        Similar to `ball_overlap_fraction`, except the value to use for the
+        3d filter during cluster splitting.
+    n_splitting_iter: int
+        The number of iterations to run the 3d filtering on a cluster. Each
+        iteration reduces the cluster size by the voxels not retained in
+        the previous iteration.
     detect_callback : Callable[int], optional
         Called every time a plane has finished being processed during the
         detection stage. Called with the plane number that has finished.
@@ -76,9 +185,14 @@ def main(
             n_free_cpus,
             log_sigma_size,
             n_sds_above_mean_thresh,
-            batch_size=classification_batch_size,
+            batch_size=detection_batch_size,
             torch_device=torch_device,
+            pin_memory=pin_memory,
             callback=detect_callback,
+            split_ball_z_size=split_ball_z_size,
+            split_ball_xy_size=split_ball_xy_size,
+            split_ball_overlap_fraction=split_ball_overlap_fraction,
+            n_splitting_iter=n_splitting_iter,
         )
 
         if detect_finished_callback is not None:
@@ -101,7 +215,7 @@ def main(
                 n_free_cpus,
                 voxel_sizes,
                 network_voxel_sizes,
-                batch_size,
+                classification_batch_size,
                 cube_height,
                 cube_width,
                 cube_depth,

cellfinder/napari/curation.py

@@ -228,8 +228,8 @@ class CurationWidget(QWidget):
         self.layout.addWidget(self.load_data_panel, row, column, 1, 1)
 
     def setup_keybindings(self):
-        self.viewer.bind_key("c", self.mark_as_cell)
-        self.viewer.bind_key("x", self.mark_as_non_cell)
+        self.viewer.bind_key("c", self.mark_as_cell, overwrite=True)
+        self.viewer.bind_key("x", self.mark_as_non_cell, overwrite=True)
 
     def set_signal_image(self):
         """

cellfinder/napari/detect/detect.py

@@ -244,24 +244,26 @@ def detect_widget() -> FunctionGui:
         detection_options,
         skip_detection: bool,
         soma_diameter: float,
+        log_sigma_size: float,
+        n_sds_above_mean_thresh: float,
         ball_xy_size: float,
         ball_z_size: float,
         ball_overlap_fraction: float,
-        log_sigma_size: float,
-        n_sds_above_mean_thresh: int,
+        detection_batch_size: int,
         soma_spread_factor: float,
-        max_cluster_size: int,
+        max_cluster_size: float,
         classification_options,
         skip_classification: bool,
         use_pre_trained_weights: bool,
         trained_model: Optional[Path],
-        batch_size: int,
+        classification_batch_size: int,
         misc_options,
         start_plane: int,
         end_plane: int,
         n_free_cpus: int,
         analyse_local: bool,
         use_gpu: bool,
+        pin_memory: bool,
         debug: bool,
         reset_button,
     ) -> None:
@@ -271,43 +273,60 @@ def detect_widget() -> FunctionGui:
         Parameters
         ----------
         voxel_size_z : float
-            Size of your voxels in the axial dimension
+            Size of your voxels in the axial dimension (microns)
         voxel_size_y : float
-            Size of your voxels in the y direction (top to bottom)
+            Size of your voxels in the y direction (top to bottom) (microns)
         voxel_size_x : float
-            Size of your voxels in the x direction (left to right)
+            Size of your voxels in the x direction (left to right) (microns)
         skip_detection : bool
             If selected, the detection step is skipped and instead we get the
             detected cells from the cell layer below (from a previous
             detection run or import)
         soma_diameter : float
-            The expected in-plane soma diameter (microns)
+            The expected in-plane (xy) soma diameter (microns)
+        log_sigma_size : float
+            Gaussian filter width (as a fraction of soma diameter) used during
+            2d in-plane Laplacian of Gaussian filtering
+        n_sds_above_mean_thresh : float
+            Intensity threshold (the number of standard deviations above
+            the mean) of the filtered 2d planes used to mark pixels as
+            foreground or background
         ball_xy_size : float
-            Elliptical morphological in-plane filter size (microns)
+            3d filter's in-plane (xy) filter ball size (microns)
         ball_z_size : float
-            Elliptical morphological axial filter size (microns)
+            3d filter's axial (z) filter ball size (microns)
         ball_overlap_fraction : float
-            Fraction of the morphological filter needed to be filled
-            to retain a voxel
-        log_sigma_size : float
-            Laplacian of Gaussian filter width (as a fraction of soma diameter)
-        n_sds_above_mean_thresh : int
-            Cell intensity threshold (as a multiple of noise above the mean)
+            3d filter's fraction of the ball filter needed to be filled by
+            foreground voxels, centered on a voxel, to retain the voxel
+        detection_batch_size: int
+            The number of planes of the original data volume to process at
+            once. The GPU/CPU memory must be able to contain this many planes
+            for all the filters. For performance-critical applications, tune
+            to maximize memory usage without
+            running out. Check your GPU/CPU memory to verify it's not full
         soma_spread_factor : float
-            Cell spread factor (for splitting up cell clusters)
-        max_cluster_size : int
-            Largest putative cell cluster (in cubic um) where splitting
-            should be attempted
-        use_pre_trained_weights : bool
-            Select to use pre-trained model weights
-        batch_size : int
-            How many points to classify at one time
+            Cell spread factor for determining the largest cell volume before
+            splitting up cell clusters. Structures with spherical volume of
+            diameter `soma_spread_factor * soma_diameter` or less will not be
+            split
+        max_cluster_size : float
+            Largest detected cell cluster (in cubic um) where splitting
+            should be attempted. Clusters above this size will be labeled
+            as artifacts
         skip_classification : bool
             If selected, the classification step is skipped and all cells from
             the detection stage are added
+        use_pre_trained_weights : bool
+            Select to use pre-trained model weights
         trained_model : Optional[Path]
             Trained model file path (home directory (default) -> pretrained
             weights)
+        classification_batch_size : int
+            How many potential cells to classify at one time. The GPU/CPU
+            memory must be able to contain at once this many data cubes for
+            the models. For performance-critical applications, tune to
+            maximize memory usage without running
+            out. Check your GPU/CPU memory to verify it's not full
         start_plane : int
             First plane to process (to process a subset of the data)
         end_plane : int
@@ -318,6 +337,12 @@ def detect_widget() -> FunctionGui:
             Only analyse planes around the current position
         use_gpu : bool
             If True, use GPU for processing (if available); otherwise, use CPU.
+        pin_memory: bool
+            Pins data to be sent to the GPU to the CPU memory. This allows
+            faster GPU data speeds, but can only be used if the data used by
+            the GPU can stay in the CPU RAM while the GPU uses it. I.e. there's
+            enough RAM. Otherwise, if there's a risk of the RAM being paged, it
+            shouldn't be used. Defaults to False.
         debug : bool
             Increase logging
         reset_button :
@@ -373,6 +398,7 @@ def detect_widget() -> FunctionGui:
             n_sds_above_mean_thresh,
             soma_spread_factor,
             max_cluster_size,
+            detection_batch_size,
         )
 
         if use_pre_trained_weights:
@@ -381,7 +407,7 @@ def detect_widget() -> FunctionGui:
             skip_classification,
             use_pre_trained_weights,
             trained_model,
-            batch_size,
+            classification_batch_size,
         )
 
         if analyse_local:
@@ -392,7 +418,13 @@ def detect_widget() -> FunctionGui:
             end_plane = len(signal_image.data)
 
         misc_inputs = MiscInputs(
-            start_plane, end_plane, n_free_cpus, analyse_local, use_gpu, debug
+            start_plane,
+            end_plane,
+            n_free_cpus,
+            analyse_local,
+            use_gpu,
+            pin_memory,
+            debug,
         )
 
         worker = Worker(

cellfinder/napari/detect/detect_containers.py

@@ -68,9 +68,10 @@ class DetectionInputs(InputContainer):
     ball_z_size: float = 15
     ball_overlap_fraction: float = 0.6
     log_sigma_size: float = 0.2
-    n_sds_above_mean_thresh: int = 10
+    n_sds_above_mean_thresh: float = 10
     soma_spread_factor: float = 1.4
-    max_cluster_size: int = 100000
+    max_cluster_size: float = 100000
+    detection_batch_size: int = 1
 
     def as_core_arguments(self) -> dict:
         return super().as_core_arguments()
@@ -97,14 +98,17 @@ class DetectionInputs(InputContainer):
                 "n_sds_above_mean_thresh", custom_label="Threshold"
             ),
             soma_spread_factor=cls._custom_widget(
-                "soma_spread_factor", custom_label="Cell spread"
+                "soma_spread_factor", custom_label="Split cell spread"
             ),
             max_cluster_size=cls._custom_widget(
                 "max_cluster_size",
-                custom_label="Max cluster",
+                custom_label="Split max cluster",
                 min=0,
                 max=10000000,
             ),
+            detection_batch_size=cls._custom_widget(
+                "detection_batch_size", custom_label="Batch size (detection)"
+            ),
         )
 
 
@@ -115,7 +119,7 @@ class ClassificationInputs(InputContainer):
     skip_classification: bool = False
     use_pre_trained_weights: bool = True
     trained_model: Optional[Path] = Path.home()
-    batch_size: int = 64
+    classification_batch_size: int = 64
 
     def as_core_arguments(self) -> dict:
         args = super().as_core_arguments()
@@ -133,7 +137,10 @@ class ClassificationInputs(InputContainer):
             skip_classification=dict(
                 value=cls.defaults()["skip_classification"]
             ),
-            batch_size=dict(value=cls.defaults()["batch_size"]),
+            classification_batch_size=dict(
+                value=cls.defaults()["classification_batch_size"],
+                label="Batch size (classification)",
+            ),
         )
 
 
@@ -146,6 +153,7 @@ class MiscInputs(InputContainer):
     n_free_cpus: int = 2
     analyse_local: bool = False
     use_gpu: bool = field(default_factory=lambda: torch.cuda.is_available())
+    pin_memory: bool = False
     debug: bool = False
 
     def as_core_arguments(self) -> dict:
@@ -172,5 +180,10 @@ class MiscInputs(InputContainer):
                 value=cls.defaults()["use_gpu"],
                 enabled=torch.cuda.is_available(),
             ),
+            pin_memory=dict(
+                widget_type="CheckBox",
+                label="Pin data to memory",
+                value=cls.defaults()["pin_memory"],
+            ),
             debug=dict(value=cls.defaults()["debug"]),
         )

{cellfinder-1.7.0.dist-info → cellfinder-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellfinder
-Version: 1.7.0
+Version: 1.8.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
@@ -53,7 +53,7 @@ Requires-Dist: brainglobe-napari-io; extra == "napari"
 Requires-Dist: magicgui; extra == "napari"
 Requires-Dist: napari-ndtiffs; extra == "napari"
 Requires-Dist: napari-plugin-engine>=0.1.4; extra == "napari"
-Requires-Dist: napari[pyqt5]; extra == "napari"
+Requires-Dist: napari[pyqt5]>=0.6.1; extra == "napari"
 Requires-Dist: pooch>=1; extra == "napari"
 Requires-Dist: qtpy; extra == "napari"
 Dynamic: license-file

{cellfinder-1.7.0.dist-info → cellfinder-1.8.0.dist-info}/RECORD

@@ -1,29 +1,29 @@
 cellfinder/__init__.py,sha256=S5oQ3EORuyQTMYC4uUuzGKZ23J3Ya6q-1DOBib1KfiA,1166
 cellfinder/cli_migration_warning.py,sha256=u4nKQiPYmpx0HRqm0PI8wBx78rNiiBSQSGciDoXEq78,1623
 cellfinder/core/__init__.py,sha256=pRFuQsl78HEK0S6gvhJw70QLbjjSBzP-GFO0AtVaGtk,62
-cellfinder/core/main.py,sha256=ZAkouPqPkg1KgR3k94E4IaxjwTKNmSg-SLsPTDpKr5c,3816
+cellfinder/core/main.py,sha256=QaangjXVi5Sq_fCvMs_PGS-qiFZAsTwymnJ7lhggSno,9497
 cellfinder/core/types.py,sha256=lTqWE4v0SMM0qLAZJdyAzqV1nLgDtobEpglNJcXt160,106
 cellfinder/core/classify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/classify/augment.py,sha256=8dMbM7KhimM6NMgdMC53oHoCfYj1CIB-h3Yk8CZAxPw,6321
-cellfinder/core/classify/classify.py,sha256=WudUeF-cWpJ7FxnjPsaSVC8HL2aPMgPfT9RJ7hZM3xE,3576
+cellfinder/core/classify/classify.py,sha256=cgZ_2aY8sbQbFo8-43RPPaQMSdS-nt4ukWRzDfWcuOU,5750
 cellfinder/core/classify/cube_generator.py,sha256=jC5aogTVy213PHouViSR9CgKkuOks3yk6csQC5kRoOE,17125
 cellfinder/core/classify/resnet.py,sha256=vGa85y_NcQnOXwAt5EtatLx5mrO8IoShCcNKtJ5-EFg,10034
 cellfinder/core/classify/tools.py,sha256=gdWE8cBMlT1pqxBKt6j2az7i7FOMR4N0ds4w9YnBvtQ,2924
 cellfinder/core/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/config/cellfinder.conf,sha256=5i8axif7ekMutKDiVnZRs-LiJrgVQljg_beltidqtNk,56
 cellfinder/core/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/detect.py,sha256=oFLu69VtjMUGLFXFeZTx1QRcTQc5uhEvLCS5Z6LNFB8,8307
+cellfinder/core/detect/detect.py,sha256=jtttIndsVsT0Ww_Dz41GgcVan0nlGzeq24Aulf8g6GQ,9919
 cellfinder/core/detect/filters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/filters/setup_filters.py,sha256=gvWhdGVdGrK_Ab-t0kKPnXaf43qLi78ed_-vNPI0nE4,14554
+cellfinder/core/detect/filters/setup_filters.py,sha256=DIOQe2bvfSTRLPLgDJdzmaPQIgLpmS4lNxihHCRnU5Y,15252
 cellfinder/core/detect/filters/plane/__init__.py,sha256=lybcPbVDnurEQeq2FiLq0zR8p_ztarQOlajhdh1Q2-4,40
 cellfinder/core/detect/filters/plane/classical_filter.py,sha256=X5k266tbl9EHRVY5dls53B5IZlmP7U0UB9BsZ1ey_pc,13250
-cellfinder/core/detect/filters/plane/plane_filter.py,sha256=6FbAjxgt39_RdGDXC_pQ9ndtZtknuHJeTWtbR8cReEA,6102
+cellfinder/core/detect/filters/plane/plane_filter.py,sha256=4ByEQkF73W5oK_YyrdUwW8GxD-XSrCTtLo4SOT8NCdQ,6127
 cellfinder/core/detect/filters/plane/tile_walker.py,sha256=IiQibvWKnYlgl9h414fRklV7C2xZ0vXNmJ9t89DhYuI,4863
 cellfinder/core/detect/filters/volume/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/filters/volume/ball_filter.py,sha256=aarEBD6z3ejhNMFdKqKEHi9zLPkopqA3HkzV9RGd7BA,14461
+cellfinder/core/detect/filters/volume/ball_filter.py,sha256=DSBaHXtJ8TM71xT4fgzwL9E1MTE1euNv0vZ6Ozcx5cQ,14491
 cellfinder/core/detect/filters/volume/structure_detection.py,sha256=AIHq-5u5VFpKBBLEsE1Py-MlndbL8T0zXu0Bq2CI16Y,12916
-cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=0LGE8cQ6EJIsKqWWmd087Q3At8m-PUDmmPjCZKV1TdY,10138
-cellfinder/core/detect/filters/volume/volume_filter.py,sha256=o9_4IsITedhqkhfwRsIhE53_zLNcFjgQzXbMMddH_q4,20544
+cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=AcQTi_Gddj0vxSVz4JhZz_z16mVBOfCHQlkv8y3uPl4,10190
+cellfinder/core/detect/filters/volume/volume_filter.py,sha256=G9uK6rALRTZufrihzz5TVtE1oGpkXNktrFA4nnOIEaM,20573
 cellfinder/core/download/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/download/cli.py,sha256=X9L9ZIkWqs58hX8G8q_0AKN4gk8BhydGxI9nLpdHQQE,1764
 cellfinder/core/download/download.py,sha256=bmPwOm48ApylydasJ8ZvuoQgSSlsb8k4_DL1ikNZrIY,3318
@@ -41,21 +41,21 @@ cellfinder/core/tools/tools.py,sha256=opMGC5GBBsId0dmL8V0KQrI4U70w_D_KtGQYpZNeHY
 cellfinder/core/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/train/train_yaml.py,sha256=tG5FXHZj26PqPUaZCVmFgnvACvIh23mCwEDXwoXv2Hc,13104
 cellfinder/napari/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/napari/curation.py,sha256=2TmpK80NMNITVz8usT6-MV9m-_bt_-zBh8V3HLv4Xj8,22175
+cellfinder/napari/curation.py,sha256=jItls1SmD5GWNzPlSlF-H73AGgmmBk-PwFO7_gZBY40,22207
 cellfinder/napari/input_container.py,sha256=upTkufWF3aOr9sPPK13C2YwqQ6tygULym8oDXrRLXJs,2510
 cellfinder/napari/napari.yaml,sha256=WMR1CIAmYIVyQngbdbomTRZLvlDbb6LxsXsvTRClQnE,921
 cellfinder/napari/sample_data.py,sha256=oUST23q09MM8dxHbUCmO0AjtXG6OlR_32LLqP0EU2UA,732
 cellfinder/napari/utils.py,sha256=AwTs76M9azutHhHj2yuaKErDEQ5F6pFbIIakBfzen6M,3824
 cellfinder/napari/detect/__init__.py,sha256=BD9Bg9NTAr6yRTq2A_p58U6j4w5wbY0sdXwhPJ3MSMY,34
-cellfinder/napari/detect/detect.py,sha256=LBgbJ_OKOrXmXvRCIYyr8a4NgBioPVz-ZCqxHiFCw1A,13945
-cellfinder/napari/detect/detect_containers.py,sha256=WQ34EjXaOS91NeWMOP6oWnTSrU4KMZPxxrhvnfXmK0I,5895
+cellfinder/napari/detect/detect.py,sha256=nFpoxXnDuKTa2nHj62ACvYsiIHzVFXJ6qczomAaBr1g,15723
+cellfinder/napari/detect/detect_containers.py,sha256=rxvSiRszyaVFevJAi8bLMoUog51McfiXWvaQkr-fZQA,6429
 cellfinder/napari/detect/thread_worker.py,sha256=PWM3OE-FpK-dpdhaE_Gi-2lD3u8sL-SJ13mp0pMhTyI,3078
 cellfinder/napari/train/__init__.py,sha256=xo4CK-DvSecInGEc2ohcTgQYlH3iylFnGvKTCoq2WkI,35
 cellfinder/napari/train/train.py,sha256=tXrB8j_c293mzhWX5iEs4FvIwV1FpZuaX1rsSP4dgDQ,5830
 cellfinder/napari/train/train_containers.py,sha256=ovPl4ZiH6DUr-CGIYu-iju05z3_rtomyYnCWI6fURKc,4296
-cellfinder-1.7.0.dist-info/licenses/LICENSE,sha256=Tw8iMytIDXLSmcIUsbQmRWojstl9yOWsPCx6ZT6dZLY,1564
-cellfinder-1.7.0.dist-info/METADATA,sha256=l2M8eBQv8-A7BX77cT9BAapFgvV78p0yV4Gjb3kFl4k,7158
-cellfinder-1.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cellfinder-1.7.0.dist-info/entry_points.txt,sha256=n2n3muDgifENJtTRz1JqYStxvuprROCwmKLt-VxvEHk,248
-cellfinder-1.7.0.dist-info/top_level.txt,sha256=jyTQzX-tDjbsMr6s-E71Oy0IKQzmHTXSk4ZhpG5EDSE,11
-cellfinder-1.7.0.dist-info/RECORD,,
+cellfinder-1.8.0.dist-info/licenses/LICENSE,sha256=Tw8iMytIDXLSmcIUsbQmRWojstl9yOWsPCx6ZT6dZLY,1564
+cellfinder-1.8.0.dist-info/METADATA,sha256=m_i5i-J0oyEdjkcipTpZIdcpWjjnxfdfIaqNN6CO4zw,7165
+cellfinder-1.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cellfinder-1.8.0.dist-info/entry_points.txt,sha256=n2n3muDgifENJtTRz1JqYStxvuprROCwmKLt-VxvEHk,248
+cellfinder-1.8.0.dist-info/top_level.txt,sha256=jyTQzX-tDjbsMr6s-E71Oy0IKQzmHTXSk4ZhpG5EDSE,11
+cellfinder-1.8.0.dist-info/RECORD,,