Andrea Bassi

napari-psf-simulator






A plugin for the simulation of the 3D Point Spread Function of an optical systen, particularly a microscope objective.
Calculates the PSF as the squared Fourier Transform of the pupil and uses the angular spectrum to propagate the PSF in 3D.
The following aberrations are included:
- phase aberration described by a Zernike polynomials with n-m coefficients
- aberration induced by a slab, with a refractive index different from the one at the object (only scalar approximation is used, polarization not considered yet).  

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

Installation
You can install napari-psf-simulator via pip:
pip install napari-psf-simulator

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

Usage
1) Lauch the plugin and select the parameters of the microscope: NA (numerical aperture), wavelenght, n (refractive index at the object),
   Nxy (number of pixels), Nz (number of slices), dxy (pixel size, transverse sampling), dz (voxel depth, axial sampling)
2) Select an aberration type (if needed) and press Calculate PSF to run the simulator. This will create a new image layer with the 3D PSF.
The option Show Airy disk creates 3 ellipses in a Shapes layer, showing the boundaries of the diffraction limited blob.

Napari viewer with the psf-simulator widget showing the in-focus plane of an aberrated PSF

Slicing through a PSF aberrated with Zernike polynomials of order N=3, M=1 (coma)
3) Click on the Plot PSF Profile in Console checkbox to see the x and z profiles of the PSF.
   They will show up in  the viewer console when Calculate PSF is executed.

Plot profile of the PSF, shown in the Console
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. 
The plugin has been concived to be modular allowing the insertion of new aberations and pupils. Please contact the developers on github for adding new propagations and aberrations types. 
Any suggestions or contributions are welcome.
License
Distributed under the terms of the BSD-3 license,
"napari-psf-simulator" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-psf-simulator

A plugin for simulations of the Point Spread Function, with aberrations

Chenqi Zhang

iacs_ipac_reader






A plugin used a convolutional neural network (CNN) to distinguish single platelets, platelet clusters, and white blood cells and performed classical image analysis for each subpopulation individually. Based on the derived single-cell features for each population, a Random Forest (RF) model was trained and used to classify COVID-19 associated thrombosis and non-COVID-19 associated thrombosis.
More information about IACS/iPAC.
IACS: DOI: 10.1016/j.cell.2018.08.028 
iPAC: DOI: 10.7554/eLife.52938

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

Installation
You can install iacs_ipac_reader via pip:
pip install iacs_ipac_reader

To install latest development version :
pip install git+https://github.com/zcqwh/iacs_ipac_reader.git

Introduction
The iacs-ipac-reader plugin mainly include 3 functional tabs:

iPAC
IACS
AID classif.

iPAC image contour tracker
Interface of iPAC contour tracker 

IACS image contour tracker
Interface of IACS contour tracker 

AID classif.
Interface of AID classif. 

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,
"iacs_ipac_reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

iacs-ipac-reader

A reader plugin for read iacs/ipac images and export .rtdc files.

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

Jan Clemens

napari-video
Napari plugin for working with videos.
Relies on pyvideoreader as a backend which itself uses opencv for reading videos.
Installation
shell
pip install napari[all] napari_video
Usage
From a terminal:
shell
napari video.avi
Or from within python:
```shell
import napari
from napari_video.napari_video import VideoReaderNP
path='video.mp4'
vr = VideoReaderNP(path)
with napari.gui_qt():
    viewer = napari.view_image(vr, name=path)
```
Internals
napari_video.napari_video.VideoReaderNP exposes a video with a numpy-like interface, using opencv as a backend.
For instance, open a video:
python
vr = VideoReaderNP('video.avi')
print(vr)
video.avi with 60932 frames of size (920, 912, 3) at 100.00 fps
Then

vr[100] will return the 100th frame as a numpy array with shape (902, 912, 3).
vr[100:200:10] will return 10 frames evenly spaced between frame number 100 and 200 (shape (10, 902, 912, 3)).
Note that by default, single-frame and slice indexing return 3D and 4D arrays, respectively. To consistently return 4D arrays, open the video with remove_leading_singleton=False. vr[100] will then return a (1, 902, 912, 3) array.
We can also request specific ROIs and channels. For instance, vr[100:200:10,100:400,800:850,1] will return an array with shape (10, 300, 50, 1).


napari_video

Adam Tyson

napari-brainglobe-io





Visualise cellfinder and brainreg results with napari

Installation
This package is likely already installed 
(e.g. with cellfinder, brainreg or another napari plugin), but if you want to 
install it again, either use the napari plugin install GUI or you can 
install brainglobe-napari-io via pip:
pip install brainglobe-napari-io

Usage

Open napari (however you normally do it, but typically just type napari into your terminal, or click on your desktop icon)

brainreg
Sample space
Drag your brainreg output directory (the one with the log file) onto the napari window.
Various images should then open, including:
* Registered image - the image used for registration, downsampled to atlas resolution
* atlas_name - e.g. allen_mouse_25um the atlas labels, warped to your sample brain
* Boundaries - the boundaries of the atlas regions
If you downsampled additional channels, these will also be loaded.
Most of these images will not be visible by default. Click the little eye icon to toggle visibility.
N.B. If you use a high resolution atlas (such as allen_mouse_10um), then the files can take a little while to load.

Atlas space
napari-brainreg also comes with an additional plugin, for visualising your data 
in atlas space. 
This is typically only used in other software, but you can enable it yourself:
* Open napari
* Navigate to Plugins -> Plugin Call Order
* In the Plugin Sorter window, select napari_get_reader from the select hook... dropdown box
* Drag brainreg_read_dir_standard_space (the atlas space viewer plugin) above brainreg_read_dir (the normal plugin) to ensure that the atlas space plugin is used preferentially.
cellfinder
Load cellfinder XML file

Load your raw data (drag and drop the data directories into napari, one at a time)
Drag and drop your cellfinder XML file (e.g. cell_classification.xml) into napari.

Load cellfinder directory

Load your raw data (drag and drop the data directories into napari, one at a time)
Drag and drop your cellfinder output directory into napari.

The plugin will then load your detected cells (in yellow) and the rejected cell 
candidates (in blue). If you carried out registration, then these results will be 
overlaid (similarly to the loading brainreg data, but transformed to the 
coordinate space of your raw data).

Loading raw data

Loading cellfinder 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 MIT license,
"brainglobe-napari-io" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

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.


brainglobe-napari-io

Read and write files from the BrainGlobe neuroanatomy suite

Laura Zigutyte, Ryan Savill, Johannes Müller, Marcelo Zoccoler, Robert Haase

napari-clusters-plotter










A plugin to use with napari for clustering objects according to their properties.

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


Jump to:
- Usage
  - Starting point
  - Measurements
  - Time-Lapse Measurements
  - Plotting
  - Time-Lapse Plotting
  - Dimensionality reduction: UMAP, t-SNE or PCA
  - Clustering
  - Plotting clustering results
- Installation
- Troubleshooting installation
- Contributing
- License
- Acknowledgements
Usage
Starting point
For clustering objects according to their properties, the starting point is a grey-value image and a label image
representing a segmentation of objects. For segmenting objects, you can for example use the
Voronoi-Otsu-labelling approach
in the napari plugin napari-segment-blobs-and-things-with-membranes.

Measurements
The first step is deriving measurements from the labelled image and the corresponding pixels in the grey-value image.
You can use the menu Tools > Measurement > Measure intensity, shape and neighbor counts (ncp) for that.
Just select the image, the corresponding label image and the measurements to analyse and click on Run.
A table with the measurements will open:

Afterwards, you can save and/or close the measurement table. Also, close the Measure widget.
If you are uploading your own measurements make sure that there is a column that specifies the which measurement belongs to which label
by adding a column with the name "label". If you don't specify this column it will be assumed that measurements start at 1 and each 
column describes the next label.
Time-Lapse Measurements
If you have 3D time-lapse data this will automatically be detected. In case you have 2D time-lapse data you need to
convert it into a suitable shape using the function: Tools > Utilities > Convert 3D stack to 2D time-lapse (time-slicer),
which can be found in the napari time slicer.
Note that tables for time-lapse data will include an additional column named "frame", which indicates which slice in
time the given row refers to. If you want to import your own csv files for time-lapse data make sure to include this column!
If you have tracking data where each column specifies measurements for a track instead of a label at a specific time point, 
this column must not be added.
Plotting
Once measurements were made, these measurements were saved in the properties of the labels layer which was analysed.
You can then plot these measurements using the menu Tools > Measurement > Plot measurement (ncp).
In this widget, you can select the labels layer which was analysed and the measurements which should be plotted
on the X- and Y-axis. If you cannot see any options in axes selection boxes, but you have performed measurements, click
on Update Axes/Clustering Selection Boxes to refresh them. Click on Run to draw the data points in the plot area.

You can also manually select a region in the plot. To use lasso (freehand) tool use left mouse click, and to use a
rectangle - right click. The resulting manual clustering will also be visualized in the original image. To optimize
visualization in the image, turn off the visibility of the analysed labels layer.

Hold down the SHIFT key while annotating regions in the plot to manually select multiple clusters.

Time-Lapse Plotting
When you plot your time-lapse datasets you will notice that the plots look slightly different.
Datapoints of the current time frame are highlighted in white and you can see the datapoints move through the plot if you press play:

You can also manually select groups using the lasso tool and plot a measurement per frame and see how the group behaves in time.
Furthermore, you could also select a group in time and see where the datapoints lie in a different feature space:

Dimensionality reduction: UMAP, t-SNE or PCA
For getting more insights into your data, you can reduce the dimensionality of the measurements, e.g.
using the UMAP algorithm, t-SNE
or PCA.
To apply it to your data use the menu Tools > Measurement > Dimensionality reduction (ncp).
Select the label image that was analysed and in the list below, select all measurements that should be
dimensionality reduced. By default, all measurements are selected in the box. If you cannot see any measurements, but
you have performed them, click on Update Measurements to refresh the box. You can read more about parameters of both
algorithms by hovering over question marks or by clicking on them. When you are done with the selection, click on Run
and after a moment, the table of measurements will re-appear with two additional columns representing the reduced
dimensions of the dataset. These columns are automatically saved in the properties of the labels layer so there is no
need to save them for usage in other widgets unless you wish to do so.

Afterwards, you can again save and/or close the table. Also, close the Dimensionality Reduction widget.
Clustering
If manual clustering, as shown above, is not an option, you can automatically cluster your data, using these implemented algorithms:
* k-means clustering (KMEANS)
* Hierarchical Density-Based Spatial Clustering of Applications with Noise (HDBSCAN)
* Gaussian Mixture Model (GMM)
* Mean Shift (MS)
* Agglomerative clustering (AC)
Therefore, click the menu Tools > Measurement > Clustering (ncp),
again, select the analysed labels layer.
This time select the measurements for clustering, e.g. select only the UMAP measurements.
Select the clustering method KMeans and click on Run.
The table of measurements will reappear with an additional column ALGORITHM_NAME_CLUSTERING_ID containing the cluster
ID of each datapoint.

Afterwards, you can again save and/or close the table. Also, close the clustering widget.
Plotting clustering results
Return to the Plotter widget using the menu Tools > Measurement > Plot measurement (ncp).
Select UMAP_0 and UMAP_1 as X- and Y-axis and the ALGORITHM_NAME_CLUSTERING_ID as Clustering, and click on Run.

Example of k-means clustering results:

Installation

Get a python environment, e.g. via mini-conda.
  If you never used python/conda environments before, please follow the instructions
  here first. It is recommended to
  install python 3.9 to your new conda environment from the start. The plugin is not yet supported with Python 3.10.
  Create a new environment, for example, like this:

conda create --name ncp-env python=3.9

Activate the new environment via conda:

conda activate ncp-env

Install pyopencl, e.g. via conda:

conda install -c conda-forge pyopencl

Install napari, e.g. via pip:

python -m pip install "napari[all]"
Afterwards, you can install napari-clusters-plotter via pip:
pip install napari-clusters-plotter
Troubleshooting installation

If the plugin does not appear in napari 'Plugins' menu, and in 'Plugin errors...' you can see such an error:

ImportError: DLL load failed while importing _cl
Try downloading and installing a pyopencl with a lower cl version, e.g. cl12 : pyopencl=2020.1. However, in this case,
you will need an environment with a lower python version (python=3.8).

Error: Could not build wheels for hdbscan which use PEP 517 and cannot be installed directly

Install hdbscan via conda before installing the plugin:
conda install -c conda-forge hdbscan

ValueError: numpy.ndarray size changed, may indicate binary incompatibility. Expected 96 from C header, got 88 from PyObject

Similar to the above-described error, this error can occur when importing hdbscan through pip or in the wrong order. This can be fixed by installing packages separately through conda and in the following order:
bash
conda install -c conda-forge napari pyopencl hdbscan
pip install napari-clusters-plotter

WARNING: No ICDs were found or LogicError: clGetPlatformIDs failed: PLATFORM_NOT_FOUND_KHR

Make your system-wide implementation visible by installing either of the following conda packages:
conda install -c conda-forge ocl-icd-system
conda install -c conda-forge ocl_icd_wrapper_apple
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-clusters-plotter" 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.
This project has been made possible in part by grant number 2021-240341 (Napari plugin accelerator grant) from the Chan Zuckerberg Initiative DAF, an advised fund of the Silicon Valley Community Foundation.
Issues
If you encounter any problems, please file an issue along
with a detailed description.

napari-clusters-plotter

A plugin to use with napari for clustering objects according to their properties

Alister Burt

napari-mrcfile-reader





Read MRC format image files into napari using the mrcfile package from CCP-EM


This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Installation
You can install napari-mrcfile-reader via pip:
pip install napari-mrcfile-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-mrcfile-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-mrcfile-reader

Lorenzo Gaifas

napari-molecule-reader






A napari plugin that read molecular structure files. It reads PDB and MMCIF files using atomium, expanding molecular assemblies to a full visualization. Data is loaded into napari as Points for ball representation and Vectors for stick representation. If multiple models or assemblies are detected, they will be loaded as separate objects.
https://user-images.githubusercontent.com/23482191/150109390-bd7fb3b4-79b4-43da-aafc-20921714df25.mp4
TODO list:
- [] handle alternate locations (i.e: different conformations in the same pdb model)

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

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

To install latest development version :
pip install git+https://github.com/brisvag/napari-molecule-reader.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-molecule-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-molecule-reader

A napari plugin that read molecular structure files.

Nicolas Pielawski

🏝 napari-tissuumaps 🧫





A Napari plugin to add compatibility with TissUUmaps.

This plugins adds a new writer to Napari to export projects to TissUUmaps. Exported projects can then be open on the browser or on a standalone GUI with TissUUmaps. More information and demonstrations are available on the TissUUmaps webpage.

🚀 Features



The plugin now supports:

Exporting images
Exporting labels
Exporting points
Exporting shapes, including:
Polygons
Rectangles
Lines
Paths
Ellipses



The plugin exports the right color for the points, shapes and labels and also saves the visibility/opacity of each layers. The shapes are exported in the GeoJSON format, the points in CSV files, and images as TIFFs.
📺 Installation
You can install napari-tissuumaps via pip:
pip install napari-tissuumaps

You can also install napari-tissumaps via napari:
In Napari, access the menubar, Plugins > Install/Uninstall Plugins.
Search for napari-tissuumaps in the list and choose install, or type
napari-tissuumaps in the "install by name/url, or drop file..." text area and choose
install.
⛏ Usage
To export a project for TissUUmaps, access the menubar, File > Save All Layers... and
choose a filename with a .tmap extension. It will create a folder containing all the
necessary files for TissUUmaps.
📚 Documentation
Install pdoc with pip install pdoc and run the docs/generate_doc.sh script from the root. It will generate a static website that contains the documentation in the docs folder.
👩‍💻 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-tissuumaps" is free and open source software
🚒 Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-tissuumaps

A plugin to add compatibility with Tissuumaps

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

Marc Boucsein, Robin Koch

Image-Part-Selecter



A napari plugin in order to select parts of images

Installation
You can install Image-Part-Selecter via pip:
pip install Image-Part-Selecter

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,
"Image-Part-Selecter" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

Image-Part-Selecter

A napari plugin in order to select parts of images

Hiroki Kawai

napari-labelimg4classification






A simple image-level annotation tool supporting multi-channel images for napari.

This napari plugin was generated with Cookiecutter using @napari's cookiecutter-napari-plugin template.
Usage
Start the labeling tool from the menu Utilities > label tool for classification. 
First, click on the Choose directory button to open the folder selection window, and select the folder that contains the
 images you want to label and annotate. 
It will automatically list and display the images of tif, png, jpg, and bmp formats.
If you want to view the channels of a multi-channel image separately, check the split channels checkbox.

Initially, all channels will be opened in grayscale, but the pseudo-color and contrast adjustments you specified will be
 carried over when you open the next image. 
Thanks to napari, you can freely merge channels and turn them on and off. 
Label classes can be added, and can be removed by typing the same name as an already added class.

It will automatically save the labels.csv file with the image path and label, and the class.txt file with the class of the label.

If labels.csv and class.txt are already in the folder, they will be loaded and reflected automatically.

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

To install latest development version :
pip install git+https://github.com/hiroalchem/napari-labelimg4classification.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 MIT license,
"napari-labelimg4classification" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-labelimg4classification

A simple image-level annotation tool supporting multi-channel images.

Marc Boucsein, Marc Buckmakowski

napari-medical-image-formats



A Plugin in order to read and write medical image formats such as DICOM, DICOM Series and NIfTI. The meta information is supported by the package napari-itk-io. 

Installation
You can install napari-medical-image-formats via pip:
pip install napari-medical-image-formats

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-medical-image-formats" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-medical-image-formats

A Plugin in order to read medical image formats such as DICOM and NIfTI

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,

Partial-Aligner



A napari plugin to affine transform images and parts of images in 2D and 3D. It was developed in the context of brain slice registration and solves multiple, related problems when working with histology slices.

Installation
You can install Partial-Aligner via pip:
pip install Partial-Aligner

To make full use of this plugin, please also install the sister plugins:
pip install Label-Creator
pip install Layer-Data-Replace
pip install World2Data

Usage
It is important to note that this plugin is part of a group of plugins (Label-Creator, Layer-Data-Replace, World2Data) which are intended to be used together. 
The principle workflow with this plugin is as follows:

Load an image of interest (ioi) using standard napari.
Find out meaningful transformation parameters for the ioi (or part of it) based on what you see in the viewer.
(optional) Save the affine transformation matrix (can later be applied to other modalities)
Apply the transformation to create a new, altered version of the ioi (use plugin World2Data)

Decisions on the parameters (step 2) are made based on the problem at hand:

Registration: You have a second (fixed) image and you want to align your ioi to that image? Transform your whole ioi! Just play with the transformation parameters until you are happy with the alignment of ioi and fixed image.


 
DAPI staining (red) before (left) and after (right) manual registration on an MRI image (green).


Histology artifact repair: Parts of your histology slice are misplaced? Transform the misplaced parts! Label them and change the transformation parameters for the misplaced parts until you are happy with their alignment with the rest of the image.


 
 Original slice with misplaced region (left), marked using the label function (middle) and after manual adjustment (right), where the misplaced region (green) was cut and newly positioned.

To make this plugin run reasonably fast, the affine transformations are not applied to the image data in real time. Instead, the internal napari viewing parameters are changed according to the transformation parameters. Therefore, to save transformed image data, the World2Data plugin is used, which calculates and saves the resulting image based on the internal napari viewing parameters.
Here we showcase a resulting multimodal 3D alignment of a whole mouse brain. The modalities are CT, MRI, simulated radiation dose distributions, DAPI staining and DNA-damage repair foci, with a Nissl-staining mouse atlas as template.
https://user-images.githubusercontent.com/36212786/149530462-51a53631-bf74-459b-ab4e-572c52cf2692.mov
Contributing
Contributions are very welcome. Tests can be run with tox.
License
Distributed under the terms of the BSD-3 license,
"Partial-Aligner" is free and open source software.
Issues
If you encounter any problems, please file an issue along with a detailed description.

Partial-Aligner

A napari plugin for manual registration of (a part of) an image

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.

Installation & Usage
Install the plugin with pip install stardist-napari or from within napari via Plugins > Install/Uninstall Package(s)…. 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: StarDist. Example images for testing are provided via File > Open Sample > StarDist.
For a more detailed demonstration of the plugin, please watch this short video.
There's no dedicated documentation yet, but the most important parameters are identical to those of our StarDist ImageJ/Fiji plugin, which are documented here.
If you use this plugin for your research, please cite us.
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.


stardist-napari

Matt McCormick

napari-itk-io





File IO with itk for napari.
Image metadata, e.g. the pixel spacing, origin, and metadata tags, are preserved and passed into napari.
Supported image file formats:

BioRad
BMP
DICOM
DICOM Series
ITK HDF5
JPEG
GE4,GE5,GEAdw
Gipl (Guys Image Processing Lab)
LSM
MetaImage
MINC 2.0
MGH
MRC
NifTi
NRRD
Portable Network Graphics (PNG)
Tagged Image File Format (TIFF)
VTK legacy file format for images

For DICOM Series, select the folder containing the series with File -> Open
Folder.... The first series will be selected and sorted spatially.
Installation
You can install napari-itk-io via pip:
pip install napari-itk-io

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.
Follow the itk contributing
guidelines
and the itk code of
conduct.
License
Distributed under the terms of the Apache Software License 2.0 license,
"napari-itk-io" is free and open source software.
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-itk-io

jhnnsrs

faser

Daniel Krentzel

PDF reader for napari
Reads PDF files into napari

napari-pdf-reader

Viktor van der Valk

napari-checkerboard





Compare two images with the itk checkerboard filter


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

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

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-checkerboard" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-checkerboard

Compare two images with the itk checkerboard filter

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

Niklas Netter

napari-timeseries-opener-plugin






Simple plugin that opens separate .tif files as a 3-dimensional layer.

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

Installation
You can install napari-timeseries-opener-plugin via pip:
pip install napari-timeseries-opener-plugin

To install latest development version :
pip install git+https://github.com/gatoniel/napari-timeseries-opener-plugin.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-timeseries-opener-plugin" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-timeseries-opener-plugin

Simple plugin that opens separate .tif files as a 3-dimensional layer.

Jay Unruh

napari-IP-workflow






A plugin to do image preprocessing, segmentation, and measurements on other images.  The typical workflow is background subtraction followed by smoothing, thresholding, and size filtering.  This is typically done on nuclear stained images.  Segmentation can optionally be followed by circular label expansion to find cytoplasmic signals. The labeled signals are then measured on background subtracted images.
General organization
The code is separated into non-interactive processing functions (ipfunctions module) and an interactive widget (segwidget module).  Please look at the code on github for examples: Github. The expected workflow is from jupyter notebooks with an interactive workflow shown in src/napari-ip-workflow/_tests/standard_segementation_widget.ipynb and a non-interactive workflow shown in src/napari-ip-workflow/_tests/standard_segmentation.ipynb.  The expectation is to find the best parameters in an interactive way (ideally testing on several images) and then use the non-interactive workflow to batch through more data sets.  All image processing algorithms are in the ipfunctions module and the segwidget module has the Napari widget code.  Below I describe the strategies that are utilized in the workflow.
Background subtraction strategy
Automated background subtraction (e.g. as in Fiji) is often accomplished with a low pass filter-style approach like rolling ball background subtraction.  This approach fails as feature sizes grow larger or measurements approach the background.  Manual selection of the background is more robust but introduces human variability and isn't compatible with high throughput analyses.  Our approach is to attempt to automate regional selection of background as follows.  First the image is smoothed with a Gaussian filter to eliminate background noise.  Next, minimum values are subtracted from each channel and the resulting images are summed.   Next, a uniform 2D boxcar smoothing is applied to the image--background level regions in the resulting image are at least the boxcar size distance away from foreground objects.  The minimum pixel in that resulting image is a good approximation for the background region of the image.  A thick border is specified to avoid lower intensity regions at the border of the image.  This algorithm is implemented in the ipfunctions module as findBackground.  Once the background region is found, it can be measured with measureCirc.
Segmentation and thresholding strategy
There are many automated thresholding algorithms available via python and, by extension, Napari.  This program uses a very simplistic but powerful method.  Most segmentable images consist of foreground and background components.  In imaging, the foreground is more noisy than the background.  Ideally a smoothed background subtracted image will have a maximum intensity that represents the foreground well and a background intensity of 0.  In that case, the threshold level can be easily defined as a fraction of that smoothed maximum intensity.  A threshold fraction of 0.25 tends to work well but lower values may be more robust if background is fairly smooth and the foreground is noisier.  In some cases the foreground has anomalous high values that will skew the estimation.  In that case it may be better to estimate the foreground as e.g. the 99th percentile of the intensity.  In some cases it may be useful to use the average intensity as a reference point instead or use the raw intensity value (statistic is Identity).  Those last options tend to be less robust and it may be desired in those cases to use some of the more complex autothresholding methods.  After thresholding, objects on the image edge are eliminated and objects are filtered according to size.  The minimum area can easy remove small debris that can contaminate a measurement.  The maximum area can be used for large contaminants or poorly segmented clusters of cells that might not be desired in the analysis.

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

Installation
You can install napari-IP-workflow via pip:
pip install napari-IP-workflow

To install latest development version :
pip install git+https://github.com/jayunruh/napari-IP-workflow.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-IP-workflow" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-IP-workflow

A plugin to do image preprocessing, segmentation, and measurements on other images.

William Patton

napari-affinities






A plugin for creating, visualizing, and processing affinities

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

Installation
Pre-requisites:
1) Install lsds with: `pip install git+https://github.com/pattonw/lsd.git@no-convenience-imports` (This is necessary since we need lsds but the package name `lsd` is already taken on pypi. While we resolve this the specific lsd version needs to be specified)

You can install napari-affinities via pip:
`pip install napari-affinities`

To install latest development version :
`pip install git+https://github.com/pattonw/napari-affinities.git`

Install torch according to your system (follow the instructions here). For example with cuda 10.2 available, run:
conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

Install conda requirements:
conda install -c conda-forge affogato

Download example model:
2D:
epithelial example model
Place the model zip file wherever you want. You can open it in the plugin with the "load from file" button.
3D
lightsheet example model
Unpack the tar file into test data (lightsheet_nuclei_test_data (an hdf5 file)) and model (LightsheetNucleusSegmentation.zip (a bioimageio model)).
Move the data into sample_data which will enable you to load the "Lightsheet Sample" data in napari.
Place the model zip file anywhere you want. You can open it in the plugin with the "load from file" button.
Workarounds to be fixed:

you need to update the rdf.yaml in the LightsheetNucleusSegmentation.zip with the following:
"shape" for "input0" should be updated with a larger minimum input size and "output0" should be updated with a larger halo. If not fixed, there will be significant tiling artifacts.
(Optional) "output0" should be renamed to affinities. The plugin supports multiple outputs and relies on names for figuring out which one is which. If unrecognized names are provided we assume the outputs are ordered (affinities, fgbg, lsds) but this is less reliable than explicit names.
This model also generates foreground in the same array as affinities, i.e. a 10 channel output (fgbg, [-1, 0, 0], [0, -1, 0], [0, 0, -1], [-2, 0, 0], ...). Although predictions will work, post processing such as mutex watershed will break unless you manually separate the first channel.

Use
Requirements for the model:

Bioimageio packaged pytorch model
Outputs with names "affinities", "fgbg"(optional) or "lsds"(optional)
if these names are not used, it will be assumed that the outputs are affinities, fgbg, then lsds in that order

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-affinities" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-affinities

A plugin for creating, visualizing, and processing affinities

Robert Haase, Ryan Savill

napari-assistant








The napari-assistant is a napari meta-plugin for building image processing workflows. 
Usage
After installing one or more napari plugins that use the napari-assistant as user interface, you can start it from the 
menu Tools > Utilities > Assistant (na) or run naparia from the command line. 
By clicking on the buttons in the assistant, you can setup a workflow for processing the images.

While setting up your workflow, you can at any point select a layer from the layer list (1) and change the parameters of
the corresponding operation (2). The layer will update when you change parameters and also all subsequent operations. 
You can also vary which operation is applied to the image (3). Also make sure the right input image layer is selected (4).

Saving and loading workflows
You can also save and load workflows to disk. 

After loading a workflow, make sure that the right input images are selected.
Code generation
The napari-assistant allows exporting the given workflow as Python script and Jupyter Notebook. 

Furthermore, if you have the napari-script-editor installed,
you can also send the current workflow as code to the script editor from the same menu.

Installation
It is recommended to install the napari-assistant via one of the plugins that use it as graphical user interface.
You find a complete list of plugins that use the assistant on the napari-hub.
For developers
If you want to make your napari-plugin accessible from the napari-assistant, consider programming functions with a simple 
interface that consume images, labels, integers, floats and strings. Annotate input and return types, e.g. like this:
```python
def example_function_widget(image: "napari.types.ImageData") -> "napari.types.LabelsData":
    from skimage.filters import threshold_otsu
    binary_image = image > threshold_otsu(image)
from skimage.measure import label
return label(binary_image)

```
Furthermore, please add your function to the napari.yaml which uses npe2:
name: napari-npe2-test
display_name: napari-npe2-test
contributions:
  commands: 
    - id: napari-npe2-test.make_magic_widget
      python_name: napari_npe2_test._widget:example_magic_widget
      title: Make example magic widget
  widgets:
    - command: napari-npe2-test.make_magic_widget
      display_name: Segmentation / labeling > Otsu Labeling (nnpe2t)
To put it in the right button within the napari-assistant, please use one of the following prefixes for the display_name:
* Filtering / noise removal >
* Filtering / background removal >
* Filtering >
* Image math >
* Transform >
* Projection >
* Segmentation / binarization >
* Segmentation / labeling >
* Segmentation post-processing >
* Measurement >
* Label neighbor filters >
* Label filters >
* Visualization >
You find a fully functional example here.
Last but not least, to make your napari-plugin is listed in the napari-hub when searching for "napari-assistant", make sure
you mention it in your readme.
Feedback welcome!
The napari-assistant is developed in the open because we believe in the open source community. Feel free to drop feedback as github issue or via image.sc
Contributing
Contributions are very welcome. Please ensure
the test coverage at least stays the same before you submit a pull request.
License
Distributed under the terms of the BSD-3 license,
"napari-assistant" 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. 
This project has been made possible in part by grant number 2021-240341 (Napari plugin accelerator grant) from the Chan Zuckerberg Initiative DAF, an advised fund of the Silicon Valley Community Foundation.

napari-assistant

A pocket calculator like interface to image processing in napari

Chris Havlin


yt-napari provides plugins to help load data from yt into napari. It includes a graphical data loader, json-based file loading and helper-functions for jupyter notebook interaction. See the full documentation for more details.

yt-napari

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.9

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).

Nicholas Sofroniew

napari-svg





A plugin for reading and writing svg files with napari

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

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

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-svg" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-svg

A plugin for reading and writing svg files with napari

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.

Juan Nunez-Iglesias & Abigail McGovern

platelet-unet-watershed





Segment platelets with pretrained unet and affinity watershed

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

Installation
You can install platelet-unet-watershed via pip:
pip install platelet-unet-watershed

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,
"platelet-unet-watershed" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

platelet-unet-watershed

Segment platelets with pretrained unet and affinity watershed

Tim Morello

napari-tiler









N-dimensional tiling and merging support for napari
This plugin allows the user to split an image into a stack of tiles and subsequently merge the tiles to reconstruct the orignal image.
See Tiler by @thelay for more details.

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

Installation
Option 1 (recommended)
You can install napari-tiler from the napari plugin manager. Go to Plugins -> Install/Uninstall Package(s), then search for napari-tiler. Click Install.
Option 2
You can also install napari-tiler via pip:
pip install napari-tiler

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

Quick Start

Open a file in napari. The file may have any number of dimensions (e.g. z-stack, time series, ...)
Start the plugin ( Plugins -> napari-tiler: make_tiles )
Select the input layer from the dropdown box
Select parameters for tiling
Click Run

Contributing
This project uses Poetry for dependency management.
To set up the development environment, it is recommended to use:
conda env create -f environment.yaml

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-tiler" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-tiler

N-dimensional tiling and merging support for napari

Computational Microscopy Platform, CZ Biohub

recOrder





This package offers a comprehensive pipeline, command line interface, and napari plugin for quantitative label-free microscopy.
In this repo you will find python tools and UI that allow the user to calibrate microscope hardware, acquire multi-modal data, reconstruct density and anisotropy, and visualize the data.
The acquisition, calibration, background correction, reconstruction, and applications of QLIPP are described in the following E-Life Paper:
Syuan-Ming Guo, Li-Hao Yeh, Jenny Folkesson, Ivan E Ivanov, Anitha P Krishnan, Matthew G Keefe, Ezzat Hashemi, David Shin, Bryant B Chhun, Nathan H Cho, Manuel D Leonetti, May H Han, Tomasz J Nowakowski, Shalin B Mehta, "Revealing architectural order with quantitative label-free imaging and deep learning," eLife 2020;9:e55502 DOI: 10.7554/eLife.55502 (2020).
recOrder is to be used alongside the QLIPP module, whose design has been optimized to fit on a conventional widefield microscope (Panel A below).  The QLIPP module allows for the collection of label-free information consisting of the intrinsic anisotropy of the sample and its relative phase (density).  All of these measurements are collected through compensated, polarization diverse illumination and quantitatively recovered through recOrder's computational reconstruction pipeline.  The overall structure of recOrder can be visualized below in Panel B, highlighting the two different usage modes and their features: graphical user interface (GUI) through napari and command line interfact (CLI).

Dataset
Slides and a dataset shared during a workshop on QLIPP and recOrder can be found on Zenodo.


Installation
Easy installation:
(Optional but recommended) install anaconda and create a virtual environment
conda create -n recorder python
conda activate recorder
Install napari:
pip install "napari[all]"
Open napari and use the Plugin > Install/Uninstall Plugins... menu to install recOrder-napari.
Developer installation:
Install git and conda (either anaconda or miniconda).
Create a conda environment dedicated to recOrder:
conda create -n recorder python
conda activate recorder
Clone this repository:
buildoutcfg
git clone https://github.com/mehta-lab/recOrder.git
Install recOrder and its dependencies:
buildoutcfg
cd recOrder
pip install -e ".[dev]"
Optional napari plugin: recOrder includes a napari plugin that can be used to acquire data via MicroManager. To install napari use
pip install "napari[all]"
To run the recOrder plugin use
napari -w recOrder-napari
To acquire data via MicroManager, follow the instructions on the wiki.
Optional GPU: recOrder supports NVIDIA GPU computation with the cupy package. Follow these instructions to install cupy and check its installation with import cupy. To enable gpu processing, set use_gpu: True in the config files.
Command-line usage
Type recOrder.help for instructions on the two command-line modes: recOrder.reconstruct and recOrder.convert.
recOrder.reconstruct
recOrder.reconstruct uses configuration files to select reconstruction parameters. Start with an example configuration file /examples/example_configs/config_example_qlipp.yml and modify the parameters to match your dataset.
Run the reconstruction with
buildoutcfg
recOrder.reconstruct --config <path/to/config.yml>
The following command-line arguments override parameters specified in the configuration file:
--method (str) method of reconstruction: QLIPP,IPS,UPTI'
   --mode (str) mode of reconstruction: 2D, 3D'
   --data_dir (str) path to raw data folder'
   --save_dir (str) path to folder where reconstructed data will be saved'
   --name (str) name under which to save the reconstructed data'
   --config (str) path to configuration file (see /examples/example_configs')
   --overwrite (bool) True/False whether or not to overwrite data that exists under save_dir/name'
For example, this command uses the QLIPP reconstruction method even if the configuration file specifies a different reconstruction method
buildoutcfg
recOrder.reconstruct --config /path/to/config.yml --method QLIPP
recOrder.convert
recOrder.convert converts MicroManager tif files to ome-zarr files. For example
buildoutcfg
recOrder.convert --input <path/to/mm/tifs> --output <path/to/output.zarr>  --data_type ometiff
License
Chan Zuckerberg Biohub Software License
This software license is the 2-clause BSD license plus clause a third clause
that prohibits redistribution and use for commercial purposes without further
permission.
Copyright © 2019. Chan Zuckerberg Biohub.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:


Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.


Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.


Redistributions and use for commercial purposes are not permitted without
the Chan Zuckerberg Biohub's written permission. For purposes of this license,
commercial purposes are the incorporation of the Chan Zuckerberg Biohub's
software into anything for which you will charge fees or other compensation or
use of the software to perform a commercial service for a third party.
Contact ip@czbiohub.org for commercial licensing opportunities.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

recOrder-napari

Computational microscopy toolkit for label-free imaging

David Stansby

napari-matplotlib







A plugin to create Matplotlib plots from napari layers

Introduction
napari-matplotlib is a bridge between napari and matplotlib, making it easy to create publication quality Matplotlib plots based on the data loaded in napari layers.
Available widgets
Slice
Plots 1D slices of data along a specified axis.

Histogram
Plots histograms of individual image layers, or RGB histograms of an RGB image

Scatter
Scatters the values of two similarly sized images layers against each other.

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

To install latest development version :
pip install git+https://github.com/dstansby/napari-matplotlib.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-matplotlib is free and open source software.
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-matplotlib

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

Robert Haase

napari-plot-profile







Plot intensities along a line in napari.

Usage


Open some images in napari.


Add a shapes layer.




Activate the line drawing tool or the path tool and draw a line.



After drawing a line, click on the menu Plugins > Measurements (Plot Profile)
If you modify the line, you may want to click the "Refresh" button to redraw the profile.


To see how these steps can be done programmatically from python, check out the demo notebook

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

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-plot-profile" 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-plot-profile

Richard De Mets

napari-yolov5






Plugin adapted from Ultralytics to bring YOLOv5 into Napari. 
Training and detection can be done using the GUI. Training dataset must be prepared prior to using this plugin. Further development will allow users to use Napari to prepare the dataset. Follow instructions stated on Ultralytics Github to prepare the dataset.
The plugin includes 3 pre-trained networks that are able to identify mitosis stages or apoptosis on soSPIM images. More details can be found on the pre-print.

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

Installation
First install conda and create an environment for the plugin
conda create --prefix env-napari-yolov5 python=3.9
conda activate env-napari-yolov5
You can install napari-yolov5 and napari via pip:
pip install napari-yolov5 
pip install napari[all]

For GPU support :
pip uninstall torch
pip install torchvision==0.10.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html
Usage
First select if you would like to train a new network or detect objects.

For Training :
Data preparation should be done following Ultralytics' instructions.
Select the size of the network, the number of epochs, the number of images per batch to load on the GPU, the size of the images (must be a stride of 32), and the name of the network.

An example of the YAML config file is provided in src/napari_yolov5/resources folder.

Progress can be seen on the Terminal. The viewer will switch to Detection mode automatically when the network is finished being trained.

For Detection :
It is possible to perform the detection on a single layer chosen in the list, all the layers opened, or by giving a folder path. For folder detection, all the images will be loaded as a single stack.

Nucleus size of the prediction layer has te be filled to resize the image to the training dataset. Nucleus size of the training dataset will be asked in case of a custom network.
Confidence threshold defines the minimum value for a detected object to be considered positive. 
iou nms threshold (intersection-over-union non-max-suppression) defines the overlapping area of two boxes as a single object. Only the box with the maximum confidence is kept.
Progress can be seen on the Terminal.

Few options allow for modification on how the boxes are being displayed (default : box + class + confidence score ; box + class ; box only) and if the box coordinates and the image overlay will be exported.
Post-processing option will perform a simple 3D assignment based on 3D connected component analysis. A median filter (1x1x3 XYZ) is applied prior to the assignment. 
The centroid of each object is then saved into a new point layer as a 3D point with a random color for each class. 

The localisation of each centroid is saved and the path is shown in the Terminal at the end of the detection.

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-yolov5" is free and open source software
Issues
If you encounter any problems, please [file an issue] along with a detailed description.

napari-yolov5

Plugin adapted from Ultralytics to bring YOLOv5 into Napari

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.

Joel Luethi and 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

napari-workflow-inspector







Inspect relationships between image processing operations in active workflows in napari. Open the inspector by clicking the menu Tools > Visualization > Workflow Inspector.

Also install the napari-script-editor 
to generate code from active workflows.

For recording workflows, all napari image processing plugins that use the @time_slicer interface are supported. See
napari-time-slicer for a list. More to come, stay tuned.
Installation
You can install napari-workflow-inspector via pip:
pip install napari-workflow-inspector
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-workflow-inspector" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-workflow-inspector

Inspect relationships between image processing operations in active workflows in napari

Trevor Manz

napari-dzi-zarr




An experimental plugin for viewing Deep Zoom Images (DZI) with napari + zarr + dask.

This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Description
The DZI File Format 
is a pyramidal tile source specification where individual tiles are RGB/RGBA JPEG/PNG images. 
DZI is a very popular tile source for zoomable web-viewers like 
OpenSeadragon, and as a result many tile sources are available over 
HTTP. This plugin wraps a DZI tile source (local or remote) as a multiscale Zarr, where each pyramidal level is a zarr.Array of shape (level_height, level_width, 3/4), allowing the same images to be viewed 
in napari + dask.
Installation
You can install napari-dzi-zarr via pip:
pip install napari-dzi-zarr

Usage
This high-resolution scan of Rembrandt's Night Watch is available thanks to R.G Erdmann. More examples can be found on boschproject.org.
$ napari http://hyper-resolution.org/dzi/Rijksmuseum/SK-C-5/SK-C-5_VIS_20-um_2019-12-21.dzi


Contributing
Contributions are very welcome. Tests can be run with tox.
License
Distributed under the terms of the BSD-3 license,
"napari-dzi-zarr" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-dzi-zarr

An experimental plugin for viewing Deep Zoom Images (DZI) with napari and zarr.

Ben Kantor

napari-bigwarp






BigWarp-like interface for napari

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

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

To install latest development version :
pip install git+https://github.com/bkntr/napari-bigwarp.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-bigwarp" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-bigwarp

SUSMITA SAHA

napari-mri





A simple plugin to use with napari for 3D-viewing of Magnetic Resonance Imaging file formats

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

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

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-mri" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-mri

A simple plugin to use with napari for 3D-viewing of                  Magnetic Resonance Imaging file formats

Andrea Bassi and Mark Neil

napari-sim-processor






A Napari plugin for the reconstruction of Structured Illumination Microscopy (SIM) with GPU acceleration (with pytorch, if installed).
Currently supports:  
   - conventional SIM data with a generic number of angle and phases (typically, 3 angles and 3 phases are used for resolution improvement in 2D)
   - 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 raw image stacks with multiple z-frames each plane is processed 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 napari widget to process Structured Illumination Microscopy data with gpu acceleration

Image-Composer



A napari plugin in order to compose a background image with a foreground image.

Installation
You can install Image-Composer via pip:
pip install Image-Composer

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,
"Image-Composer" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

Image-Composer

A napari plugin in order to compose a background image with a foreground image

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)

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

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

napari-clemreg

An automated point-set based registration algorithm for correlative light and electron microscopy (CLEM)
Installation
To install napari-clemreg it is recommended to create a fresh conda enviornment with Python 3.8:
conda create -n clemreg_env python=3.8
Next, install napari with the following command via pip: 
pip install "napari[all]"
Finally, napari-clemreg can be installed with:
pip install napari-clemreg
When installing napari-clemreg on a Windows machine, the following error might appear:
error Microsoft Visual C++ 14.0 is required
Ensure that Visual Studios C++ 14.00 is installed
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-clemreg" 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-clemreg

A plugin for registering multimodal image volumes based on common segmented structures of interest with point-clouds.

Zach Marin, Robert Haase

napari-pymeshlab






Interfaces between napari and the pymeshlab library to allow import, export, construction and processing of surfaces. 
This is a WIP and feature requests are welcome. Please check PyMeshLab
for possible features.

Feature list

Read/write .3ds, .apts, .asc, .bre, .ctm, .dae, .e57, .es, .fbx, .glb, .gltf, .obj, .off, .pdb, .ply,
                  .ptx, .qobj, .stl, .vmi, .wrl, .x3d, .x3dv
Screened Poisson Surface Reconstruction
Convex hull of a surface
Laplacian smoothing of surfaces
Smoothing surfaces using Taubin's method
Surface simplification using clustering decimation
colorize_curvature_apss

Some functions are shown in the demo notebook.


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

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-pymeshlab" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-pymeshlab

Interfaces between napari and pymeshlab library to allow import, export and construction of surfaces.

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

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

The segmentation game - for napari







Gamified image segmentation quality estimation


Usage
The Segmentation Game allows to quantitatively compare segmentation results to a given ground truth annotation.
This allows fine-tuning parameters of image processing workflows to get optimal segmentation quality. 
It also allows comparing different segmentation algorithms and identify which algorithm performs best objectively.
The game can be found in napari's Tools > Games > The Segmentation Game menu.
Ground Truth Annotation
Before you can start playing the game, some annotated cells/nuclei are necessary to later compute segmentation quality from.
Depending on the used metric, it might be sufficient to annotate a hand full of objects. 
Use napari's annotation tools as shown below. 
Use the + and - keys on your keyboard to increase and decrease the label number that is currently drawn.

Parameter tuning
If you work with one of napari's segmentation plugins that produce labels layers,
you can tune their parameters and see how this influences segmentation quality.

Segmentation algorithm comparison
If you aim at comparing different segmentation algorithms, you can collect their results in label layers in the napari viewer.
You can then select the segmentation result from the corresponding pulldown and save quantitative comparison results in the Highscore table.

Metrics
Currently, these metrics are implemented:
* Jaccard Index (sparse): The Jaccard Index is a measure of overlap. 
  It lies between 0 (no overlap) and 1 (perfect overlap). 
  For each annotated ground truth label, the maximum overlap of any segmented label is determined. 
  The mean overlap of all annotated labels serves as metric result.
* Jaccard Index (binary): The annotated ground truth labels and the segmentation result are first binarized considering all annotated pixels as positive and all other labels as negative.
  Afterwards, the overlap between the two binary images is computed. This allows comparing binary segmentation algorithms, such as thresholding techniques.
* Jaccard Index (binary, sparse): The annotated ground truth image can contain values 1 (negative, false) and 2 (positive, true) and
  the segmentation result image will be binarized (0: False, otherwise: True). This allows comparing object/no-object annotations with label images.
Related plugins
If you aim at automatically optimizing segmentation quality, there are also napari plugins available with this capability:

napari-accelerated-pixel-and-object-classification
napari-workflow-optimizer

Installation
You can install the-segmentation-game via pip:
pip install the-segmentation-game

Contributing
Contributions - especially new image segmentation quality metrics - 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,
"the-segmentation-game" is free and open source software
Issues
If you encounter any problems, please open a thread on image.sc along with a detailed description.

the-segmentation-game

Gamified image segmentation quality estimation

Mauro Silberberg

text/markdown; charset=UTF-8; variant=GFM

SMO
SMO is a Python package that implements the Silver Mountain Operator (SMO), which allows to recover an unbiased estimation of the background intensity distribution in a robust way.
We provide an easy to use Python package and plugins for some of the major image processing softwares: napari, CellProfiler, and ImageJ / FIJI. See Plugins section below.
Usage
To obtain a background-corrected image, it is as straightforward as:
```python
import skimage.data
from smo import SMO
image = skimage.data.human_mitosis()
smo = SMO(sigma=0, size=7, shape=(1024, 1024))
background_corrected_image = smo.bg_corrected(image)
```
where we used a sample image from scikit-image.
A notebook explaining in more detail the meaning of the parameters and other possible uses for SMO is available here: smo/examples/usage.ipynb .
Installation
It can be installed with pip from PyPI:
pip install smo
Plugins
Napari
A napari plugin is available.
To install:


Option 1: in napari, go to Plugins > Install/Uninstall Plugins... in the top menu, search for smo and click on the install button.


Option 2: just pip install this package in the napari environment.


It will appear in the Plugins menu.
CellProfiler
A CellProfiler plugin in available in the smo/plugins/cellprofiler folder.

To install, save this file into your CellProfiler plugins folder. You can find (or change) the location of your plugins directory in File > Preferences > CellProfiler plugins directory.
ImageJ / FIJI
An ImageJ / FIJI plugin is available in the smo/plugins/imagej folder.

To install, download this file and:


Option 1: in the ImageJ main window, click on Plugins > Install... (Ctrl+Shift+M), which opens a file chooser dialog. Browse and select the downloaded file. It will prompt to restart ImageJ for changes to take effect.


Option 2: copy into your ImageJ plugins folder (File > Show Folder > Plugins).


To use the plugin, type smo on the bottom right search box:

select smo in the Quick Search window and click on the Run button.

Note: the ImageJ plugin does not check that saturated pixels are properly excluded.
Development
Code style is enforced via pre-commit hooks. To set up a development environment, clone the repository, optionally create a virtual environment, install the [dev] extras and the pre-commit hooks:
git clone https://github.com/maurosilber/SMO
cd SMO
conda create -n smo python pip numpy scipy
pip install -e .[dev]
pre-commit install

Implementation of the Silver Mountain Operator (SMO) for the estimation of background distributions.

Luis Perdigao

Red lionfish (RL) deconvolution
Richardson-Lucy deconvolution for fishes, scientists and engineers.
This software is for filtering 3D data using the Richardson-Lucy deconvolution algorithm.
Richardson-Lucy is an iterative deconvolution algorithm that is used to remove
point spread function (PSF) or optical transfer function (OTF) artifacts from experimental images.
The method was originally developed for astronomy to remove optical effects and simultaneously reduce poisson noise in 2D images.
Lucy, L. B. An iterative technique for the rectification of observed distributions. The Astronomical Journal 79, 745 (1974). DOI: 10.1086/111605
The method can also be applied to 3D data. Nowadays this filtering technique is also widely used by microscopists.
The Richardson-Lucy deconvolution algorigthm is iterative. Each iteration involves the calculation of 2 convolutions, one element-wise multiplication and one element-wise division.
When dealing with 3D data, the Richardson-Lucy algorithm is quite computional intensive primarly due to the calculation of the convolution, and can take a while to complete depending on the resources available. Convolution is significantly sped up using FFT compared to raw convolution.
This software was developed with the aim to make the R-L computation faster by exploiting GPU resources, and with the use of FFT convolution.
To make RedLionfish easily accessible, it is available through PyPi and anaconda (conda-forge channel). A useful plugin for Napari is also available.
Please note that this software only works with 3D data. For 2D data there are many alternatives such as the DeconvolutionLab2 in Fiji (ImageJ) and sckikit-image.
Installation
It is strongly recommended to install this package under a python anaconda or miniconda environment.
This is because some calculations use PyOpenCL, and this is best installed in a conda environment.
Conda install (recommended)
This package is available in conda-forge channel.
It contains the precompiled libraries and it will install all the requirments for GPU-accelerated RL calculations.
conda install redlionfish -c conda-forge
Install from PyPi
A major problem in installing using pip is that the installation of the optional package PyOpenCL needs to perform a build step.
If you want to make the GPU acceleration accessible you can pre-install Reikna and PyOpenCL using conda.
conda install reikna pyopencl -c conda-forge
pip install redlionfish
In Linux , the package ocl-icd-system is also useful.
conda install reikna pyopencl ocl-icd-system -c conda-forge
pip install redlionfish
Manual installation using the conda package file.
Download the appropriate conda package .bz2 at https://github.com/rosalindfranklininstitute/RedLionfish/releases
In the command line, successively run:
conda install <filename.bz2>
conda update --all -c conda-forge
The second line is needed because you are installing from a local file, conda installer will not install dependencies. Right after this you should run the update command given.
Napari plugin
If you follow the installation instructions above, and install the napari in the same conda environment
then the plugin should be immediately available in the Menu -> Plugins -> RedLionfish.

Alternatively, you can use the Napari's plugin installation in Menu -> Plugins -> Install/Uninstall Plugins....
However, if you chose to use this method, GPU acceleration may not be available and it will use the CPU backend.
Manual installation (advanced and for developers)
Please note that in order to use OpenCL GPU accelerations, PyopenCL must be installed.
The best way to get it working is to install it under a conda environment.
The installation is similar to the previously described for PyPi.
conda install reikna pyopencl
or
conda install reikna pyopencl ocl-icd-system -c conda-forge (Linux)
Clone/download from source https://github.com/rosalindfranklininstitute/RedLionfish/
and run
python setup.py install
Debug installation
If you want to test and modify the code then you should probably install instead using:
python setup.py develop
More information
The software has algorithms for Richardson-Lucy deconvolution that use either CPU and GPU.
The CPU version is very similar to the skimage.restoration.richardson_lucy code, with improvments in speed.
major differences are:

the convolution steps use FFT only.
PSF and PSF-flipped FFTs are precalcated before starting iterations.

The GPU version, was written in to use Reikna package, which does FFT using OpenCL, via PyOpenCL.
Unfortunately, a major limitation in RAM usage exists with PyOpenCL.
Large 3D data volumes with cause out-of-memory error when trying to upload data to the GPU for FFT calculations.
As such, to overcome this problem, a block algorithm is used, which splits data into blocks with padded data.
The results are then combined together to give the final result.
This affects the perfomance of the calculation rather significantly, but with the advantage of being possible to handle large data volumes.
If Richardson-Lucy deconvolution using the GPU method fails, RedLionfish will falls back to CPU calculation. Check console output for messages.
If you are using the RedLionfish in your code, note that, by default, def doRLDeconvolutionFromNpArrays() method it uses the GPU OpenCL version.
Testing
Many examples can be found in `/test' folder.
Computer generated data and an experimental PSF can be found in test\testdata
Here is an example using the Redlionfish plugin in napari:

load data test\testdata\gendata_psfconv_poiss_large.tif
load psf data test\testdata\PSF_RFI_8bit.tif
In the RedLionfish side window ensure that 'gendata_psfconv_poiss_large' is selected in data dropdown widget, and PSF_RFI_8bit is selected in psfdata widget.
Choose number of iterations (default=10)
Click 'Go' button and wait until result shows as a new data layer.
Use controls of the left panel to compare before and after RL deconvolution: select 'RL-deconvolution' layer and set colormap to red. Hide PSF_RFI_8bit. Make sure that both 'RL-deconvolution' and 'gendata-psfconv' are visible. Now, hide/unhide RL-deconvolution layer to see before and after deconvolution. Adjust contrast limits of each layer as desired.

For benchmarking, it is recommended to run test_and_benchm.py from the command line.
This will print out information about your GPU device (if available) and run some deconvolutions.
It initially creates some data programatically, convolutes with a gaussian PSF, and add Poisson noise.
Then it executes executes the
Richardson-Lucy deconvolution calculation using CPU and GPU methods, for 10 iterations.
During the calculation it will print some information to the console/terminal, including the time it takes to run the calculation.
GPU vs CPU
You may notice that choosing GPU does not make RL-calculation much faster compared with CPU, and sometimes is slower.
Which method runs the R-L deconvolution faster. That depends on the computer configuration/architecture.
GPU calculations will be generally faster than CPU with bigger data volumes.
GPU calculation will be significantly faster if using a dedicated GPU card.
Please see benchmark values that highlights significant variability in calculation speeds.
Coding
Please feel free to browse /test folder for examples.
In your code, add the import.
import RedLionfishDeconv
in order to use the functions.
The most useful function is perhaps the following.
def doRLDeconvolutionFromNpArrays(data_np , psf_np ,*, niter=10, method='gpu', useBlockAlgorithm=False, callbkTickFunc=None, resAsUint8 = False)
This will do the Richardson-Lucy deconvolution on the data_np (numpy, 3 dimensional data volume) using the provided PSF data volume, for 10 iterations. GPU method is generally faster but it may fail. If it does fail, the program will automatically use the CPU version that uses the scipy fft package.
Manually building the conda package
For this installation, ensure that the conda-build package is installed
conda install conda-build
In windows, simply execute
conda-create-package.bat
Or, execute the following command-line to create the installation package.
conda-build --output-folder ./conda-built-packages -c conda-forge conda-recipe
and the conda package will be created in folder conda-built-packages.
Otherwise, navigate to conda-recipe, and execute on the command-line conda build .
It will take a while to complete.
Contact
Report issues and questions in project's github page, please. Please don't try to send emails as they may be igored or spam-filtered.

RedLionfish

Fast Richardson-Lucy deconvolution of 3D volume data using GPU or CPU with napari plugin.

Graham Dellaire, Robert Haase

BBii-Decon






Projected Barzilai-Borwein Image Deconvolution with Infeasible Iterates (BBii-Decon)
The projected Barzilai-Borwein method of image deconvolution utilizing infeasible iterates (BBii-Decon), utilizes Barzilai-Borwein (BB) or projected BB (PBB) method and enforces a nonnegativity constraint, but allows for infeasible iterates between projections. This algorithm (BBii) results in faster convergence than the basic PBB method, while achieving better quality images, with reduced background than the unconstrained BB method (1). 
The code represented is based on the original BBii algorithm written in MatLab by Kathleen Fraser and Dirk Arnold, which was ported to python 3.8 by Graham Dellaire, Dirk Arnold and Kathleen Fraser for non-commercial use.
The first implementation shown here is for 2D deconvolution using a known 2D PSF of 256 X 256 pixels, and images of at least 256 pixels in one dimension. One file implements just the deconvolution of a blurred image, while the second file contains a modification of the BBii-Decon algorithm that has a built in heuristic for measuring image reconstruction error relative to a ground truth image. For general 2D deconvolution, either a theoretical 2D PSF (if you know the optical properties of your system) or the central in focus image of a fluorescent bead taken with the same imaging setup (lens, magnification, camera) can produce a suitable PSF.
GPU-acceleration
For most 2D deconvolution, optimal results are obtained with 10 iterations of the algorithm. However, if processing takes too long, acceleration using graphics processing units (GPUs) may make sense, especially for processing larger images with >10 iterations or 3D images. (Note: At this time BBii-Decon is optimized for 2D deconvolution, with a 3D implementation planned in future). 
This plugin supports accelerated processing using the cupy library. To make use of it, please follow 
the instructions to install cupy. 
Installation may look like this:
conda create --name cupy_p38 python=3.8
conda activate cupy_p38
conda install -c conda-forge cupy cudatoolkit=10.2
If cupy installation worked out, you will find another checkbox in the user interface. By activating it, processing 
should become faster by factor 5-10, depending on processed image data and use GPU hardware.

Usage - napari
You can use the BBii deconvolution from within napari by clicking the menu Plugins > bbii-decon > bbii deconvolution. 
In the dialog, select the PSF, the image to process (a) and click on Run. After a moment, the deconvolved image (b) 
will show up.

Usage from python
You can also call the function from python. There is a full working example in this notebook.
```
from bbii_decon import bbii
bbii(PSF, image, number_of_iterations = 15, tau = 1.0e-08, rho = 0.98)
```
Citation
1) Kathleen Fraser, Dirk V. Arnold, and Graham Dellaire (2014). Projected Barzilai-Borwein
method with infeasible iterates for nonnegative least-squares image deblurring. In Proceedings
of the Eleventh Conference on Computer and Robot Vision (CRV 2014), Montreal, Canada, pp.
189--194.

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

Installation
You can install bbii-decon via pip:
pip install bbii-decon

Installation for developers
Clone the github repository:
```
conda install git
git clone https://github.com/gdellaire/BBii-Decon.git
cd BBii-Decon
pip install -e .
```
Deployment to pypi
For deploying the plugin to the python package index (pypi), one needs a pypi user account 
first. For deploying the plugin to pypi, one needs to install some tools:
python -m pip install --user --upgrade setuptools wheel
python -m pip install --user --upgrade twine
The following command allows us to package the souce code as a python wheel. Make sure that the 'dist' and 'build' folders are deleted before doing this:
python setup.py sdist bdist_wheel
This command ships the just generated to pypi:
python -m twine upload --repository pypi dist/*
Read more about distributing your python package via pypi.
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,
"bbii-decon" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

bbii-decon

Projected Barzilai-Borwein Image Deconvolution with Infeasible Iterates (BBii-Decon)

Offset-Subtraction



A napari plugin in oder to subtract an intensity offset such as autofluorescence

Installation
You can install Offset-Subtraction via pip:
pip install Offset-Subtraction

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,
"Offset-Subtraction" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

Offset-Subtraction

A napari plugin in oder to subtract an intensity offset such as autofluorescence

Search for a plugin by keyword or author

Browse plugins: 188

napari-roi-registration

version

release date

Plugin type

napari-time-slicer

version

release date

Plugin type

devbio-napari

version

release date

Plugin type

vollseg-napari

version

release date

Plugin type

arcos-gui

version

release date

Plugin type

Apple

version

release date

Plugin type

DEXP

version

release date

Plugin type

btrack

version

release date

Plugin type

napari labels overlap

version

release date

Plugin type

Napari Error Reporter

version

release date

Plugin type

napari-sc3D-viewer

version

release date

Plugin type

beetlesafari

version

release date

Plugin type

Blossom

version

release date

Plugin type

Hesperos application

version

release date

Plugin type

napari-flowering-apple-tree-pixel-classification

version

release date

Plugin type

Sign up to receive updates