cellfinder 1.1.3__py3-none-any.whl → 1.3.0__py3-none-any.whl

cellfinder/napari/detect/detect.py

@@ -1,8 +1,11 @@
+from functools import partial
 from math import ceil
 from pathlib import Path
-from typing import Optional
+from typing import Any, Callable, Dict, Optional, Tuple
 
 import napari
+import napari.layers
+from brainglobe_utils.cells.cells import Cell
 from magicgui import magicgui
 from magicgui.widgets import FunctionGui, ProgressBar
 from napari.utils.notifications import show_info
@@ -10,10 +13,11 @@ from qtpy.QtWidgets import QScrollArea
 
 from cellfinder.core.classify.cube_generator import get_cube_depth_min_max
 from cellfinder.napari.utils import (
-    add_layers,
-    header_label_widget,
+    add_classified_layers,
+    add_single_layer,
+    cellfinder_header,
     html_label_widget,
-    widget_header,
+    napari_array_to_cells,
 )
 
 from .detect_containers import (
@@ -33,14 +37,194 @@ CUBE_DEPTH = 20
 MIN_PLANES_ANALYSE = 0
 
 
+def get_heavy_widgets(
+    options: Dict[str, Any]
+) -> Tuple[Callable, Callable, Callable]:
+    # signal and other input are separated out from the main magicgui
+    # parameter selections and are inserted as widget children in their own
+    # sub-containers of the root. Because if these image parameters are
+    # included in the root widget, every time *any* parameter updates, the gui
+    # freezes for a bit likely because magicgui is processing something for
+    # all the parameters when any parameter changes. And this processing takes
+    # particularly long for image parameters. Placing them as sub-containers
+    # alleviates this
+    @magicgui(
+        call_button=False,
+        persist=False,
+        scrollable=False,
+        labels=False,
+        auto_call=True,
+    )
+    def signal_image_opt(
+        viewer: napari.Viewer,
+        signal_image: napari.layers.Image,
+    ):
+        """
+        magicgui widget for setting the signal_image parameter.
+
+        Parameters
+        ----------
+        signal_image : napari.layers.Image
+             Image layer containing the labelled cells
+        """
+        options["signal_image"] = signal_image
+        options["viewer"] = viewer
+
+    @magicgui(
+        call_button=False,
+        persist=False,
+        scrollable=False,
+        labels=False,
+        auto_call=True,
+    )
+    def background_image_opt(
+        background_image: napari.layers.Image,
+    ):
+        """
+        magicgui widget for setting the background image parameter.
+
+        Parameters
+        ----------
+        background_image : napari.layers.Image
+             Image layer without labelled cells
+        """
+        options["background_image"] = background_image
+
+    @magicgui(
+        call_button=False,
+        persist=False,
+        scrollable=False,
+        labels=False,
+        auto_call=True,
+    )
+    def cell_layer_opt(
+        cell_layer: napari.layers.Points,
+    ):
+        """
+        magicgui widget for setting the cell layer input when detection is
+        skipped.
+
+        Parameters
+        ----------
+        cell_layer : napari.layers.Points
+            If detection is skipped, select the cell layer containing the
+            detected cells to use for classification
+        """
+        options["cell_layer"] = cell_layer
+
+    return signal_image_opt, background_image_opt, cell_layer_opt
+
+
+def add_heavy_widgets(
+    root: FunctionGui,
+    widgets: Tuple[FunctionGui, ...],
+    new_names: Tuple[str, ...],
+    insertions: Tuple[str, ...],
+) -> None:
+    for widget, new_name, insertion in zip(widgets, new_names, insertions):
+        # make it look as if it's directly in the root container
+        widget.margins = 0, 0, 0, 0
+        # the parameters of these widgets are updated using `auto_call` only.
+        # If False, magicgui passes these as args to root() when the root's
+        # function runs. But that doesn't list them as args of its function
+        widget.gui_only = True
+        root.insert(root.index(insertion) + 1, widget)
+        getattr(root, widget.name).label = new_name
+
+
+def restore_options_defaults(widget: FunctionGui) -> None:
+    """
+    Restore default widget values.
+    """
+    defaults = {
+        **DataInputs.defaults(),
+        **DetectionInputs.defaults(),
+        **ClassificationInputs.defaults(),
+        **MiscInputs.defaults(),
+    }
+    for name, value in defaults.items():
+        if value is not None:  # ignore fields with no default
+            getattr(widget, name).value = value
+
+
+def get_results_callback(
+    skip_classification: bool, viewer: napari.Viewer
+) -> Callable:
+    """
+    Returns the callback that is connected to output of the pipeline.
+    It returns the detected points that we have to visualize.
+    """
+    if skip_classification:
+        # after detection w/o classification, everything is unknown
+        def done_func(points):
+            add_single_layer(
+                points,
+                viewer=viewer,
+                name="Cell candidates",
+                cell_type=Cell.UNKNOWN,
+            )
+
+    else:
+        # after classification we have either cell or unknown
+        def done_func(points):
+            add_classified_layers(
+                points,
+                viewer=viewer,
+                unknown_name="Rejected",
+                cell_name="Detected",
+            )
+
+    return done_func
+
+
+def find_local_planes(
+    viewer: napari.Viewer,
+    voxel_size_z: float,
+    signal_image: napari.layers.Image,
+) -> Tuple[int, int]:
+    """
+    When detecting only locally, it returns the start and end planes to use.
+    """
+    current_plane = viewer.dims.current_step[0]
+
+    # so a reasonable number of cells in the plane are detected
+    planes_needed = MIN_PLANES_ANALYSE + int(
+        ceil((CUBE_DEPTH * NETWORK_VOXEL_SIZES[0]) / voxel_size_z)
+    )
+
+    start_plane, end_plane = get_cube_depth_min_max(
+        current_plane, planes_needed
+    )
+    start_plane = max(0, start_plane)
+    end_plane = min(len(signal_image.data), end_plane)
+
+    return start_plane, end_plane
+
+
+def reraise(e: Exception) -> None:
+    """Re-raises the exception."""
+    raise Exception from e
+
+
 def detect_widget() -> FunctionGui:
     """
     Create a detection plugin GUI.
     """
     progress_bar = ProgressBar()
 
+    # options that is filled in from the gui
+    options = {
+        "signal_image": None,
+        "background_image": None,
+        "viewer": None,
+        "cell_layer": None,
+    }
+
+    signal_image_opt, background_image_opt, cell_layer_opt = get_heavy_widgets(
+        options
+    )
+
     @magicgui(
-        header=header_label_widget,
         detection_label=html_label_widget("Cell detection", tag="h3"),
         **DataInputs.widget_representation(),
         **DetectionInputs.widget_representation(),
@@ -52,16 +236,13 @@ def detect_widget() -> FunctionGui:
         scrollable=True,
     )
     def widget(
-        header,
         detection_label,
         data_options,
-        viewer: napari.Viewer,
-        signal_image: napari.layers.Image,
-        background_image: napari.layers.Image,
         voxel_size_z: float,
         voxel_size_y: float,
         voxel_size_x: float,
         detection_options,
+        skip_detection: bool,
         soma_diameter: float,
         ball_xy_size: float,
         ball_z_size: float,
@@ -71,8 +252,10 @@ def detect_widget() -> FunctionGui:
         soma_spread_factor: float,
         max_cluster_size: int,
         classification_options,
-        trained_model: Optional[Path],
+        skip_classification: bool,
         use_pre_trained_weights: bool,
+        trained_model: Optional[Path],
+        batch_size: int,
         misc_options,
         start_plane: int,
         end_plane: int,
@@ -86,16 +269,16 @@ def detect_widget() -> FunctionGui:
 
         Parameters
         ----------
-        signal_image : napari.layers.Image
-             Image layer containing the labelled cells
-        background_image : napari.layers.Image
-             Image layer without labelled cells
         voxel_size_z : float
             Size of your voxels in the axial dimension
         voxel_size_y : float
             Size of your voxels in the y direction (top to bottom)
         voxel_size_x : float
             Size of your voxels in the x direction (left to right)
+        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)
         ball_xy_size : float
@@ -116,6 +299,11 @@ def detect_widget() -> FunctionGui:
             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
+        skip_classification : bool
+            If selected, the classification step is skipped and all cells from
+            the detection stage are added
         trained_model : Optional[Path]
             Trained model file path (home directory (default) -> pretrained
             weights)
@@ -132,18 +320,48 @@ def detect_widget() -> FunctionGui:
         reset_button :
             Reset parameters to default
         """
-        if signal_image is None or background_image is None:
+        # we must manually call so that the parameters of these functions are
+        # initialized and updated. Because, if the images are open in napari
+        # before we open cellfinder, then these functions may never be called,
+        # even though the image filenames are shown properly in the parameters
+        # in the gui. Likely auto_call doesn't make magicgui call the functions
+        # in this circumstance, only if the parameters are updated once
+        # cellfinder plugin is fully open and initialized
+        signal_image_opt()
+        background_image_opt()
+        cell_layer_opt()
+
+        signal_image = options["signal_image"]
+
+        if signal_image is None or options["background_image"] is None:
             show_info("Both signal and background images must be specified.")
             return
+
+        detected_cells = []
+        if skip_detection:
+            if options["cell_layer"] is None:
+                show_info(
+                    "Skip detection selected, but no existing cell layer "
+                    "is selected."
+                )
+                return
+
+            # set cells as unknown so that classification will process them
+            detected_cells = napari_array_to_cells(
+                options["cell_layer"], Cell.UNKNOWN
+            )
+
         data_inputs = DataInputs(
             signal_image.data,
-            background_image.data,
+            options["background_image"].data,
             voxel_size_z,
             voxel_size_y,
             voxel_size_x,
         )
 
         detection_inputs = DetectionInputs(
+            skip_detection,
+            detected_cells,
             soma_diameter,
             ball_xy_size,
             ball_z_size,
@@ -157,24 +375,18 @@ def detect_widget() -> FunctionGui:
         if use_pre_trained_weights:
             trained_model = None
         classification_inputs = ClassificationInputs(
-            use_pre_trained_weights, trained_model
+            skip_classification,
+            use_pre_trained_weights,
+            trained_model,
+            batch_size,
         )
 
-        end_plane = len(signal_image.data) if end_plane == 0 else end_plane
-
         if analyse_local:
-            current_plane = viewer.dims.current_step[0]
-
-            # so a reasonable number of cells in the plane are detected
-            planes_needed = MIN_PLANES_ANALYSE + int(
-                ceil((CUBE_DEPTH * NETWORK_VOXEL_SIZES[0]) / voxel_size_z)
+            start_plane, end_plane = find_local_planes(
+                options["viewer"], voxel_size_z, signal_image
             )
-
-            start_plane, end_plane = get_cube_depth_min_max(
-                current_plane, planes_needed
-            )
-            start_plane = max(0, start_plane)
-            end_plane = min(len(signal_image.data), end_plane)
+        elif not end_plane:
+            end_plane = len(signal_image.data)
 
         misc_inputs = MiscInputs(
             start_plane, end_plane, n_free_cpus, analyse_local, debug
@@ -186,45 +398,34 @@ def detect_widget() -> FunctionGui:
             classification_inputs,
             misc_inputs,
         )
+
         worker.returned.connect(
-            lambda points: add_layers(points, viewer=viewer)
+            get_results_callback(skip_classification, options["viewer"])
         )
-
         # Make sure if the worker emits an error, it is propagated to this
         # thread
-        def reraise(e):
-            raise Exception from e
-
         worker.errored.connect(reraise)
+        worker.connect_progress_bar_callback(progress_bar)
 
-        def update_progress_bar(label: str, max: int, value: int):
-            progress_bar.label = label
-            progress_bar.max = max
-            progress_bar.value = value
-
-        worker.update_progress_bar.connect(update_progress_bar)
         worker.start()
 
-    widget.header.value = widget_header
-    widget.header.native.setOpenExternalLinks(True)
+    widget.native.layout().insertWidget(0, cellfinder_header())
 
-    @widget.reset_button.changed.connect
-    def restore_defaults():
-        """
-        Restore default widget values.
-        """
-        defaults = {
-            **DataInputs.defaults(),
-            **DetectionInputs.defaults(),
-            **ClassificationInputs.defaults(),
-            **MiscInputs.defaults(),
-        }
-        for name, value in defaults.items():
-            if value is not None:  # ignore fields with no default
-                getattr(widget, name).value = value
+    # reset restores defaults
+    widget.reset_button.changed.connect(
+        partial(restore_options_defaults, widget)
+    )
 
     # Insert progress bar before the run and reset buttons
-    widget.insert(-3, progress_bar)
+    widget.insert(widget.index("debug") + 1, progress_bar)
+
+    # add the signal and background image etc.
+    add_heavy_widgets(
+        widget,
+        (background_image_opt, signal_image_opt, cell_layer_opt),
+        ("Background image", "Signal image", "Candidate cell layer"),
+        ("voxel_size_z", "voxel_size_z", "soma_diameter"),
+    )
 
     scroll = QScrollArea()
     scroll.setWidget(widget._widget._qwidget)

cellfinder/napari/detect/detect_containers.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 import numpy
+from brainglobe_utils.cells.cells import Cell
 
 from cellfinder.napari.input_container import InputContainer
 from cellfinder.napari.utils import html_label_widget
@@ -59,6 +60,8 @@ class DataInputs(InputContainer):
 class DetectionInputs(InputContainer):
     """Container for cell candidate detection inputs."""
 
+    skip_detection: bool = False
+    detected_cells: Optional[List[Cell]] = None
     soma_diameter: float = 16.0
     ball_xy_size: float = 6
     ball_z_size: float = 15
@@ -75,6 +78,7 @@ class DetectionInputs(InputContainer):
     def widget_representation(cls) -> dict:
         return dict(
             detection_options=html_label_widget("Detection:"),
+            skip_detection=dict(value=cls.defaults()["skip_detection"]),
             soma_diameter=cls._custom_widget("soma_diameter"),
             ball_xy_size=cls._custom_widget(
                 "ball_xy_size", custom_label="Ball filter (xy)"
@@ -107,8 +111,10 @@ class DetectionInputs(InputContainer):
 class ClassificationInputs(InputContainer):
     """Container for classification inputs."""
 
+    skip_classification: bool = False
     use_pre_trained_weights: bool = True
     trained_model: Optional[Path] = Path.home()
+    batch_size: int = 64
 
     def as_core_arguments(self) -> dict:
         args = super().as_core_arguments()
@@ -123,6 +129,10 @@ class ClassificationInputs(InputContainer):
                 value=cls.defaults()["use_pre_trained_weights"]
             ),
             trained_model=dict(value=cls.defaults()["trained_model"]),
+            skip_classification=dict(
+                value=cls.defaults()["skip_classification"]
+            ),
+            batch_size=dict(value=cls.defaults()["batch_size"]),
         )
 
 

cellfinder/napari/detect/thread_worker.py

@@ -1,3 +1,4 @@
+from magicgui.widgets import ProgressBar
 from napari.qt.threading import WorkerBase, WorkerBaseSignals
 from qtpy.QtCore import Signal
 
@@ -41,6 +42,19 @@ class Worker(WorkerBase):
         self.classification_inputs = classification_inputs
         self.misc_inputs = misc_inputs
 
+    def connect_progress_bar_callback(self, progress_bar: ProgressBar):
+        """
+        Connects the progress bar to the work so that updates are shown on
+        the bar.
+        """
+
+        def update_progress_bar(label: str, max: int, value: int):
+            progress_bar.label = label
+            progress_bar.max = max
+            progress_bar.value = value
+
+        self.update_progress_bar.connect(update_progress_bar)
+
     def work(self) -> list:
         self.update_progress_bar.emit("Setting up detection...", 1, 0)
 
@@ -58,10 +72,10 @@ class Worker(WorkerBase):
         def classify_callback(batch: int) -> None:
             self.update_progress_bar.emit(
                 "Classifying cells",
-                # Default cellfinder-core batch size is 32. This seems to give
+                # 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 // 32 + 1, batch + 1),
+                max(self.npoints_detected // 64 + 1, batch + 1),
                 batch + 1,
             )
 

cellfinder/napari/train/train.py

@@ -8,11 +8,7 @@ from napari.utils.notifications import show_info
 from qtpy.QtWidgets import QScrollArea
 
 from cellfinder.core.train.train_yml import run as train_yml
-from cellfinder.napari.utils import (
-    header_label_widget,
-    html_label_widget,
-    widget_header,
-)
+from cellfinder.napari.utils import cellfinder_header, html_label_widget
 
 from .train_containers import (
     MiscTrainingInputs,
@@ -41,7 +37,6 @@ def run_training(
 
 def training_widget() -> FunctionGui:
     @magicgui(
-        header=header_label_widget,
         training_label=html_label_widget("Network training", tag="h3"),
         **TrainingDataInputs.widget_representation(),
         **OptionalNetworkInputs.widget_representation(),
@@ -52,7 +47,6 @@ def training_widget() -> FunctionGui:
         scrollable=True,
     )
     def widget(
-        header: dict,
         training_label: dict,
         data_options: dict,
         yaml_files: Path,
@@ -161,8 +155,7 @@ def training_widget() -> FunctionGui:
             )
             worker.start()
 
-    widget.header.value = widget_header
-    widget.header.native.setOpenExternalLinks(True)
+    widget.native.layout().insertWidget(0, cellfinder_header())
 
     @widget.reset_button.changed.connect
     def restore_defaults():

cellfinder/napari/train/train_containers.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 from magicgui.types import FileDialogMode
 
-from cellfinder.core.download.models import model_weight_urls
+from cellfinder.core.download.download import model_filenames
 from cellfinder.core.train.train_yml import models
 from cellfinder.napari.input_container import InputContainer
 from cellfinder.napari.utils import html_label_widget
@@ -46,7 +46,7 @@ class OptionalNetworkInputs(InputContainer):
     trained_model: Optional[Path] = Path.home()
     model_weights: Optional[Path] = Path.home()
     model_depth: str = list(models.keys())[2]
-    pretrained_model: str = str(list(model_weight_urls.keys())[0])
+    pretrained_model: str = str(list(model_filenames.keys())[0])
 
     def as_core_arguments(self) -> dict:
         arguments = super().as_core_arguments()
@@ -65,7 +65,7 @@ class OptionalNetworkInputs(InputContainer):
             ),
             pretrained_model=cls._custom_widget(
                 "pretrained_model",
-                choices=list(model_weight_urls.keys()),
+                choices=list(model_filenames.keys()),
             ),
         )