Uwe Schmidt

Martin Weigert

StarDist Napari Plugin




This project provides the napari plugin for StarDist, a deep learning based 2D and 3D object detection method with star-convex shapes. StarDist has originally been developed (see papers) for the segmentation of densely packed cell nuclei in challenging images with low signal-to-noise ratios. The plugin allows to apply pretrained and custom trained models from within napari.
If you use this plugin for your research, please cite us.

Installation
Install the plugin with pip install stardist-napari or from within napari via Plugins > Install/Uninstall Plugins…. If you want GPU-accelerated prediction, please read the more detailed installation instructions for StarDist.

You can activate the plugin in napari via Plugins > stardist-napari: StarDist.
Example images for testing are provided via File > Open Sample > stardist-napari.

Documentation
The two main buttons at the bottom of the plugin are (see right side of screenshot above):
Restore Defaults: Restore default values for inputs (exceptions: Input Image, Image Axes, Custom Model).
Run: Start the prediction with the selected inputs and create the outputs when done.
All plugin activity is shown in the napari activity dock, which can be shown/hidden by clicking on the word activity next to the little arrow at the bottom right of the napari window.
Inputs
The plugin does perform input validation, i.e. it will disable the Run button if it detects a problem with the selected inputs. Problematic input fields are highlighted with a "lightcoral" background color , and their tooltips typically explain what the problem is. Some error messages are shown at the bottom in napari's status bar, such as for incompatibilities between multiple input fields. Input fields with warnings (also explained via tooltips) are highlighted with an orange background color .
Input Image: Select a napari layer of type Image as the input.
Tooltip: Shows the shape of the image.
Image Axes: String that describes the semantic image axes and their order, e.g. YX for a 2D image. This parameter is automatically chosen (i.e. guessed) when a new input image is selected and should work in most cases. Permissible axis values are: X (width/columns), Y (height/rows), Z (depth/planes), C (channels), T (frames/time).
Tooltip: Shows the mapping of semantic axes to the shape of the selected input image.
Predict on field of view (only for 2D models in 2D view): If enabled, the StarDist prediction is only applied to the current field of view of the napari viewer. As the name of this checkbox indicates, this only works for 2D StarDist models and when the napari viewer is in 2D viewing mode. The checkbox is not even shown if those conditions are not met.
Neural Network Prediction
Model Type: Choice whether to use registered pre-trained models (2D, 3D) or provide a path to a model folder (Custom 2D/3D). Based on this choice, either the input for Pre-trained Model or Custom Model is shown below.
(Further information regarding pre-trained models: how to register your own model, model registration in StarDist.)
Pre-trained Model: Select a registered pre-trained model from a list. The first time a model is selected, it is downloaded and cached locally.
Custom Model: Provide a path to a StarDist model folder, containing at least config.json and a compatible neural network weights file (with suffix .h5 or .hdf5). If present, thresholds.json is also loaded and its values can be used via the button Set optimized postprocessing thresholds (for selected model).
Model Axes: A read-only text field that shows the semantic axes that the currently selected model expects as input. Additionally, we show the number of expected input channels, e.g. YXC[2] to indicate that the model expects a 2D input image with 2 channels. Seeing the model axes is helpful to understand whether the axes of the input image are compatible or not.
Normalize Image: A checkbox to indicate whether to perform percentile-based input image normalization or not. This should be checked if the input image wasn't manually normalized such that most pixel values are in the range 0 to 1. If unchecked, inputs Percentile low and Percentile high are hidden.
Percentile low: Percentile value of input pixel distribution that is mapped to 0 (~min value). If there aren't any outlier pixels in your image, you may use percentile 0 to do a standard min-max image normalization.
Percentile high: Percentile value of input pixel distribution that is mapped to 1 (~max value). If there aren't any outlier pixels in your image, you may use percentile 100 to do a standard min-max image normalization.
Input image scaling: Number or list of numbers (one per input axis) to scale the input image before prediction and rescale the output accordingly. For example, a value of 0.5 indicates that all spatial axes are downscaled to half their size before prediction, and that the outputs are scaled to double their size. This is useful to adapt to different object sizes in the input image.
Tooltip: Shows the mapping of scale values to the semantic axes of the selected input image.
NMS Postprocessing
Probability/Score Threshold: Determine the number of object candidates to enter non-maximum suppression. Higher values lead to fewer segmented objects, but will likely avoid false positives. The selected model may have an associated threshold value, which can be loaded via the Set optimized postprocessing thresholds (for selected model) button.
Overlap Threshold: Determine when two objects are considered the same during non-maximum suppression. Higher values allow segmented objects to overlap substantially. The selected model may have an associated threshold value, which can be loaded via the Set optimized postprocessing thresholds (for selected model) button.
Output Type: Choose format of outputs (see below for details). Selecting Label Image will create the outputs StarDist labels and StarDist class labels (for multi-class models only) as napari Labels layers. Selecting Polygons / Polyhedra will instead return the output StarDist polygons as a napari Shapes layer for a 2D model, or StarDist polyhedra as a napari Surface layer for a 3D model. Selecting Both will return both types of outputs.
Advanced Options
Number of Tiles: String None (to disable tiling) or list of integer numbers (one per axis of input image) to determine how the input image is tiled before the CNN prediction is computed on each tile individually. This is needed to avoid (GPU) memory issues that can occur for large input images. Note that the NMS postprocessing is still run only once with candidates from the predictions of all image tiles.
Tooltip: Shows the mapping of tile values to the semantic axes of the selected input image.
Normalization Axes: String of semantic axes which are jointly normalized (if they are present in the input image). For example, the default value ZYX indicates that all spatial axes are always normalized together; if an image has multiple channels, the pixels will be normalized separately per channel (e.g. this is what typically makes sense for fluorescence microscopy where channels are independent). On the other hand, the channels in RGB color images typically need to be normalized jointly, hence using ZYXC makes sense in this case. Note: if an image is explicitly opened with rgb=True in napari, the channels are automatically normalized together.
Tooltip: Shows a brief explanation.
Time-lapse Labels: If the input is a time-lapse/movie, each frame is first independently processed by StarDist. If Separate per frame (no processing) is chosen, the object ids in the label images of each frame are not modified, i.e. they are consecutive integers that always start at 1. Selecting Unique through time will cause object ids to be unique over time, i.e. the smallest object id in a given frame is larger than the largest object id of the previous frame. Finally, choosing Match to previous frame (via overlap) will perform a simple form of greedy matching/tracking, where object ids are propagated from one frame to the next based on object overlap.
Show CNN Output: Create additional outputs (see below for details) StarDist probability and StarDist distances that show the direct results of the CNN prediction which are the inputs to the NMS postprocessing. Additionally, StarDist class probabilities is created for multi-class models.
Set optimized postprocessing thresholds (for selected model): Button to set Probability/Score Threshold and Overlap Threshold to the values provided by the selected model. Nothing is changed if the model does not provide threshold values.
Outputs
StarDist polygons: The detected/segmented 2D objects as polygons (napari Shapes layer).
StarDist polyhedra: The detected/segmented 3D objects as surfaces (napari Surface layer).
StarDist labels: The detected/segmented 2D/3D objects as a label image (napari Labels layer). In an integer-valued label image, the value of a given pixel denotes the id of the object that it belongs to. For example, all pixels with value 5 belong to the object with id 5. All background pixels (that don't belong to any object) have value 0.
StarDist class labels (multi-class models only): The classes of detected/segmented 2D/3D objects as a semantic segmentation labeling (napari Labels layer). The integer value of a given pixel denotes the class id of the object that it belongs to. For example, all pixels with value 3 belong to the object class 3. Note that all pixels that belong to a specific object instance (as returned by StarDist labels) do have the same object class here. All background pixels (that don't belong to an object class) have value 0.
StarDist probability: The object probabilities predicted by the neural network as a single-channel image (napari Image layer).
StarDist distances: The radial distances predicted by the neural network as a multi-channel image (napari Image layer).
StarDist class probabilities (multi-class models only): The object class probabilities predicted by the neural network as a multi-channel image (napari Image layer).
Troubleshooting & Support

The image.sc forum is the best place to start getting help and support. Make sure to use the tag stardist, since we are monitoring all questions with this tag.
For general questions about StarDist, it's worth taking a look at the frequently asked questions (FAQ).
If you have technical questions or found a bug, feel free to open an issue.

Other resources
A demonstration of an earlier version of the plugin is shown in this video.
Many of the parameters are identical to those of our StarDist ImageJ/Fiji plugin, which are documented here.

stardist-napari

Grzegorz Bokota

Description
PartSeg is a specialized GUI for feature extraction from multichannel light microscopy images, but also most of its features are available as napari Widgets.
Information about PartSeg as standalone program or library are here
Who is This For?
This plugin is for 2D and 3D segmentation of distinct objects from images and measuring various parameters of these objects.
This plugin process everything in memory, so it may not work with images stored in dask arrays. Currently, this plugin does not support the processing of Time data.
How-to Guide
The example data is stored here.
https://user-images.githubusercontent.com/3826210/149146100-973498c7-7d2e-4298-a3c8-3051912e3183.mp4
The above video presents simple segmentation and measurement of various parameters of this segmentation (ROI).
As bellow described, algorithms are the result of porting PartSeg utilities to napari
then detailed description could be found in PartSeg documentation/
ROI Extraction (Segmentation, pixel labeling)
The PartSeg is focused on the reproducible ROI Extraction process and offers two groups of algorithms:

ROI Mask Extraction set of algorithms (from PartSeg ROI Analysis) to work on a whole stack and mainly used for extracting nucleus or cell from a stack.
ROI Analysis Extraction set of algorithms (from PartSeg ROI Mask) for detailed segmentation on the level of a single nucleus.
    If possible, they use an inner caching mechanism to improve performance while adjusting parameters.

Algorithms from both groups should support masking.
(perform ROI extraction only on the mask layer's area has non-zero values).
Parameters of ROI Extraction could be saved for later reuse (in the program) or exported to JSON and imported in another instance.
With an accuracy of up to channel selection, they are identical to PartSeg,
so importing should work both ways, but the channel selection step needs to be repeated.
The list of available algorithms could be extensible using the PartSeg plugin mechanism.
Measurement widgets
PartSeg offers two measurement widgets:
Measurement
Interface to PartSeg measurement engine.
In this widget, there are two tabs. *Measurement settings that allow
to define, delete, import, and export set of measurements

and Measurement for performing measures using an already defined set.

The list of available measurements could be extensible using the PartSeg plugin mechanism.
Simple Measurement

Set of measurements that could be calculated per component respecting data voxel size.
In comparison to  Measurement list of available measures is limited to ones that do not need
Mask information and could be calculated per component.
This widget is equivalent to the PartSeg ROI Mask Simple Measurement window.
Search label
Widget to find the layer with the given number By highlighting it or zooming on it. The highlight widget uses white color, so the highlight may not be visible if the label has a bright color.
https://user-images.githubusercontent.com/3826210/154669409-cdac9be8-3dbf-4a0e-a66f-af8a44aed0fb.mp4
Mask create
Transform labels layer into another labels layer with the possibility to dilate, and filling small holes

Reader plugins
In this plugin, there are also all PartSeg readers and writers.
The most important readers are this, which allows loading PartSeg projects to napari.
The one which could impact a user workflow is tiff reader.
In comparison to the napari default one, there are two essential differences.
Napari's built-in plugin loads data as they are in a file.
PartSeg plugin read file metadata and return data in TZYX order.
PartSeg reader returns each channel as a separate layer.
PartSeg reader also tries to parse voxel size metadata and set scale parameters to nanometers' size.

PartSeg

PartSeg is python GUI and set of napari plugins for bio imaging analysis especially nucleus analysis,

Alan R. Lowe











BayesianTracker (btrack) is a multi object tracking algorithm,
specifically used to reconstruct trajectories in crowded fields.  New
observations are assigned to tracks by evaluating the posterior probability of
each potential linkage from a Bayesian belief matrix for all possible
linkages.
We developed btrack for cell tracking in time-lapse microscopy data.


associated plugins

napari-arboretum - Napari plugin to enable track graph and lineage tree visualization.
napari-btrack - (Experimental) Napari plugin to provide a frontend GUI for btrack.


btrack

A framework for Bayesian multi-object tracking

John Fozard

skimage-sift-registration






Simple plugin for 2D keypoint detection and affine registration with RANSAC.



Artificial data 


Moving and fixed images showing inlier keypoints after RANSAC

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.
It uses the scikit-image SIFT keypoint detection routines to find distinctive image points and generate local descriptions of the image around them.
Correspondences between the two images are then found by looking for pairs of keypoints, one in each of the two images, with closely matching descriptors.
For typical images, many of these correspondences will be wrong. To reduce these false correspondences, the plugin applies the RANSAC algorithm. This randomly selects a small subset of the matching pairs of keypoints, estimates the affine transformation between this subset of keypoints, and then evaluates how many of the other pairs of keypoints also closely agree with this affine transformation ("inliers"). A large number of random samples are tested, and the transformation with the most inliers retained.
The plugin outputs two points layers, one for each image, containing all the corresponding (inlier) SIFT keypoints. It also uses the estimated affine transformation between the two images to deform the "moving" image layer onto the "fixed" image layer.
This approach is an attempt to provide similar functionality to the Stephan Saalfeld's Fiji "Extract SIFT Correspondences" plugin extract, and more-or-less
just provides a napari interface to the existing routines in scikit-image. There are great examples in the scikit-image documentation (e.g. SIFT-example and RANSAC-example) that can be used if you would like to use these routines in your own analysis scripts.
Installation
You can install napari-sift-registration via pip:
pip install napari-sift-registration

To install the latest development version :
pip install git+https://github.com/jfozard/napari-sift-registration.git

Usage
Basic usage

Load two 2D single channel images in Napari.
Select the menu item Plugins > napari-sift-registration
Select these two images as the "Moving image layer" and the "Fixed image layer". The moving image will be deformed by the transformation to look like the fixed image.
The remaining parameters are the default settings from scikit-image; try these default values first.

Advanced usage
The parameter values for SIFT feature detection, keypoint matching and RANSAC are accessible from the plugin gui. For further information about their use, see the appropriate scikit-image documentation:
Upsampling before feature detection, maximum number of octaves, maximum number of scales in every octave, blur level of seed image, feature descriptor size, feature descriptor orientation bins: see scikit-image-SIFT.
Closest/next closest ratio: see scikit-image-match_descriptors
Minimum number of points sampled for each RANSAC model, distance for points to be inliers in RANSAC model, maximum number of trials in RANSAC model: see scikit-image-RANSAC
Only show inlier keypoints: If checked, only show corresponding keypoints that are inliers after RANSAC. If unchecked, show all corresponding keypoints.
Limitations
Only 2D, single channel images (for now).
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-sift-registration" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-sift-registration

Simple plugin for SIFT keypoint detection, and affine registration with RANSAC, based on scikit-image

Joel Luethi

Max Hess

napari-feature-classifier






An interactive classifier plugin that allows the user to assign objects in a label image to multiple classes and train a classifier to learn those classes based on a feature dataframe.
Usage

To use the napari-feature-classifier, you need to have a label image and a csv file containing measurements that correspond to the object in the label image. The csv file needs to contain a column with integer values corresponding to the label values in the label image.
These interactive classification workflows are well suited to visually define cell types, find mitotic cells in images, do quality control by automatically detecting missegmented cells and other tasks where a user can easily assign objects to groups.
Initialize a classifier:

Start the classifier in napari by going to Plugins -> napari-feature-classifier -> Initialize a Classifier 
Provide a csv file that contains feature measurements and a column with the integer labels corresponding to the label layer you are using.
Choose a name (or relative path from the current working directory) for the classifier. The classifier is initially saved in the current working directory (you can change this later on).
Select the features you want to use for the classifier (you need to do the feature selection before initializing. The feature selection can't be changed after initialization anymore). Hold the command key to select multiple features.


Classify objects:

Make sure you have the label layer selected on which you want to classify
Select the current class with the radio buttons or by pressing 0, 1, 2, 3 or 4
Click on label objects in the viewer to assign them to the currently selected class
While you need to have the label layer active to select, sometimes you want to focus on the intensity images. You can press v (or manually change the opacity of the label layer) to focus on the intensity images.
Once you have trained enough examples, click "Run Classifier" (or press t) to run the classifier and have it make a prediction for all objects. Aim for at least a dozen annotations per class, as the classifier divides your annotations 80/20 in training and test sets. To get good performance readouts, aim for >30 annotations per class.
Once you get predictions, correct mistakes the classifier made and retrain it to improve its performance.
You can save the classifier under a different name (to move it to a new folder or to have a slightly different version of the classifier - but careful, it autosaves whenever you run it). Define the new output location and then click Save Classifier (you need to click the Save Classifier button. Just defining the new output path does not save it yet)


Apply the classifier to additional images:

You can apply a classifier trained on one image to additional label images. Use Plugins -> napari-feature-classifier -> Load Classifier 
Select the classifier (.clf file with the name you gave above) and a csv file containing the same features as the past images.
Click Load Classifier, proceed as above.


Export classifier results

To export the training data and the results of the classifier, define an Export Name (full path to an output file or just a filename ending in .csv) where the results of the classifier shall be saved
Click Export Classifier Result (Just selecting a filename is not enough, you need to click the export button)
The results of the classifier are save in a csv file. The first two columns are index columns: path describes the Feature Path used (and allows you to understand which image / feature dataframe a result is from) and label is an integer of the label object within that image. The predict column contains predictions of the classifier for all objects (except those that contained NaNs in their feature data) and the train column contains the annotations you made (0 for unclassified objects, 1, 2, 3 or 4 for the classes)


There is a simple workflow for the classifier in the examples folder:
- Install jupyter-lab (pip install jupyterlab)
- Open the notebook in jupyter lab (Type jupyter-lab in the terminal when you are in the examples folder)
- Follow the instructions to generate an example dataframe and an example label image
- Use the classifier in napari with this simplified data
Installation
This plugin is written for the new napari npe2 plugin engine. Thus, it requires napari >= 0.4.13.
Activate your environment where you have napari installed (or install napari using pip install "napari[all]"), then install the classifier plugin:
pip install napari-feature-classifier

Contributing
Contributions are very welcome.
License
Distributed under the terms of the BSD-3 license,
"napari-feature-classifier" is free and open source software
Issues
If you encounter any problems, please [file an issue] along with a detailed description.
Contributors
Joel Lüthi & Max Hess

napari-feature-classifier

An interactive classifier plugin to use with label images and feature measurements

Hiroki Kawai

napari-PHILOW






PHILOW 
Python-based platform for human-in-the-loop (HITL)  workflow (PHILOW) 
PHILOW is an interactive deep learning-based platform for 3D datasets implemented on top of napari

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-PHILOW via pip:
pip install napari-PHILOW

or clone this repository 
then
angular2
cd PHILOW
pip install -e .
Usage
Launch napari 
angular2
napari
load dataset
1) Plugins > napari-PHILOW > Annotation Mode
2) Select original dir : all slices must be in separate PNG and must be sequentially numbered (e.g. 000.png, 001.png ...)
3) Select mask dir : To resume from the middle of the annotation, specify here the name of the directory containing the mask image. The directory must contain the same number of files with the same name as the original image. 
 If you are starting a completely new annotation, you do not need to specify a directory. The directory for mask is automatically created and blank images are generated and stored.
4) Enter a name for the label or model you want to create (e.g. mito, cristae, ...) 
This name will be used as the directory name of the newly created mask dir if no mask dir is specified, 
and as the name of the csv file for training dataset management.
5) Check if you want to create new dataset (new model)
When checked, if there is already a csv file for training dataset management, a new csv file with one sequential number will be generated.
6) Start tracing
create labels
Create a label with the brush function.
more information → https://napari.org/tutorials/fundamentals/labels.html
Orthogonal view
If you want to see orthogonal view, click on the location you want to see while holding down the Shift button.  
The image from xy, yz, and zx will be displayed on the right side of the screen.
Low confident layer
If you are in the second iteration and you are loading the prediction results, you will see a low confidence layer.  
This shows the area where the confidence of the prediction result is low.  
Use this as a reference for correction.   
Small object layer
We provide a small object layer to find small painted areas. 
This is a layer for displaying small objects. 
The slider widget on the left allows you to change the maximum object size to be displayed.   
save labels
If you want to save your label, click the "save" button on the bottom right.
select training dataset
We are providing a way to manage the dataset for use in training. 
If you want to use the currently displayed slice as your training data, click the 'Not Checked' button near the center left to display 'Checked'.
Train and pred with your gpu machine
Train
To train on your GPU machine (or with CPU), 
1) Plugins > napari-PHILOW > Trainer
2) Select original dir : all slices must be in separate PNG and must be sequentially numbered (e.g. 000.png, 001.png ...)   
3) Select labels dir : all label images should be named same as original images and contains data management csv file   
4) Select dir for save trained model   
5) Click on the "start training" button   
6) Dice score and dice loss are displayed. For more detail, check the command line for the progress of training. If you want to stop in the middle, click stop button.   
Predict
To predict labels on your machine,  
1) Plugins > napari-PHILOW > Predicter
2) Select original dir : all slices must be in separate PNG and must be sequentially numbered (e.g. 000.png, 001.png ...)   
3) (Optional) Select labels dir if you want to keep labels witch were used on training, and data management csv file   
4) Select model dir contains hdf5 file   
5) Select output dir for predicted labels   
6) Uncheck the box if you DO NOT want to use TAP (Three-Axis-Prediction)   
7) Click on the "predict" button  
8) Check the command line for the progress of prediction. If you want to stop in the middle, use ctrl+C.   
9) You can start the next round of annotation by selecting the merged_prediction directory as the mask dir in Annotation mode.
Train and predict with Google Colab
If you don't have a GPU machine, you can use Google Colab to perform GPU-based training and prediction for free.    
1) Open train and predict notebook and click "Open in Colab" button
2) You can upload your own dataset to train and predict, or try it on demo data   
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the GNU GPL v3.0 license,
"napari-PHILOW" is free and open source software
Issues
If you encounter any problems, please [file an issue] along with a detailed description.
Authors 
Shogo Suga 
Hiroki Kawai 
Yusuke Hirabayashi 
How to Cite 
Shogo Suga, Koki Nakamura, Bruno M Humbel, Hiroki Kawai, Yusuke Hirabayashi, An interactive deep learning-based approach reveals mitochondrial cristae topologies
https://doi.org/10.1101/2021.06.11.448083
@article {Suga2021.06.11.448083,
    author = {Suga, Shogo and Nakamura, Koki and Humbel, Bruno M and Kawai, Hiroki and Hirabayashi, Yusuke},
    title = {An interactive deep learning-based approach reveals mitochondrial cristae topologies},
    elocation-id = {2021.06.11.448083},
    year = {2021},
    doi = {10.1101/2021.06.11.448083},
    publisher = {Cold Spring Harbor Laboratory},
    URL = {https://www.biorxiv.org/content/early/2021/06/11/2021.06.11.448083},
    eprint = {https://www.biorxiv.org/content/early/2021/06/11/2021.06.11.448083.full.pdf},
    journal = {bioRxiv}
}

napari-PHILOW

PHILOW is an interactive deep learning-based platform for 3D datasets

Sylvain Prigent

Description
The STracking suite provides a set of plugins for particles tracking in 2D+t and 3D+t images. 
A classical particles tracking pipeline is made of 5 sequential steps:



A full documentation is available here 
Installation
You can install napari-stracking via pip:
pip install napari-stracking

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-tracks-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-stracking

Talley Lambert

napari-manual-transforms





Interface to manually edit layer affine transforms.

express rotations as quaternion, euler angle, or axis + angle.
allows rotation around arbitrary origin
currently, focusing on rigid rotations
Alt-Drag to rotate a layer independently of the rest.
image resampling (i.e. "apply" the transformation to create new dataset that can be saved)


caveats:

only works on 3D Image layers for now, open a feature request for other dims/layers.
will likely result in "Non-orthogonal slicing is being requested" warnings in 2D view.

Try it out
```python
import napari
v = napari.Viewer()
v.dims.ndisplay = 3
v.open_sample('napari', 'cells3d')
v.window.add_plugin_dock_widget('napari-manual-transforms')
napari.run()
```

Installation
You can install napari-manual-transforms via pip:
sh
pip install napari-manual-transforms
To install latest development version :
sh
pip install git+https://github.com/tlambert03/napari-manual-transforms.git
License
Distributed under the terms of the BSD-3 license,
"napari-manual-transforms" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-manual-transforms

Interface to manually edit layer affine transforms

Nathan Heath Patterson

napari-wsireg
Plugin to perform whole slide image registration based on wsireg.
Please see wsireg for more info image formats, features and how registration works.
Usage
Add images from napari layers or from file and set up "registration paths" between them. OME-TIFF is best supported format.
Installation
You can install napari-wsireg via pip:
pip install napari-wsireg

To install latest development version :
pip install git+https://github.com/nhpatterson/napari-wsireg.git

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-wsireg" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-wsireg

plugin to perform whole slide image registration with wsireg

Ervin Tasnadi

napari_nucleaizer






GUI for the nucleaAIzer method in Napari.

Overview
This is a napari plugin to execute the nucleaizer nuclei segmentation algorithm.
Main functionalities
Using this plugin will be able to

Load your image into Napar, then outline the nuclei.
Specify an image folder containing lots of images and an output folder, and automatically segment all of the images in the input folder.
If you are not satisfied with the results, you can train your own model:
You can use our pretrained models and fine tune them on your data.
You can skip the nucleaizer pipeline and train only on your data.



Supported image types
We have several pretrained models for the following image modelities:
* fluorescent microscopy images
* IHC stained images
* brightfield microscopy images,
among others. For the detailed descriptions of our models, see: https://zenodo.org/record/6800341.
How it works?
For the description of the algorithm, see our paper: "Hollandi et al.: nucleAIzer: A Parameter-free Deep Learning Framework for Nucleus Segmentation Using Image Style Transfer, Cell Systems, 2020. https://doi.org/10.1016/j.cels.2020.04.003"
The original code (https://github.com/spreka/biomagdsb) is partially transformed into a python package (nucleaizer_backend) to actually perform the operations. See the project page of the backend at: https://github.com/etasnadi/nucleaizer_backend.
If you wish to use the web interface, check: http://nucleaizer.org.


Install


Create an environment (recommended).


Install napari: pip install "napari[pyqt5]". Other methods: https://napari.org/tutorials/fundamentals/installation.html


Install the plugin into napari:


User mode from PyPI: start Napari (command line: napari) and select he Install/Uninstall Plugins... under the Plugins menu. In the popup, filter for napari-nucleaizer.


Developer mode: clone this project and use pythhon3 -m pip install -e <path> to install the project locally into the same evnrionment as napari. It has the advantage that you will have the latest version.


Run


Start Napari by calling napari from the command line.

Then, activate the plugin in the Plugins menu. If you successfully installed the plugin, you have to see something like this:


Further help
See the documentation (work in progress).
Issues
Use the github issue tracker if you experinece unexpected behaviour.
Contact
You can contact me in e-mail where MY-INSTITUTE is brc.hu.

napari-nucleaizer

A GUI interface for training and prediction using the nucleAIzer nuclei detection method.

Draga Doncila Pop

What is this?
This plugin was created to serve as a semi-meaningful example of a plugin using
the new napari npe2 architecture.
It provides a reader, a writer and two dock widgets to support opening, processing
and writing out cell tracking challenge data.
We've provided comments and example tests that can be used as a reference
when building your own plugin.
Using this plugin
Sample Data
You can download sample data for this plugin from the tracking challenge website. Any 2D+T
sequence should work, but this plugin has been tested only with the 
Human hepatocarcinoma-derived cells expressing the fusion protein YFP-TIA-1 
dataset.
Reading Data
This plugin's reader is designed for tracking challenge segmentation gold standard ground truth
data conforming to the file format described in the data specification.
Ground truth data is only provided for a subset of the frames of the entire sequence. This
reader will attempt to find the number of frames of the associated sequence in a sister
directory of the ground truth data directory and open a labels layer with the same number
of frames, thus ensuring the labelled data is correctly overlaid onto the original sequence.
https://user-images.githubusercontent.com/17995243/146114062-36124c05-f44a-488e-8991-f39a702c917f.mov
Segmenting Data
One of the dock widgets provided by this plugin is "Segment by Threshold". The widget
allows you to select a 2D+T image layer in the viewer (e.g. any of the sequences in the Human 
hepatocarcinoma dataset above) and segment it using a selection of scikit-image thresholding functions.
The segmentation is then returned as a Labels layer into the viewer.
https://user-images.githubusercontent.com/17995243/146114088-f6fb645e-8d78-4880-827b-2f0334dad859.mov
Highlighting Segmentation Differences
The second dock widget provided by this plugin allows you to visually compare your segmentation
against the ground truth data by computing the difference between the two and adding this as a
layer in the napari viewer.
To use this widget, open it from the Plugins menu and select the two layers you wish to compare.
https://user-images.githubusercontent.com/17995243/146114112-c891723f-8640-4708-8014-c78731fb3396.mov
Writing to Zip
Finally, you can save your segmentation to a zip file whose internal directory structure
will closely mimic that of the tracking challenge datasets, so that it may be opened 
again in the viewer.
To save your layer, choose File -> Save selected layer(s) with one labels layer selected,
then select label zipper from the dropdown choices.
https://user-images.githubusercontent.com/17995243/146114163-ee886990-979c-4756-97c5-aaf2c39dccde.mov

workshop-demo

A demo napari plugin incorporating reader, writer and dock widget contributions using the new npe2 plugin architecture.

Robert Cudmore

napari-layer-table









A plugin to display a layer as a table.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-layer-table via pip:
pip install napari-layer-table

To install latest development version :
pip install git+https://github.com/mapmanager/napari-layer-table.git

Using the Plugin
You can use the napari-layer-table plugin to display points layer as a table.

Open a napari viewer with a Points layer
Add the plugin to the napari viewer from Plugins menu -> Add dock widget -> napari-layer-table: Points Table
The selected layer is displayed in the table.
The table has columns for:
Point symbol with face color
Point coordinates (x,y,z)
If the layer has properties, they are also shown as columns




Plugin Features

Bi-directional selection between layer and table.
Bi-directional deletion between layer and table.
Points added to the layer are added to the table.
Points moved in the layer are updated in the table.
Multiple points selected in the layer are also selected in the table
Changes to face color and symbol in the layer are updated in the table.
Ability to sort individual columns from low to high or high to low
Refresh button to manually refresh the table data
btf button to manually bring the layer whose table data is being shown to front

Right-click for context menu to:

Toggle table columns on/off.
Toggle shift+click to add a point to the layer (no need to switch viewer mode)
Copy table to clipboard

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the GNU GPL v3.0 license,
"napari-layer-table" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-layer-table

Robert Haase

napari-segment-blobs-and-things-with-membranes (nsbatwm)







This napari-plugin is based on scikit-image and allows segmenting nuclei and cells based on fluorescence microscopy images with high intensity in nuclei and/or membranes.
Usage
This plugin populates image processing operations to the Tools menu in napari.
You can recognize them with their suffix (nsbatwm) in brackets.
Furthermore, it can be used from the napari-assistant graphical user interface. 
Therefore, just click the menu Tools > Utilities > Assistant (na) or run naparia from the command line.

You can also call these functions as shown in the demo notebook.
Voronoi-Otsu-Labeling
This algorithm uses Otsu's thresholding method in combination with 
Gaussian blur and a 
Voronoi-Tesselation 
approach to label bright objects such as nuclei in an intensity image. The alogrithm has two sigma parameters which allow
you to fine-tune where objects should be cut (spot_sigma) and how smooth outlines should be (outline_sigma).
This implementation aims to be similar to Voronoi-Otsu-Labeling in clesperanto.

Seeded Watershed
Starting from an image showing high-intensity membranes and a seed-image where objects have been labeled (e.g. using Voronoi-Otsu-Labeling),
objects are labeled that are constrained by the membranes.

Seeded Watershed with mask
If there is additionally a mask image available, one can use the Seeded Watershed with mask, to constraint the flooding 
on a membrane image (1), starting from nuclei (2), limited by a mask image (3) to produce a cell segmentation within the mask (4).

Seeded Watershed using local minima as starting points
Similar to the Seeded Watershed and Voronoi-Otsu-Labeling explained above, you can use this tool to segment an image
showing membranes without an additional image showing nuclei. The two sigma parameters allow to fine tune how close 
objects can be and how precise their boundaries are detected.

Gaussian blur
Applies a Gaussian blur to an
image. This might be useful for denoising, e.g. before applying the Threshold-Otsu method.

Subtract background
Subtracts background using scikit-image's rolling-ball algorithm. 
This might be useful, for example to make intensity of membranes more similar in different regions of an image.

Threshold Otsu
Binarizes an image using scikit-image's threshold Otsu algorithm, also known as 
Otsu's method.

Split touching objects (formerly known as binary watershed).
In case objects stick together after thresholding, this tool might help.
It aims to deliver similar results as ImageJ's watershed implementation.

Connected component labeling
Takes a binary image and produces a label image with all separated objects labeled differently. Under the hood, it uses
scikit-image's label function.

Manual split and merge labels
Split and merge labels in napari manually via the Tools > Utilities menu:


This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Installation
You can install napari-segment-blobs-and-things-with-membranes using conda and pip.
If you have never used conda before, please go through this tutorial first.
conda install -c conda-forge napari
pip install napari-segment-blobs-and-things-with-membranes

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-segment-blobs-and-things-with-membranes" is free and open source software
Issues
If you encounter any problems, please create a thread on image.sc along with a detailed description and tag @haesleinhuepf.

napari-segment-blobs-and-things-with-membranes

A plugin based on scikit-image for segmenting nuclei and cells based on fluorescent microscopy images with high intensity in nuclei and/or membranes

Hippolyte Verdier

Palmari





A processing pipeline for PALM movies analysis (pre-processing, localization, drift correction, tracking).
Check out the documentation to get started.


This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install palmari via pip:
pip install palmari

To install latest development version :
pip install git+https://github.com/hippover/palmari.git

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the CeCILL license.
Issues
If you encounter any problems, please file an issue along with a detailed description.

palmari

A pipeline for PALM movies analysis (pre-processing, localization, drifft correction, tracking)

Carsen Stringer

cellpose-napari 











a napari plugin for anatomical segmentation of general cellular images

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
The plugin code was written by Carsen Stringer, and the cellpose code was written by Carsen Stringer and Marius Pachitariu. To learn about Cellpose, read the paper or watch this talk. 
For support with the plugin, please open an issue. For support with cellpose, please open an issue on the cellpose repo. 
If you use this plugin please cite the paper:
::
  @article{stringer2021cellpose,
  title={Cellpose: a generalist algorithm for cellular segmentation},
  author={Stringer, Carsen and Wang, Tim and Michaelos, Michalis and Pachitariu, Marius},
  journal={Nature Methods},
  volume={18},
  number={1},
  pages={100--106},
  year={2021},
  publisher={Nature Publishing Group}
  }


Installation
Install an Anaconda distribution of Python -- Choose Python 3 and your operating system. Note you might need to use an anaconda prompt if you did not add anaconda to the path.
Install napari with pip: pip install napari[all]. Then install cellpose-napari via [pip]:
pip install cellpose-napari

Or install the plugin inside napari in the plugin window.
If install fails in your base environment, create a new environment:
1. Download the environment.yml file from the repository. You can do this by cloning the repository, or copy-pasting the text from the file into a text document on your local computer.
2. Open an anaconda prompt / command prompt with conda for python 3 in the path
3. Change directories to where the environment.yml is and run conda env create -f environment.yml
4. To activate this new environment, run conda activate cellpose-napari
5. You should see (cellpose-napari) on the left side of the terminal line. 
If you have issues with cellpose installation, see the cellpose docs for more details, and then if the suggestions fail, open an issue.
Upgrading software
You can upgrade the plugin with
~~~
pip install cellpose-napari --upgrade
~~~
and you can upgrade cellpose with
~~~
pip install cellpose --upgrade
~~~
GPU version (CUDA) on Windows or Linux
If you plan on running many images, you may want to install a GPU version of torch (if it isn't already installed).
Before installing the GPU version, remove the CPU version:
~~~
pip uninstall torch
~~~
Follow the instructions here to determine what version to install. The Anaconda install is recommended along with CUDA version 10.2. For instance this command will install the 10.2 version on Linux and Windows (note the torchvision and torchaudio commands are removed because cellpose doesn't require them):
~~~
conda install pytorch cudatoolkit=10.2 -c pytorch
~~~~
When upgrading GPU Cellpose in the future, you will want to ignore dependencies (to ensure that the pip version of torch does not install):
~~~
pip install --no-deps cellpose --upgrade
~~~
Installation of github version
Follow steps from above to install the dependencies. In the github repository, run pip install -e . and the github version will be installed. If you want to go back to the pip version of cellpose-napari, then say pip install cellpose-napari.
Running the software
Open napari with the cellpose-napari dock widget open
napari -w cellpose-napari
There is sample data in the File menu, or get started with your own images!
Detailed usage documentation.
Contributing
Contributions are very welcome. Tests are run with pytest.
License
Distributed under the terms of the BSD-3 license,
"cellpose-napari" is free and open source software.
Dependencies
cellpose-napari relies on the following excellent packages (which are automatically installed with conda/pip if missing):
- napari
- magicgui
cellpose relies on the following excellent packages (which are automatically installed with conda/pip if missing):
- torch
- numpy (>=1.16.0)
- numba
- scipy
- natsort
- tifffile
- opencv

cellpose-napari

a generalist algorithm for anatomical segmentation

jhnnsrs

faser

Kunal Pandit

napari-PICASSO






Unmix spectral spillover

Automatic Usage
You can find the PICASSO plugin in the menu Plugins > napari-PICASSO: PICASSO. Select sink images that have spectral spillover from corresponding source images, then click run to optimise the mixing parameters with PICASSO. 
Manual Usage

Select the manual button in options pop up window. Then select sink images that have spectral spillover from corresponding source images. In the source images window, sliders for each $source$ control the mixing spillover, $m$ (top), and background, $b$ (bottom, optional).
Mixing model
$$ sink = \sum_{i} m_i(source - b_i) $$
Installation
You can install napari-PICASSO via pip:
pip install napari-PICASSO

Details
napari-PICASSO is a napari widget to blindly unmix fluorescence images of known members using PICASSO1. 
For example, if 2 fluorophores with overlapping spectra are imaged, spillover fluorescesce from a channel into an adjacent channel could be removed if you know which channel is the source of the spillover fluorescence and which channel is the sink of the spillover fluorescence. 
PICASSO is an algorithm to remove spillover fluorescence by minimizing the mutual information between sink and source images. The original algorithm described by Seo et al, minimized the mutual information between pairs of sink and source images using a Nelson-Mead simplex algorithm and computing the mutual information outright with custom written MATLAB code1. The napari plugin uses a neural net to estimate and minimize the mutual information (MINE2) between pairs of sink and source images using stochastic gradient descent with GPU acceleration.
References

Seo, J. et al. PICASSO allows ultra-multiplexed fluorescence imaging of spatially overlapping proteins without reference spectra measurements. Nat Commun 13, 2475 (2022).
Belghazi, M. I. et al. MINE: Mutual Information Neural Estimation. arXiv:1801.04062 [cs, stat] (2018).


napari-PICASSO

napari-accelerated-pixel-and-object-classification (APOC)








clesperanto meets scikit-learn to classify pixels and objects in images, on a GPU using OpenCL in napari.

The processed example image was kindly acquired by Daniela Vorkel, Myers lab, MPI-CBG / CSBD (Download full video)
For using the accelerated pixel and object classifiers in python, check out apoc.
Training classifiers from pairs of image and label-mask folders is explained in 
this notebook.
For executing APOC classifiers in Fiji using clij2 please read the documentation of the corresponding Fiji plugin.

Usage
Object and Semantic Segmentation
Starting point is napari with at least one image layer and one labels layer (your annotation).

You find Object and Semantic Segmentation in the Tools > Segmentation / labeling. When starting those, the following graphical user interface will show up.


Choose one or multiple images to train on. These images will be considered as multiple channels. Thus, they need to be spatially correlated. 
   Training from multiple images showing different scenes is not (yet) supported from the graphical user interface. Check out this notebook if you want to train from multiple image-annotation pairs.
Select a file where the classifier should be saved. If the file exists already, it will be overwritten.
Select the ground-truth annotation labels layer. 
Select which label corresponds to foreground (not available in Semantic Segmentation)
Select the feature images that should be considered for segmentation. If segmentation appears pixelated, try increasing the selected sigma values and untick Consider original image.
Tree depth and number of trees allow you to fine-tune how to deal with manifold regions of different characteristics. The higher these numbers, the longer segmentation will take. In case you use many images and many features, high depth and number of trees might be necessary. (See also max_depth and n_estimators in the scikit-learn documentation of the Random Forest Classifier.
The estimation of memory consumption allows you to tune the configuration to your GPU-hardware. Also consider the GPU-hardware of others who want to use your classifier.
Click on Run when you're done with configuring. If the segmentation doesn't fit after the first execution, consider fine-tuning the ground-truth annotation and try again.

A successful segmentation can for example look like this:

After your classifier has been trained successfully, click on the "Application / Prediction" tab. If you apply the classifier again, python code will be generated. 
You can use this code for example to apply the same classifier to a folder of images. If you're new to this, check out this notebook.

A pre-trained classifier can be applied from scripts as shown in the example notebook or from the Tools > Segmentation / labeling > Object segmentation (apply pretrained, APOC).
Integration with the napari-assistant
Pre-trained models can also be assembled to workflows using the napari-assistant. You find APOC-operations in the categories Filter, Label and Label Filters:

Semantic segmentation
Users can also generate semantic segmentation label images where the label identifier corresponds to a class the pixel has been allocated to. 
The tool can be found in the menu Tools > Segmentation / labeling > Semantic segmentation (APOC).
It works analogously like the Object Segmenter, just without the need to specify the class identifier that objects correspond to.

Probability maps
The tool for generating probability maps (Tools > Filtering > Probability Mapper (APOC) menu) works analogously to the Object Segmenter as well. 
The only difference is that the result image is not a label image but an intensity image where the intensity represents the probability (between 0 and 1)
that a pixel belongs to a given class. In this example: The raw image (grey) has been annotated with three classes: background (black, label 1), foreground (white, label 2) and edges (grey, label 3).
The probability mapper was configured to create probability image (shown in green) for edges (label 3):

Classifier statistics
While training, you can also activate the Show classifier statistics checkbox. 
When doing so, it is recommended to increase the number of trees so that the measurements are more reliable, especially when selecting many features.
This will open a small table after training where you can see how large the share of decision trees are for each analysed feature image.

It is recommended to turn on/off the features that hold a very large share (green) or a very small share (magenta) of trees in the random forest. 
Retrain the classifier to see how the features influence the decision making.
Note: Multiple of these parameters may be correlated. 
If you select 11 feature images, which all allow to make the pixel classification similarly, but 10 of those are correlated, these 10 may appear with a share of about 0.05 while the 11th parameter has a share of 0.5. 
Thus, study these values with care.
Object classification
Click the menu Tools > Segmentation post-processing > Object classification (APOC). 

This user interface will be shown:


The image layer will be used for intensity based feature extraction (see below).
The labels layer should be contain the segmentation of objects that should be classified. 
   You can use the Object Segmenter explained above to create this layer.
The annotation layer should contain manual annotations of object classes. 
   You can draw lines crossing single and multiple objects of the same kind. 
   For example draw a line through some elongated objects with label "1" and another line through some rather roundish objects with label "2".
   If these lines touch the background, that will be ignored.
Tree depth and number of trees allow you to fine-tune how to deal with manifold objects of different characteristics. The higher these numbers, the longer classification will take. In case you use many features, high depth and number of trees might be necessary. (See also max_depth and n_estimators in the scikit-learn documentation of the Random Forest Classifier.
Select the right features for training. For example, for differentiating objects according to their shape as suggested above, select "shape".
   The features are extracted using clEsperanto and are shown by example in this notebook.
Click on the Run button. If classification doesn't perform well in the first attempt, try changing selected features.  

If classification worked well, it may for example look like this. Note the two thick lines which were drawn to annotate elongated and roundish objects with brown and cyan:

A pre-trained model can later be applied from scripts as shown in the example notebook or using the menu Tools > Segmentation post-processing > Object classification (apply pretrained, APOC).
Feature correlation matrix
When training object classifiers it is crucial to investigate to which degree features are correlated and select the right, ideally uncorrelated features to classify objects robustly.
After measuring features with any compatible napari plugin listed below, you can visualize the feature correlation matrix using the menu Tools > Measurement > Show feature correlation matrix (pandas, APOC) and by selecting the labels layer which has been analyzed.
Before computing the correlation matrix, all rows containing NaN values are removed.
For further details, please refer to the documentation of the underlying function in pandas.

Classifier statistics
After classifier training, you can study the share of the individual features/measurements and how they are correlated by activating the checkboxes Show classifier statistics and Show feature correlation matrix.

This can help understanding how the classifier works. Furthermore, you can accelerate the classifier by reducing the number of correlated features.
Object classification from custom measurements
You can also classify labeled objects according to custom measurements. For deriving those measurements, you can use these napari plugins:

morphometrics
PartSeg
napari-simpleitk-image-processing
napari-cupy-image-processing
napari-pyclesperanto-assistant
napari-skimage-regionprops

Furthermore, if you use napari from Python, you can also create a dictionary or pandas DataFrame with measurements and store it in the labels_layer.features to make them available in the object classifier.
After labels have been measured, you can start the Object Classifier (custom properties, APOC) from the Tools > Segmentation post-processing menu:


Select the labels layers that has been measured.
The annotation layer should contain manual annotations of object classes. 
   You can draw lines crossing single and multiple objects of the same kind. 
   For example draw a line through some elongated objects with label "1" and another line through some rather roundish objects with label "2".
   If these lines touch the background, that will be ignored.
Select the measurements / features that should be used for object classification.
Use the Update Measurements button in case you did new measurements after Object classifier dialog was opened.
Enter the filename of the classifier to be trained here. This file will be overwritten in case it existed already.
Tree depth and number of trees allow you to fine-tune how to deal with manifold objects of different characteristics. The higher these numbers, the longer classification will take. In case you use many features, high depth and number of trees might be necessary. (See also max_depth and n_estimators in the scikit-learn documentation of the Random Forest Classifier.
The classification result will be stored under this name in the labels-layer's properties.
Choose if the results table should be shown. Choose if classifier statistics should be shown. Read more about classifier statistics.
Click on Run to start training and prediction.

You can also train those classifiers from Python and reuse them: Read more about using the TableRowClassifier from python
Classifier statistics and correlation matrix
After classifier training, you can study the share of the individual features/measurements and how they are correlated by activating the checkboxes Show classifier statistics and Show correlation matrix.

This can help understanding how the classifier works. Furthermore, you can accelerate the classifier by reducing the number of correlated features.

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Installation
It is recommended to install the plugin in a conda environment. Therefore install conda first, e.g. mini-conda.
If you never worked with conda before, reading this short introduction might be helpful.
Optional: Setup a fresh conda environment, activate it and install napari:
conda create --name napari_apoc python=3.9
conda activate napari_apoc
conda install napari
If your conda environment is set up, you can install napari-accelerated-pixel-and-object-classification using pip. Note: you need pyopencl first.
conda install -c conda-forge pyopencl
pip install napari-accelerated-pixel-and-object-classification
Mac-users please also install this:
conda install -c conda-forge ocl_icd_wrapper_apple

Linux users please also install this:
conda install -c conda-forge ocl-icd-system

Contributing
Contributions, feedback and suggestions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
Similar napari plugins
There are other plugins with similar functionality for interactive classification of pixels and objects.

napari-feature-classifier

License
Distributed under the terms of the BSD-3 license,
"napari-accelerated-pixel-and-object-classification" is free and open source software
Issues
If you encounter any problems, please open a thread on image.sc along with a detailed description and tag @haesleinhuepf.

napari-accelerated-pixel-and-object-classification

Pixel and label classification using OpenCL-based Random Forest Classifiers

Chi-Li Chiu

napari-bio-sample-data




a sample data plugin for bio-related demos

This plugin contains 5 sample datasets with additional napari layer types:
(1) 3D EM dataset (image + points + vectors)
Image credit: Alister Burt
The original data is down-sampled to have smaller file size.

(2) 2D skin RGB dataset (image + shape)
Image credit: skimage.data.skin

(3) 3D nuclei dataset (image + label + surface)
Image credit: skimage.data.cells3d

(4) 2D timelapse dataset (image + points + tracks)
Image credit: Cell Tracking Challenge
The original data is cropped to have smaller file size.

(5) large multi-resolution 3D EM dataset
Image credit: Janelia Open Organelle 
This plugin only accesses 2 lower resolution levels.

Datasets (1)-(4) are stored locally. 
Dataset (5) is downloaded and temporarily stored on RAM when accessed.    
This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-bio-sample-data via pip:
pip install napari-bio-sample-data

To install latest development version :
pip install git+https://github.com/chili-chiu/napari-bio-sample-data.git

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-bio-sample-data" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-bio-sample-data

a sample data plugin for bio-related demos

A library for working with light sheet imaging data of developing embryos acquired using ClearControl at the Center for Systems Biology Dresden, e.g. Tribolium castaneum.
Installation
conda install -c conda-forge pyopencl
pip install beetlesafari

beetlesafari

A napari plugin for loading and working with light sheet imaging data of developing embryos acquired using ClearControl, e.g. _Tribolium castaneum_.

Tristan Cotte

napari-IDS




A simple plugin to use with napari

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-IDS via pip:
pip install napari-IDS

To install latest development version :
pip install git+https://github.com/githubuser/napari-IDS.git

First utilisation
Suggested environment : 
- Python 3.8
- IDS 1.2.0.5 version installed
To use this package for the first time :
1. Install Napari pip install "napari[all]"
2. Install napari-IDS package
3. Install IDS Python api thanks to the command ids_packages
If your environment is not the suggested environment, you have to install IDS packages manually. 
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-IDS" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-IDS

Plug in which enables to take photo with IDS uEye camera

Tom Burke

napari-labeling






This is a napari-plugin based on the labeling project.
It allows the generation of overlapping labels in one layer, save and load of this layer in a json-based file format and
it contains a widget to explore the overlapping labels layer and select specific segments with a mouse click .
Please note that currently, the widget part only works by adding it through code with:
from napari_labeling import edit_widget
viewer = napari.Viewer()
viewer.window.add_dock_widget(edit_widget)

An example on how to achieve this can be found in the main.py on GitHub.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-labeling via pip:
pip install napari-labeling

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-labeling" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-labeling

A napari plugin for handling overlapping labeling data

Lennart Kowitz

vessel-express-napari






A simple plugin for 3D vessel segmentation of LSFM images
This napari plugin can be used to optimize the segmentation parameters for the main VesselExpress software platform.

Installation
The easiest way to install the plugin is to open napari, go to Plugins, then Install/Uninstall plugins. You will be able to find the plugin by name "vessel-express-napari". 
Or, you can install vessel-express-napari via pip:
pip install vessel-express-napari

To install latest development version :
pip install git+https://github.com/MMV-Lab/vessel-express-napari.git

Documentation
We provide a quick start guide to explain the important pieces of this plugin. Suggestions and feature quests are very welcomed. 
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"vessel-express-napari" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

vessel-express-napari

A simple plugin for 3D vessel segmentation

Joel Jonsson

napari-apr-viewer






A simple plugin to view APR images in napari

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.
Installation
You can install napari-apr-viewer via pip:
pip install napari-apr-viewer

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the Apache Software License 2.0 license,
"napari-apr-viewer" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-apr-viewer

A simple plugin to view APR images in napari

Chenqi Zhang

napari-aideveloper






napari_aideveloper is a napari-plugin derived from AIDeveloper that allows you to train, evaluate, and apply deep neural nets for image classification within a graphical user-interface (GUI).

Installation
You can install napari-aideveloper via pip:
pip install napari-aideveloper

Introduction
Main functions

Build
History


Build
1. Load data
Drag and drop your data in .rtdc (HDF5) format into the file table and set the class and training/validation.

2. Choose Neural Networks

3. Set model storage path

4. Start fitting


Preview image

Image augmentation


History
1. Load meta data

2. Check model details

3. Rolling median & Linear fit

Contributing
Contributions are very welcome. You can submit your pull request on GitHub. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-aideveloper" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

napari-aideveloper

napari_aideveloper is a napari-plugin deived from AIDeveloper that allows you to train, evaluate and apply deep neural nets for image classification within a graphical user-interface (GUI).

Geneva Schlafly

Amitabh Verma

Rudolf Oldenbourg


Deconvolves a 4D light field image into a full 3D focal stack reconstruction
https://user-images.githubusercontent.com/23206511/180571940-9500dd19-119b-4d0d-8b33-5ab1705e9b6f.mov
napari-LF provides three basic processes to Calibrate, Rectify, and Deconvolve light field images:
The Calibrate process generates a calibration file that represents the optical setup that was used to record the light field images. The same calibration file can be used to rectify and deconvolve all light field images that were recorded with the same optical setup, usually the same microscope and light field camera. The Calibrate process requires as input the radiometry frame, dark frame, optical parameters, and volume parameters to generate the calibration file, which is subsequently used to rectify and deconvolve related light field images. The calibration file includes a point spread function (PSF) derived from the optical and volume parameters and is stored in HDF5 file format.
The Rectify process uses the calibration file for an affine transformation to scale and rotate experimental light field images that were recorded with a light field camera whose microlens array was (slightly) rotated with respect to the pixel array of the area detector and whose pixel pitch is not commensurate with the microlens pitch. After rectification, the rectified light field has the same integer number of pixels behind each microlens. When the Deconvolve process is called for an experimental light field image, rectifying the light field image is automatically applied before the iterative deconvolution does begin. However, the rectified light field image is not saved and is not available for viewing. Therefore, by pushing the Rectify button in the middle of the napari-LF widget, only the rectification step is invoked and the rectified light field image is saved to the project directory.
The Deconvolve process uses the PSF and a wave optics model to iteratively deconvolve a light field image into a stack of optical sections.
The Parameter panels, located in the lower half of the napari-LF widget, allows the user to specify settings for the reconstruction process. Once the appropriate parameters are selected, the Calibrate button followed by the Deconvolve button can be pushed to complete the reconstruction.
Quickstart

Install the napari-LF plugin into your napari environment, as described below under Installation.
From the napari Plugins menu, select the napari-LF plugin to install its widget into the napari viewer
Near the top of the widget, select your project folder containing the following images: light field, radiometry, and dark frame.
Write the name of the metadata file you want for recording your reconstruction settings, e.g. metadata.txt. This file will be updated each time a calibration process is started.
Calibration
In the parameters panel, navigate to Calibrate, Required (top tab Calibrate, bottom tab Required), which is the default selection.
Select radiometry and dark frame images from pull down menus.
Write the name of the calibration file you would like to produce, e.g. calibration.lfc.
Enter the appropriate optical parameters according to your microscope and sample material.
Enter the volume parameters you would like for your 3D reconstuction.
Push the Calibrate button.


Deconvolution
In the parameters panel, navigate to Deconvolve, Required.
Select light field image and calibration file from pull down menus.
Write the name of the output image stack you would like to produce, e.g. output_stack.tif.
Push the Deconvolve button.
3D focal stack reconstruction will display in the napari viewer and be saved in your original project folder.



Getting Help
For details about each parameter, hover over each parameter textbox to read the tooltip description.
For additional information about the reconstruction process, see our User Guide along with our general documentation on GitHub.
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-LF" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-LF

Chris Wood

napari-nikon-nd2





Opens Nikon ND2 files into napari. This plugin uses the nd2reader and pims python packages. 

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-nikon-nd2 via pip:
pip install napari-nikon-nd2

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the Apache Software License 2.0 license,
"napari-nikon-nd2" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.
Credits
This napari plugin was created using Napari Delta Vision Reader and
the Allen Institute IO plugin as examples.

napari-nikon-nd2

Andrea Bassi

Mark Neil

napari-sim-processor






A Napari plugin for the reconstruction of Structured Illumination Microscopy (SIM) with GPU acceleration (pytorch/cupy if installed).
Currently supports:  
   - conventional SIM data with a generic number of angles and phases (typically, 3 angles and 3 phases are used for resolution improvement in 2D, but any combination can be processed by the widget)
   - hexagonal SIM data with 7 phases.
The SIM processing widget accepts image stacks organized in 5D (angle,phase,z,y,x).
The reshape widget can be used to easily reshape the data if they are not organized as 5D (angle,phase,z,y,x).
Currently only square images are supported (x=y)
For 3D stacks (raw images) with multiple z-frames, a batch reconstruction method is available, as described here:
    https://doi.org/10.1098/rsta.2020.0162
Support for 3D SIM with enhanced resolution in all directions is not yet available.
Multicolor reconstruction is not yet available.  

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-sim-processor via pip:
pip install napari-sim-processor

To install latest development version :
pip install git+https://github.com/andreabassi78/napari-sim-processor.git

Usage
1) Open napari. 
2) Launch the reshape and sim-processor widgets.
3) Open your raw image stack (using the napari built-in or your own file openers).

4) If your image is ordered as a 5D stack (angle, phase, z-frame, y, x) go to point 6. 
5) In the reshape widget, select the actual number of acquired angles, phases, and frames (red arrow) and press Reshape Stack.
 Note that the label axis of the viewer will be updated (green arrow).

6) In the sim-reconstruction widget press the Select image layer button. Note that the number of phases and angles will be updated (blue arrow). 
7) Choose the correct parameters of the SIM acquisition (NA, pixelsize, M, etc.) and processing parameters (alpha, beta, w, eta, group):
   - w: parameter of the Weiner filter.
   - eta: constant used for calibration. It should be slightly smaller than the carrier frequency (in pupil radius units).
   - group: for stacks with multiple z-frames, it is the number of frames that are used together for the calibration process.
For details on the other parameters see https://doi.org/10.1098/rsta.2020.0162.
8) Calibrate the SIM processor, pressing the Calibrate button. This will find the carrier frequencies (red circles if the Show Carrier checkbox is selected), the modulation amplitude and the phase, using cross correlation analysis.
9) Click on the checkboxes to show the power spectrum of the raw image (Show power spectrum) or the cross-correlation (Show Xcorr), to see if the found carrier frequency is correct.

Napari viewer showing the power spectrum of the raw stack. The pupil circle is in blue. A circle corresponding to eta is shown in green.

Napari viewer showing the cross-correlation of the raw stack. The red circles indicate the found carrier frequencies
10) Run the reconstruction of a single plane (SIM reconstruction) or of a stack (Stack reconstruction). After execution, a new image_layer will be added to the napari viewer. Click on the Batch reconstruction checkbox in order to process an entire stack in one shot. Click on the pytorch checkbox for gpu acceleration.

Napari viewer with widgets showing a pseudo-widefield reconstruction

Napari viewer with widgets showing a SIM reconstruction
GPU processing
The underlying processing classes will use numpy (and FFTW if available) for 
its calculations. For GPU accelerated processing you need to have either the 
PyTorch (tested with torch v1.11.0+cu113) or the CuPy (tested with cupy-cuda113 
v10.4.0) package installed.  Make sure to match the package cuda version to the CUDA library 
installed on your system otherwise PyTorch will default to CPU and CuPy will not work at all.  
Both packages give significant speedup on even relatively modest CUDA GPUs compared 
to Numpy, and PyTorch running on the CPU only can show improvements relative to numpy 
and FFTW. Selection of which processing package to use is via a ComboBox in the 
napari_sim_processor widget.  Only available packages are shown. 
Other than requiring a CUDA GPU it is advisable to have significant GPU memory 
available, particularly when processing large datasets.  Batch processing is the 
most memory hungry of the methods, but can process 280x512x512 datasets on a 4GB GPU.
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-sim-processor" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-sim-processor

A plugin to process Structured Illumination Microscopy data with gpu acceleration

Alan M Watson

Description
This plugin enables viewing of Bitplane Imaris files, including very large datasets.  The GIFs below demonstrate rendering of a ~2TB IMS file containing a 2 color whole mouse brain.  The plugin has been tested on datasets as large as 20TB.
NOTE: For this plugin to work "File/Preferences/Experimental/Render Images Asynchronously" must be selected.
Open IMS file:

Render in 3D:
A plugin is provided to dynamically reload the data after selecting the lowest resolution level to be included in the viewer.  Since napari only renders the lowest resolution, the user can use this plugin to control the quality of 3D rendering.  See features and limitations for tips on suggested usage.

Features

Multiscale Rendering
Image pyramids which are present in the native IMS format are automatically added to napari during file loading.
Chunks are implemented by dask and matched to the chunk sizes stored in each dataset.  (Napari appears to only ask for 2D chunks - unclear how helpful this feature is currently)
Successfully handles multi-terabyte multi-timepoint multi-channel datasets.
Tested with all sample files provided by Bitplane.
Higher 3D rendering quality is enabled by a widget that reloads data after specifying the lowest resolution level (higher number = lower resolution) to be included in the multiscale series.

Known Issues / limitations

Currently, this is only an image loader, and there are no features for loading or viewing objects
Napari sometimes throws errors indicating that it expected a 3D or 5D array but receives the other.
This sometimes but relatively rarely causes napari to crash
Would like to enable Asynchronous Tiling of Images, but this results in more instability and causes crashes.


This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-imaris-loader via pip:
pip install napari-imaris-loader

Change Log:
v0.1.2:
Fixed: Issue where .ims files containing a single color 2D image would not open.
Fixed: Issue where using the widget to change resolutions while in 3D rendering would cause a crash.  Now the viewer is automatically forced into 2D rendering mode when the widget is used.
Dependency change: The loader is now dependent in a separate package for loading IMS files.  https://pypi.org/project/imaris-ims-file-reader/
v0.1.3:
Documentation
v0.1.4:
Add napari to install requirements for plugin compatibility
v0.1.5:
Changes to napari:

now requires napari[all] upon install.
requires >=v0.1.5 of imaris-ims-file-reader

v0.1.6:

Fix issue #7 where contrastLimits possibly unbound in reader

v0.1.7:

For squeeze_output=False when opening .ims file for Napari compatibility

v0.1.8:

Add automatic determination of contrast_limits
Fix bug in squeeze_output

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-imaris-loader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-imaris-loader

Napari plugin for loading Bitplane imaris files '.ims'

This plugin implements various methods to reconstruct high resolution images for the Airyscan 
microscope raw data 
Description
Airyscan raw images are confocal images obtained from 32 sub-detectors. Several methods can be used
to reconstruct a high resolution image from these 32 sub-detectors images. This plugin implements
the following methods:
- Pseudo-confocal: creates a pseudo confocal image by summing 7, 19 or 19 detectors
- ISM: creates a higher resolution image by summing the images from the 32 sub-detectors after 
co-registering all the images to the central detector. A deconvolution algorithm can be applied in 
post-processing to gain more resolution
- IFED: reconstructs a high resolution image by subtracting the outer ring detector to the central 
detector. This method can be interpreted as a 'virtual STED'
- ISFED: reconstructs a high resolution image by combining the co-registered detectors images and the
raw detectors images   
- Join deconvolution: reconstructs a high resolution image by jointly deblurring all 32 detectors 
with a variational approach.

Intended Audience & Supported Data
Supported data are raw images from the Airyscan microscope. These images must be stacks of 32 
layers corresponding to the 32 detectors. The Airyscan reader plugin can open .czi raw files. Data
can also be stored in any format that napari can open. 
Quickstart

Open the sample image from the menu File > Open samples > napari-sairyscan > SAiryscan




Open the SAiryscan plugin from the menu Plugins > napari-sairyscan: Airyscan reconstruction




We select the join deconvolution method and run it with the default parameters. Default parameters
are optimized for the sample image:


Getting Help
For any bug report or feature request please file an issue
How to Cite
If you use this plugin please cite the paper:
@INPROCEEDINGS{9054640,
author={Prigent, Sylvain and Dutertre, Stephanie and Kervrann, Charles},
booktitle={ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)}, 
title={Empirical Sure-Guided Microscopy Super-Resolution Image Reconstruction from Confocal Multi-Array Detectors}, 
year={2020},
volume={},
number={},
pages={1075-1079},
doi={10.1109/ICASSP40776.2020.9054640}}


napari-sairyscan

Alexis Japas

napari-vesicles-segmentation






A simple plugin to detect vesicles in cells images.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-vesicles-segmentation via pip:
pip install napari-vesicles-segmentation

To install latest development version :
pip install git+https://github.com/alexisjapas/napari-vesicles-segmentation.git

Usage

Open napari
Open your data

Launch the vesicles-segmentation plugin
Select the data you want to segment and set the parameters of the segmentation

image: The image to segment vesicles in. The image can be a 2D or 3D temporal stack of images.
minimum vesicles size: The minimum size of the vesicles to detect. Smaller detected vesicles are removed.
membrane erosion: The size of the disk radius used for eroding the cell. This is used to remove the external membrane. This parameter scales when downsizing the image, for more information see 'downsizing ratio' parameter.
closing size: The size of the disk radius used for closing the cell. This is used to fill holes in the cell. This parameter scales when downsizing the image, for more information see 'downsizing ratio' parameter.
clip: If set to zero, no standardization is performed. Otherwise, the standard deviation of the image is set to n_sigma * the standard deviation of the image, the image is standardized and its values are clipped to the range [-1, 1] in order to remove outliers. The higher the value of n_sigma, the less outliers are removed. This operation can lead to a better detection of the cell.
downsampling ratio: The downsampling ratio used for the downsampled image. This is used to speed up the computation. Downsampling the image have impact in reducing the resolution of erosion and closing e.g. for a downsize ratio of 2, setting the erosion size to 3 will result in an erosion size of 6.
display cell detection: If set to True, the cell detection is displayed in the viewer instead of the vesicle detection.


Click on the "Segment" button to start the segmentation. This can take few seconds or minutes depending on the size of the data. The result is added to the viewer as below.


Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-vesicles-segmentation" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-vesicles-segmentation

A simple plugin to detect vesicles in cells images.

Gursharan Ahir

Ryan Thiermann

napari-mm3






A plugin for Mother Machine Image Analysis by Jun Lab.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
Ensure python and napari are installed in your system. To install the plugin, use:
pip install napari-mm3
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
Workflow
Generally, there is one widget for each process.
Basic workflow is as follows:

Locate channels, create channel stacks, and return metadata (Compile widget).
User guided selection of empty and full channels (ChannelSorter widget).
Subtract phase contrast images (Subtract widget).
Segment images (Segment widget).
Create cell lineages

mm3 currently currently takes individual TIFF images as its input. If there are multiple color layers, then each TIFF image should be a stack of planes corresponding to a color. The quality of your images is important for mm3 to work properly.
The working directory now contains:
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
1. Locate channels, create channel stacks, and return metadata (Compile widget).

The Compile widget attempts to automatically identify and crop out individual growth channels. Images corresponding to a specific channel are then stacked in time, and these "channel stacks" are the basis of further analysis. If there are multiple colors, a channel stack is made for each color for each channel.
It is also at this time that metadata is drawn from the images and saved. 
Parameters

TIFF_source needs to be specified to indicate how the script should look for TIFF metadata. Choices are elements and nd2ToTIFF.
channel_width, channel_separation, and channel_detection_snr, which are used to help find the channels.
channel_length_pad and channel_width_pad will increase the size of your channel slices.
t_end : Will only analyze images up to this time point. Useful for debugging.

The working directory now contains:
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
├── analysis
│   ├── time_table.pkl
│   ├── time_table.txt
│   ├── TIFF_metadata.pkl
│   ├── TIFF_metadata.txt
│   ├── channel_masks.pkl
│   ├── channel_masks.txt
│   └── channels
2. User guided selection of empty and full channels (ChannelSorter).

The Compile widget identifies all growth channels, regardless of if they contain or do not contain cells. ChannelSorter first attempts to guess, and then presents the user with a GUI to decide which channels should be analyzed, which channels should be ignored, and which channels should be used as empty channels during subtraction. This information is contained within the specs.yaml file.
Clicking the "Load data" button displays the first FOV analyzed, along with the program's predicted channel classification. The user is asked to click on the channels to change their designation between analyze (green), empty (blue) and ignore (red).
Click on the colored channels until they are as you wish. To navigate between fields of view click the "next FOV" or "prior FOV" buttons.  The widget will output the specs file with channels indicated as analyzed (green, 1), empty for subtraction (blue, 0), or ignore (red, -1).
Parameters

phase_plane is the postfix of the channel which contains the phase images
channel_picking_threshold is a measure of correlation between a series of images, so a value of 1 would mean the same image over and over. Channels with values above this value (like empty channels) will be designated as empty before the user selection GUI.

The working directory is now:
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
├── analysis
│   ├── time_table.pkl
│   ├── time_table.txt
│   ├── TIFF_metadata.pkl
│   ├── TIFF_metadata.txt
│   ├── channel_masks.pkl
│   ├── channel_masks.txt
│   ├── channels
│   ├── crosscorrs.pkl
│   ├── crosscorrs.txt
│   ├── specs.yaml
3. Subtract phase contrast images (Subtract widget).

Downstream analysis of phase contrast (brightfield) images requires background subtraction to remove artifacts of the PDMS device in the images. 
The working directory is now:
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
├── analysis
│   ├── time_table.pkl
│   ├── time_table.txt
│   ├── TIFF_metadata.pkl
│   ├── TIFF_metadata.txt
│   ├── channel_masks.pkl
│   ├── channel_masks.txt
│   ├── channels
│   ├── crosscorrs.pkl
│   ├── crosscorrs.txt
│   ├── empties
│   ├── specs.yaml
│   └── subtracted
4. Segment images (SegmentOTSU or SegmentUnet).


mm3 can use either deep learning or a traditional machine vision approach (Otsu thresholding, morphological operations and watershedding) to locate cells from the subtracted images.
OTSU parameters

first_opening_size : Size in pixels of first morphological opening during segmentation.
distance_threshold : Distance in pixels which thresholds distance transform of binary cell image.
second_opening_size : Size in pixels of second morphological opening.

U-net parameters

threshold : threshold value (between 0 and 1) for cell classification
min_object_size : Objects smaller than this area in pixels will be removed before labeling.

The working directory is now:
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
├── analysis
│   ├── time_table.pkl
│   ├── time_table.txt
│   ├── TIFF_metadata.pkl
│   ├── TIFF_metadata.txt
│   ├── channel_masks.pkl
│   ├── channel_masks.txt
│   ├── channels
│   ├── crosscorrs.pkl
│   ├── crosscorrs.txt
│   ├── empties
│   ├── segmented
│   ├── specs.yaml
│   └── subtracted
5. Create cell lineages (Track widget).

After cells are found for each channel in each time point, these labeled cells are connected across time to create complete cells and lineages.
Parameters

lost_cell_time : If this many time points pass and a region has not yet been linked to a future region, it is dropped.
max_growth_length : If a region is to be connected to a previous region, it cannot be larger in length by more than this ratio.
min_growth_length : If a region is to be connected to a previous region, it cannot be smaller in length by less than this ratio.
max_growth_area : If a region is to be connected to a previous region, it cannot be larger in area by more than this ratio.
min_growth_area : If a region is to be connected to a previous region, it cannot be smaller in area by less than this ratio.
new_cell_y_cutoff : distance in pixels from closed end of image above which new regions are not considered for starting new cells.
segmentation_method: whether to construct lineage from cells segmented by the Otsu or U-net method

The working directory is now:
```
.
├── 20170720_SJ388_mopsgluc12aa.nd2
├── TIFF
├── analysis
│   ├── time_table.pkl
│   ├── time_table.txt
│   ├── TIFF_metadata.pkl
│   ├── TIFF_metadata.txt
│   ├── cell_data
│   │   └── complete_cells.pkl
│   ├── channel_masks.pkl
│   ├── channel_masks.txt
│   ├── channels
│   ├── crosscorrs.pkl
│   ├── crosscorrs.txt
│   ├── empties
│   ├── segmented
│   ├── specs.pkl
│   ├── specs.txt
│   └── subtracted
└── params.yaml
License
Distributed under the terms of the BSD-3 license,
"napari-mm3" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-mm3

a plugin for mother machine image analysis

Blik Team


blik



it means glance in Dutch

blik is a tool for visualising and interacting with cryo-ET and subtomogram averaging data. It leverages the fast, multi-dimensional napari viewer and the scientific python stack.
DISCLAIMER: this package is in development phase. Expect frequent bugs and crashes. Please, report them on the issue tracker and ask if anything is unclear!
Installation
You can either install blik through the napari plugin system, through pip, or get both napari and blik directly with:
bash
pip install blik[all]
Basic Usage
From the command line:
bash
napari /path/to.star /path/to/mrc/files/* [-w blik]
The optional -w blik addition will open the main blik widget and set up a few things (such as the scale bar) on the napari viewer.
blik is just napari. Particles and images are exposed as simple napari layers, which can be analysed and manipulated with simple python, and most importantly other napari plugins.

blik

Python tool for visualising and interacting with cryo-ET and subtomogram averaging data.

Reka Hollandi


Description
This plugin allows easy object annotation on 2D images. Annotation is made quick, easy and fun, just start drawing! See a quick start guide below.

It is the napari version of the ImageJ plugin AnnotatorJ.
What kind of data it works on
2D images. That's the only requirement. Whether you have microscopy images of cells or tissue, natural photos of cats and dogs, vehichle dash-cam footage, industrial pipeline monitoring etc., just open the image and you can start annotating.
Annotations are save to ImageJ-compatible roi.zip files. Export is possible to several file formats depending on the intended application.
Intended users
Anyone. No experience in computer science or underlying technology is needed; if you know how to use MS Paint, you are ready to start annotating. Biologists, programmers, even children can use it. See quick start guide or demos. If you experience any issues or have questions, feel free to open an issue on GitHub.
Main features
Why choose napari-annotatorj?
- Assisted annotation is possible with automatic deep learning-based contour suggestion,
- freehand contour drawing in instance annotation,
- shape editing via painting labels,
- class annotation,
- export to formats directly suitable for deep CNN training
- import of previous annotations as overlay; e.g. when comparing annotations or curating
- and more.
See demos.
Quick start
Demo data is available in the GitHub repository's demo folder.
napari-annotatorj has several convenient functions to speed up the annotation process, make it easier and more fun. These modes can be activated by their corresponding checkboxes on the left side of the main AnnotatorJ widget.

Contour assist mode
Edit mode
Class mode
Overlay

Freehand drawing is enabled in the plugin. The "Add polygon" tool is selected by default upon startup. To draw a freehand object (shape) simply hold the mouse and drag it around the object. The contour is visualized when the mouse button is released.
See the guide below or a demo script.
Instance annotation
Allows freehand drawing of object contours (shapes) with the mouse as in ImageJ.
Shape contour points are tracked automatically when the left mouse button is held and dragged to draw a shape. The shape is closed when the mouse button is released, automatically, and added to the default shapes layer (named "ROI"). In direct selection mode (from the layer controls panel), you can see the saved contour points. The slower you drag the mouse, the more contour points saved, i.e. the more refined your contour will be.
Click to watch demo video below.

How to annotate

Open --> opens an image
(Optionally) 
... --> Select annotation type --> Ok --> a default tool is selected from the toolbar that fits the selected annotation type
The default annotation type is instance
Selected annotation type is saved to a config file


Start annotating objects
instance: draw contours around objects
semantic: paint the objects' area
bounding box: draw rectangles around the objects



Save --> Select class --> saves the annotation to a file in a sub-folder of the original image folder with the name of the selected class


(Optionally)

Load --> continue a previous annotation
Overlay --> display a different annotation as overlay (semi-transparent) on the currently opened image
Colours --> select annotation and overlay colours
... (coming soon) --> set options for semantic segmentation and Contour assist mode
checkboxes --> Various options
(default) Add automatically --> adds the most recent annotation to the ROI list automatically when releasing the left mouse button
Smooth (coming soon) --> smooths the contour (in instance annotation type only)
Show contours --> displays all the contours in the ROI list
Contours assist --> suggests a contour in the region of an initial, lazily drawn contour using the deep learning method U-Net
Show overlay --> displays the overlayed annotation if loaded with the Overlay button
Edit mode --> edits a selected, already saved contour in the ROI list by clicking on it on the image
Class mode --> assigns the selected class to the selected contour in the ROI list by clicking on it on the image and displays its contour in the class's colour (can be set in the Class window); clicking on the object a second time unclassifies it


[^] --> quick export in 16-bit multi-labelled .tiff format; if classified, also exports by classes



Semantic annotation
Allows painting with the brush tool (labels).
Useful for semantic (e.g. scene) annotation. Currently saves all labels to binary mask only (foreground-background).
Bounding box annotation
Allows drawing bounding boxes (shapes, rectangles) around objects with the mouse.
Useful for object detection annotation.
Demo
Instance annotation mode
See above.
Contour assist mode
Assisted annotation via a pre-trained deep learning model's suggested contour.

initialize a contour with mouse drag around an object
the suggested contour is displayed automatically
modify the contour:
edit with mouse drag or 
erase holding "Alt" or
invert with pressing "u"



finalize it

accept with pressing "q" or
reject with pressing "Ctrl" + "Del"



if the suggested contour is a merge of multiple objects, you can erase the dividing line around the object you wish to keep, and keep erasing (or splitting with the eraser) until the object you wish to keep is the largest, then press "q" to accept it

this mode requires a Keras model to be present in the model folder

Click to watch demo video below

Edit mode
Allows to modify created objects with a brush tool.

select an object (shape) to modify by clicking on it
an editing layer (labels layer) is created for painting automatically
modify the contour:
edit with mouse drag or 
erase holding "Alt"



finalize it

accept with pressing "q" or
delete with pressing "Ctrl" + "Del" or
revert changes with pressing "Esc" (to the state before editing)



if the edited contour is a merge of multiple objects, you can erase the dividing line around the object you wish to keep, and keep erasing (or splitting with the eraser) until the object you wish to keep is the largest, then press "q" to accept it


Click to watch demo video below

Class mode
Allows to assign class labels to objects by clicking on shapes.

select a class from the class list to assign
click on an object (shape) to assign the selected class label to it

the contour colour of the clicked object will be updated to the selected class colour, plus the class label is updated in the text properties of object (turn on "display text" on the layer control panel to see the text properties as objectID:(classLabel) e.g. 1:(0) for the first object)


optionally, you can set a default class for all currently unlabelled objects on the ROI (shapes) layer by selecting a class from the drop-down menu on the right to the text label "Default class"

class colours can be changed with the drop-down menu right to the class list; upon selection, all objects whose class label is the currently selected class will have their contour colour updated to the selected colour
clicking on an object that has already been assigned a class label will unclassify it: assign the label 0 to it

Click to watch demo video below

Export
See also: Quick export
The exporter plugin AnnotatorJExport can be invoked from the Plugins menu under the plugin name napari-annotatorj. It is used for batch export of annotations to various formats directly suitable to train different types of deep learning models. See a demonstrative figure in the AnnotatorJ repository and further description in its README or documentation.

browse original image folder with either the
"Browse original..." button or
text input field next to it


browse annotation folder with either the
"Browse annot..." button or
text input field next to it


select the export options you wish to export the annotations to (see tooltips on hover for help)
at least one export option must be selected to start export
(optional) right click on the checkbox "Coordinates" to switch between the default COCO format and YOLO format; see explanation


click on "Export masks" to start the export
this will open a progress bar in the napari window and close it upon finish



The folder structure required by the exporter is as follows:
```
image_folder
    |--- image1.png
    |--- another_image.png
    |--- something.png
    |--- ...
annotation_folder
    |--- image1_ROIs.zip
    |--- another_image_ROIs.zip
    |--- something_ROIs.zip
    |--- ...
```
Multiple export options can be selected at once, any selected will create a subfolder in the folder where the annotations are saved.
Click to watch demo video below

Quick export
Click on the "[^]" button to quickly save annotations and export to mask image. It saves the current annotations (shapes) to an ImageJ-compatible roi.zip file and a generated a 16-bit multi-labelled mask image to the subfolder "masks" under the current original image's folder.
Coordinate formats
In the AnnotatorJExport plugin 2 coordinates formats can be selecting by right clicking on the Coordinates checkbox: COCO or YOLO. The default is COCO.
COCO format:
- [x, y, width, height] based on the top-left corner of the bounding box around the object
- coordinates are not normalized
- annotations are saved with header to 
    - .csv file
    - tab delimeted
YOLO format:
- [class, x, y, width, height] based on the center point of the bounding box around the object
- coordinates are normalized to the image size as floating point values between 0 and 1
- annotations are saved with header to
    - .txt file
    - whitespace delimeted
    - class is saved as the 1st column
Overlay
A separate annotation file can be loaded as overlay for convenience, e.g. to compare annotations.


load another annotation file with the "Overlay" button


(optional) switch its visibility with the "Show overlay" checkbox

(optional) change the contour colour of the overlay shapes with the "Colours" button

Change colours
Clicking on the "Colours" button opens the Colours widget where you can set the annotation and overlay colours.

select a colour from the drop-down list either next to the text label "overlay" or "annotation"

click the "Ok" button to apply changes


contour colour of shapes on the annotation shapes layer (named "ROI") that already have a class label assigned to them will not be updated to the new annotation colour, only those not having a class label (the class label can be displayed with the "display text" checkbox on the layer controls panel as objectID:(classLabel) e.g. 1:(0) for the first object)

contour colour of shapes on the overlay shapes layer (named "overlay") will all have the overlay colour set, regardless of any existing class information saved to the annotation file loaded as overlay

For coding users
Demo scripts
Run a demo of napari-annotatorj with sample data: a small 3-channel RGB image as original image and an ImageJ roi.zip file as annotations loaded.
shell
    # from the napari-annotatorj folder
    python src/napari_annotatorj/load_imagej_roi.py
Alternatively, you can startup the napari-annotatorj plugin by running
shell
    # from the napari-annotatorj folder
    python src/napari_annotatorj/startup_annotatorj.py
Configure model folder
The Contour assist mode imports a pre-trained Keras model from a folder named models under exactly the path napari_annotatorj. This is automatically created on the first startup in your user folder:
- C:\Users\Username\.napari_annotatorj on Windows
- \home\username\.napari_annotatorj on Linux
A pre-trained model for nucleus segmentation is automatically downloaded from the GitHub repository of the ImageJ version of AnnotatorJ. The model will be saved to [your user folder]\.napari_annotatorj\models\model_real.h5. This location is printed to the console (command prompt or powershell on Windows, terminal on Linux).
(deprecated) When bulding from source the model folder is located at path\to\napari-annotatorj\src\napari_annotatorj\models whereas installing from pypi it is located at path\to\virtualenv\Lib\site-packages\napari_annotatorj\models.
The model must be in either of these file formats:
- config .json file + weights file: model_real.json and model_real_weights.h5
- combined weights file: model_real.hdf5
You can also train a new model on your own data in e.g. Python and save it with this code block:
```python
    # save model as json
    model_json=model.to_json()
    with open(‘model_real.json’, ‘w’) as f:
        f.write(model_json)
# save weights too
model.save_weights(‘model_real_weights.h5’)

```
This configuration will change in the next release to allow model browse and custom model name in an options widget.
Setting device for deep learning model prediction
The Contour assist mode uses a pre-trained U-Net model for suggesting contours based on a lazily initialized contour drawn by the user. The default configuration loads and runs the model on the CPU so all users can run it. It is possible to switch to GPU if you have:
- a CUDA-capable GPU in your computer
- nVidia's CUDA toolkit + cuDNN installed
See installation guide on nVidia's website according to your system.
To switch to GPU utilization, edit _dock_widget.py and set to the device you would like to use. Valid values are 'cpu','0','1','2',.... The default value is cpu. The default GPU device is 0 if your system has any CUDA-capable GPU. If the device you set cannot be found or utilized by the code, it will fall back to cpu. An informative message is printed to the console upon plugin startup.
License
Distributed under the terms of the BSD-3 license,
"napari-annotatorj" is free and open source software.
Getting help
If you experience any issues or have questions, feel free to open an issue on GitHub.
How to cite
Réka Hollandi, Ákos Diósdi, Gábor Hollandi, Nikita Moshkov, Péter Horváth (2020): “AnnotatorJ: an ImageJ plugin to ease hand-annotation of cellular compartments”, Molecular Biology of the Cell, Vol. 31, No. 20, 2179-2186, https://doi.org/10.1091/mbc.E20-02-0156

napari-annotatorj

The napari adaptation of the ImageJ/Fiji plugin AnnotatorJ for easy and fun image annotation.

Lorenzo Gaifas

napari-help






Helpful tooltips for napari.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-help via pip:
pip install napari-help

To install latest development version :
pip install git+https://github.com/brisvag/napari-help.git

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the GNU GPL v3.0 license,
"napari-help" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-help

Johannes Müller

Ben J. Gross

Elijah Shelton

Carlos Gomez

Otger Campas










napari-stress
This plugin provides tools for the analysis of surfaces in Napari, such as utilities to determine and refine the surface-representation of objects using a ray-casting approach and calculate the curvature of surfaces. 
It re-implements code in Napari that was written for Gross et al. (2021): STRESS, an automated geometrical characterization of deformable particles for in vivo measurements of cell and tissue mechanical stresses 
and has been made open source in this repository.

Usage
Functionality in this repository is divided in two groups: Recipes and plugins.
Recipes
Receipes are workflows for processing images, points and surface data step-by-step.
| Recipe| Description |
| --- | --- |
|  | Confocal data (.tif), 3D+t: Interactive tutorial on how to extract surfaces from intensity image data |
|| Confocal data (.tif), 3D+t:  Interactive tutorial on how to extract curvature from surfaces|
|| Confocal data (.tif), 3D+t:  Jupyter notebook for processing single channel data and extracting gaussian curvature.|
Plugins
All functions in napari-stress are documented separately for interactive usage from the napari viewer as well as Jupyter notebooks. 
|Function| Links |
| --- | --- |
| |Fit spherical harmonics: Interactive Code |
| |Surface tracing: Code |
||Reconstruct surface: Code|
Utilities
Data to be used for this plugin is typically of the form [TZYX] (e.g., 3D + time). 
Napari-stress offers convenient ways to use functions from other repositories (which are often made for 3D data) on timelapse data with the frame_by_frame function and the TimelapseConverter class. 
Both are described in more detail in this notebook.
Installation
Create a new conda environment with the following command. 
If you have never used conda before, please read this guide first.
conda create -n napari-stress Python=3.9 napari jupyterlab -c conda-forge
conda activate napari-stress
You can then install napari-stress using pip:
pip install napari-stress
Issues
To report bugs, request new features or get in touch, please open an issue or tag @EL_Pollo_Diablo on image.sc.
See also
There are other napari plugins with similar / overlapping functionality

morphometrics
napari-pymeshlab
napari-process-points-and-surfaces

Contributing
Contributions are very welcome. Tests can be run with pytest, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-stress" is free and open source software
Acknowledgements
This project was supported by the Deutsche Forschungsgemeinschaft under Germany’s Excellence Strategy – EXC2068 - Cluster of Excellence "Physics of Life" of TU Dresden.

napari-stress

Interactive surface analysis in napari for measuring mechanical stresses in biological tissues

OME Team

Description
This plugin provides a reader for zarr backed OME-NGFF images in napari. The reader
will inspect the .zattrs metadata provided and pass any relevant metadata, including channel, scale and colormap metadata.

The example above uses the image at https://idr.openmicroscopy.org/webclient/?show=image-6001240
Supported Data
This plugin is designed to allow bioimaging researchers and analysts to explore their
multi-resolution images stored in Zarr filesets (according to the OME zarr spec)
without needing an intricate understanding of zarr, or the spec itself.
This plugin supports reading all images recognised as ome-zarr, namely, containing
well-formed .zattrs and .zgroup files, as well as the appropriate directory
hierarchy as described in the spec.
The image metadata from OMERO will be used to set channel names, colormaps and rendering settings in napari.
Quickstart
You can open local or remote images using napari at the terminal and the path to your file:
```
$ napari 'https://uk1s3.embassy.ebi.ac.uk/idr/zarr/v0.1/6001240.zarr/'
also works with local files
$ napari 6001240.zarr
```
OR in python:
```python
import napari
viewer = napari.Viewer()
viewer.open('https://uk1s3.embassy.ebi.ac.uk/idr/zarr/v0.1/6001240.zarr/')
napari.run()
```
If a single zarray is passed to the plugin, it will be opened without the use of
the metadata:
$ napari '/tmp/6001240.zarr/0'
If an image group contains labels, they will also be opened, and added as a
separate layer in napari.
When the labels group metadata additionally contains "rgba" and "properties" keys,
the labels will be given appropriate colors and the properties will be displayed
in the status bar.
Working with ome-zarr images can be more convenient using the command-line interface
and utility functions of our associated library ome-zarr. For more information
please see the package documentation for ome-zarr.
Getting Help
If you discover a bug with the plugin, or would like to request a new feature, please
raise an issue on our repository at https://github.com/ome/napari-ome-zarr.
If you would like assistance with using the plugin, or converting images to
ome-zarr format, please reach out on image.sc.
How to Cite OME-NGFF:
Next-generation file format (NGFF) specifications for storing bioimaging data in the cloud. J. Moore, et al. Editors. Open Microscopy Environment Consortium, 20 November 2020. This edition of the specification is https://ngff.openmicroscopy.org/0.1/. The latest edition is available at https://ngff.openmicroscopy.org/latest/. (doi:10.5281/zenodo.4282107)

napari-ome-zarr

A reader for zarr backed OME-NGFF images.

Marcelo Leomil Zoccoler

napari-metroid






This napari plugin is an adaptation of metroid. It creates several regions of interest of similar area over cells in a fluorescence video (2D+time). It then gets ROIs means over time and performs signal denoising: fixes photobleaching and separates signal from noise by means of blind source separation (with or without wavelet filtering).

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

A Picture (to boil down a thousand words)
Below is the graphical abstract of the Metroid software. This napari plugin works very similarly.

Table of Contents

Quick Walktrough
Installation
Usage
Open Sample Data
Open Plugin Main Interface
Auto-generate Cell Mask
Split Mask into ROIs
Get ROI Means over Time
Remove Photobleaching
Filter Signals
Save outputs
Contributing
Citing napari-metroid
License
Issues

Quick Walkthrough
Below is a full demonstration of using napari-metroid. It shows the following:
  * Open sample data;
  * Create cell mask;
  * Split mask into ROIs of similar area;
  * Get ROIs signals over time and plots two of them;
  * Remove photobleaching;
  * Remove noise:
    * Use ICA to decompose ROIs signals into independent components;
    * Plot 4 components;
    * Manually select the component of interest (source);
    * Perform inverse transformation with selected source;

Installation
Download and install Anaconda or Miniconda.
Create a new conda environment:
conda create -n metroid-env python=3.8

Install napari, e.g. via pip:
pip install "napari[all]"

Install napari-metroid via pip:
pip install napari-metroid

To install latest development version :
pip install git+https://github.com/zoccoler/napari-metroid.git

Usage
Open Sample Data
This plugin comes with two sample videos:
- Cell1 Video Action Potential: 2D + time fluorescence video of a rat isolated cardiomyocyte labeled with a membrane potential dye upon which an external electrical field pulse is applied.
- Cell1 Video Electroporation: Same cell, but submitted to a strong external electrical field pulse.
You can open them under "File -> Open Sample -> napari-metroid", as shown below. Both videos are loaded from the metroid main repository. To know more about the experimental conditions, please refer to the original publication.

Open Plugin Main Interface

Auto-generate Cell Mask
Metroid can generate cell binary masks automatically by cumulative sum of images until any pixel saturation happens. It then applies Otsu thresholding and removes small objects.

Split Mask into ROIs
By default, a cell mask is split into 32 regions of interest (ROIs) in a double-layer fashion: An outer layer of ROIs and an inner layer. 
The method is solely based on the shape of the cell mask and the main criteria is that ROIs must have similar areas. The number of ROIs in each layer can be editted. 

Get ROI Means over Time
The 'Get Signals' button serves to collect each ROI mean fluorescence over time and enable plotting. There, you can optionally provide the frame rate so that the time axis is properly displayed.
Double click over a ROI to have its signal plotted. Hold the 'ALT' key to plot multiple signals together.

Remove Photobleaching
Metroid removes photobleaching by curve fitting over time periods that lack the cellular signal (which can be an action potential or an electroporation signal). That is why the 'Transitory' parameter is important. Action potentials are transitory signals whereas electroporation (at least for the duration of this experiment) are not, and the algorithm must be informed about that for proper trend removal.

Filter Signals
Cellular signals are filtered by separating signal components with either PCA or ICA (plus optional wavelet filtering). It then chooses one (or several) components and it applies the inverse transform using only the selected components. Metroid can do this component/source selection automatically based on estimations of signal power. Instead, we show below the manual selection procedure, where 4 components are plotted and the user selects one of them.

Save Outputs
Raw, corrected and filtered signals, as well as time and components, are arranged in a table with values for each time point. The table is displayed as a widget after each Run button click. Estimated signal-to-noise (SNR) in dB for each label/ROI are also provided (in this case, each line corresponds to a ROI, not a time point).
The user can save these data by clicking on the buttons "Copy to clipboard" or "Save as csv...".

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
Citing napari-metroid
If you use this plugin in your research, please be kind to cite the original paper below:
Zoccoler, M., de Oliveira, P.X. METROID: an automated method for robust quantification of subcellular fluorescence events at low SNR. BMC Bioinformatics 21, 332 (2020). https://doi.org/10.1186/s12859-020-03661-9
License
Distributed under the terms of the BSD-3 license,
"napari-metroid" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-metroid

This napari plugin creates several regions of interest of similar area over cells in a fluorescence video (2D+time). It then gets ROIs means over time and performs signal denoising: fixes photobleaching and separates signal from noise by means of blind source separation (with or without wavelet filtering).

Hieu Hoang

napari-pram






Plugin for PRAM data annotation and processing.


This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Usage
Open napari-pram toolbox:
On the toolbar, select [Plugins] > napari-pram: Open PRAM's toolbox
Load PRAM image and annotations:
Press Command/Control + O: 
- Select *.json files for annotations (from either VGG Annotator or napari-pram)
- Select *.png files for PRAM image
Annotate

Press Annotate
Click the plus-in-circle icon on the top-left panel and start editing

Run PRAM particles detector

Select a proper threshold between 1 (ultra sensitive) - 10 (less sensitive)
Press Run Detector

Evaluate

Press Evaluate
Hide/Unhide true positive/ false postive/false negative layers

Load new image

Press Clear All to remove all layers

Export to JSON

Press Save to File to export all annotations, predictions from the algorithm to a JSON file

Installation
Following this tutorial to install napari. 
Alternatively, you can follow my instructions as follows:
You will need a python environment. I recommend Conda. Create a new environment, for example:
conda create --name napari-env python=3.7 pip

Activate the new environment:
conda activate napari-env

Install napari via pip:
pip install napari[all]

Then you can finally install our plugin napari-pram via pip:
pip install napari-pram

Alternatively, the plugin can be installed using napari-GUI
[Plugins] > Install/Uninstall Plugins and search for napari-pram
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the MIT license,
"napari-pram" is free and open source software
Issues
If you encounter any problems, please [file an issue] along with a detailed description.

napari-pram

plugin for PRAM data annotation and processing

napari-btrack-reader





A plugin to load btrack files

This plugin reads tracking data generated by BayesianTracker (btrack).
This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-btrack-reader via pip:
pip install napari-btrack-reader

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-btrack-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-btrack-reader

Trevor Manz

napari-lazy-openslide




An experimental plugin to lazily load multiscale whole-slide tiff images with openslide and dask.

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Installation
Step 1.) Make sure you have OpenSlide installed. Download instructions here.

NOTE: Installation on macOS is easiest via Homebrew: brew install openslide. Up-to-date and multiplatform 
binaries for openslide are also avaiable via conda: conda install -c sdvillal openslide-python

Step 2.) Install napari-lazy-openslide via pip:
pip install napari-lazy-openslide

Usage
Napari plugin
bash
$ napari tumor_004.tif
By installing this package via pip, the plugin should be recognized by napari. The plugin
attempts to read image formats recognized by openslide that are multiscale 
(openslide.OpenSlide.level_count > 1). 
It should be noted that napari-lazy-openslide is experimental and has primarily 
been tested with CAMELYON16 and CAMELYON17 datasets, which can be 
downloaded here.

Using OpenSlideStore with Zarr and Dask
The OpenSlideStore class wraps an openslide.OpenSlide object as a valid Zarr store. 
The underlying openslide image pyramid is translated to the Zarr multiscales extension,
where each level of the pyramid is a separate 3D zarr.Array with shape (y, x, 4).
```python
import dask.array as da
import zarr
from napari_lazy_openslide import OpenSlideStore
store = OpenSlideStore('tumor_004.tif')
grp = zarr.open(store, mode="r")
The OpenSlideStore implements the multiscales extension
https://forum.image.sc/t/multiscale-arrays-v0-1/37930
datasets = grp.attrs["multiscales"][0]["datasets"]
pyramid = [grp.get(d["path"]) for d in datasets]
print(pyramid)
[
,
,
,
]
pyramid = [da.from_zarr(store, component=d["path"]) for d in datasets]
print(pyramid)
[
dask.array,
dask.array,
dask.array,
]
Now you can use numpy-like indexing with openslide, reading data into memory lazily!
low_res = pyramid[-1][:]
region = pyramid[0][y_start:y_end, x_start:x_end]
```
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-lazy-openslide

A plugin to lazily load multiscale whole-slide images with openslide and dask

Stephen Lenzi

Adam Tyson






brainreg-napari
Napari plugin to run brainreg,
developed by Stephen Lenzi.
Installation
bash
pip install brainreg-napari
Usage
Documentation for the plugin is to come, but documentation for the original
brainreg can be found here
and a tutorial is here.
For segmentation of bulk structures in 3D space
(e.g. injection sites, Neuropixels probes), please see
brainreg-segment.
This software is at a very early stage, and was written with our data in mind.
Over time we hope to support other data types/formats. If you have any issues, please get in touch on the forum or by
raising an issue.
Details
brainreg is an update to
amap (itself a port
of the original Java software)
to include multiple registration backends, and to support the many atlases
provided by bg-atlasapi.
The aim of brainreg is to register the template brain
 (e.g. from the Allen Reference Atlas)
  to the sample image. Once this is complete, any other image in the template
  space can be aligned with the sample (such as region annotations, for
  segmentation of the sample image). The template to sample transformation
  can also be inverted, allowing sample images to be aligned in a common
  coordinate space.
To do this, the template and sample images are filtered, and then registered in
a three step process (reorientation, affine registration, and freeform
registration.) The resulting transform from template to standard space is then
applied to the atlas.
Full details of the process are in the
original aMAP paper.

Overview of the registration process
Contributing
Contributions to brainreg-napari are more than welcome. Please see the contributing guide.
Citing brainreg
If you find brainreg useful, and use it in your research, please let us know and also cite the paper:

Tyson, A. L., Vélez-Fort, M.,  Rousseau, C. V., Cossell, L., Tsitoura, C., Lenzi, S. C., Obenhaus, H. A., Claudi, F., Branco, T.,  Margrie, T. W. (2022). Accurate determination of marker location within whole-brain microscopy images. Scientific Reports, 12, 867 doi.org/10.1038/s41598-021-04676-9

Please also cite aMAP (the original pipeline from which this software is based):

Niedworok, C.J., Brown, A.P.Y., Jorge Cardoso, M., Osten, P., Ourselin, S., Modat, M. and Margrie, T.W., (2016). AMAP is a validated pipeline for registration and segmentation of high-resolution mouse brain data. Nature Communications. 7, 1–9. https://doi.org/10.1038/ncomms11879

Lastly, if you can, please cite the BrainGlobe Atlas API that provided the atlas:

Claudi, F., Petrucco, L., Tyson, A. L., Branco, T., Margrie, T. W. and Portugues, R. (2020). BrainGlobe Atlas API: a common interface for neuroanatomical atlases. Journal of Open Source Software, 5(54), 2668, https://doi.org/10.21105/joss.02668

Don't forget to cite the developers of the atlas that you used (e.g. the Allen Brain Atlas)!

The BrainGlobe project is generously supported by the Sainsbury Wellcome Centre and the Institute of Neuroscience, Technical University of Munich, with funding from Wellcome, the Gatsby Charitable Foundation and the Munich Cluster for Systems Neurology - Synergy.


brainreg-napari

Multi-atlas whole-brain microscopy registration

napari-skimage-regionprops (nsr)







A napari plugin for measuring properties of labeled objects based on scikit-image

Usage
From the menu Tools > Measurement > Regionprops (nsr) you can open a dialog where you can choose an intensity image, a corresponding label image and the features you want to measure:

If you want to interface with the labels and see which table row corresponds to which labeled object, use the label picker and
activate the show selected checkbox.

If you closed a table and want to reopen it, you can use the menu Tools > Measurements > Show table (nsr) to reopen it. 
You just need to select the labels layer the properties are associated with.
For visualizing measurements with different grey values, as parametric images, you can double-click table headers.

Usage, programmatically
You can also control the tables programmatically. See this example notebook for details.
Features
The user can select categories of features for feature extraction in the user interface. These categories contain measurements from the scikit-image regionprops list of measurements library:


size:


area


bbox_area


convex_area


equivalent_diameter


intensity:


max_intensity 


mean_intensity


min_intensity


standard_deviation_intensity (extra_properties implementation using numpy)


perimeter:


perimeter


perimeter_crofton


shape


major_axis_length


minor_axis_length


orientation


solidity


eccentricity


extent


feret_diameter_max


local_centroid


roundness as defined for 2D labels by ImageJ


circularity as defined for 2D labels  by ImageJ


aspect_ratio as defined for 2D labels by ImageJ


position:


centroid


bbox


weighted_centroid


moments:


moments


moments_central


moments_hu


moments_normalized


This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
See also
There are other napari plugins with similar functionality for extracting features:


morphometrics


PartSeg


napari-simpleitk-image-processing


napari-cupy-image-processing


napari-pyclesperanto-assistant


Furthermore, there are plugins for postprocessing extracted measurements


napari-feature-classifier


napari-clusters-plotter


napari-accelerated-pixel-and-object-classification


Installation
You can install napari-skimage-regionprops via pip:
pip install napari-skimage-regionprops

Or if you plan to develop it:
git clone https://github.com/haesleinhuepf/napari-skimage-regionprops

cd napari-skimage-regionprops

pip install -e .

If there is an error message suggesting that git is not installed, run conda install git.
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-skimage-regionprops" is free and open source software
Issues
If you encounter any problems, please create a thread on image.sc along with a detailed description and tag @haesleinhuepf.

napari-skimage-regionprops

A regionprops table widget plugin for napari

Jonas Windhager

napari-czifile2















Carl Zeiss Image (.czi) file type support for napari
Open .czi files and interactively view scenes co-registered in the machine's coordinate system using napari
Installation
You can install napari-czifile2 via pip:
pip install napari-czifile2

Alternatively, you can install napari-czifile2 via conda:
conda install -c conda-forge napari-czifile2

Authors
Created and maintained by Jonas Windhager jonas.windhager@uzh.ch
Contributing
Contributing
Changelog
Changelog
License
MIT

napari-czifile2

Carl Zeiss Image (.czi) file support for napari

disease-classifier






A napari plugin for disease classification based on iPAC images.
Installation
You can install disease-classifier via pip:
pip install disease-classifier

To install latest development version :
pip install git+https://github.com/zcqwh/disease-classifier.git

Introduction
Load data (.rtdc or .bin)

Drag and drop the data in .rtdc or .bin into the files table.
Click eye button to preview images.


Choose model and classify

Choose the model folder including CNN and RF/PLDA.
Check the data.
Click classify.


Preview classification results

Click the eye button to preview the result.
Click the header to show all.


Save results

Click “Add classification to .rtdc file” button to save results.


Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"disease-classifier" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.


disease-classifier

A disease classifier based on iPAC images.

Allen Institute for Cell Science

napari-allencell-annotator






A plugin that enables large image set annotating and writes annotations to a .csv file. 
Plugin provided by the Allen Institute for Cell Science.
The Allen Cell Image Annotator plugin for napari provides an intuitive
graphical user interface to create annotation templates, annotate large 
image sets using these templates, and save image annotations to a csv file. 
The Allen Cell Image Annotator is a Python-based open source toolkit 
developed at the Allen Institute for Cell Science for both blind, unbiased and un-blind 
microscope image annotating. This toolkit supports easy image set selection
from a file finder and creation of annotation templates (text, checkbox, drop-down, and spinbox).
With napari's multi-dimensional image viewing capabilities and AICSImageIO's
image reading and metadata conversion, the plugin seamlessly allows users to
view each image in a set and annotate according to the selected template.
Annotation templates can be written to a json file for sharing or re-using. After annotating,
both annotation template data and the annotations written for the image set 
are saved to csv file, which can be re-opened for further annotating and conveniently
stores annotations.

Supports the following image types:
OME-TIFF
TIFF
CZI 
PNG 
JPEG 




This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-allencell-annotator via pip:
pip install napari-allencell-annotator

To install latest development version :
pip install git+https://github.com/bbridge0200/napari-allencell-annotator.git

Quick Start
In the current version, there are two parts in the plugin: Image List and Annotation Editor. 
The Annotation Editor allows users to create new annotation templates or upload existing annotation templates 
from a previous plugin-created csv or json file. 
Once an annotation template is chosen and approved, annotating can begin on the image set
selected in the Image Uploader section of the plugin. 

Select create new annotation template or upload existing. If the annotation template is uploaded from a csv file, using the image set will open and allow continued editing of all annotations in the csv. 
Select images for annotating (the plugin is able to support .tiff, .tif. ome.tif, .ome.tiff, .czi, .png, .jpeg, and .jpg files). Once selected, the images can be shuffled and hidden or deleted using the checkbox on the right side. 
Start Annotating and select or create a .csv file for writing. If the selected file already exists, it will be overwritten. 
Click Save and Exit at any time and all created image annotations will be written to the .csv file. If the file is opened in the plugin again, annotation will start at the first image with a blank annotation.

To install latest development version :
pip install git+https://github.com/bbridge0200/napari-allencell-annotator.git

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-allencell-annotator" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-allencell-annotator

A plugin that enables annotations provided by Allen Institute for Cell Science

napari-em-reader





A napari plugin to read .em files

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-em-reader via pip:
pip install napari-em-reader

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-em-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-em-reader

Jacopo Abramo

napari-live-recording





A napari plugin for live video recording with a generic camera device and generate a stack of TIFF images from said device.

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-live-recording via pip:
pip install napari-live-recording

Documentation
You can review the documentation of this plugin here
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the MIT license,
"napari-live-recording" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-live-recording

A napari plugin for live video recording with a generic camera device.

Loïc Sauteur

Description
This light-weight plugin provides additional control over label layers.
It is intended to ease your work when annotating data manually.

--> the image link needs to be updated... (to weblink)  <--
It provides you with a widget listing all individual labels.
For each label, you can:
- select it from the list to activate it for further drawing.
- toggle the visibility of individual labels
- locate the drawn label (i.e. move to the centroid location at the current zoom level)
- change the label color with a color picker
- erase the label (sets all the drawn pixels to the label layer background value, not un-doable)
Intended Audience & Supported Data
Everyone that has 2D or 3D data and wants to annotate (or curate annotated data) 
should find a useful extension with this plugin.
The plugin will recognise and work only on label layers.
Note:
The "locate center" button will only work on 2D/3D label layers, i.e.: YX, ZYX, TYX, CYX.
Channels are considered a dimension.
Quickstart

Start napari
Open an image you want to annotate 
Best, an image with the same dimension as you labels layer should have
e.g. File > Open Sample > napari > Binary Blobs (3D)
Add (or load) a labels layer
Start the plugin Plugins > napari-annotator: Annotator
Make sure the labels layer is selected
Start drawing

Known limitations

Lag when drawing (see GitHub README for more info).
Maximum 255 labels supported (see GitHub README for more info).

Getting Help
If you encounter bugs, please [file an issue] along with a detailed description.
Or open a thread on forum.image.sc with a detailed description 
and a @loicsauteur tag.
For general help, reach out via the forum.image.sc with a tag @loicsauteur.
How to Cite
No citation needed. Honorable mention welcome.

napari-annotator

A lightweight plugin extending label layer control

Benjamin Grädel

arcos-gui






A napari plugin to detect and visualize collective signaling events


Package specific Documentation: https://bgraedel.github.io/arcos-gui
ARCOS documentation: https://arcos.gitbook.io

Automated Recognition of Collective Signalling (ARCOS) is an algorithm to identify collective spatial events in time series data,
that was written by Maciej Dobrzynski (https://github.com/dmattek). It is available as an R (ARCOS) and python (arcos4py) package.
ARCOS can identify and visualize collective protein activation in 2- and 3D cell cultures over time.
This plugin integrates ARCOS into napari. Users can import tracked time-series data in CSV format. The plugin
provides GUI elements to process this data with ARCOS. Layers containing the detected collective events are subsequently added to the viewer.
Following analysis, the user can export the output as a CSV file with the detected collective events or as a sequence of images to generate a movie.

Watch full demo on youtube
Installation
You can install arcos-gui via pip:
pip install arcos-gui

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"arcos-gui" is free and open-source software
Issues
If you encounter any problems, please file an issue along with a detailed description.
Credits
This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.

arcos-gui

A napari plugin to detect and visualize collective signaling events

Jordao Bragantini

napari-DEXP





A plugin to interface DEXP with napari.

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.

Installation
You can install napari-dexp via pip:
pip install napari-dexp

Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-dexp" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-dexp

Edgar Lefevre

napari-deepmeta






Mice lungs and metastases segmentation tool.
This tool is a demo tool for DeepMeta network.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.
Installation
You can install napari-deepmeta via pip:
pip install napari-deepmeta

To install latest development version :
pip install git+https://github.com/EdgarLefevre/napari-deepmeta.git

Usage
This plugin is designed to process your mouse MRI images with our dataset. It comes with a demo, including one of our
test images.
By opening the deepmeta demo plugin, you will see an interface with one unique button, by clicking on it, it will load an image,
run prediction and then draw the masks contours on each slice.
If you open the deepmeta plugin, you will see an interface with one button and 3 checkboxes.
By checking the checkboxes, you add steps to the pipeline (enhance contrast, do postprocessing, segment metastases).
Once everything is setup, just click on the button and wait (the waiting time depends on your computer performance.)
Contributing
Contributions are very welcome. Tests can be run with tox, please ensure
the coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the MIT license,
"napari-deepmeta" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-deepmeta

Mice lungs and metastases segmentation tool.

napari-cupy-image-processing







GPU-accelerated image processing using cupy and CUDA
Usage
This napari plugin adds some menu entries to the Tools menu. You can recognize them with their suffix (n-cupy) in brackets.
Furthermore, it can be used from the napari-assistant graphical user interface. 
Therefore, just click the menu Tools > Utilities > Assistant (na) or run naparia from the command line.

You can also call operations from python, e.g. as shown in this demo notebook.
Installation
Follow the instructions for installing cupy on your computer first.
conda install -c conda-forge cupy

Afterwards, you can install napari-cupy-image-processing via pip:
pip install napari-cupy-image-processing

A more detailed example for installation (change 11.2 to your desired CUDA version):
conda create --name cupy_p39 python=3.9
conda activate cupy_p39
conda install -c conda-forge cupy cudatoolkit=11.2 napari
pip install napari-cupy-image-processing
Contributing
Contributions are very welcome. Adding cupy ndimage functions is quite easy as you can see in the 
implementation of the current operations. 
If you need another function in napari, just send a PR. Please make sure the tests pass locally before submitting a PR.
pip install pytest-cov pytest-qt
pytest --cov=napari_cupy_image_processing
This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
License
Distributed under the terms of the MIT license,
"napari-cupy-image-processing" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-cupy-image-processing

GPU-accelerated image processing using CUDA

Search for a plugin by keyword or author

Browse plugins: 212

napari-tissuumaps

version

release date

license

Python version

operating system

napari-timeseries-opener-plugin

version

release date

license

Python version

operating system

napari-serialcellpose

version

release date

license

Python version

operating system

napari-allencell-annotator

version

release date

license

Python version

operating system

napari-segment-blobs-and-things-with-membranes

version

release date

license

Python version

operating system

napari-nd2-folder-viewer

version

release date

license

Python version

operating system

napari-stl-exporter

version

release date

license

Python version

operating system

imaxt-multiscale-plugin

version

release date

license

Python version

operating system

napari-LF

version

release date

license

Python version

operating system

napari-help

version

release date

license

Python version

operating system

napari-sift-registration

version

release date

license

Python version

operating system

napari-nlm

version

release date

license

Python version

operating system

avidaq

version

release date

license

Python version

operating system