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

cellfinder/core/detect/detect.py

@@ -54,6 +54,8 @@ def main(
     split_ball_z_size: float = 15,
     split_ball_overlap_fraction: float = 0.8,
     n_splitting_iter: int = 10,
+    n_sds_above_mean_tiled_thresh: float = 10,
+    tiled_thresh_tile_size: float | None = None,
     *,
     callback: Optional[Callable[[int], None]] = None,
 ) -> List[Cell]:
@@ -96,8 +98,8 @@ def main(
         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
+        Per-plane 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.
@@ -136,6 +138,20 @@ def main(
         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.
+    n_sds_above_mean_tiled_thresh : float
+        Per-plane, per-tile intensity threshold (the number of standard
+        deviations above the mean) for the filtered 2d planes used to mark
+        pixels as foreground or background. When used, (tile size is not zero)
+        a pixel is marked as foreground if its intensity is above both the
+        per-plane and per-tile threshold. I.e. it's above the set number of
+        standard deviations of the per-plane average and of the per-plane
+        per-tile average for the tile that contains it.
+    tiled_thresh_tile_size : float
+        The tile size used to tile the x, y plane to calculate the local
+        average intensity for the tiled threshold. The value is multiplied
+        by soma diameter (i.e. 1 means one soma diameter). If zero or None, the
+        tiled threshold is disabled and only the per-plane threshold is used.
+        Tiling is done with 50% overlap when striding.
     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.
@@ -193,6 +209,8 @@ def main(
         ball_overlap_fraction=ball_overlap_fraction,
         log_sigma_size=log_sigma_size,
         n_sds_above_mean_thresh=n_sds_above_mean_thresh,
+        n_sds_above_mean_tiled_thresh=n_sds_above_mean_tiled_thresh,
+        tiled_thresh_tile_size=tiled_thresh_tile_size,
         outlier_keep=outlier_keep,
         artifact_keep=artifact_keep,
         save_planes=save_planes,
@@ -228,7 +246,9 @@ def main(
         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,
+        n_sds_above_mean_thresh=settings.n_sds_above_mean_thresh,
+        n_sds_above_mean_tiled_thresh=settings.n_sds_above_mean_tiled_thresh,
+        tiled_thresh_tile_size=settings.tiled_thresh_tile_size,
         log_sigma_size=log_sigma_size,
         soma_diameter=settings.soma_diameter,
         torch_device=torch_device,

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

@@ -1,13 +1,12 @@
-from dataclasses import dataclass, field
 from typing import Tuple
 
 import torch
+import torch.nn.functional as F
 
 from cellfinder.core.detect.filters.plane.classical_filter import PeakEnhancer
 from cellfinder.core.detect.filters.plane.tile_walker import TileWalker
 
 
-@dataclass
 class TileProcessor:
     """
     Processor that filters each plane to highlight the peaks and also
@@ -63,12 +62,22 @@ class TileProcessor:
     # voxels who are this many std above mean or more are set to
     # threshold_value
     n_sds_above_mean_thresh: float
+    # If used, voxels who are this many or more std above mean of the
+    # containing tile as well as above n_sds_above_mean_thresh for the plane
+    # average are set to threshold_value.
+    n_sds_above_mean_tiled_thresh: float
+    # the tile size, in pixels, that will be used to tile the x, y plane when
+    # we calculate the per-tile mean / std for use with
+    # n_sds_above_mean_tiled_thresh. We use 50% overlap when tiling.
+    local_threshold_tile_size_px: int = 0
+    # the torch device name
+    torch_device: str = ""
 
     # filter that finds the peaks in the planes
-    peak_enhancer: PeakEnhancer = field(init=False)
+    peak_enhancer: PeakEnhancer = None
     # generates tiles of the planes, with each tile marked as being inside
     # or outside the brain based on brightness
-    tile_walker: TileWalker = field(init=False)
+    tile_walker: TileWalker = None
 
     def __init__(
         self,
@@ -76,6 +85,8 @@ class TileProcessor:
         clipping_value: int,
         threshold_value: int,
         n_sds_above_mean_thresh: float,
+        n_sds_above_mean_tiled_thresh: float,
+        tiled_thresh_tile_size: float | None,
         log_sigma_size: float,
         soma_diameter: int,
         torch_device: str,
@@ -85,6 +96,12 @@ class TileProcessor:
         self.clipping_value = clipping_value
         self.threshold_value = threshold_value
         self.n_sds_above_mean_thresh = n_sds_above_mean_thresh
+        self.n_sds_above_mean_tiled_thresh = n_sds_above_mean_tiled_thresh
+        if tiled_thresh_tile_size:
+            self.local_threshold_tile_size_px = int(
+                round(soma_diameter * tiled_thresh_tile_size)
+            )
+        self.torch_device = torch_device
 
         laplace_gaussian_sigma = log_sigma_size * soma_diameter
         self.peak_enhancer = PeakEnhancer(
@@ -131,7 +148,10 @@ class TileProcessor:
             planes,
             enhanced_planes,
             self.n_sds_above_mean_thresh,
+            self.n_sds_above_mean_tiled_thresh,
+            self.local_threshold_tile_size_px,
             self.threshold_value,
+            self.torch_device,
         )
 
         return planes, inside_brain_tiles
@@ -145,21 +165,98 @@ def _threshold_planes(
     planes: torch.Tensor,
     enhanced_planes: torch.Tensor,
     n_sds_above_mean_thresh: float,
+    n_sds_above_mean_tiled_thresh: float,
+    local_threshold_tile_size_px: int,
     threshold_value: int,
+    torch_device: str,
 ) -> None:
     """
     Sets each plane (in-place) to threshold_value, where the corresponding
     enhanced_plane > mean + n_sds_above_mean_thresh*std. Each plane will be
     set to zero elsewhere.
     """
-    planes_1d = enhanced_planes.view(enhanced_planes.shape[0], -1)
+    z, y, x = enhanced_planes.shape
 
+    # ---- get per-plane global threshold ----
+    planes_1d = enhanced_planes.view(z, -1)
     # add back last dim
-    avg = torch.mean(planes_1d, dim=1, keepdim=True).unsqueeze(2)
-    sd = torch.std(planes_1d, dim=1, keepdim=True).unsqueeze(2)
-    threshold = avg + n_sds_above_mean_thresh * sd
+    std, mean = torch.std_mean(planes_1d, dim=1, keepdim=True)
+    threshold = mean.unsqueeze(2) + n_sds_above_mean_thresh * std.unsqueeze(2)
+    above_global = enhanced_planes > threshold
+
+    # ---- calculate the local tiled threshold ----
+    # we do 50% overlap so there's no jumps at boundaries
+    stride = local_threshold_tile_size_px // 2
+    # make tile even for ease of computation
+    tile_size = stride * 2
+    # Due to 50% overlap, to get tiles we move the tile by half tile (stride).
+    # Total moves will be y // stride - 2 (we start already with mask on first
+    # tile). So add back 1 for the first tile. Partial tiles are dropped
+    n_y_tiles = max(y // stride - 1, 1) if stride else 1
+    n_x_tiles = max(x // stride - 1, 1) if stride else 1
+    do_tile_y = n_y_tiles >= 2
+    do_tile_x = n_x_tiles >= 2
+    # we want at least one axis to have at least two tiles
+    if local_threshold_tile_size_px >= 2 and (do_tile_y or do_tile_x):
+        # num edge pixels dropped b/c moving by stride would move tile off edge
+        y_rem = y % stride
+        x_rem = x % stride
+        enhanced_planes_raw = enhanced_planes
+        if do_tile_y:
+            enhanced_planes = enhanced_planes[:, y_rem // 2 :, :]
+        if do_tile_x:
+            enhanced_planes = enhanced_planes[:, :, x_rem // 2 :]
+
+        # add empty channel dim after z "batch" dim -> zcyx
+        enhanced_planes = enhanced_planes.unsqueeze(1)
+        # unfold makes it 3 dim, z, M, L. L is number of tiles, M is tile area
+        unfolded = F.unfold(
+            enhanced_planes,
+            (tile_size if do_tile_y else y, tile_size if do_tile_x else x),
+            stride=stride,
+        )
+        # average the tile areas, for each tile
+        std, mean = torch.std_mean(unfolded, dim=1, keepdim=True)
+        threshold = mean + n_sds_above_mean_tiled_thresh * std
+
+        # reshape it back into Y by X tiles, instead of YX being one dim
+        threshold = threshold.reshape((z, n_y_tiles, n_x_tiles))
+
+        # we need total size of n_tiles * stride + stride + rem for the
+        # original size. So we add 2 strides and then chop off the excess above
+        # rem. We center it because of 50% overlap, the first tile is actually
+        # centered in between the first two strides
+        offsets = [(0, y), (0, x)]
+        for dim, do_tile, n_tiles, n, rem in [
+            (1, do_tile_y, n_y_tiles, y, y_rem),
+            (2, do_tile_x, n_x_tiles, x, x_rem),
+        ]:
+            if do_tile:
+                repeats = (
+                    torch.ones(n_tiles, dtype=torch.int, device=torch_device)
+                    * stride
+                )
+                # add total of 2 additional strides
+                repeats[0] = 2 * stride
+                repeats[-1] = 2 * stride
+                output_size = (n_tiles + 2) * stride
+
+                threshold = threshold.repeat_interleave(
+                    repeats, dim=dim, output_size=output_size
+                )
+                # drop the excess we gained from padding rem to whole stride
+                offset = (stride - rem) // 2
+                offsets[dim - 1] = offset, n + offset
+
+        # can't use slice(...) objects in jit code so use actual indices
+        (a, b), (c, d) = offsets
+        threshold = threshold[:, a:b, c:d]
+
+        above_local = enhanced_planes_raw > threshold
+        above = torch.logical_and(above_global, above_local)
+    else:
+        above = above_global
 
-    above = enhanced_planes > threshold
     planes[above] = threshold_value
     # subsequent steps only care about the values that are set to threshold or
     # above in planes. We set values in *planes* to threshold based on the

cellfinder/core/detect/filters/setup_filters.py

@@ -133,11 +133,31 @@ class DetectionSettings:
 
     n_sds_above_mean_thresh: float = 10
     """
-    Intensity threshold (the number of standard deviations above
-    the mean) of the filtered 2d planes used to mark pixels as
+    Per-plane intensity threshold (the number of standard deviations
+    above the mean) of the 2d filtered planes used to mark pixels as
     foreground or background.
     """
 
+    n_sds_above_mean_tiled_thresh: float = 10
+    """
+    Per-plane, per-tile intensity threshold (the number of standard deviations
+    above the mean) for the filtered 2d planes used to mark pixels as
+    foreground or background. When used, (tile size is not zero) a pixel is
+    marked as foreground if its intensity is above both the per-plane and
+    per-tile threshold. I.e. it's above the set number of standard deviations
+    of the per-plane average and of the per-plane per-tile average for the tile
+    that contains it.
+    """
+
+    tiled_thresh_tile_size: float | None = None
+    """
+    The tile size used to tile the x, y plane to calculate the local average
+    intensity for the tiled threshold. The value is multiplied by soma
+    diameter (i.e. 1 means one soma diameter). If zero or None, the tiled
+    threshold is disabled and only the per-plane threshold is used. Tiling is
+    done with 50% overlap when striding.
+    """
+
     outlier_keep: bool = False
     """Whether to keep outlier structures during detection."""
 

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

@@ -222,6 +222,11 @@ class CellDetector:
                         neighbour_ids[2] = previous_plane[y, x]
 
                     if is_new_structure(neighbour_ids):
+                        if self.next_structure_id > self.soma_centre_value:
+                            raise ValueError(
+                                "label overflow: number of connected "
+                                "components exceeds label capacity"
+                            )
                         neighbour_ids[0] = self.next_structure_id
                         self.next_structure_id += 1
                     struct_id = self.add(x, y, self.z, neighbour_ids)

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

@@ -66,8 +66,7 @@ def coords_to_volume(
     relative_zs = np.array((zs - z_min + ball_radius), dtype=np.int64)
 
     # set each point as the center with a value of threshold
-    for rel_x, rel_y, rel_z in zip(relative_xs, relative_ys, relative_zs):
-        volume[rel_x, rel_y, rel_z] = threshold_value
+    volume[relative_xs, relative_ys, relative_zs] = threshold_value
 
     volume = volume.swapaxes(0, 2)
     return torch.from_numpy(volume)

cellfinder/core/main.py

@@ -42,6 +42,8 @@ def main(
     split_ball_z_size: float = 15,
     split_ball_overlap_fraction: float = 0.8,
     n_splitting_iter: int = 10,
+    n_sds_above_mean_tiled_thresh: float = 10,
+    tiled_thresh_tile_size: float | None = None,
     *,
     detect_callback: Optional[Callable[[int], None]] = None,
     classify_callback: Optional[Callable[[int], None]] = None,
@@ -94,8 +96,8 @@ def main(
         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
+        Per-plane 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
@@ -155,6 +157,20 @@ def main(
         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.
+    n_sds_above_mean_tiled_thresh : float
+        Per-plane, per-tile intensity threshold (the number of standard
+        deviations above the mean) for the filtered 2d planes used to mark
+        pixels as foreground or background. When used, (tile size is not zero)
+        a pixel is marked as foreground if its intensity is above both the
+        per-plane and per-tile threshold. I.e. it's above the set number of
+        standard deviations of the per-plane average and of the per-plane
+        per-tile average for the tile that contains it.
+    tiled_thresh_tile_size : float
+        The tile size used to tile the x, y plane to calculate the local
+        average intensity for the tiled threshold. The value is multiplied
+        by soma diameter (i.e. 1 means one soma diameter). If zero or None, the
+        tiled threshold is disabled and only the per-plane threshold is used.
+        Tiling is done with 50% overlap when striding.
     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.
@@ -172,19 +188,21 @@ def main(
         logger.info("Detecting cell candidates")
 
         points = detect.main(
-            signal_array,
-            start_plane,
-            end_plane,
-            voxel_sizes,
-            soma_diameter,
-            max_cluster_size,
-            ball_xy_size,
-            ball_z_size,
-            ball_overlap_fraction,
-            soma_spread_factor,
-            n_free_cpus,
-            log_sigma_size,
-            n_sds_above_mean_thresh,
+            signal_array=signal_array,
+            start_plane=start_plane,
+            end_plane=end_plane,
+            voxel_sizes=voxel_sizes,
+            soma_diameter=soma_diameter,
+            max_cluster_size=max_cluster_size,
+            ball_xy_size=ball_xy_size,
+            ball_z_size=ball_z_size,
+            ball_overlap_fraction=ball_overlap_fraction,
+            soma_spread_factor=soma_spread_factor,
+            n_free_cpus=n_free_cpus,
+            log_sigma_size=log_sigma_size,
+            n_sds_above_mean_thresh=n_sds_above_mean_thresh,
+            n_sds_above_mean_tiled_thresh=n_sds_above_mean_tiled_thresh,
+            tiled_thresh_tile_size=tiled_thresh_tile_size,
             batch_size=detection_batch_size,
             torch_device=torch_device,
             pin_memory=pin_memory,

cellfinder/core/tools/tools.py

@@ -261,7 +261,7 @@ def random_bool(likelihood: Optional[float] = None) -> bool:
     if likelihood is None:
         return bool(getrandbits(1))
     else:
-        if uniform(0, 1) > likelihood:
+        if uniform(0, 1) < likelihood:
             return True
         else:
             return False

cellfinder/core/train/train_yaml.py

@@ -29,7 +29,7 @@ from fancylog import fancylog
 from keras.callbacks import CSVLogger, ModelCheckpoint, TensorBoard
 from sklearn.model_selection import train_test_split
 
-import cellfinder.core as program_for_log
+import cellfinder.core as package_for_log
 from cellfinder.core import logger
 from cellfinder.core.classify.cube_generator import CubeGeneratorFromDisk
 from cellfinder.core.classify.resnet import layer_type
@@ -269,7 +269,7 @@ def cli():
 
     fancylog.start_logging(
         args.output_dir,
-        program_for_log,
+        package=package_for_log,
         variables=[args],
         log_header="CELLFINDER TRAINING LOG",
     )

cellfinder/napari/curation.py

@@ -11,7 +11,7 @@ from brainglobe_utils.IO.yaml import save_yaml
 from magicgui.widgets import ProgressBar
 from napari.qt.threading import thread_worker
 from napari.utils.notifications import show_info
-from qt_niu.dialog import display_warning
+from qt_niu.dialog import display_info, display_warning
 from qt_niu.interaction import add_button, add_combobox
 from qtpy import QtCore
 from qtpy.QtWidgets import (
@@ -495,26 +495,61 @@ class CurationWidget(QWidget):
             return False
 
     def check_training_data_exists(self) -> bool:
-        if not (
-            self.training_data_cell_layer or self.training_data_non_cell_layer
-        ):
-            show_info(
-                "No training data layers have been added. "
-                "Please add a layer and annotate some points.",
+        """
+        Checks that
+        - both training data layers exists
+        - at least one of them is not empty.
+
+        Will display a popup dialog and return False if these conditions
+        are not both fulfilled.
+
+        Will show a notification if only one layer is non-empty, but this
+        is considered valid.
+
+        Returns
+        -------
+        bool
+            True if both training layers exists and at least one
+            of them contains some data. False otherwise.
+        """
+        both_training_layers_exist = (
+            self.training_data_cell_layer and self.training_data_non_cell_layer
+        )
+
+        if not both_training_layers_exist:
+            display_info(
+                self,
+                "No training data layers have been added.",
+                "Please add layers for both cells and non-cells,"
+                "and annotate some points.",
             )
             return False
-        else:
-            if (
-                len(self.training_data_cell_layer.data) > 0
-                or len(self.training_data_non_cell_layer.data) > 0
-            ):
-                return True
-            else:
+
+        at_least_one_training_layer_contains_data = (
+            len(self.training_data_cell_layer.data) > 0
+            or len(self.training_data_non_cell_layer.data) > 0
+        )
+
+        both_training_layers_contain_data = (
+            len(self.training_data_cell_layer.data) > 0
+            and len(self.training_data_non_cell_layer.data) > 0
+        )
+
+        if at_least_one_training_layer_contains_data:
+            if not both_training_layers_contain_data:
                 show_info(
-                    "No training data points have been added. "
-                    "Please annotate some points.",
+                    "One of the training layers is empty. This is OK, but"
+                    "For optimal (re-)training ensure you have roughly equal "
+                    "number of points in each of your training points layers."
                 )
-                return False
+            return True
+        else:
+            display_info(
+                self,
+                "No training data points have been added.",
+                "Please annotate points in the training data layers.",
+            )
+            return False
 
     def get_output_directory(self):
         """

cellfinder/napari/detect/detect.py

@@ -148,7 +148,7 @@ def restore_options_defaults(widget: FunctionGui) -> None:
 
 
 def get_results_callback(
-    skip_classification: bool, viewer: napari.Viewer
+    skip_classification: bool, viewer: napari.Viewer, scale
 ) -> Callable:
     """
     Returns the callback that is connected to output of the pipeline.
@@ -162,6 +162,7 @@ def get_results_callback(
                 viewer=viewer,
                 name="Cell candidates",
                 cell_type=Cell.UNKNOWN,
+                scale=scale,
             )
 
     else:
@@ -172,6 +173,7 @@ def get_results_callback(
                 viewer=viewer,
                 unknown_name="Rejected",
                 cell_name="Detected",
+                scale=scale,
             )
 
     return done_func
@@ -246,6 +248,8 @@ def detect_widget() -> FunctionGui:
         soma_diameter: float,
         log_sigma_size: float,
         n_sds_above_mean_thresh: float,
+        n_sds_above_mean_tiled_thresh: float,
+        tiled_thresh_tile_size: float,
         ball_xy_size: float,
         ball_z_size: float,
         ball_overlap_fraction: float,
@@ -288,9 +292,23 @@ def detect_widget() -> FunctionGui:
             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
+            Per-plane intensity threshold (the number of standard deviations
+            above the mean) of the filtered 2d planes used to mark pixels as
             foreground or background
+        n_sds_above_mean_tiled_thresh : float
+            Per-plane, per-tile intensity threshold (the number of standard
+            deviations above the mean) for the filtered 2d planes used to mark
+            pixels as foreground or background. When used, (tile size is not
+            zero) a pixel is marked as foreground if its intensity is above
+            both the per-plane and per-tile threshold. I.e. it's above the set
+            number of standard deviations of the per-plane average and of the
+            per-plane per-tile average for the tile that contains it.
+        tiled_thresh_tile_size : float
+            The tile size used to tile the x, y plane to calculate the local
+            average intensity for the tiled threshold. The value is multiplied
+            by soma diameter (i.e. 1 means one soma diameter). If zero, the
+            tiled threshold is disabled and only the per-plane threshold is
+            used. Tiling is done with 50% overlap when striding.
         ball_xy_size : float
             3d filter's in-plane (xy) filter ball size (microns)
         ball_z_size : float
@@ -396,6 +414,8 @@ def detect_widget() -> FunctionGui:
             ball_overlap_fraction,
             log_sigma_size,
             n_sds_above_mean_thresh,
+            n_sds_above_mean_tiled_thresh,
+            tiled_thresh_tile_size,
             soma_spread_factor,
             max_cluster_size,
             detection_batch_size,
@@ -435,7 +455,11 @@ def detect_widget() -> FunctionGui:
         )
 
         worker.returned.connect(
-            get_results_callback(skip_classification, options["viewer"])
+            get_results_callback(
+                skip_classification,
+                options["viewer"],
+                options["signal_image"].scale,
+            )
         )
         # Make sure if the worker emits an error, it is propagated to this
         # thread

cellfinder/napari/detect/detect_containers.py

@@ -69,6 +69,8 @@ class DetectionInputs(InputContainer):
     ball_overlap_fraction: float = 0.6
     log_sigma_size: float = 0.2
     n_sds_above_mean_thresh: float = 10
+    n_sds_above_mean_tiled_thresh: float = 10
+    tiled_thresh_tile_size: float = 0
     soma_spread_factor: float = 1.4
     max_cluster_size: float = 100000
     detection_batch_size: int = 1
@@ -95,7 +97,14 @@ class DetectionInputs(InputContainer):
                 "log_sigma_size", custom_label="Filter width"
             ),
             n_sds_above_mean_thresh=cls._custom_widget(
-                "n_sds_above_mean_thresh", custom_label="Threshold"
+                "n_sds_above_mean_thresh", custom_label="Plane threshold"
+            ),
+            n_sds_above_mean_tiled_thresh=cls._custom_widget(
+                "n_sds_above_mean_tiled_thresh", custom_label="Tiled threshold"
+            ),
+            tiled_thresh_tile_size=cls._custom_widget(
+                "tiled_thresh_tile_size",
+                custom_label="Thresholding tile size",
             ),
             soma_spread_factor=cls._custom_widget(
                 "soma_spread_factor", custom_label="Split cell spread"

cellfinder/napari/detect/thread_worker.py

@@ -56,28 +56,35 @@ class Worker(WorkerBase):
         self.update_progress_bar.connect(update_progress_bar)
 
     def work(self) -> list:
-        self.update_progress_bar.emit("Setting up detection...", 1, 0)
+        if not self.detection_inputs.skip_detection:
+            self.update_progress_bar.emit("Setting up detection...", 1, 0)
 
         def detect_callback(plane: int) -> None:
-            self.update_progress_bar.emit(
-                "Detecting cells",
-                self.data_inputs.nplanes,
-                plane + 1,
-            )
+            if not self.detection_inputs.skip_detection:
+                self.update_progress_bar.emit(
+                    "Detecting cells",
+                    self.data_inputs.nplanes,
+                    plane + 1,
+                )
 
         def detect_finished_callback(points: list) -> None:
             self.npoints_detected = len(points)
-            self.update_progress_bar.emit("Setting up classification...", 1, 0)
+            if not self.classification_inputs.skip_classification:
+                self.update_progress_bar.emit(
+                    "Setting up classification...", 1, 0
+                )
 
         def classify_callback(batch: int) -> None:
-            self.update_progress_bar.emit(
-                "Classifying cells",
-                # Default cellfinder-core batch size is 64. This seems to give
-                # a slight underestimate of the number of batches though, so
-                # allow for batch number to go over this
-                max(self.npoints_detected // 64 + 1, batch + 1),
-                batch + 1,
-            )
+            if not self.classification_inputs.skip_classification:
+                self.update_progress_bar.emit(
+                    "Classifying cells",
+                    # Default cellfinder-core batch size is 64.
+                    # This seems to give a slight
+                    # underestimate of the number of batches though,
+                    # so allow for batch number to go over this
+                    max(self.npoints_detected // 64 + 1, batch + 1),
+                    batch + 1,
+                )
 
         result = cellfinder_run(
             **self.data_inputs.as_core_arguments(),
@@ -88,5 +95,8 @@ class Worker(WorkerBase):
             classify_callback=classify_callback,
             detect_finished_callback=detect_finished_callback,
         )
-        self.update_progress_bar.emit("Finished classification", 1, 1)
+        if not self.classification_inputs.skip_classification:
+            self.update_progress_bar.emit("Finished classification", 1, 1)
+        else:
+            self.update_progress_bar.emit("Finished detection", 1, 1)
         return result

cellfinder/napari/utils.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 import napari
 import napari.layers
@@ -44,6 +44,7 @@ def add_classified_layers(
     viewer: napari.Viewer,
     unknown_name: str = "Rejected",
     cell_name: str = "Detected",
+    scale: Optional[Tuple[float, float, float]] = None,
 ) -> None:
     """
     Adds cell candidates as two separate point layers - unknowns and cells, to
@@ -60,6 +61,7 @@ def add_classified_layers(
         face_color="lightskyblue",
         visible=False,
         metadata=dict(point_type=Cell.UNKNOWN),
+        scale=scale,
     )
     viewer.add_points(
         cells_to_array(points, Cell.CELL, napari_order=True),
@@ -70,6 +72,7 @@ def add_classified_layers(
         symbol="ring",
         face_color="lightgoldenrodyellow",
         metadata=dict(point_type=Cell.CELL),
+        scale=scale,
     )
 
 
@@ -78,6 +81,7 @@ def add_single_layer(
     viewer: napari.Viewer,
     name: str,
     cell_type: int,
+    scale: Optional[Tuple[float, float, float]] = None,
 ) -> None:
     """
     Adds all cells of cell_type Cell.TYPE to a new point layer in the napari
@@ -93,6 +97,7 @@ def add_single_layer(
         face_color="lightskyblue",
         visible=True,
         metadata=dict(point_type=cell_type),
+        scale=scale,
     )
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellfinder
-Version: 1.8.0
+Version: 1.9.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
@@ -26,7 +26,7 @@ License-File: LICENSE
 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
+Requires-Dist: fancylog>=0.6.0
 Requires-Dist: natsort
 Requires-Dist: numba
 Requires-Dist: numpy
@@ -53,24 +53,26 @@ 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]>=0.6.1; extra == "napari"
+Requires-Dist: napari[pyqt5]>=0.6.5; extra == "napari"
 Requires-Dist: pooch>=1; extra == "napari"
 Requires-Dist: qtpy; extra == "napari"
 Dynamic: license-file
 
 [![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)
+[![Anaconda version](https://anaconda.org/conda-forge/cellfinder/badges/version.svg)](https://anaconda.org/conda-forge/cellfinder)
+[![Napari hub](https://img.shields.io/endpoint?url=https://npe2api-git-add-shields-napari.vercel.app/api/shields/cellfinder)](https://napari-hub.org/plugins/cellfinder.html)
+[![PyPI 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/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/)
+[![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json)](https://github.com/astral-sh/ruff)[![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/community/developers/index.html)
-[![Twitter](https://img.shields.io/twitter/follow/brain_globe?style=social)](https://twitter.com/brain_globe)
-
+[![image.sc forum](https://img.shields.io/badge/dynamic/json.svg?label=forum&url=https%3A%2F%2Fforum.image.sc%2Ftags%2Fbrainglobe.json&query=%24.topic_list.tags.0.topic_count&colorB=brightgreen&suffix=%20topics&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAABPklEQVR42m3SyyqFURTA8Y2BER0TDyExZ+aSPIKUlPIITFzKeQWXwhBlQrmFgUzMMFLKZeguBu5y+//17dP3nc5vuPdee6299gohUYYaDGOyyACq4JmQVoFujOMR77hNfOAGM+hBOQqB9TjHD36xhAa04RCuuXeKOvwHVWIKL9jCK2bRiV284QgL8MwEjAneeo9VNOEaBhzALGtoRy02cIcWhE34jj5YxgW+E5Z4iTPkMYpPLCNY3hdOYEfNbKYdmNngZ1jyEzw7h7AIb3fRTQ95OAZ6yQpGYHMMtOTgouktYwxuXsHgWLLl+4x++Kx1FJrjLTagA77bTPvYgw1rRqY56e+w7GNYsqX6JfPwi7aR+Y5SA+BXtKIRfkfJAYgj14tpOF6+I46c4/cAM3UhM3JxyKsxiOIhH0IO6SH/A1Kb1WBeUjbkAAAAAElFTkSuQmCC)](https://forum.image.sc/tag/brainglobe)
+[![Bluesky](https://img.shields.io/badge/Bluesky-0285FF?logo=bluesky&logoColor=fff)](https://bsky.app/profile/brainglobe.info)
+[![Mastodon](https://img.shields.io/badge/Mastodon-6364FF?logo=mastodon&logoColor=fff)](https://mastodon.online/@brainglobe)
 # cellfinder
 
 cellfinder is software for automated 3D cell detection in very large 3D images (e.g., serial two-photon or lightsheet volumes of whole mouse brains).

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

@@ -1,7 +1,7 @@
 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=QaangjXVi5Sq_fCvMs_PGS-qiFZAsTwymnJ7lhggSno,9497
+cellfinder/core/main.py,sha256=8VRM05-FvUPLjcBFFYruV_0Yct-UQOW2a0u5ubjBDnw,10875
 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
@@ -12,17 +12,17 @@ cellfinder/core/classify/tools.py,sha256=gdWE8cBMlT1pqxBKt6j2az7i7FOMR4N0ds4w9Yn
 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=jtttIndsVsT0Ww_Dz41GgcVan0nlGzeq24Aulf8g6GQ,9919
+cellfinder/core/detect/detect.py,sha256=DZxots88sG7GgKjXT-35TecQtRXGVEB-tRx12fTZjXU,11245
 cellfinder/core/detect/filters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/filters/setup_filters.py,sha256=DIOQe2bvfSTRLPLgDJdzmaPQIgLpmS4lNxihHCRnU5Y,15252
+cellfinder/core/detect/filters/setup_filters.py,sha256=-OFQsvMhxRhzHHATghQWjTUNudvo64uY27CHd7FSIk4,16210
 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=4ByEQkF73W5oK_YyrdUwW8GxD-XSrCTtLo4SOT8NCdQ,6127
+cellfinder/core/detect/filters/plane/plane_filter.py,sha256=G22c48ecK7cCQWOutqmy0o5Y06rKTm0dM66-c7qUndk,10503
 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=DSBaHXtJ8TM71xT4fgzwL9E1MTE1euNv0vZ6Ozcx5cQ,14491
-cellfinder/core/detect/filters/volume/structure_detection.py,sha256=AIHq-5u5VFpKBBLEsE1Py-MlndbL8T0zXu0Bq2CI16Y,12916
-cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=AcQTi_Gddj0vxSVz4JhZz_z16mVBOfCHQlkv8y3uPl4,10190
+cellfinder/core/detect/filters/volume/structure_detection.py,sha256=jibzhm5WDKDQMO2vMRiqDwxoMKsjNYzUVfp5Dla2sBU,13207
+cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=C4YFamJtJuHZJwC5IJfrFG6TBIUh20kvSyvVR67SEOo,10129
 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
@@ -37,25 +37,25 @@ cellfinder/core/tools/source_files.py,sha256=vvwsIMe1ULKvXg_x22L75iqvCyMjEbUjJsD
 cellfinder/core/tools/system.py,sha256=WvEzPr7v-ohLDnzf4n13TMcN5OYIAXOEkaSmrHzdnwc,2438
 cellfinder/core/tools/threading.py,sha256=mc-XVEfLHj3AFWYcK1Qh4TKmVuW4mNaxgLBlQmBVViU,14154
 cellfinder/core/tools/tiff.py,sha256=NzIz6wq2GzxmcIhawFMwZADe-uQO2rIG46H7xkpGKLs,2899
-cellfinder/core/tools/tools.py,sha256=opMGC5GBBsId0dmL8V0KQrI4U70w_D_KtGQYpZNeHYQ,9390
+cellfinder/core/tools/tools.py,sha256=fh8PAcoIGh9U5ChUUPl5a8JY2orR1DqZ3qPGHNxi-zI,9390
 cellfinder/core/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/train/train_yaml.py,sha256=tG5FXHZj26PqPUaZCVmFgnvACvIh23mCwEDXwoXv2Hc,13104
+cellfinder/core/train/train_yaml.py,sha256=_6XsW82npFRcwHTJK3nUUlQfRbY7IVVAgoXYR2-_IBc,13112
 cellfinder/napari/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/napari/curation.py,sha256=jItls1SmD5GWNzPlSlF-H73AGgmmBk-PwFO7_gZBY40,22207
+cellfinder/napari/curation.py,sha256=XxrsdK6gHmxgOtmxAJaq-JmheeB4nFJNMrl-0yH--Dc,23464
 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/utils.py,sha256=pXuEoDIUeqgDtEsQg1U7OM3ie0_9rCmxAOZgJOwU-mQ,4009
 cellfinder/napari/detect/__init__.py,sha256=BD9Bg9NTAr6yRTq2A_p58U6j4w5wbY0sdXwhPJ3MSMY,34
-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/detect/detect.py,sha256=A0FLHnWSEx1h4Lrkx5kmQY4fvgBVYoyla51kWdXcg98,17049
+cellfinder/napari/detect/detect_containers.py,sha256=K4TO7KFac6jzjTt6Mvh6ey4zpO-RHzzs6a8SOfByAfY,6843
+cellfinder/napari/detect/thread_worker.py,sha256=dQitk83sbY8MSx0iSROub3Wnp6nR0HlPOkFvjESm1dQ,3593
 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.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,,
+cellfinder-1.9.0.dist-info/licenses/LICENSE,sha256=Tw8iMytIDXLSmcIUsbQmRWojstl9yOWsPCx6ZT6dZLY,1564
+cellfinder-1.9.0.dist-info/METADATA,sha256=EfJdieyhSLKELsEcDv6Go1w7sLfmxZ0n18fQESBQm88,8452
+cellfinder-1.9.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cellfinder-1.9.0.dist-info/entry_points.txt,sha256=n2n3muDgifENJtTRz1JqYStxvuprROCwmKLt-VxvEHk,248
+cellfinder-1.9.0.dist-info/top_level.txt,sha256=jyTQzX-tDjbsMr6s-E71Oy0IKQzmHTXSk4ZhpG5EDSE,11
+cellfinder-1.9.0.dist-info/RECORD,,

{cellfinder-1.8.0.dist-info → cellfinder-1.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any