# Gigapixel and Whole-Slide Image Annotation Tools Compared

Source: https://www.potatoannotator.com/docs/guides/gigapixel-image-annotation-tools-compared

**QuPath and ASAP are free desktop programs for one person outlining and analyzing whole-slide pathology scans, Cytomine and the Digital Slide Archive are free web platforms that keep a lab's slides on one server, and V7 is a hosted platform priced by quote. Potato is a free, self-hosted alternative for studies in which several annotators outline the same slides or large mosaics. Potato opens slides tile by tile in the browser, imports and exports QuPath GeoJSON and ASAP XML, and reports agreement between annotators on boxes and polygons corrected for chance.**

A [gigapixel image](https://en.wikipedia.org/wiki/Gigapixel_image) has about a billion pixels, and a browser cannot open an image of that size as one picture. Viewers instead use an [image pyramid](https://en.wikipedia.org/wiki/Pyramid_(image_processing)). An image pyramid stores copies of the image at halving resolutions and cuts each copy into small tiles. The viewer fetches only the tiles on screen at the current magnification. A whole-slide image is a scanned microscope slide stored as such a pyramid, in vendor formats such as Aperio `.svs`, Hamamatsu `.ndpi`, and 3DHISTECH `.mrxs` (see [digital pathology](https://en.wikipedia.org/wiki/Digital_pathology)). The [International Image Interoperability Framework](https://en.wikipedia.org/wiki/International_Image_Interoperability_Framework) (IIIF) defines web APIs through which libraries and archives serve such images and describe sequences of images.

The comparison below covers tools for annotating images too large to open as one file, from pathology slides to aerial mosaics and IIIF collections. [Gigapixel Image Annotation with Deep Zoom](/docs/vision-spatial/deep-zoom) documents Potato's viewer and every option. [Medical Image and Clinical Text Annotation Tools Compared](/docs/guides/medical-annotation-tools-compared) covers CT and MR volumes and clinical notes, and [Image Annotation Tools Compared](/docs/guides/image-annotation-tools-compared) covers ordinary photographs and point clouds.

## Gigapixel annotation tools worth comparing

Licenses, prices, and large-image support come from each project's own pages on 2026-11-02.

| Tool | Runs as | License | Price | Large images | Suits |
|---|---|---|---|---|---|
| **[QuPath](https://qupath.github.io/)** | Desktop app for Windows, macOS, and Linux | GPL-3.0 | Free | Whole-slide images through OpenSlide and Bio-Formats | One pathologist or scientist annotating slides, with built-in cell and tissue detection |
| **[ASAP](https://computationalpathologygroup.github.io/ASAP/)** | Desktop app for 64-bit Windows and Linux | GPL-2.0 | Free | Multi-resolution slides from many vendors through OpenSlide | Viewing slides and drawing points, rectangles, polygons, and splines, saved as XML |
| **[Cytomine](https://github.com/cytomine/Cytomine)** | Web platform on your own server, installed with Docker Compose | Apache-2.0 | Free | Large biomedical images | A team sharing slides and annotations and running analysis apps |
| **[Digital Slide Archive](https://digitalslidearchive.github.io/digital_slide_archive/)** | Web platform on your own server, installed with Docker Compose | Apache-2.0 | Free | Tiled formats, including TIFF, SVS, and JP2 | A slide archive with role-based access, annotation and review in HistomicsUI, and HistomicsTK analysis |
| **[napari](https://napari.org/stable/)** | Python desktop viewer | BSD-3-Clause | Free | Multiscale arrays, with the resolution in 2D chosen from the viewport | Annotation inside a Python analysis, on NumPy or Zarr arrays |
| **[V7](https://www.v7labs.com/)** | Hosted web platform | Proprietary | By quote | Pyramidal tiles for files over 10,000 pixels on a side, up to 65,535 pixels per side and 268,435,456 pixels in area, with `.svs` and `.ndpi` listed | Managed labeling with a vendor's support |
| **[Recogito Studio](https://recogitostudio.org/)** | Web platform, self-hosted with Docker or hosted by the project | AGPL-3.0 | Free to self-host; hosted plans by quote | IIIF images | Several people annotating IIIF images, TEI text, and PDFs together as W3C Web Annotations |
| **[Potato](/)** | Python web server on your own server | GPL-3.0-or-later | Free | Tile pyramids served as DZI and IIIF Image API 3.0, and slides in the formats openslide reads | Several annotators per slide or mosaic, with agreement between annotators |

QuPath's site states that QuPath is not intended for clinical, diagnostic, or therapeutic purposes. Potato is research software with no clinical or regulatory clearance.

## Which tool for which task

The table pairs each kind of large-image project with the tools built for that kind of project.

| Task | Good fits |
|---|---|
| One pathologist annotating slides and detecting or classifying cells | QuPath |
| Opening a slide and drawing regions saved as human-readable XML | ASAP |
| A lab server that stores slides and runs analysis on slide regions | Cytomine and the Digital Slide Archive |
| Annotating multiscale arrays from a Python script | napari |
| Managed slide labeling with vendor support | V7 |
| Annotating IIIF images with colleagues in a humanities project | Recogito Studio |
| Several annotators outlining the same slides, with agreement reported | Potato |
| Correcting QuPath or ASAP regions with several annotators | QuPath or ASAP for the first pass, then Potato |

## Slide formats and tile pyramids

QuPath reads whole-slide images through the OpenSlide and Bio-Formats libraries. QuPath's format page rates NDPI as well supported and gives MRXS limited support. The Digital Slide Archive accepts new formats through a Python interface, and V7 lets annotators work on a tiled file as one image.

Potato's `image_annotation` scheme takes `viewer: deepzoom`. The deep zoom viewer draws the image through OpenSeadragon and lays the annotation canvas over the image. Potato reads whole-slide files in `.svs`, `.ndpi`, `.mrxs`, `.scn`, `.vms`, `.vmu`, `.bif`, and `.svslide` through openslide, one tile at a time from the slide's own pyramid. Slide support needs the `wsi` extra. The extra installs openslide-python, openslide-bin, and tifffile:

```bash
pip install "potato-annotation[wsi]"
```

A flat image such as a large aerial TIFF has no pyramid of its own. Potato builds each level of a flat image the first time a tile of that level is requested. For each level, Potato decodes the source once. Potato refuses to build a level above 640 megapixels unless `tiles.max_pixels` is raised. A tiled TIFF with several levels needs no such decode. With the `wsi` extra installed, openslide reads a tiled TIFF from the TIFF's own levels. Potato serves every pyramid both as DZI and over the [IIIF Image API 3.0](https://iiif.io/api/image/3.0/) at `/media/iiif/<path>/info.json`. Mirador and other IIIF clients can open the same images from that route.

## Several annotators on the same slide

In a study that reports tumor area, each slide goes to more than one annotator, because pathologists draw the same tumor boundary differently. QuPath and ASAP run on one person's computer, and we found no way to assign a slide to several annotators in either program's pages. Cytomine shares a project's work among teammates, and the Digital Slide Archive controls access by user or role and includes annotation review.

Potato assigns each slide to the number of annotators that `num_annotators_per_item` sets and keeps every annotator's regions under that annotator's name. Potato reports [agreement over geometry](/docs/measurement/geometry-agreement) for every `image_annotation` scheme, with or without the deep zoom viewer. The report gives detection, classification, and localization separately. For localization, Potato compares annotators on the same slide with a chance baseline taken from pairs of annotations on different slides. We have found no other annotation platform reporting chance-corrected agreement over spatial labels. [How to Measure Inter-Annotator Agreement on Bounding Boxes](/docs/guides/measuring-agreement-on-bounding-boxes) explains the method.

## A two-pathologist slide study in Potato

The config below sends every slide to two annotators. Each annotator outlines tumor regions with polygons and boxes clusters of mitoses. The agreement report covers both shapes, and the full config passes Potato's validator:

```yaml
annotation_task_name: Tumor regions on whole-slide images
task_dir: .
output_annotation_dir: annotation_output/
media_directory: media
data_files:
  - data/slides.json
item_properties:
  id_key: id
  text_key: note
user_config:
  allow_all_users: true
  users: []

# Two pathologists outline every slide, and each pathologist's regions are kept apart
num_annotators_per_item: 2
agreement_metrics:
  enabled: true

annotation_schemes:
  - annotation_type: image_annotation
    name: regions
    description: "Outline each tumor region and box each cluster of mitoses."
    source_field: image
    viewer: deepzoom
    tools: [polygon, bbox, landmark]
    labels:
      - {name: tumor, color: "#c0397b"}
      - {name: mitosis cluster, color: "#5b2c86"}
      - {name: artifact, color: "#7f8c8d"}
```

Each item in `data/slides.json` names a slide under `media/`, such as `{"id": "slide_01", "image": "case_01.svs", "note": "Case 01"}`. The agreement report appears at `/admin/iaa` once two annotators have finished the same slides. Potato stores coordinates as fractions of the full-resolution slide. The tile descriptor at `/media/tiles/<slide>.dzi?format=json` gives the slide's microns per pixel for converting a region to microns.

## QuPath GeoJSON and ASAP XML in Potato

From Potato 2.13, `potato import` reads QuPath GeoJSON and ASAP XML and pairs each region file with the slide of the same name. The first command below builds a project in which the regions appear as pre-annotations for every annotator to correct, and the second writes each annotator's regions back to QuPath GeoJSON in level-0 slide pixels:

```bash
potato import -i case_01.geojson --image-dir /data/slides -o case-project
python -m potato.export -c case-project/config.yaml -f qupath_geojson -o out/qupath
```

The export writes one file per annotator and slide, and `-f asap_xml` writes ASAP XML instead. Labels become QuPath classifications and ASAP groups. The import reads at most 50,000 regions per slide. Export only annotations from QuPath and leave cell detections out of the file. The [microscopy](/docs/annotation-types/microscopy#whole-slide-pathology-images) page covers the options.

## Aerial mosaics and IIIF collections

Large aerial and drone mosaics open in the same deep zoom viewer as slides. Save a mosaic over 640 megapixels as a tiled pyramidal TIFF, or raise `tiles.max_pixels` to a value the server's memory allows. The deep zoom viewer stores regions as fractions of the image rather than as map coordinates. When annotations have to land in a GIS, annotators draw with the [`geo_annotation` scheme](/docs/annotation-types/geo-annotation) on an OpenLayers map over a GeoTIFF or XYZ tiles you host, and Potato saves each answer as GeoJSON in EPSG:4326.

For IIIF collections, `potato import -f iiif` reads a IIIF Presentation manifest and makes one item per canvas. The importer loads each canvas as one picture, from the image's own URL or from a request to the canvas's Image service sized to fit a 2,000-pixel square by default. The annotator of an imported manifest sees one image rather than tiles. The `iiif_annotations` export writes the regions as W3C annotation pages beside a copy of the manifest, and Mirador and Universal Viewer open the copy with the regions shown. [Annotorious](https://annotorious.dev/) is a BSD-licensed JavaScript library that adds annotation to OpenSeadragon and IIIF viewers. Annotorious suits a team building its own viewer. [Digital humanities](/use-cases/digital-humanities) collects Potato's IIIF features.

## What Potato does not do for gigapixel images

- **No cell or tissue detection.** Potato runs no detection or segmentation model on slides. The detection and segmentation trainers coming in Potato 2.14.0 read ordinary image files and do not train on whole-slide or deep zoom images. QuPath detects cells and tissue and trains pixel classifiers, and HistomicsTK covers nuclei segmentation and color deconvolution.
- **No masks in QuPath or ASAP exports.** Brush masks on a deep zoom image are stored at the source's full resolution with no texture-size ceiling, because the mask buffer indexes image pixels rather than a GPU texture. The QuPath and ASAP exports write shapes only. Draw slide regions as polygons when the regions go back to QuPath or ASAP.
- **No region-aware fill in deep zoom.** The deep zoom page has no single source image to read colors from. The fill tool falls back to filling empty mask area.
- **No micron coordinates in storage.** Regions are stored as fractions of the slide, and the exports write level-0 pixels.
- **No managed workforce.** Bring your own annotators, or recruit annotators on [Prolific](/docs/guides/crowdsourcing-prolific-mturk).

We checked every cell against each project's own documentation and pricing pages on 2026-11-02. If a cell is wrong, [tell us](https://github.com/davidjurgens/potato/issues/new).

## Frequently asked questions

### Which gigapixel image annotator should I use for pathology slides?

Use QuPath for one pathologist annotating and analyzing slides on a desktop computer, and Cytomine or the Digital Slide Archive for a lab that keeps slides on a shared server. Use Potato when several annotators outline the same slides and the study reports agreement between the annotators. Potato reads SVS, NDPI, MRXS, and the other formats openslide reads, and exchanges regions with QuPath and ASAP.

### Which gigapixel annotation tool works for aerial and satellite mosaics?

Potato's deep zoom viewer opens aerial and satellite mosaics as tile pyramids. Potato reads a mosaic saved as a tiled pyramidal TIFF without decoding the whole image. V7 tiles any file over 10,000 pixels on a side, within a stated maximum of 65,535 pixels per side. When annotations need map coordinates, annotators draw with Potato's `geo_annotation` scheme over a GeoTIFF or hosted XYZ tiles, and Potato saves GeoJSON in EPSG:4326.

### Is there an AI gigapixel annotator for whole-slide images?

QuPath has built-in cell and tissue detection and interactive machine learning for pixel and object classification, and Cytomine runs analysis apps such as cell counting and tumor delineation. Potato runs no detection model on slides. Potato instead imports regions from QuPath GeoJSON or ASAP XML files as pre-annotations that every annotator corrects.

## Further reading

- [Gigapixel Image Annotation with Deep Zoom](/docs/vision-spatial/deep-zoom), for every viewer option
- [Microscopy](/docs/annotation-types/microscopy), for fluorescence images and the slide import and export commands
- [Microscopy and pathology](/use-cases/microscopy), for Potato's microscopy features in one place
- [Healthcare and clinical annotation](/use-cases/healthcare)
- [Medical Image and Clinical Text Annotation Tools Compared](/docs/guides/medical-annotation-tools-compared)
- [Image Annotation Tools Compared](/docs/guides/image-annotation-tools-compared)
- [Agreement over Geometry](/docs/measurement/geometry-agreement)
- [Annotation Tools Compared](/docs/guides/annotation-tools-compared), for every data type on one page