Daniel Krentzel

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.

Robert Haase

napari-script-editor






A python script editor for napari based on haesleinhuepf's fork of PyQode.

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

Usage
Start the script editor from the menu Tools > Scripts > Script Editor. Use the auto-completion while typing, 
check out the napari tutorials and the
example scripts. 
Use the Run button to execute a script.

If you save the script to the folder ".napari-scripts" in your home directory, you will find the script in the 
Tools > Scripts menu in napari. You can then also start it from there.

Note: If you have scripts, that might be useful to others, please send them as 
pull-request to the examples in 
repository or share them in any other way that suits you.
Installation

Get a python environment, e.g. via mini-conda. 
  If you never used python/conda environments before, please follow the instructions 
  here first.
Install napari using conda. 

conda install -c conda-forge napari
Afterwards, install napari-script-editor using pip:
pip install napari-script-editor
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-script-editor" is free and open source software
Known issues

Sometimes, the script editor thinks, the file has been changed on disk and asks to reload it.

Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-script-editor

Jonas Windhager

napari-roi






Select regions of interest (ROIs) using napari
Installation
You can install napari-roi via pip:
pip install napari-roi

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

Usage
The napari-roi plugin can be opened from within napari.
Authors
Created and maintained by Jonas Windhager jonas.windhager@uzh.ch
Contributing
Contributing
Changelog
Changelog
License
MIT

napari-roi

Select regions of interest (ROIs) using napari

Chenqi Zhang

disease-classifier






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

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

Introduction
Load data (.rtdc or .bin)

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


Choose model and classify

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


Preview classification results

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


Save results

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


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

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


disease-classifier

A disease classifier based on iPAC images.

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

napari-bioimageio
napari plugin for managing AI models in the BioImage Model Zoo.

WARNING: This is an alpha release. The API may change in future versions, and please feel free to create issues to report bugs or provide feedbacks.


Installation
pip install napari-bioimageio
(If you don't have napari installed, run pip install napari[pyqt5])
Usage
This library is meant for helping developers to ease the handling of models in napari.
We provide a set of API functions for managing and selecting models.
show_model_manager()
Show the model manager with a model list pulled from the BioImage Model Zoo, the user can explore all the available models, download or remove models.
show_model_selector(filter=None)
Display a dialog for selecting models from the BioImage Model Zoo, the user can either select an existing model or download from the BioImage Model Zoo.
The selecte model information (a dictionary) will be returned if the user selected a model, otherwise it returns None.
Once the user selected the model, you can access the name, and also the file path to the model resource description file (via the rdf_source key). With the bioimageio.core library (installed via pip install bioimageio.core or conda install -c conda-forge bioimageio.core), you can run inference directly, the following examples shows how to implement it:
```python
Popup a model selection dialog for choosing the model
model_info = show_model_selector(filter=nuclear_segmentation_model_filter)
if model_info:
  self.nucseg_model_source = model_info["rdf_source"]
  # Load model 
  model_description = bioimageio.core.load_resource_description(model_info["rdf_source"])
  input_image = imageio.imread("./my-image.tif")
with bioimageio.core.create_prediction_pipeline(
      bioimageio_model=model_description
  ) as pipeline:
    output_image = bioimageio.core.prediction.predict_with_padding(
        pipeline, input_image, padding=padding
    )
```
Note: To run the models, you need to setup the conda environment properly according to the installation guide of bioimageio.core.
For more examples, see this example notebook for bioimageio.core.
You can also access the weight files directly by searching the model folder (e.g. extract the model folder path via os.path.dirname(model_description["rdf_source"])), this will be useful if you prefer to use your own model inference logic.
show_model_uploader()
Display a dialog to instruct the user to upload a model package to the BioImage Model Zoo.
Currently, it only shows a message, in the future, we will try to support direct uploading with user's credentials obtained from Zenodo (a public data repository used by the BioImage Model Zoo to store models).
To create a BioImageIO-compatible model package, you can use the build_model function as demonstrated in this notebook.
Development

Install and set up development environment.

sh
  pip install -r requirements_dev.txt
This will install all requirements.
It will also install this package in development mode, so that code changes are applied immediately without reinstall necessary.

Here's a list of development tools we use.
black
flake8
mypy
pydocstyle
pylint
pytest
tox
It's recommended to use the corresponding code formatter and linters also in your code editor to get instant feedback. A popular editor that can do this is vscode.
Run all tests, check formatting and linting.

sh
  tox

Run a single tox environment.

sh
  tox -e lint

Reinstall all tox environments.

sh
  tox -r

Run pytest and all tests.

sh
  pytest

Run pytest and calculate coverage for the package.

sh
  pytest --cov-report term-missing --cov=napari-bioimageio

Continuous integration is by default supported via GitHub actions. GitHub actions is free for public repositories and comes with 2000 free Ubuntu build minutes per month for private repositories.


napari-bioimageio

Herearii Metuarea

napari-apple






Detection of apple based on YOLOv4 model

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

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

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

napari-apple

Sylvain Prigent

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



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

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

napari-stracking

Charlotte Godard



# Hesperos plugin for Napari

[![License](https://img.shields.io/pypi/l/hesperos.svg?color=green)](https://github.com/DBC/hesperos/raw/main/LICENSE)
[![PyPI](https://img.shields.io/pypi/v/hesperos.svg?color=green)](https://pypi.org/project/hesperos)
[![Python Version](https://img.shields.io/pypi/pyversions/hesperos.svg?color=green)](https://python.org)
[![tests](https://github.com/DBC/hesperos/workflows/tests/badge.svg)](https://github.com/DBC/hesperos/actions)
[![codecov](https://codecov.io/gh/DBC/hesperos/branch/main/graph/badge.svg)](https://codecov.io/gh/DBC/hesperos)
[![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/hesperos)](https://napari-hub.org/plugins/hesperos)

    TODO : DESCRIPTION

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



# Table of Contents
- [Installation and Requirements](#installation-and-requirements)
    * [Automatic installation](#automatic-installation)
    * [Manual installation](#manual-installation)
    * [Upgrade Hesperos version](#upgrade-hesperos-version)
- [Hesperos: Manual Segmentation and Correction](#hesperos-manual-segmentation-and-correction)
    * [Load your image](#load-your-image)



# Installation and Requirements
Hesperos plugin is designed to run on Windows operating system and macOS with Python 3.8, 3.9 or 3.10.

## Automatic installation
1. Install [Anaconda] and deselect *Add to PATH*. Note the path where you install anaconda.

2. Download only the *script_files* folder, for [Windows](/script_files/for_Windows/) or [Macos](/script_files/for_Windows/).

3. Add the Anaconda path in these script files:
    1. For Windows: 
    Right click on the .bat files (for [installation](/script_files/for_Windows/install_hesperos_env.bat) and [running](/script_files/for_Windows/run_hesperos.bat)) and select *Modify*. Change *PATH_TO_ADD* with your Anaconda path. Then save changes.
        > for exemple: $ `anaconda_dir=C:\Users\chgodard\anaconda3` 
    2. For Macos:
        1. Right click on the .command files (for [installation](/script_files/for_Macos/install_hesperos_env.command) and [running](/script_files/for_Macos/run_hesperos.command)) and select *Open with TextEdit*. Change *PATH_TO_ADD* with your Anaconda path. Then save changes.
            > for exemple: $ `source ~/opt/anaconda3/etc/profile.d/conda.sh ` 
        2. On your terminal allow running of your .command files (change *PATH* with the path of your .command files): 
            > $ `chmod u+x PATH/install_hesperos_env.command `

            > $ `chmod u+x PATH/run_hesperos.command `

4. Double click on the **install_hesperos_env file** to create a virtual environment in Anaconda with python 3.9 and Napari 0.4.14. /!\ Hesperos plugin is not yet compatible with Napari version superior to 0.4.14.

5. Double click on the **run_hesperos file** to run napari from your virtual environment.

6. On Napari: 
    1. Go to *Plugins/Install Plugins...*
    2. Search for "hesperos" (it can take a while to load).
    3. Install **hesperos** plugin.
    4. When installation is done, close Napari. A restart of Napari is needed to take in consideration the new installed plugin.

7. Double click on the **run_hesperos file** to run Napari.

8. On Napari, use the hesperos plugin with *Plugins/hesperos*.

## Manual installation
1. Install [Anaconda] and deselect *Add to PATH*.
2. Open your Anaconda prompt command.
3. Create a virtual environment with Python 3.8, 3.9 or 3.10 :
    > $ ` conda create -n hesperos_env python=3.9`  
4. Install Python packages (in your virtual environment):
    > $ ` conda activate hesperos_env` 

    > $ ` conda install -c conda-forge napari=0.4.14` /!\ Hesperos plugin is not yet compatible with napari version superior to 0.4.14.

    > $ ` conda install -c anaconda pyqt` if needed

    > $ ` pip install hesperos`             
5. Launch Napari:
    > $ ` napari`

## Upgrade Hesperos version
1. Double click on the **run_hesperos file** to run Napari. 
2. On Napari: 
    1. Go to *Plugins/Install Plugins...*
    2. Search for "hesperos" (it can take a while to load).
    3. Click on *Update* if a new version of Hesperos have been found. You can check the last version of Hesperos in the [Napari Hub](https://www.napari-hub.org/plugins/hesperos).
    4. When installation is done, close Napari. A restart of Napari is needed to take in consideration the new installed plugin.



# Hesperos: Manual Segmentation and Correction

## Loading panel
Hesperos plugin can be used with Digital imaging and communications in medicine (DICOM), Neuroimaging Informatics Technology Initiative (NIfTI) or Tagged Image File Format (TIFF) images. To improve performances, use images that are located on your disk.

To load a image file (.tiff, .tif, .nii or .nii.gz) use the IMAGE button. To load a unique DICOM serie use the IMAGE button. Folder with multiple DICOM series is not supported.  

After Loading, a slider appears to zoom in/out on the image. Zoom is also possible with the mouse scroller. 
If the image is a DICOM serie, a default contrast  have the possibility to select a default contrast for the image (to highlight bones or soft tissues according to their Hounsfield Units.) 

## 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,
"hesperos" is free and open source software

[napari]: https://github.com/napari/napari
[Cookiecutter]: https://github.com/audreyr/cookiecutter
[@napari]: https://github.com/napari
[BSD-3]: http://opensource.org/licenses/BSD-3-Clause
[cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin

[tox]: https://tox.readthedocs.io/en/latest/
[pip]: https://pypi.org/project/pip/
[PyPI]: https://pypi.org/

[Anaconda]: https://www.anaconda.com/products/distribution#Downloads

hesperos

A plugin to manually or semi-automatically segment medical data and correct previous segmentation data.

Marcelo Leomil Zoccoler

napari-metroid






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

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

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

Table of Contents

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

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

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

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

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

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

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

Open Plugin Main Interface

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

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

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

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

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

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

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

napari-metroid

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

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

Talley Lambert

napari-bioformats






Bioformats plugin for napari using
pims-bioformats

Use this plugin as a fallback!
Anyone coming to napari from the Fiji/ImageJ world will likely be aware of the
incredible Bio-Formats
library.  A heroic effort, built over years, to read
more than a 100 file formats.  Naturally, we want some of that goodness for napari ... hence this plugin.
However: it's important to note that this plugin still
requires having a java runtime engine installed.  This is easy enough to do
(the plugin will ask to install it for you if you're in a conda environment), but
it definitely makes for a more complicated environment setup, it's not very
"pythonic", and the performance will likely not feel as snappy as a native "pure"
python module.
So, before you reflexively install this plugin to fill that bio-formats
sized hole in your python heart, consider trying some of the other pure-python
plugins designed to read your format of interest:

Zeiss (.czi): napari-aicsimageio, napari-czifile2
Nikon (.nd2): napari-nikon-nd2, nd2-dask
Leica (.lif): napari-aicsimageio
Olympus (.oif): no plugin?  (but see oiffile )
DeltaVision (.dv, .mrc): napari-dv


if you have a pure-python reader for a bio-formats-supported file format that
you'd like to see added to this list, please open an issue

Installation
The easiest way to install napari-bioformats is via conda, from the
conda-forge channel:
conda install -c conda-forge napari-bioformats

It is also possible to install via pip, but you will need to have a working
JVM installed, and may need to set the JAVA_HOME environment variable
pip install napari-bioformats

First Usage
The first time you attempt to open a file with napari-bioformats, you will
likely notice a long delay as pims downloads the loci_tools.jar (speed will
depend on your internet connection). Subsequent files should open more quickly.
License
Distributed under the terms of the GPLv3 license,
"napari-bioformats" 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 with @napari's cookiecutter-napari-plugin template.

napari-bioformats

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

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

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

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




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




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


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


napari-sairyscan

Jordão Bragantini

Grabber: A Tool to Improve Convergence in Interactive Image Segmentation





A tool for contour-based segmentation correction (2D only).
This repository provides a demo code of the paper:

Grabber: A Tool to Improve Convergence in Interactive Image Segmentation
Jordão Bragantini, Bruno Moura, Alexandre X. Falcão, Fábio A. M. Cappabianco

https://user-images.githubusercontent.com/21022743/145699960-57da06a5-668f-4e81-82b5-7f3d3ddf8ee3.mp4

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

Installation
You can install grabber-ift via pip:
pip install grabber-ift

Known Limitations
This implementation doesn't support the items below, feel free to open a PR to add them.

It only support 2D image, supporting 3D images isn't trivial, but it could be applied per slice with minor changes.

Citation
If this work was useful for your research, please cite our paper:
@article{bragantini2020grabber,
  title={Grabber: A Tool to Improve Convergence in Interactive Image Segmentation,
  author={Bragantini, Jord{\~a}o and Bruno Moura, Falc{\~a}o, Alexandre Xavier and Cappabianco, F{\'a}bio AM,
  journal={Pattern Recognition Letters},
  year={2020}
}
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,
"grabber" is free and open source software
Issues
If you encounter any problems, please [file an issue] along with a detailed description.

grabber-ift

A tool for contour-based segmentation correction (2D only).

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,

Description
napari-sdeconv is a suite of Napari plugins for the sdeconv library
<https://sylvainprigent.github.io/sdeconv/>_ dedicated to 2D and 3D images deconvolution. It contains multiple
deconvolution algorithms and PSF Generators.

Example of deconvolution with Spitfire



Example of how to generate a 3D PSF


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

Note that the current version of the package only support python 3.9    
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-tracks-reader" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-sdeconv

Viktor van der Valk

Description
This plugin makes the elastix toolbox for rigid and nonrigid registration of images available in napari.
elastix is open source software, based on the well-known Insight Segmentation and Registration Toolkit (ITK). The software consists of a collection of algorithms that are commonly used to solve (medical) image registration problems. The modular design of elastix allows the user to quickly configure, test, and compare different registration methods for a specific application.
Who is This For?
With this plugin both 2D and 3D images in all file formats available in ITK can be registered.
The plugin supports various transformations including rigid, affine and bspline.
Registration within the plugin is done based on user defined parameters, but for novice users
defaults for each transformation model are available.
How to Guide
Load the images you want to register into napari and select them in the fixed (or reference) and moving image dropdowns of plugin interface.
For fast and easy registration only the preferred transformation (rigid, affine or bspline) has to be selected (see Transformations section for explanation).
For more advanced registrations the following adjustments can be made in the plugin:

Masks for both the fixed and the moving images can be selected to let elastix only include certain areas in the registration. These masks have to be loaded into napari and selected in the correct mask dropdown menus, which appear when the masks box is ticked.
Point sets for both the fixed and the moving images can de selected to use certain points to aid registration. These point set files have to be .txt files in the following format:

index/point\
  #points\
  point1 x point1 y [point1 z]\
  point2 x point2 y [point2 z]
The first line indicates whether the points are given as “indices” (of the fixed image), or as “points” (in
  physical coordinates). The second line stores the number of points that will be specified. After that the
  point data is given. For example:
point\
  3\
  2.32 5.34 -4.12\
  -1.56 0.12 9.23\
  1.00 7.34 -0.23


An initial transform file that specifies a transform that is applied before the registration is done, can be uploaded as a .txt file. For the latest file and transform formats that are supported, see the elastix manual


For the most common registration parameters adjustments can be made in the plugin GUI


Other, less common registration parameters can be adjusted by uploading custom transform parameter file(s). (Select 'custom' in the preset dropdown).



Transformations
In the plugin 3 common transformations are available as presets, other transformations can be done with the 'custom' option in the preset dropdown. The plugin then has the ability to upload custom parameter files in which other transformations can be specified.
The three common transformations are:


Rigid Transform:
Also known as a Euclidean transformation, this transform preserves the Euclidean
distance between each pair of points on the image. This includes rotation,
translation and reflection but not scaling or shearing.


Affine Transform:
This transfrom preserves
lines and parallelism, but not necessarily distance and angles. Translation,
scaling, similarity, reflection, rotation and shearing are all valid
affine transformations.


BSpline Transform:
This is a deformable transformation that preserves none of the properties mentioned in the transforms describe above.


Getting Help
If you find a bug in the elastix napari plugin, or would like support with using it, please raise an
issue on the GitHub repository.
For question specifically about the elastix toolbox we have a mailing list.
Contributions
Contributions to the elastix_napari plugin, itkelastix (the python wrapper) or elastix (the C++ core) on which the plugin is build, are welcome.

elastix-napari

A toolbox for rigid and nonrigid registration of images.

Juan Nunez-Iglesias

Description
This GUI plugin allows you to quickly find the affine matrix mapping
one image to another using manual correspondence points annotation.
More simply, this plugin allows you to select corresponding points
on an image, and a second image you wish to transform. It computes 
the requisite transformation matrix using Affine Transform, Euclidean Transform, 
or Similarity Transform, and performs this transformation on the
moving image, aligning it to the reference image.
https://user-images.githubusercontent.com/17995243/120086403-f1d0b300-c121-11eb-8000-a44a2ac54339.mp4
Who is This For?
This is a simple plugin which can be used on any 2D images, provided
they can be loaded as layers into napari. The images need not be the same
file format and this plugin also works with labels layers.
No prior understanding of the transformation methods is required, as
they perform in the background based on the reference points selected.
How to Guide
You will need a combination of two or more 2D image and/or labels layers 
loaded into napari. Once you have installed affinder, you can find it in
the dock widgets menu.

The first two dropdown boxes will be populated with the layers currently
loaded into napari. Select a layer to use as reference, and another to
transform.

Next, you can select the transformation model to use (affine is selected by default
and is the least rigid transformation of those available). See below for a
description of the different models.
Finally, you can optionally select a path to a text file for saving out the
resulting transformation matrix.
When you click Start, affinder will add two points layers to napari. 
The plugin will also bring your reference image in focus, and its associated points
layer. You can then start adding reference points by clicking on your image.

Once three points are added, affinder will switch focus to the moving image,
and you should then proceed to select the corresponding three points.

affinder will immediately transform the moving image to align the points you've
selected when you add your third corresponding point to your moving image.

From there, you can continue iteratively adding points until you 
are happy with the alignment. Affinder will switch focus between
reference and moving image with each point.
Click Finish to exit affinder.
Transformation Models
There are three transformation models available for use with affinder.
They are listed here in order of increasing rigidity in the types of
transforms they will allow. The eponymous Affine Transform is the 
least rigid and is the default choice.


Affine Transform: 
the least rigid transformation, it preserves
lines and parallelism, but not necessarily distance and angles. Translation,
scaling, similarity, reflection, rotation and shearing are all valid
affine transformations.


Similarity Transform: 
this is a "shape preserving" transformation, producing objects which are 
geometrically similar. Translation, rotation, reflection and uniform scaling are 
valid similarity transforms. Shearing is not.


Euclidean Transform:
Also known as a rigid transformation, this transform preserves the Euclidean
distance between each pair of points on the image. This includes rotation,
translation and reflection but not scaling or shearing.


Getting Help
If you find a bug with affinder, or would like support with using it, please raise an
issue on the GitHub repository.
How to Cite
Many plugins may be used in the course of published (or publishable) research, as well as
during conference talks and other public facing events. If you'd like to be cited in
a particular format, or have a DOI you'd like used, you should provide that information here.

affinder

Quickly find the affine matrix mapping one image to another using manual correspondence points annotation

🐛 napari-error-reporter





Want to help out napari?  Install this plugin!
This plugin will automatically send error reports to napari (via
sentry.io) whenever an exception occurs while you are using
napari.
The first time you run napari after installing this plugin an opt-in
notification will appear (Be sure to click "yes", otherwise no reports will be
collected or sent).  You may opt back out at any time in napari's help menu.
Every effort is made to strip these reports of personally identifiable
information.  Here is an example exception event:

Example bug report

```python
{
    'breadcrumbs': {
        'values': [
            {
                'category': 'subprocess',
                'data': {},
                'message': 'sw_vers -productVersion',
                'timestamp': '2022-02-02T01:30:00.216738Z',
                'type': 'subprocess'
            }
        ]
    },
    'contexts': {
        'runtime': {
            'build': '3.9.9 | packaged by conda-forge | (main, Dec 20 2021, 02:41:37) \n[Clang 11.1.0 ]',
            'name': 'CPython',
            'version': '3.9.9'
        }
    },
    'environment': 'macOS-10.15.7-x86_64-i386-64bit',
    'event_id': '02dd8ddd3a4b4743af3d7d7a09949df4',
    'exception': {
        'values': [
            {
                'mechanism': None,
                'module': None,
                'stacktrace': {
                    'frames': [
                        {
                            'context_line': '                x = 1 / 0',
                            'filename': 'napari_error_reporter/_util.py',
                            'function': 'get_sample_event',
                            'in_app': True,
                            'lineno': 130,
                            'module': 'napari_error_reporter._util',
                            'post_context': [
                                '            except Exception:',
                                '                with sentry_sdk.push_scope() as scope:',
                                '                    for k, v in _get_tags().items():',
                                '                        scope.set_tag(k, v)',
                                '                    del v, k, scope'
                            ],
                            'pre_context': [
                                "            # remove locals that wouldn't really be there",
                                '            del settings, _trans, kwargs, client, EVENT',
                                '            try:',
                                '                some_variable = 1',
                                '                another_variable = "my_string"'
                            ]
                        }
                    ]
                },
                'type': 'ZeroDivisionError',
                'value': 'division by zero'
            }
        ]
    },
    'extra': {'sys.argv': ['napari']},
    'level': 'error',
    'modules': {
        'aicsimageio': '4.5.2',
        'aicspylibczi': '3.0.4',
        'aiohttp': '3.8.1',
        'aiosignal': '1.2.0',
        'alabaster': '0.7.12',
        'anyio': '3.5.0',
        'appdirs': '1.4.4',
        'appnope': '0.1.2',
        'argon2-cffi': '21.3.0',
        'argon2-cffi-bindings': '21.2.0',
        'arrow': '1.2.1',
        'asciitree': '0.3.3',
        'asttokens': '2.0.5',
        'async-timeout': '4.0.2',
        'atomium': '1.0.11',
        'attrs': '21.4.0',
        'autopep8': '1.6.0',
        'babel': '2.9.1',
        'backcall': '0.2.0',
        'bcrypt': '3.2.0',
        'beautifulsoup4': '4.10.0',
        'binaryornot': '0.4.4',
        'black': '20.8b1',
        'bleach': '4.1.0',
        'bracex': '2.2.1',
        'build': '0.7.0',
        'cachey': '0.2.1',
        'cellpose': '0.6.5',
        'certifi': '2021.10.8',
        'cffi': '1.15.0',
        'cfgv': '3.3.1',
        'chardet': '4.0.0',
        'charset-normalizer': '2.0.10',
        'check-manifest': '0.47',
        'click': '7.1.2',
        'click-option-group': '0.5.3',
        'cloudpickle': '2.0.0',
        'colorama': '0.4.4',
        'commonmark': '0.9.1',
        'cookiecutter': '1.7.3',
        'coverage': '6.2',
        'cryptography': '36.0.1',
        'cycler': '0.11.0',
        'dask': '2022.1.0',
        'debugpy': '1.5.1',
        'decorator': '5.1.1',
        'defusedxml': '0.7.1',
        'distlib': '0.3.4',
        'dnspython': '2.2.0',
        'docstring-parser': '0.13',
        'docutils': '0.16',
        'elementpath': '2.4.0',
        'email-validator': '1.1.3',
        'entrypoints': '0.3',
        'executing': '0.8.2',
        'fancycompleter': '0.9.1',
        'fasteners': '0.17.2',
        'fastremap': '1.12.2',
        'filelock': '3.4.2',
        'flake8': '3.8.4',
        'fonttools': '4.28.5',
        'freetype-py': '2.2.0',
        'frozenlist': '1.3.0',
        'fsspec': '2022.1.0',
        'furo': '2022.1.2',
        'gitdb': '4.0.9',
        'gitpython': '3.1.26',
        'greenlet': '1.1.2',
        'heapdict': '1.0.1',
        'hsluv': '5.0.2',
        'hypothesis': '6.35.1',
        'identify': '2.4.4',
        'idna': '3.3',
        'imagecodecs': '2021.11.20',
        'imageio': '2.10.5',
        'imageio-ffmpeg': '0.4.5',
        'imagesize': '1.3.0',
        'importlib-metadata': '4.10.1',
        'iniconfig': '1.1.1',
        'install': '1.3.5',
        'intervaltree': '3.1.0',
        'ipykernel': '6.7.0',
        'ipython': '8.0.0',
        'ipython-genutils': '0.2.0',
        'ipywidgets': '7.6.5',
        'jedi': '0.18.1',
        'jinja2': '3.0.3',
        'jinja2-time': '0.2.0',
        'jsonschema': '3.2.0',
        'jupyter': '1.0.0',
        'jupyter-book': '0.12.1',
        'jupyter-cache': '0.4.3',
        'jupyter-client': '7.1.1',
        'jupyter-console': '6.4.0',
        'jupyter-core': '4.9.1',
        'jupyter-server': '1.13.3',
        'jupyter-server-mathjax': '0.2.3',
        'jupyter-sphinx': '0.3.2',
        'jupyterlab-pygments': '0.1.2',
        'jupyterlab-widgets': '1.0.2',
        'jupytext': '1.11.5',
        'kiwisolver': '1.3.2',
        'latexcodec': '2.0.1',
        'linkify-it-py': '1.0.3',
        'llvmlite': '0.38.0',
        'locket': '0.2.1',
        'loguru': '0.5.3',
        'lxml': '4.7.1',
        'magicgui': '0.3.5.dev18+g78d1687',
        'markdown-it-py': '1.1.0',
        'markupsafe': '2.0.1',
        'matplotlib': '3.5.1',
        'matplotlib-inline': '0.1.3',
        'mccabe': '0.6.1',
        'mdit-py-plugins': '0.2.8',
        'meshzoo': '0.9.2',
        'mistune': '0.8.4',
        'mrc': '0.2.0',
        'msgpack': '1.0.3',
        'multidict': '5.2.0',
        'mypy': '0.931',
        'mypy-extensions': '0.4.3',
        'myst-nb': '0.13.1',
        'myst-parser': '0.15.2',
        'napari': '0.4.14rc1.dev4+gcdf58d44b',
        'napari-aicsimageio': '0.4.1',
        'napari-console': '0.0.4',
        'napari-dv': '0.2.7.dev0+g54e1691.d20220128',
        'napari-error-reporter': '0.1.dev1+g1b388f2.d20220201',
        'napari-hello': '0.0.1',
        'napari-math': '0.0.1a0',
        'napari-micromanager': '0.0.1rc6.dev14+g5149788.d20220128',
        'napari-molecule-reader': '0.1.2.dev1+gc2ec2de',
        'napari-plugin-engine': '0.2.0',
        'napari-pyclesperanto-assistant': '0.12.0',
        'napari-skimage-regionprops': '0.2.9',
        'napari-svg': '0.1.6',
        'napari-time-slicer': '0.4.2',
        'napari-workflows': '0.1.2',
        'natsort': '8.0.2',
        'nbclient': '0.5.10',
        'nbconvert': '6.4.0',
        'nbdime': '3.1.1',
        'nbformat': '5.1.3',
        'nd2': '0.1.4',
        'nest-asyncio': '1.5.4',
        'networkx': '2.6.3',
        'nodeenv': '1.6.0',
        'notebook': '6.4.7',
        'npe2': '0.1.1',
        'numba': '0.55.0',
        'numcodecs': '0.9.1',
        'numpy': '1.20.3',
        'numpydoc': '1.1.0',
        'ome-types': '0.2.10',
        'opencv-python-headless': '4.5.5.62',
        'packaging': '21.3',
        'pandas': '1.3.5',
        'pandocfilters': '1.5.0',
        'paramiko': '2.9.2',
        'parso': '0.8.3',
        'partd': '1.2.0',
        'pathspec': '0.9.0',
        'pdbpp': '0.10.3',
        'peewee': '3.14.8',
        'pep517': '0.12.0',
        'pexpect': '4.8.0',
        'pickleshare': '0.7.5',
        'pillow': '8.4.0',
        'pint': '0.18',
        'pip': '21.3.1',
        'platformdirs': '2.4.1',
        'pluggy': '1.0.0',
        'pooch': '1.5.2',
        'poyo': '0.5.0',
        'pre-commit': '2.16.0',
        'prometheus-client': '0.12.0',
        'prompt-toolkit': '3.0.24',
        'psutil': '5.9.0',
        'psygnal': '0.2.0',
        'ptyprocess': '0.7.0',
        'pure-eval': '0.2.1',
        'py': '1.11.0',
        'pybtex': '0.24.0',
        'pybtex-docutils': '1.0.1',
        'pyclesperanto-prototype': '0.12.0',
        'pycodestyle': '2.8.0',
        'pycparser': '2.21',
        'pydantic': '1.9.0',
        'pydata-sphinx-theme': '0.7.2',
        'pyflakes': '2.2.0',
        'pygments': '2.11.2',
        'pymmcore': '10.1.1.70.5',
        'pymmcore-plus': '0.1.8',
        'pynacl': '1.5.0',
        'pyopencl': '2021.2.13',
        'pyopengl': '3.1.5',
        'pyparsing': '3.0.6',
        'pyperclip': '1.8.2',
        'pyrepl': '0.9.0',
        'pyro5': '5.13.1',
        'pyrsistent': '0.18.1',
        'pyside2': '5.15.2.1',
        'pytest': '6.2.5',
        'pytest-cookies': '0.6.1',
        'pytest-cov': '3.0.0',
        'pytest-faulthandler': '2.0.1',
        'pytest-order': '1.0.1',
        'pytest-qt': '4.0.2',
        'python-dateutil': '2.8.2',
        'python-dotenv': '0.19.2',
        'python-slugify': '5.0.2',
        'pytomlpp': '1.0.10',
        'pytools': '2021.2.9',
        'pytz': '2021.3',
        'pywavelets': '1.2.0',
        'pyyaml': '6.0',
        'pyzmq': '22.3.0',
        'qtconsole': '5.2.2',
        'qtpy': '2.0.0',
        'regex': '2021.11.10',
        'requests': '2.27.1',
        'rich': '11.0.0',
        'rmsd': '1.4',
        'ruamel.yaml': '0.17.20',
        'ruamel.yaml.clib': '0.2.6',
        'scikit-image': '0.19.1',
        'scipy': '1.7.3',
        'semgrep': '0.78.0',
        'send2trash': '1.8.0',
        'sentry-sdk': '1.5.4',
        'serpent': '1.40',
        'setuptools': '60.5.0',
        'shiboken2': '5.15.2.1',
        'six': '1.16.0',
        'smmap': '5.0.0',
        'sniffio': '1.2.0',
        'snowballstemmer': '2.2.0',
        'sortedcontainers': '2.4.0',
        'soupsieve': '2.3.1',
        'sourcery-cli': '0.10.0',
        'sphinx': '4.4.0',
        'sphinx-autodoc-typehints': '1.12.0',
        'sphinx-book-theme': '0.1.10',
        'sphinx-comments': '0.0.3',
        'sphinx-copybutton': '0.4.0',
        'sphinx-external-toc': '0.2.3',
        'sphinx-jupyterbook-latex': '0.4.6',
        'sphinx-multitoc-numbering': '0.1.3',
        'sphinx-panels': '0.6.0',
        'sphinx-tabs': '3.2.0',
        'sphinx-thebe': '0.0.10',
        'sphinx-togglebutton': '0.2.3',
        'sphinxcontrib-applehelp': '1.0.2',
        'sphinxcontrib-bibtex': '2.2.1',
        'sphinxcontrib-devhelp': '1.0.2',
        'sphinxcontrib-htmlhelp': '2.0.0',
        'sphinxcontrib-jsmath': '1.0.1',
        'sphinxcontrib-qthelp': '1.0.3',
        'sphinxcontrib-serializinghtml': '1.1.5',
        'sqlalchemy': '1.4.29',
        'stack-data': '0.1.4',
        'superqt': '0.2.5.post2.dev7+ga49bcd7',
        'tensorstore': '0.1.16',
        'terminado': '0.12.1',
        'testpath': '0.5.0',
        'text-unidecode': '1.3',
        'tifffile': '2021.11.2',
        'toml': '0.10.2',
        'tomli': '2.0.0',
        'toolz': '0.11.2',
        'torch': '1.10.1',
        'tornado': '6.1',
        'tox': '3.24.5',
        'tox-conda': '0.9.1',
        'tqdm': '4.62.3',
        'traitlets': '5.1.1',
        'transforms3d': '0.3.1',
        'transitions': '0.8.10',
        'typed-ast': '1.5.1',
        'typer': '0.4.0',
        'typing-extensions': '4.0.1',
        'uc-micro-py': '1.0.1',
        'urllib3': '1.26.8',
        'useq-schema': '0.1.1.dev13+g01d1b46.d20220120',
        'valerius': '0.2.0',
        'virtualenv': '20.13.0',
        'vispy': '0.9.4',
        'watchdog': '2.1.6',
        'wcmatch': '8.3',
        'wcwidth': '0.2.5',
        'webencodings': '0.5.1',
        'websocket-client': '1.2.3',
        'wheel': '0.37.1',
        'widgetsnbextension': '3.5.2',
        'wmctrl': '0.4',
        'wrapt': '1.13.3',
        'wurlitzer': '3.0.2',
        'xarray': '0.20.2',
        'xmlschema': '1.9.2',
        'yarl': '1.7.2',
        'zarr': '2.10.3',
        'zipp': '3.7.0'
    },
    'platform': 'python',
    'release': '0.4.14rc1.dev4+gcdf58d44b',
    'sdk': {
        'integrations': [
            'aiohttp',
            'argv',
            'atexit',
            'dedupe',
            'excepthook',
            'logging',
            'modules',
            'sqlalchemy',
            'stdlib',
            'threading',
            'tornado'
        ],
        'name': 'sentry.python',
        'packages': [{'name': 'pypi:sentry-sdk', 'version': '1.5.4'}],
        'version': '1.5.4'
    },
    'server_name': '',
    'tags': {
        'platform.name': 'MacOS 10.15.7',
        'platform.system': 'Darwin',
        'qtpy.API_NAME': 'PySide2',
        'qtpy.QT_VERSION': '5.15.2'
    },
    'timestamp': '2022-02-02T01:30:00.229122Z'
}
```



NOTE: in the opt-in dialog, there is a checkbox labeled "include local variables",
checking this will include the value of variables in the local scope when an exception
occurs.  While these can be very useful when interpreting a bug report, they may
occasionally include local file path strings.  If that concerns you, please leave this
box unchecked

Install
This plugin requires napari version 0.4.15 or greater, or the main branch with PR
napari/napari#4055.
Install via pip with:
sh
pip install napari-error-reporter
or in the built-in plugin installer (a restart will be required):

Thank you!!
Privacy FAQ
Even with the multiple layers of opt-ins, and the attempts to wipe all personal info
prior to sending reports, we understand that privacy is always a concern.
Do you collect personal info?
We make every attempt to collect no personally identifiable information.  No
name, location, IP address, etc...  We do collect your
(uuid.getnode()) to
be able to track bug resolution over time. As mentioned above, allowing local
variables to be collected may occasionally include a file path in the log.
If that concerns you, please leave that unchecked.
Is this shipped with napari?
napari-error-reporter is not bundled with napari or listed as a napari dependency.
In order for reports to be sent, you must first install this plugin yourself, and then
opt in on the next launch.  If you uninstall the plugin, no more reports can be sent.
Who can access these reports?
Only the following napari core developers have access to these reports.
If this
list changes in the future, you will be asked to opt-in again in napari:

Juan Nunez-Iglesias (@jni)
Talley Lambert (@tlambert03)

This plugin is not associated with the Chan Zuckerberg Initiative.
How will these reports be used?
Commonly occuring errors will be will be manually purged of file paths and
local variables and posted to https://github.com/napari/napari/issues
How long is data retained
Sentry retains event data for 90 days by default.  For complete details,
see Sentry's page on Security & Compliance

napari-error-reporter

Opt-in automated bug/error reporting for napari

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-time-slicer







A meta plugin for processing timelapse data timepoint by timepoint. It 
enables a list of napari plugins to process 2D+t or 3D+t data step by step when the user goes 
through the timelapse. Currently, these plugins are using napari-time-slicer:
* napari-segment-blobs-and-things-with-membranes
* napari-cupy-image-processing
* napari-pyclesperanto-assistant
* napari-accelerated-pixel-and-object-classification
* napari-simpleitk-image-processing
* napari-stress
* napari-process-points-and-surfaces
napari-time-slicer enables inter-plugin communication, e.g. allowing to combine the plugins listed above in 
one image processing workflow for segmenting a timelapse dataset:

The workflow can then also be exported as a script. The 'Generate Code' button can be found in the Workflow Inspector
If you want to convert a 3D dataset into a 2D + time dataset, use the 
menu Tools > Utilities > Convert 3D stack to 2D timelapse (time-slicer). It will turn the 3D dataset to a 4D datset
where the Z-dimension (index 1) has only 1 element, which will in napari be displayed with a time-slider. Note: It is 
recommended to remove the original 3D dataset after this conversion.
Working with large on-the-fly processed datasets
Using the napari-assistant complex image processing workflows on timelapse datasets can be setup. 
In combination with the time-slicer it is possible to process time-lapse data that is larger than available computer memory.
In case the workflow only consists of images and label-images and out-of-memory issues arise, consider storing intermediate results on disk following this procedure: 
After setting up the workflow and testing it on a couple of selected frames, store the entire processed timelapse dataset to disk 
using the menu Tools > Utilities > Convert to file-backed timelapse data (time-slicer). It will open this dialog, where you can select 

It is recommended to enter a folder location in the text field. 
If not provided, a temporary folder will be created, typically in the User's temp folder in the home directory. 
The user is responsible for emptying this folder from time to time.
The data stored in this folder can also be loaded into napari using its File > Open Folder... menu.
Executing this operation can take time as every timepoint of the timelapse is computed. 
Afterwards, there will be another layer available in napari, which is typically faster to navigate through. 
Consider removing the layer(s) that were only needed to determine the new file-backed layer.

Usage for plugin developers
Plugins which implement the napari_experimental_provide_function hook can make use of the @time_slicer. At the moment,
only functions which take napari.types.ImageData, napari.types.LabelsData and basic python types such as int 
and float are supported. If you annotate such a function with @time_slicer it will internally convert any 4D dataset
to a 3D dataset according to the timepoint currently selected in napari. Furthermore, when the napari user changes the
current timepoint or the input data of the function changes, a re-computation is invoked. Thus, it is recommended to 
only use the time_slicer for functions which can provide [almost] real-time performance. Another constraint is that 
these annotated functions have to have a viewer parameter. This is necessary to read the current timepoint from the 
viewer when invoking the re-computions.
Example
```python
import napari
from napari_time_slicer import time_slicer
@time_slicer
def threshold_otsu(image:napari.types.ImageData, viewer: napari.Viewer = None) -> napari.types.LabelsData:
    # ...
```
You can see a full implementations of this concept in the napari plugins listed above.
If you want to combine slicing in time and processing z-stack images slice-by-slice, you can use the @slice_by_slice annotation.
Make sure, to insert it after @time_slicer as shown below and implemented in napari-pillow-image-processing
```python
from napari_time_slicer import slice_by_slice
@time_slicer
@slice_by_slice
def blur_2d(image:napari.types.ImageData, sigma:float = 1, viewer: napari.Viewer = None) -> napari.types.LabelsData:
    # ...
```

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

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

napari-time-slicer

A meta plugin for processing timelapse data in napari timepoint by timepoint

Guillaume Witz

napari-serialcellpose






This napari plugin allows you to segment single images or series of images using built-in or custom Cellpose models as well as to analyze the properties of these segmented regions ("region properties"). Properties can be visualized for a single image or a complete experiment in the form of histograms that can also be filtered (e.g. based on area size, mean intensity etc.) Thanks to the napari-skimage-regionprops plugin, properties of segmented objects can be interactively explored at a single object level.
Main goal
The main goal of this plugin is to simplify the classical image processing pipeline of image segmentation followed by region analysis via Cellpose. It allows to quickly get a quantification of a set of images without the need for any scripting.
Installation
In order to use this plugin, whe highly recommend to create a specific environment and to install the required software in it. You can create a conda environment using:
conda create -n serialcellpose python=3.8.5 napari -c conda-forge

Then activate it and install the plugin:
conda activate serialcellpose
pip install napari-serialcellpose

Potential issue with PyTorch
Cellpose and therefore the plugin and napari can crash without warning in some cases with torch==1.12.0. This can be fixed by reverting to an earlier version using:
pip install torch==1.11.0

GPU
In order to use a GPU:


Uninstall the PyTorch version that gets installed by default with Cellpose:
pip uninstall torch



Make sure your have up-to-date drivers for your NVIDIA card installed.


Re-install a GPU version of PyTorch via conda using a command that you can find here (this takes care of the cuda toolkit, cudnn etc. so no need to install manually anything more than the driver). The command will look like this:
conda install pytorch torchvision cudatoolkit=11.3 -c pytorch



Plugin Updates
To update the plugin, you only need to activate the existing environment and install the new version:
conda activate serialcellpose
pip install napari-serialcellpose -U

Usage: segmentation
The main interface is shown below. The sequence of events should be the following:

Select a folder containing images. The list of files within that folder will appear in the area above. You can also just drag and drop a folder or an image in that area. When selecting an image, it gets displayed in the viewer. Images are opened via aicsimageio. You can use grayscale images, RGB images or multi-channel images. In the latter case, make sure each channel opens as a separate layer when you open them using the napari-aicsimagio importer.
If you want to save the segmentation and tables with properties, select a folder that will contain the output.
Select the type of cellpose model.
If you use a custom model, select its location.
Run the analysis on the currently selected image or on all files in the folder.

Options

Select if you want to use a GPU or not.
If you are using multi-channel images, you can specify which channel to segment and optionally which to use as "nuclei" channel to help cell segmentation.
In case you are using one of the built-in models, you can set the estimated diameter of your objects.
In the Options tab you will find a few more options for segmentation, including the two thresholds flow_threshold and cellprob_threshold. You can also decide to discard objects touching the border. Using the Select options yml file you can select a .yml file which contains a list of additional options to pass to the eval method of the Cellpose model. Note that options specified in the yml file will override options set in the GUI. The file my_options.yml is an example of such a file where for example the diameter (also available in the GUI) and resample (not available in the GUI) options are set. 



Properties

After segmentation, properties of the objects can automatically be computed. You can select which properties should be computed in the Options tab. As defined in napari-skimage-regionprops properties are grouped by types. If you want to measure intensity properties such as mean intensity, you have to specify which channel (Analysis channel) you want to perform the measurement on.

Output
The results of the analysis are saved in the folder chosen in #2. The segmentation mask is saved with the same name as the original image with the suffix _mask.tif. A table with properties is saved in the subfolder tables also with the same name as the image with the suffix props.csv. If you run the plugin on multiple files in a folder, a summary.csv file is also generated which compiles all the data.
Usage: post-processing
After the analysis is done, when you select an image, the corresponding segmentation mask is shown on top of the image as shown below. This also works for saved segmentations: in that case you just select a folder with data and the corresponding output folder.

Properties
If you head to the Properties tab, you will find there two histograms showing the distribution of two properties that you can choose from a list at the top of the window. Below the plot you find the table containing information for each cell (each line is a cell).
As shown below, if you select the box show selected, you can select items in the properties table and it will highlight the corresponding cell in the viewer. If you select the pipet tool, you can also select a cell and see the corresponding line in the table highlighted.

Summary
Finally if you select the Summary tab, and click on Load summary, it will load all data of the current output folder and create histograms of two properties that can be selected. An additional property can be used for filtering the data. Using the sliders, one can set a minimum and maximum threshold on the "filtering property", which will create a sub-selection of the data.

Data
Sample data were acquired by Fabian Blank at the DBMR, University of Bern.
License
Distributed under the terms of the BSD-3 license,
"napari-serialcellpose" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-serialcellpose

A simple plugin to batch segment cells with cellpose

Meizhu Liang

napari-generic-SIMulator






A napari plugin to simulate raw-image stacks of Structured illumination microscopy (SIM) with light sheet. 
The simulation is originally based on the paper GPU-accelerated real-time reconstruction in Python of three-dimensional datasets from structured illumination microscopy with hexagonal patterns by
Hai Gong, Wenjun Guo and Mark A. A. Neil (https://doi.org/10.1098/rsta.2020.0162). 
The calculation can be GPU-accelerated if the CUPY (tested with cupy 8.3.0) is installed. In addition, the TORCH package can complete the acceleration both on CPU if TORCH is installed, and on GPU if TORCH is compiled with the CUDA (tested with torch v1.12.0+cu116) enabled.
Currently applies to:
- conventional 2-beam SIM data with 3 angles and 3 phases
- 3-beam hexagonal SIM data with 7 phases, as described in the paper
- 3-beam hexagonal SIM data with 7 phases at right-angles

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

Installation
You can install napari-generic-SIMulator via pip:
pip install napari-generic-SIMulator

To install latest development version :
pip install git+https://github.com/Meizhu-Liang/napari-generic-SIMulator.git

Usage
1) Open napari and create the viewer.
2) Launch the widget in Plugin


3) Adjust the parameters in the widget and calculate the raw-image stack.
    
4) The sum, psf and otf can be showed. Note the all of these correspond the generated raw-image stack, so keep the parameters the same before showing the sum (or psf and otf).
    
5) The raw image stacks can be then processed by napari-sim-processor (https://www.napari-hub.org/plugins/napari-sim-processor).
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-generic-SIMulator" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-generic-SIMulator

A simple plugin to use with napari to simulate raw image stacks in Structured illumination microscopy (SIM) with napari.

Chi-Li Chiu

napari-labels-overlap






create an overlap labels layer from two labels layers
Description
This plugin takes two labels layers (layerA, layerB) as inputs, and generate the overlapped regions as a binary labels layer.
Three modes:
(1) A_OR_B: new layer = layerA OR layerB (union)
(2) A_AND_B: new layer = layerA AND layerB (intersection)
(3) A_OUTSIDE_B: new layer = layerA OUTSIDE layerB (complement)
[comment]: 

Applicaions

Object colocalization
Merge separately identified objects

Future work

Support N labels layers
Basic coloc stats (% volume overlap)
Output Labels with distinct IDs and links to original label IDs

Release log

0.0.2
-- Run on npe2
-- Add output types: binary/connected component
0.0.1
-- Run on npe1


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

Installation
You can install napari-labels-overlap via pip:
pip install napari-labels-overlap

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

napari-labels-overlap

create an overlap labels layer from two labels layers

Reka Hollandi


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

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

Contour assist mode
Edit mode
Class mode
Overlay

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

How to annotate

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


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



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


(Optionally)

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


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



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

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



finalize it

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



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

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

Click to watch demo video below

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

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



finalize it

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



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


Click to watch demo video below

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

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

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


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

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

Click to watch demo video below

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

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


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


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


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



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

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


load another annotation file with the "Overlay" button


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

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

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

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

click the "Ok" button to apply changes


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

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

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

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

napari-annotatorj

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

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







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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

napari-mouse-controls






Control zoom, slicing and contrast windowing with mouse and touch screen

Usage
You find the mouse control panel in the menu Tools > Utilities > Mouse controls
Zoom
After clicking the Zoom button , you can click in the napari canvas and move the mouse up and down to zoom in and out.

Slicing
After clicking the Slicing button , you can control the currently displayed slice by moving the mouse.
By moving the mouse up and down, you control the currently selected Z-plane.
By moving the mouse left and right, you control the currently seleted time point.

Windowing
After clicking the Windowing button , you can modify the brightness and contrast by moving the mouse. 
By moving the mouse up and down, you control window width of the range of displayed grey values (max - min).
By moving the mouse left and right, you control the center of the grey value window. 

Normal / default mode
Click the Default button 
to return to napari's normal mode.
This napari plugin was generated with Cookiecutter using with @napari's cookiecutter-napari-plugin template.
Installation
You can install napari-mouse-controls via pip:
pip install napari-mouse-controls

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-mouse-controls" 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-mouse-controls

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

beetlesafari

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

Kunal Pandit

napari-PICASSO






Unmix spectral spillover

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

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

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

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


napari-PICASSO

natari



Napari gaming
Sliding puzzle
Restore the image by reordering the superpixels using the W, A, S, D keys! 

Cell counting arcade
Commander! Cells are intruding our dish! Control your tiny space ship using 1 and 2 keys to move it left/right.
Use the 9 key to shoot a anti-cell bullet.

The image originates from BBBC022v1 (Gustafsdottir et al., PLOS ONE, 2013), available from the Broad Bioimage Benchmark Collection (Ljosa et al., Nature Methods, 2012).
Snake
Two mitochondria navigating in a cell searching for stress granules. 
The two players can control their mito using the W, A, S, D and I, J, K, L  keys, respectively.

Ping pong
Don't drop the organoid! Use your racket and hit it back to your colleague!
The two players can use W, S and I, K to control their racket, respectively.

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

Known issues

To make the keyboard buttons work, you sometimes have to click within the image after starting the game.

Contributing
Contributions are very welcome. 
License
"natari" is free and open source software. The code is in the public domain.
See also: unlicense.org
Issues
If you encounter any problems, please file an issue along with a detailed description.

natari

Nicolas Pielawski

🏝 napari-tissuumaps 🧫






A plugin to export Napari projects to 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
type in a filename. Choose the .tmap extension in the dropdown and click on the Save
button, It will create a folder containing all the necessary files for TissUUmaps.
👩‍💻 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 export Napari projects to TissUUmaps.

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








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

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

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

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


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

A successful segmentation can for example look like this:

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

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

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

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

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

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

This user interface will be shown:


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

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

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

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

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

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

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


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

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

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

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

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

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

napari-feature-classifier

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

napari-accelerated-pixel-and-object-classification

Pixel and label classification using OpenCL-based Random Forest Classifiers

PDF reader for napari
Reads PDF files into napari

napari-pdf-reader

Johannes Müller

napari-process-points-and-surfaces (nppas)







Process and analyze surfaces using open3d and vedo in napari.
Usage
You find a couple of surface generation, smoothing and analysis functions in the menu Tools > Surfaces and Tools > Points. For detailed explanation of the underlying algorithms, please refer to the open3d documentation.
Some code snippets and the knot example data have been taken from the open3d project which is 
MIT licensed 
and from the vedo documentation 
which is MIT licensed.
The Standford Bunny example dataset has been taken from the The Stanford 3D Scanning Repository.
For processing meshes in Python scripts, see the demo notebook. There you also learn how this screenshot is made:

For performing quantitative measurements of meshes in Python scripts, see the demo notebook. 
There you also learn how this screenshot is made:

Installation
You can install napari-process-points-and-surfaces via pip:
pip install napari-process-points-and-surfaces
See also
There are other napari plugins with similar / overlapping functionality
* pymeshlab
* morphometrics
* napari-pyclesperanto-assistant
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-process-points-and-surfaces" 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-process-points-and-surfaces

Process and analyze surfaces using open3d and vedo in napari

napari-lattice






This napari plugin allows deskewing, cropping, visualisation and analysis of lattice lightsheet data skewed in the Y plane (Zeiss Lattice Lightsheet). Support will eventually be for other types of data.

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

Installation
Use a conda environment for installation. You will need Anaconda Navigator or a lighter version Miniconda installed. Click on the Anaconda prompt or terminal and create an environment first:
conda create -n napari-lattice python=3.9

You can use any name instead of "llsz". Once an environment is created, activate it by typing with the name you used:
conda activate napari-lattice

Start with installing pyopencl
conda install -c conda-forge pyopencl

If you have trouble installing pyopencl on Windows, use a precompiled wheel from here. As we use python 3.9, you have to download and try the wheels which have cp39 in their name. For example, if we download pyopencl‑2022.1‑cp39‑cp39‑win_amd64.whl, then we navigate to the download folder and run:
pip install pyopencl‑2022.1‑cp39‑cp39‑win_amd64.whl

If this version doesn't work, try pyopencl‑2021.2.9+cl12‑cp39‑cp39‑win_amd64.whl

You need to install napari first. 
Once napari is installed, to install latest version of the napari_lattice plugin, by typing the following command in the terminal :
pip install git+https://github.com/BioimageAnalysisCoreWEHI/napari_lattice.git

The plugin will be made available by napari-> Install/Uninstall Plugins soon.

Features



All transformations are now powered by clesperanto.
Functions:
* Deskewing of Zeiss lattice lightsheet images
  * Ability to preview deskewed image at channel or timepoint of interest
* Crop and deskew only a small portion of the image 
* You can import ROIs created in ImageJ into the plugin for cropping
* Create image processing workflows using napari-workflows and apply them to lattice data
* Run napari_lattice from the terminal
Deconvolution not implemented yet!

Usage
Once installed, just start napari and the plugin should be under "Plugins" tab
Note that channels and timepoints start from 0.
**File compatibility

You can directly open a Zeiss lattice file by dragging the file into napari. 
You will get a prompt to Choose Reader. Select aicsimageio-out-of-memory for large datasets that don't fit in memory. 
Once image has loaded, click Initialize Plugin. If its a czi file, it will load voxel size from the metadata. Once the button turns green, it means the plugin is initialized

Deskewing
To preview the deskewed output of a single timepoint and channel, choose the layer under the box img data, enter the timepoint and channel of interest and click  Preview. You can see the status of the processing in the terminal. 
Once finished, you will see a deskewed image and the corresponding maximum intensity projection as two layers.



To deskew and save a range of timepoints and channels, select the Deskew tab. Choose the channel and time ranges, save directory and click Save.
Cropping

Click on the Crop & Deskew tab. 
Clicking on Click to activate Cropping Preview will activate the Import ImageJ ROI and Crop Preview buttons. This will also add a shapes layer for the ROIs or shapes. 

Crop & Deskew (initial)            |  Crop & Deskew (Activated) 
:-------------------------:|:-------------------------:
  |  

For cropping regions of interest on the deskewed image, you can either:
draw the regions using shapes layer in napari AND/OR
import ImageJ ROIs an ImageJ ROI file (.zip). 
You can use a combination of shapes and ImageJ ROIs if needed.
To preview the cropped image, select the ROI and then click Crop Preview.

Note: The cropping functionality works by finding the inverse transform of the ROI from the deskewed image and extracting the corresponding data from the skewed or raw image. Only the extracted portion will be deskewed. This saves time and is low on memory compared to deskewing the entire image and then cropping. You can select the range of channels and time poitns you'd like to crop and save under Crop and Save Data section.
Workflow
This section uses napari-workflows to implement custom image processing routines on lattice lightsheet datasets. You can create a custom workflow using napari-assistant and save it. This can then be loaded into the napari_lattice plugin under the Workflow tab which can then be applied to the deskewed output.
 
If you'd like to use the shapes layer for cropping and applying a workflow, tick Crop Data checkbox. This will crop the data and then apply the workflow. 
You can also use custom python functions with workflows. The function needs to be called within the workflow yml file and the custom function should be a .py file in the same directory as the workflow file. An example will be added soon. 
More details will be added soon.

Batch processing (No GUI)
The software can also be used to batch process data in a folder. To run the program, you will have to open a terminal and make sure your environment is activated using conda activate. To see a list of options, you type napari_lattice -h . The -h means help and will print out a list of options on how to run the program. Currently, the available options are:
usage: napari_lattice [-h] [--input INPUT] [--output OUTPUT] [--skew_direction SKEW_DIRECTION] [--deskew_angle DESKEW_ANGLE] [--processing PROCESSING] [--roi_file ROI_FILE] [--channel CHANNEL]
                    [--voxel_sizes VOXEL_SIZES] [--file_extension FILE_EXTENSION] [--time_range TIME_RANGE TIME_RANGE] [--channel_range CHANNEL_RANGE CHANNEL_RANGE][--workflow_path WORKFLOW_PATH]

Lattice Data processing

optional arguments:
-h, --help            show this help message and exit
--input INPUT         Enter input file or folder of files
--output OUTPUT       Enter save folder
--skew_direction SKEW_DIRECTION
                        Enter the direction of skew (default is Y)
--deskew_angle DESKEW_ANGLE
                        Enter the angle of deskew (default is 30)
--processing PROCESSING
                        Enter the processing option: deskew, crop, workflow or workflow_crop
--roi_file ROI_FILE   Enter the path to the ROI file or a folder of ROI files for cropping
--channel CHANNEL     If input is a tiff file and there are channel dimensions but no time dimensions, choose as True
--voxel_sizes VOXEL_SIZES
                        Enter the voxel sizes as (dz,dy,dx). Make sure they are in brackets. If its a czi file, will read it from metadata.
--file_extension FILE_EXTENSION
                        If choosing a folder, enter the extension of the files (make sure you enter it with the dot at the start, i.e., .czi or .tif), else .czi and .tif files will be used
--time_range TIME_RANGE TIME_RANGE
                        Enter time range to extract ,example 0 10 will extract first 10 timepoints> default is to extract entire timeseries if no range is specified
--channel_range CHANNEL_RANGE CHANNEL_RANGE
                        Enter channel range to extract, default will be all channels if no range is specified. Example 0 1 will extract first two channels.
--workflow_path WORKFLOW_PATH
                        If using workflow or workflow_crop, enter the path to the workflow file (*.yml)

As an example, if you would like to deskew a bunch of files in a folder, you would need to define the input folder, save location and processing option (deskew). The skew direction by default is Y and deskew angle is 30.
If the input folder is:
C:\source

and output or save location is:
C:\deskewed

then you run the command, 
napari_lattice --input "C:\source" --output "C:\deskewed" --processing deskew

Note that the folder locations are in quotes. This is useful especially if you have spaces in the folder names. 
If you'd like to run cropping and deskew and have a list of ImageJ ROI files (.zip) files which are located at, say D:\rois and the folder locations are the same as above, then we can use the command:
napari_lattice --input "C:\source" --output "C:\deskewed" --roi_file "D:\rois" --processing crop

Note: The ROI files need to have the same name as the image files.
You can also replace the input, output, and roi_file arguments with file locations instead of folders.
Please find sample data for testing in the sample_data folder above
Data Credit: Cindy Evelyn & Niall Geoghegan, Walter and Eliza Hall Institute of Medical Research, Melbourne, Australia
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 [GPL-3.0 License] license,
"napari_lattice" is free and open source software
Acknowledgment
This project was supported by funding from the Rogers Lab at the Centre for Dynamic Imaging at the Walter and Eliza Hall Institute of Medical Research. This project has been made possible in part by 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-lattice

Napari plugin to process and analyze lattice lightsheet data especially from the Zeiss lattice lightsheet. It can also be used for lattice lightsheet data acquired at different angles. The plugin can be used in batchmode without napari.

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

Graham Dellaire

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)

napari-dv





Deltavision/MRC file reader for napari.
This wraps the mrc library.
See also napari-aicsimageio, which also uses the mrc to provide dv file support,
along with many other common file formats.
Installation
You can install napari-dv via pip:
pip install napari-dv

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

napari-dv

Lukasz G. Migas

napari-plot





Plugin providing support for 1d plotting in napari.
This plugin is in very early stages of development and many things are still in a state of disarray. New features and bug fixes
will be coming over the coming months. 
Note
napari-plot provides several custom icons and stylesheets to take advantage of the Qt backend. Since it would be a bit busy to add multiple layer lists,
I opted to include a toolbar that quickly pulls the layer list whenever requested. Simple use the toolbar to access several commonly accessed elements.
Usage
You can use napari-plot alongside napari where it is embedded as a dock widget. If using this option, controls are relegated to toolbar
where you can adjust layer properties like you would do in napari.

Or as a standalone app where only one-dimensional plotting is enabled. In this mode, controls take central stage and reflect napari's own
behaviour where layer controls are embedded in the main application.

Roadmap:
This is only provisional list of features that I would like to see implemented. It barely scratches the surface of what plotting tool should cover so as soon as the basics are covered,
focus will be put towards adding more exotic features. If there are features that you certainly wish to be included,
please modify the list below or create a new issue

[ ] Support for new layer types. Layers are based on napari's Layer, albeit in a two-dimensional setting. Supported and planned layers:
[x] Line Layer - simple line plot.
[x] Scatter Layer - scatter plot (similar to napari's Points layer).
[x] Centroids/Segments Layer - horizontal or vertical line segments.
[x] InfLine Layer - infinite horizontal or vertical lines that span over very broad range. Useful for defining regions of interest.
[x] Region Layer - infinite horizontal or vertical rectangular boxes that span over very broad range. Useful for defining regions of interest.
[x] Shapes Layer - napari's own Shapes layer
[x] Points Layer - napari's own Points layer
[x] Multi-line Layer - more efficient implementation of Line layer when multiple lines are necessary.
[ ] Bar - horizontal and vertical barchart (TODO)
[x] Proper interactivity of each layer type (e.g. moving Region or InfLine, adding points, etc...)
[x] Intuitive interactivity. napari-plot will provide excellent level of interactivity with the plotted data. We plan to support several types of Tools that permit efficient interrogation of the data. We currently provide several zoom and select tools and hope to add few extras in the future.
[x] Box-zoom - standard zooming rectangle. Simply left-mouse + drag/release in the canvas on region of interest
[x] Horizontal span - zoom-in only in the y-axis by Ctrl + left-mouse + drag/release in the canvas.
[x] Vertical span - span-in only in the x-axis by Shift + left-mouse + drag/release in the canvas.
[x] Rectangle select - rectangle tool allowing sub-selection of data in the canvas. Similar to the Box-zoom but without the zooming part.
[x] Polygon select - polygon tool allowing sub-selection of data in the canvas.
[x] Lasso select - lasso tool allowing sub-selection of data in the canvas.
[ ] Interactive plot legend
[ ] Customizable axis visuals.
[x] Plot axis enabling customization of tick/label size and color
[ ] Support for non-linear scale
[ ] Add convenient plotting interface:
[ ] Add .plot functionality
[ ] Add .scatter functionality
[ ] Add .hbar and .vbar functionality
[ ] Add .imshow functionality


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

Installation
You can install napari-plot directly from PyPI via:
python
pip install napari-plot
or from the git repo:
python
git clone https://github.com/lukasz-migas/napari-1d.git
cd napari-1d
pip install -e '.[all]'
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" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-plot

Plugin providing support for 1d plotting in napari.

Jordao Bragantini

napari-DEXP





A plugin to interface DEXP with napari.

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

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

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

napari-dexp

Thorsten Beier

napari-splineit






A napari plugin for spline manipulation

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

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

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

napari-splineit

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

Alexandr Dibrov

napari-kics







A plugin to estimate chromosome sizes from karyotype images.

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

Install
Usage
Example
Citation
Maintainer
Contributing
License

Install
You can install napari-kics via pip:
sh
pip install napari-kics
This will install all required dependencies as well. We recommend installing it in a virtual environment, e.g. using conda:
sh
conda create -n kics python
conda activate kics
pip install napari-kics
We recommend using mamba as a faster alternative to conda.
Usage

Launch Napari via command line (napari).
Activate the plugin via menu Plugins -> napari-kics: Karyotype Widget.
Select file via File -> Open File.
Follow instructions in the panel on the right.

You may use the interactive analysis plots directly via command line:
sh
karyotype-analysis-plots
Example

Launch Napari via command line (napari).
Activate the plugin via menu Plugins -> napari-kics: Karyotype Widget.
Select file via File -> Open Sample -> napari-kics: sample.
Follow instructions in the panel on the right.

Try out the interactive analysis plots directly via command line:
sh
karyotype-analysis-plots --example
Citation

Arne Ludwig, Alexandr Dibrov, Gene Myers, Martin Pippel.
Estimating chromosome sizes from karyotype images enables validation of
de novo assemblies. To be published.

License
Distributed under the terms of the BSD-3 license,
"napari-kics" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.
Contributing
Contributions are very welcome. Please file a pull request with your
contribution.
You can setup a local development environment for napari-kics via pip:
sh
git clone https://github.com/mpicbg-csbd/napari-kics.git
cd napari-kics
pip install -e .
Overview
https://user-images.githubusercontent.com/17703905/139654249-685703b5-2196-4a73-a036-d40d578ebcdf.mp4

napari-kics

A plugin to estimate chromosome sizes from karyotype images.

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.

Run
In powershell run when you do not have sufficient GPU support in your environment
$env:CUDA_VISIBLE_DEVICES=-1; napari
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.

Santiago N. Rodriguez Alvarez

Nfinder
Automatic inference of neighboring cells based on their Delaunay triangulation.
Dependencies
nfinder was tested with:

python = 3.8.5
napari = 0.4.12
numpy = 1.21.2
pandas = 1.3.4
scikit-image = 0.18.3
scipy = 1.7.1
importlib-resources 5.4.0

Installation
It can be installed with pip from PyPI:
pip install nfinder
Usage
For usage examples, please check out the notebook in our GitHub repository.

nfinder

Automatic inference of neighboring cells based on their Delaunay triangulation.

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

Hanjin Liu

napari-text-layer
Napari text layer for bio-image annotation.


Installation
You can install using pip:
pip install napari-text-layer
Keybindings and mouse callbacks

"→", "←", "↑", "↓" ... Move selected shapes by 1 pixel.
"F2" ... Enter edit mode at the selected shape (or the last one if no shape is selected).
"Enter" ... Finish edit mode or add a new shape at the same interval.
"Ctrl" + "Shift" + "<" or ">" ... Change font size.
double click ... Enter edit mode at the clicked shape.


napari-text-layer

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

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

Nicholas Sofroniew

napari-console (WIP, under active development)





A plugin that adds a console to napari

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

Installation
You can install napari-console via pip:
pip install napari-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.
License
Distributed under the terms of the BSD-3 license,
"napari-console" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-console

waver





Run simulations of the wave equation in nD on grids of variable speed in Python. This library owes a lot of its design and approach to the fdtd library, a Python 3D electromagnetic FDTD simulator.
This package allows for a fair amount of customization over your wave simulation. You can
 - specify the size and spacing of the grid
 - specify the time step for the simulation, which will be checked to ensure stability of the simulation
 - specify the duration of the simulation
 - setting a variable speed array (one value per grid point) to allow for "objects" in your environment
 - set the source of the wave, which can be a point, line, or any (n-1)D subarray
 - record the wave with a detector, which can be the full grid, the full boundary, or a particular boundary
 - use convenience methods to run many simulations with different sources on the same grid and detector combination
You can use napari, a multi-dimensional image viewer for Python, to allow for easy visualization of the detected wave. Some functionality is also available as a napari plugin to allow for running simulations from a graphical user interface.
Results can look like
https://user-images.githubusercontent.com/6531703/128283012-a784ec06-4df9-4ddf-bf4f-e21b927fe4a3.mov

Installation
You can install waver via pip:
pip install waver

Usage
Convenience Methods
The most convenient way to use waver is to use one of two convenience methods that will create and run a simulation
for you and return the results.
The first method run_single_source allows you to run a single simulation with a single source on one grid and 
record the results using a detector. For example
```python
from waver.simulation import run_single_source
single_sim_params = {
    'size': (12.8e-3, 12.8e-3),
    'spacing': 100e-6,
    'duration': 80e-6,
    'min_speed': 343,
    'max_speed': 686,
    'speed': 686,
    'time_step': 50e-9,
    'temporal_downsample': 2,
    'location': (6.4e-3, 6.4e-3),
    'period': 5e-6,
    'ncycles':1,
}
detected_wave, speed_grid = run_single_source(**single_sim_params)
```
The second method run_multiple_sources allows you to run multiple simulations with multiple sources on the same
grid and with the same detector and return the results. For example
```python
from waver.simulation import run_multiple_sources
multi_sim_params = {
    'size': (12.8e-3, 12.8e-3),
    'spacing': 100e-6,
    'duration': 80e-6,
    'min_speed': 343,
    'max_speed': 686,
    'speed': 686,
    'time_step': 50e-9,
    'temporal_downsample': 2,
    'sources': [{
        'location': (6.4e-3, 6.4e-3),
        'period': 5e-6,
        'ncycles':1,
    }]
}
detected_wave, speed_grid = run_multiple_sources(**multi_sim_params)
```
The main difference between these two methods is that run_multiple_sources takes a sources parameter which takes a list 
of dictionaries with keys corresponding to source related keyword arguments found in run_single_source.
Visualization
If you want to quickly visualize the results of run_multiple_sources, you can use the run_and_visualize command which will 
run the simulation and then launch napari with the results, as seen in examples/2D/point_source.py
```python
from waver.datasets import run_and_visualize
run_and_visualize(**multi_sim_params)
```
Datasets
If you want to run simulations with on many different speed grids you can use the generate_simulation_dataset method as a convenience. The results will be saved to a zarr file of your chosing. You can then use the load_simulation_dataset to load the dataset.
```python
from waver.datasets import generate_simulation_dataset
Define root path for simulation
path = './simulation_dataset.zarr'
runs = 5
Define a simulation, 12.8mm, 100um spacing
dataset_sim_params = {
    'size': (12.8e-3, 12.8e-3),
    'spacing': 100e-6,
    'duration': 80e-6,
    'min_speed': 343,
    'max_speed': 686,
    'speed': 'mixed_random_ifft',
    'time_step': 50e-9,
    'sources': [{
        'location': (None, 0),
        'period': 5e-6,
        'ncycles':1,
    }],
    'temporal_downsample': 2,
    'boundary': 1,
    'edge': 1,
}
Run and save simulation
generate_simulation_dataset(path, runs, **dataset_sim_params)
```
The generate_simulation_dataset allows the speed to be a string that will specify a particular method of randomly generating speed values for the simulation grid.
The Simulation Object
If you'd like to understand in a little bit more detail how a simulation is defined then you might want to use the unerlying simulation object Simulation and manually set key objects like the Source and Detector. A full example of this is as follows
```python
Create a simulation
sim = Simulation(size=size, spacing=spacing, max_speed=max_speed, time_step=time_step)
Set speed array
sim.set_speed(speed=speed, min_speed=min_speed, max_speed=max_speed)
Add source
sim.add_source(location=location, period=period, ncycles=ncycles, phase=phase)
Add detector grid
sim.add_detector(spatial_downsample=spatial_downsample,
                    boundary=boundary, edge=edge)
Run simulation
sim.run(duration=duration, temporal_downsample=temporal_downsample, progress=progress, leave=leave)
Print simulation wave and speed data
print('wave: ', sim.detected_wave)
print('speed: ', sim.grid_speed)
```
Note these steps are done inside the run_single_source method for you as a convenience.
Known Limitations
A perfectly matched layer boundary has recently been added, but might not perform well under all conditions. Additional contributions would be welcome here.
Right now the simulations are quite slow. I'd like to add a JAX backend, but 
havn't done so yet. Contributions would be welcome.
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,
"waver" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

waver

Alister Burt

napari-tomoslice





A napari plugin for visualising and interacting with electron cryotomograms.
Installation
You can install napari-tomoslice via pip:
pip install napari-tomoslice

Usage
This plugin provides a user interface for opening electron cryotomograms in 
napari as both volumes and slices through volumes.

The plugin can be opened from the plugins menu in napari, or with 
napari-tomoslice at the command line.

```yaml
Usage: napari-tomoslice [TOMOGRAM_FILE]
An interactive tomogram slice viewer in napari.
Controls: 
  x/y/z - align normal vector along x/y/z axis 
  click and drag - shift plane along its normal vector
  alt-click - add point on plane (if points layer is active)
  o - align plane normal to view direction
  [] - decrease/increase plane thickness
Arguments:
  [TOMOGRAM_FILE]
Options:
  --help                          Show this message and exit.
```
Contributing
Contributions are very welcome. 
License
Distributed under the terms of the BSD-3 license,
"napari-tomoslice" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-tomoslice

A napari plugin for interacting with electron cryotomograms

napari-animated-gif-io






Open and save 3D image stacks as animated gifs
You find the menus for opening and saving animated gifs in the Tools > File Import/Export menu:

Furthermore, if in 3D view, you can save the current view with a little tilt animation as animated gif.
Under the hood this uses the microfilm library.


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

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

napari-animated-gif-io

Loic A. Royer

napari-nasa-samples






This napari plugin written by Loic A. Royer provides sample datasets from NASA.
In particular, you can access directly from napari the recently released images for the James Webb Space Telescope, as well as
some of the classic and most beautiful images obtained by the venerable and still strong Hubble Space Telescope. 
More images will be added over time.
Thanks to (NASA)[https://www.nasa.gov/] for releasing these incredible images!


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

Installation
You can install napari-nasa-samples via pip:
pip install napari-nasa-samples

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

napari-nasa-samples

This napari plugin provides sample datasets from NASA.

Emma Zhou

napari-dvid





DVID loader for napari, from a url

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

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

Examples
Once installed, run napari --with napari-dvid to get the plugin sidebar:

Paste in a URL to a DVID volume and hit "Load" to load the volume! As an example, try:
https://emdata.janelia.org/api/node/ab6e610d4/grayscale/raw/0_1_2/256_256_256/7500_7000_4400
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-dvid" is free and open source software
Issues
If you encounter any problems, please file an issue along with a detailed description.

napari-dvid

Pranjal Dhole

Duway Nicolas Lesmes Leon

napari-yapic-prediction





A napari widget plugin to perform YAPiC model segmentation prediction in the napari window. 

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

Description
This napari plugin provides a widget to upload a YAPiC trained model and perform segmentation over all the present images in the napari window. The segmentation results are uploaded as napari layers into the viewer automatically with the name structure of imgename_prediction.
Installation


Please install either GPU or CPU version of tensorflow that is compatible with your cuda and cudnn libraries before installing the plugin depending on your system.
One of the plugin dependency is yapic that currently has sensitivity to tensorflow versions.


You can install napari-yapic-prediction via pip:
pip install napari-yapic-prediction


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

napari-yapic-prediction

napari widget that performs image segmentation with yapic model in the napari window. Install TENSORFLOW to use this plugin.

Joel Luethi

Max Hess

napari-feature-classifier






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

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

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


Classify objects:

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


Apply the classifier to additional images:

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


Export classifier results

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


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

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

napari-feature-classifier

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

napari-filaments






A napari plugin for filament analysis.
This plugin helps you to manually track filaments using path shapes of Shapes layer.

Currently implemented functions

Fit paths to filaments in an image as a 2-D spline curve.
Clip/extend paths.
Measurement of filament length at sub-pixel precision.
Basic quantification (mean, std, etc.) along paths.
Import paths from ImageJ ROI file.

Basic Usage
Click Layers > open image to open a tif file. You'll find the image you chose and a shapes layer are added to the layer list.


The "target filaments" box shows the working shapes layer.
The "target image" box shows the image layer on which fitting and quantification will be conducted.
The "filament" box shows currently selected shape (initially this box is empty).

Add path shapes and push key F1 to fit the shape to the filament in the target image layer.

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

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

napari-filaments

Allen Institute for Cell Science

napari-allencell-annotator






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

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




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

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

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

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

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

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

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

napari-allencell-annotator

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

Search for a plugin by keyword or author

Browse plugins: 212

napari-tissuumaps

version

release date

license

Python version

operating system

napari-timeseries-opener-plugin

version

release date

license

Python version

operating system

napari-serialcellpose

version

release date

license

Python version

operating system

napari-allencell-annotator

version

release date

license

Python version

operating system

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

version

release date

license

Python version

operating system

napari-nd2-folder-viewer

version

release date

license

Python version

operating system

napari-stl-exporter

version

release date

license

Python version

operating system

imaxt-multiscale-plugin

version

release date

license

Python version

operating system

napari-LF

version

release date

license

Python version

operating system

napari-help

version

release date

license

Python version

operating system

napari-sift-registration

version

release date

license

Python version

operating system

napari-nlm

version

release date

license

Python version

operating system

avidaq

version

release date

license

Python version

operating system