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

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
@@ -244,23 +246,28 @@ def detect_widget() -> FunctionGui:
         detection_options,
         skip_detection: bool,
         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,
-        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:
@@ -270,43 +277,74 @@ 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
+            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
-            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
@@ -315,6 +353,14 @@ def detect_widget() -> FunctionGui:
             How many CPU cores to leave free
         analyse_local : bool
             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 :
@@ -368,8 +414,11 @@ 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,
         )
 
         if use_pre_trained_weights:
@@ -378,7 +427,7 @@ def detect_widget() -> FunctionGui:
             skip_classification,
             use_pre_trained_weights,
             trained_model,
-            batch_size,
+            classification_batch_size,
         )
 
         if analyse_local:
@@ -389,7 +438,13 @@ def detect_widget() -> FunctionGui:
             end_plane = len(signal_image.data)
 
         misc_inputs = MiscInputs(
-            start_plane, end_plane, n_free_cpus, analyse_local, debug
+            start_plane,
+            end_plane,
+            n_free_cpus,
+            analyse_local,
+            use_gpu,
+            pin_memory,
+            debug,
         )
 
         worker = Worker(
@@ -400,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

@@ -1,8 +1,9 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional
 
 import numpy
+import torch
 from brainglobe_utils.cells.cells import Cell
 
 from cellfinder.napari.input_container import InputContainer
@@ -30,7 +31,7 @@ class DataInputs(InputContainer):
             self.voxel_size_x,
         )
         # del operator doesn't affect self, because asdict creates a copy of
-        # fields.
+        # the dict.
         del data_input_dict["voxel_size_z"]
         del data_input_dict["voxel_size_y"]
         del data_input_dict["voxel_size_x"]
@@ -67,9 +68,12 @@ 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
+    n_sds_above_mean_tiled_thresh: float = 10
+    tiled_thresh_tile_size: float = 0
     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()
@@ -93,17 +97,27 @@ 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="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)"
+            ),
         )
 
 
@@ -114,7 +128,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()
@@ -132,7 +146,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)",
+            ),
         )
 
 
@@ -144,10 +161,14 @@ class MiscInputs(InputContainer):
     end_plane: int = 0
     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:
         misc_input_dict = super().as_core_arguments()
+        misc_input_dict["torch_device"] = "cuda" if self.use_gpu else "cpu"
+        del misc_input_dict["use_gpu"]
         del misc_input_dict["debug"]
         del misc_input_dict["analyse_local"]
         return misc_input_dict
@@ -162,5 +183,16 @@ class MiscInputs(InputContainer):
                 "n_free_cpus", custom_label="Number of free CPUs"
             ),
             analyse_local=dict(value=cls.defaults()["analyse_local"]),
+            use_gpu=dict(
+                widget_type="CheckBox",
+                label="Use GPU",
+                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/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/input_container.py

@@ -1,8 +1,18 @@
 from abc import abstractmethod
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass, fields
 from typing import Optional
 
 
+def asdict_no_copy(obj: dataclass) -> dict:
+    """
+    Similar to `asdict`, except it makes no copies of the field values.
+    asdict will do a deep copy of field values that are non-basic objects.
+
+    It still creates a new dict to return, though.
+    """
+    return {field.name: getattr(obj, field.name) for field in fields(obj)}
+
+
 @dataclass
 class InputContainer:
     """Base for classes that contain inputs
@@ -23,7 +33,7 @@ class InputContainer:
         # Derived classes are not expected to be particularly
         # slow to instantiate, so use the default constructor
         # to avoid code repetition.
-        return asdict(cls())
+        return asdict_no_copy(cls())
 
     @abstractmethod
     def as_core_arguments(self) -> dict:
@@ -32,10 +42,10 @@ class InputContainer:
         The implementation provided here can be re-used in derived classes, if
         convenient.
         """
-        # note that asdict returns a new instance of a dict,
+        # note that asdict_no_copy returns a new instance of a dict,
         # so any subsequent modifications of this dict won't affect the class
         # instance
-        return asdict(self)
+        return asdict_no_copy(self)
 
     @classmethod
     def _custom_widget(

cellfinder/napari/train/train.py

@@ -7,7 +7,7 @@ from napari.qt.threading import thread_worker
 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.core.train.train_yaml import run as train_yaml
 from cellfinder.napari.utils import cellfinder_header, html_label_widget
 
 from .train_containers import (
@@ -25,14 +25,14 @@ def run_training(
     optional_training_inputs: OptionalTrainingInputs,
     misc_training_inputs: MiscTrainingInputs,
 ):
-    print("Running training")
-    train_yml(
+    show_info("Running training...")
+    train_yaml(
         **training_data_inputs.as_core_arguments(),
         **optional_network_inputs.as_core_arguments(),
         **optional_training_inputs.as_core_arguments(),
         **misc_training_inputs.as_core_arguments(),
     )
-    print("Finished!")
+    show_info("Training finished!")
 
 
 def training_widget() -> FunctionGui:
@@ -60,7 +60,6 @@ def training_widget() -> FunctionGui:
         continue_training: bool,
         augment: bool,
         tensorboard: bool,
-        save_weights: bool,
         save_checkpoints: bool,
         save_progress: bool,
         epochs: int,
@@ -96,9 +95,6 @@ def training_widget() -> FunctionGui:
             Augment the training data to improve generalisation
         tensorboard : bool
             Log to output_directory/tensorboard
-        save_weights : bool
-            Only store the model weights, and not the full model
-            Useful to save storage space
         save_checkpoints : bool
             Store the model at intermediate points during training
         save_progress : bool
@@ -133,7 +129,6 @@ def training_widget() -> FunctionGui:
             continue_training,
             augment,
             tensorboard,
-            save_weights,
             save_checkpoints,
             save_progress,
             epochs,
@@ -147,6 +142,7 @@ def training_widget() -> FunctionGui:
         if yaml_files[0] == Path.home():  # type: ignore
             show_info("Please select a YAML file for training")
         else:
+            show_info("Starting training process...")
             worker = run_training(
                 training_data_inputs,
                 optional_network_inputs,

cellfinder/napari/train/train_containers.py

@@ -5,7 +5,7 @@ from typing import Optional
 from magicgui.types import FileDialogMode
 
 from cellfinder.core.download.download import model_filenames
-from cellfinder.core.train.train_yml import models
+from cellfinder.core.train.train_yaml import models
 from cellfinder.napari.input_container import InputContainer
 from cellfinder.napari.utils import html_label_widget
 
@@ -31,7 +31,7 @@ class TrainingDataInputs(InputContainer):
                 "yaml_files",
                 custom_label="YAML files",
                 mode=FileDialogMode.EXISTING_FILES,
-                filter="*.yml",
+                filter="*.yaml",
             ),
             output_directory=cls._custom_widget(
                 "output_directory", mode=FileDialogMode.EXISTING_DIRECTORY
@@ -75,7 +75,6 @@ class OptionalTrainingInputs(InputContainer):
     continue_training: bool = False
     augment: bool = True
     tensorboard: bool = False
-    save_weights: bool = False
     save_checkpoints: bool = True
     save_progress: bool = True
     epochs: int = 100
@@ -98,7 +97,6 @@ class OptionalTrainingInputs(InputContainer):
             continue_training=cls._custom_widget("continue_training"),
             augment=cls._custom_widget("augment"),
             tensorboard=cls._custom_widget("tensorboard"),
-            save_weights=cls._custom_widget("save_weights"),
             save_checkpoints=cls._custom_widget("save_checkpoints"),
             save_progress=cls._custom_widget("save_progress"),
             epochs=cls._custom_widget("epochs"),

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.4.1.dist-info → cellfinder-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cellfinder
-Version: 1.4.1
+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
@@ -16,26 +16,27 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 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
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: keras>=3.7.0
-Requires-Dist: torch!=2.4,>=2.1.0
+Requires-Dist: torch>=2.4.1
 Requires-Dist: tifffile
 Requires-Dist: tqdm
+Requires-Dist: qt-niu
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -52,23 +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]; 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).