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

cellfinder/core/main.py

@@ -7,10 +7,11 @@ import os
 from typing import Callable, List, Optional, Tuple
 
 import numpy as np
+from brainglobe_utils.cells.cells import Cell
 from brainglobe_utils.general.logging import suppress_specific_logs
 
 from cellfinder.core import logger
-from cellfinder.core.download.models import model_type
+from cellfinder.core.download.download import model_type
 from cellfinder.core.train.train_yml import depth_type
 
 tf_suppress_log_messages = [
@@ -42,6 +43,9 @@ def main(
     cube_height: int = 50,
     cube_depth: int = 20,
     network_depth: depth_type = "50",
+    skip_detection: bool = False,
+    skip_classification: bool = False,
+    detected_cells: List[Cell] = None,
     *,
     detect_callback: Optional[Callable[[int], None]] = None,
     classify_callback: Optional[Callable[[int], None]] = None,
@@ -65,52 +69,58 @@ def main(
     from cellfinder.core.detect import detect
     from cellfinder.core.tools import prep
 
-    logger.info("Detecting cell candidates")
+    if not skip_detection:
+        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,
-        callback=detect_callback,
-    )
-
-    if detect_finished_callback is not None:
-        detect_finished_callback(points)
-
-    install_path = None
-    model_weights = prep.prep_model_weights(
-        model_weights, install_path, model, n_free_cpus
-    )
-    if len(points) > 0:
-        logger.info("Running classification")
-        points = classify.main(
-            points,
+        points = detect.main(
             signal_array,
-            background_array,
-            n_free_cpus,
+            start_plane,
+            end_plane,
             voxel_sizes,
-            network_voxel_sizes,
-            batch_size,
-            cube_height,
-            cube_width,
-            cube_depth,
-            trained_model,
-            model_weights,
-            network_depth,
-            callback=classify_callback,
+            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,
+            callback=detect_callback,
         )
+
+        if detect_finished_callback is not None:
+            detect_finished_callback(points)
     else:
-        logger.info("No candidates, skipping classification")
+        points = detected_cells or []  # if None
+        detect_finished_callback(points)
+
+    if not skip_classification:
+        install_path = None
+        model_weights = prep.prep_model_weights(
+            model_weights, install_path, model, n_free_cpus
+        )
+        if len(points) > 0:
+            logger.info("Running classification")
+            points = classify.main(
+                points,
+                signal_array,
+                background_array,
+                n_free_cpus,
+                voxel_sizes,
+                network_voxel_sizes,
+                batch_size,
+                cube_height,
+                cube_width,
+                cube_depth,
+                trained_model,
+                model_weights,
+                network_depth,
+                callback=classify_callback,
+            )
+        else:
+            logger.info("No candidates, skipping classification")
+
     return points
 
 

cellfinder/core/tools/prep.py

@@ -13,18 +13,19 @@ from brainglobe_utils.general.system import get_num_processes
 
 import cellfinder.core.tools.tf as tf_tools
 from cellfinder.core import logger
-from cellfinder.core.download import models as model_download
-from cellfinder.core.download.download import amend_user_configuration
+from cellfinder.core.download.download import (
+    DEFAULT_DOWNLOAD_DIRECTORY,
+    amend_user_configuration,
+    download_models,
+    model_type,
+)
 from cellfinder.core.tools.source_files import user_specific_configuration_path
 
-home = Path.home()
-DEFAULT_INSTALL_PATH = home / ".cellfinder"
-
 
 def prep_model_weights(
     model_weights: Optional[os.PathLike],
     install_path: Optional[os.PathLike],
-    model_name: model_download.model_type,
+    model_name: model_type,
     n_free_cpus: int,
 ) -> Path:
     n_processes = get_num_processes(min_free_cpu_cores=n_free_cpus)
@@ -42,9 +43,9 @@ def prep_tensorflow(max_threads: int) -> None:
 def prep_models(
     model_weights_path: Optional[os.PathLike],
     install_path: Optional[os.PathLike],
-    model_name: model_download.model_type,
+    model_name: model_type,
 ) -> Path:
-    install_path = install_path or DEFAULT_INSTALL_PATH
+    install_path = install_path or DEFAULT_DOWNLOAD_DIRECTORY
     # if no model or weights, set default weights
     if model_weights_path is None:
         logger.debug("No model supplied, so using the default")
@@ -53,13 +54,13 @@ def prep_models(
 
         if not Path(config_file).exists():
             logger.debug("Custom config does not exist, downloading models")
-            model_path = model_download.main(model_name, install_path)
+            model_path = download_models(model_name, install_path)
             amend_user_configuration(new_model_path=model_path)
 
         model_weights = get_model_weights(config_file)
         if not model_weights.exists():
             logger.debug("Model weights do not exist, downloading")
-            model_path = model_download.main(model_name, install_path)
+            model_path = download_models(model_name, install_path)
             amend_user_configuration(new_model_path=model_path)
             model_weights = get_model_weights(config_file)
     else:

cellfinder/core/tools/source_files.py

@@ -1,5 +1,7 @@
 from pathlib import Path
 
+from cellfinder import DEFAULT_CELLFINDER_DIRECTORY
+
 
 def default_configuration_path():
     """
@@ -17,11 +19,11 @@ def user_specific_configuration_path():
 
     This function returns the path to the user-specific configuration file
     for cellfinder. The user-specific configuration file is located in the
-    user's home directory under the ".cellfinder" folder and is named
-    "cellfinder.conf.custom".
+    user's home directory under the ".brainglobe/cellfinder" folder
+    and is named "cellfinder.conf.custom".
 
     Returns:
         Path: The path to the custom configuration file.
 
     """
-    return Path.home() / ".cellfinder" / "cellfinder.conf.custom"
+    return DEFAULT_CELLFINDER_DIRECTORY / "cellfinder.conf.custom"

cellfinder/core/train/train_yml.py

@@ -31,7 +31,7 @@ from sklearn.model_selection import train_test_split
 import cellfinder.core as program_for_log
 from cellfinder.core import logger
 from cellfinder.core.classify.resnet import layer_type
-from cellfinder.core.tools.prep import DEFAULT_INSTALL_PATH
+from cellfinder.core.download.download import DEFAULT_DOWNLOAD_DIRECTORY
 
 tf_suppress_log_messages = [
     "sample_weight modes were coerced from",
@@ -112,8 +112,7 @@ def misc_parse(parser):
 
 def training_parse():
     from cellfinder.core.download.cli import (
-        download_directory_parser,
-        model_parser,
+        download_parser,
     )
 
     training_parser = ArgumentParser(
@@ -223,8 +222,7 @@ def training_parse():
     )
 
     training_parser = misc_parse(training_parser)
-    training_parser = model_parser(training_parser)
-    training_parser = download_directory_parser(training_parser)
+    training_parser = download_parser(training_parser)
     args = training_parser.parse_args()
 
     return args
@@ -306,7 +304,7 @@ def run(
     n_free_cpus=2,
     trained_model=None,
     model_weights=None,
-    install_path=DEFAULT_INSTALL_PATH,
+    install_path=DEFAULT_DOWNLOAD_DIRECTORY,
     model="resnet50_tv",
     network_depth="50",
     learning_rate=0.0001,

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,6 +252,7 @@ def detect_widget() -> FunctionGui:
         soma_spread_factor: float,
         max_cluster_size: int,
         classification_options,
+        skip_classification: bool,
         trained_model: Optional[Path],
         use_pre_trained_weights: bool,
         misc_options,
@@ -86,16 +268,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 +298,9 @@ def detect_widget() -> FunctionGui:
             should be attempted
         use_pre_trained_weights : bool
             Select to use pre-trained model weights
+        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 +317,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 +372,15 @@ 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
         )
 
-        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 +392,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)