All Classes and Interfaces
Class
Description
Abstract plugin aimed towards cases where new objects will be detected inside existing objects (normally TMA cores or annotations).
Wrapper for a deep learning model in a pipeline using OpenCV.
Abstract
PathOverlay with additional properties relevant when drawing BufferedImages.Abstract
ImageRenderer, which adds a timestamp variable.Abstract implementation of ImageServer providing some common functionality.
Abstract class to help with implementing an interactive plugin.
Abstract class to help with the creation of object classifiers.
Abstract class to help with implementing PathOverlays.
Define a function to perform the task of
PathOverlay.getLocationString(ImageData, double, double, int, int)General abstract plugin implementation, which defines some methods to facilitate
creating plugins that do parallel processing.
Abstract PluginRunner to help with the creation of plugin runners for specific circumstances,
e.g.
Abstract plugin used for detection tasks that support breaking large regions into smaller ones,
and analyzing these in parallel - optionally with overlaps.
Abstract
ImageServer for BufferedImages that internally breaks up requests into constituent tiles.Annotation used to specify a preferred accelerator for an an action.
Annotation indicating the a key in the external resources file containing
the menu, text and (optional) description.
Default icon for an action.
Annotation indicating the menu path where an action should be installed.
Annotation indicating that a method should be converted to an
Action if possible.Helper methods for generating and configuring Actions and UI elements.
Builder class for custom
Action objects.ImageServer that dynamically applies an AffineTransform to an existing ImageServer.
Helper class for working with affine transforms.
Component for displaying annotations within the active image.
Implementation of an arbitrary area ROI - which could contain disjointed or hollow regions.
Simple wrappers for primitive arrays that returns values as doubles.
Simple wrapper for an array or list, enabling values to be returned as doubles.
Class to deal with script auto-completions.
A single completion.
Functional interface to extract a token from a string needed to determine
a completion.
Default actions associated with QuPath's 'Automate' (scripting) menu.
A collection of static methods useful when working with AWT shapes and
ImageRegions.QuPath ImageServer that uses the Bio-Formats library to read image data.
A QuPath extension that adds options relating to the BioFormatsImageServer to the main QuPath preference pane.
Builder for ImageServers that make use of the Bio-Formats library.
Container for various options that can customize the behavior of the
BioFormatsImageServer.Helper class for working with Bioimage Model Zoo model specs, and attempting to
replicating the processing within QuPath.
Convert OpenCV Mats into blobs (tensors) for use with a deep learning framework.
Parameter that can take on true of false value - or null.
Helper class for handling the boundaries of training annotations when creating a pixel classifier.
A pane responsible for the display and selection of channels from an image display.
Command to show a Brightness/Contrast dialog to adjust the image display.
A pane to display a histogram for brightness/contrast adjustment, allowing the user to select min/max values.
A pane to save and load display settings, using a
ResourceManager.A pane containing sliders for adjusting the min/max display range and gamma value
associated with an
ImageDisplay.Tool for drawing (and subtract from) freehand regions, optionally adapting brush size to magnification.
An overlay used to display one or more
BufferedImage objects on top of a primary image shown in a viewer.Static methods for working with BufferedImages and QuPath objects.
Basic version information about the current QuPath build.
Simple plugin to attempt a very fast cell counting based upon (smoothed) peak detection.
Command to (sub)classify cells as Negative/Positive or Negative/1+/2+/3+ based on a single (usually intensity-based) measurement.
Helper class for working with PathObjects that represent cells.
A simple class to store the color of an image channel.
Interface used to control the display of single channels of image data, where
'single channel' means one value per pixel (in Java's parlance, one band for the
SampleModel).
Helper interface to indicate that the display ranges can be modified.
Display mode for an image channel, used in combination with
ImageDisplay and ChannelDisplayInfo.ImageServer that applies a color transform to an image.
A simple class to store the main information needed by QuPath to display an image channel
with a requested color and brightness/contrast setting.
A
TransformingImageServer that applies color transforms to generate channels.Helper class for generating interactive charts.
Builder for creating scatter charts.
Builder for creating pie charts.
Builder for creating scatter charts.
Pane that can be used to contain an XYChart, adding adjustable thresholds to be displayed.
Collection of static methods to help when working with JavaFX charts,
and adapting these for QuPath's purposes.
Parameter that supports a list of choices.
Wrapper for a
PixelCalibration to be used to define classifier resolution.Code area control using RichTextFX.
Plugin to calculate coherence features for image tiles.
Simple class for representing - and inverting a 3x3 matrix.
Static methods to assist with color deconvolution.
Helper class for storing stain vectors and maximum channel values to be used for color deconvolution.
Enum for common stain defaults.
Canvas to show the range of a ColorMap (i.e.
Helper class to manage colormaps, which are rather like lookup tables but easily support interpolation.
colormap, which acts as an interpolating lookup table with an arbitrary range.
Factory methods to help create ColorModels for use with BufferedImages.
An
ImageRenderer that uses a ColorModel.Helper class for creating a JSON-serializable way to generate a
ColorModel.Helper class for creating a JSON-serializable way to generate a
ColorModel.Simple builder to create a
ColorModel.Simple builder to create a
ColorModel.Helper class to the display of a single channel (band) in a
ColorModel.Helper class to the display of a single channel (band) in a
ColorModel.Static functions to help work with RGB(A) colors using packed ints.
Helper class for converting between packed RGB colors and Java's AWT representation, as well as creating some ColorModels for BufferedImages.
Helper class for converting between packed RGB colors and Java's AWT representation, as well as creating some ColorModels for BufferedImages.
Static methods for computing a range of color transforms for packed RGB values.
Enum consisting of color transforms that may be applied to RGB images.
Color transforms that may be used to extract single-channel images from BufferedImages.
Interface defining a color transform that can extract a float values from a BufferedImage.
TypeAdapter to support serializing a ColorTransforms.ColorTransform.Helper tools for creating components that enable fast access to menu commands via a filtered list.
Available modes for displaying the command bar.
Helper class to wrap summary data for a command to display in the list.
A PluginRunner that simply logs progress and output.
A
SimpleProgressMonitor that sends progress to a log.Helper class implementing simple 'single-method' commands for easy inclusion in the GUI.
Default actions associated with a specific QuPath instance.
Help window providing context-dependent help.
Class to convert labelled images to Geometry objects, ROIs and PathObjects.
Helper class defining global thresholds to apply to a single image channel.
Allows command line option to convert an input image to OME-TIFF
Helper method for calculating the convex hull from a list of points.
Data structure to hold cooccurrence matrices for computation of Haralick features.
Command to open up a counting panel to aid with creating Point annotations.
Command to create training images based upon channel names, and add these to a project.
Command to create a composite classifier by merging together two or more other classifiers.
Command to help create annotations defining regions that will be further annotated for
algorithm training.
Command to generate a
SparseImageServer from multiple image regions across a project.ImageServer that treats a particular sub-region of another ImageServer as a full image,
i.e.
Class for representing CSS in QuPath.
Default auto-completor for JVM-based languages, optionally including QuPath default imports.
An ImageRegionStore suitable for either Swing or JavaFX applications.
Default comparator to enable objects to be sorted in a more predictable manner.
Simple, default implementation of
PathObjectConnectionGroup.Default comparator to enable ROIs to be sorted in a more predictable manner.
A scriptable workflow step where the script is provided directly as an argument.
Default multilingual script editor.
Default implementation for a
ScriptLanguage, based on a ScriptEngine.Interface defining how the import statements should be generated for the language.
Default implementation of a TMAGrid.
Plugin for calculating Delaunay clustering, and associated features.
Tools for creating and querying Delaunay triangulations and Voronoi diagrams.
Builder class to create a
DelaunayTools.Subdivision based on Delaunay triangulation.Helper class for extracting information from a Delaunay triangulation computed from PathObjects.
Compute Delaunay triangulation using OpenCV.
Command for generating density maps from detections on an image.
Dialog for interactively generating a custom density map.
Class for constructing and using density maps.
Builder for an
ImageServer representing a density map or for DensityMaps.DensityMapParameters.Class for storing parameters to build a
ImageServer representing a density map.Density map types.
UI elements associated with density maps.
Simple command to detect tumor regions stained with cytokeratin.
Helper methods to convert ObjectDetectors into runnable tasks, which take care of resolving
overlaps when using ParallelTileObjects after the detection is complete and firing notification
events in a PathObjectHierarchy.
Deprecated.
since v0.5.0.
Deprecated.
Possible buttons pressed in a yes/no/cancel dialog.
Plugin to create new annotations by expanding the size of existing annotations.
Line cap to use for annotation expansion.
ChannelInfo intended for use with a single or multichannel image (possibly fluorescence)
where the pixel's value is used to scale a single color according to a specified display range according to the following rules:
If the pixel's value is >= maxDisplay, the pure color is used.
If the pixel's value is <= minDisplay, the black is used.
Otherwise, a scaled version of the color is used
The end result is like having a lookup table (LUT) that stretches from black to the 'pure' color specified,
but without actually generating the LUT.
Utility class for working with image display and image display settings objects.
Static methods for calculating distances between objects.
General interface for implementing a deep learning model in a pipeline using OpenCV.
Builder to create a
DnnModel from DnnModelParams.Parameters to build a
DnnModel.Builder for
DnnModelParams.Helper class for building new DnnModels.
Initial implementation of a patch-based
ObjectClassifier using an OpenCV-compatible DNN.Helper class to represent input and output shapes associated with
PredictionFunction.Tools for working with OpenCV's DNN module.
Helper class to summarize a DNN layer.
Command line tool to export icons and markdown documentation for QuPath commands.
A simple superpixel-generating command based upon applying ImageJ's watershed transform to the
absolute values of a Difference-of-Gaussians filtered image.
Parameter to represent a floating point numeric value.
Drag and drop support for main QuPath application, which can support a range of different object types (Files, URLs, Strings,..)
Interface to define a new drop handler.
Interface for objects that manage editable text, including a caret position and selection.
ROI implementing a circle, or (unrotated) ellipse.
Parameter that doesn't actually store any value, but might contain some
useful text (or a title) that may need to be displayed.
Code for estimating stain vectors automatically from an image, or to launch an editor for visually/interactively modifying stain vectors.
Functional interface for scripting languages that are runnable (e.g.
Command to export object(s) in GeoJSON format to an output file.
Command to help export training regions as labelled images to train AI algorithms elsewhere.
ClassLoader for loading QuPath extensions and other jars from the user directory.Borderpane that displays extensions, with options to remove,
open containing folder, update, where possible.
Manage loading extensions for a QuPathGUI instance.
Class to wrap a collection of objects to indicate they should be export as a GeoJSON "FeatureCollection".
Interface for extracting features from PathObjects for the purpose of object classification.
Helper class for extracting features from objects, used along with ObjectClassifiers.
Create a preprocessor for an image or training matrix.
Builder to create a custom
FeaturePreprocessor.Copy files to an output directory, prompting the user if necessary.
Helper class that, given a path, determines some basic file format information without enlisting
the help of an external library or performing extensive parsing of the data.
Interface defining some basic image metadata that may be extracted from an image file
to help ascertain whether an
ImageServerBuilder can handle it.Plugin to create new annotations by expanding the size of existing annotations.
Plugin to identify/remove detections from the convex hull of all detections.
Collection of generally useful static methods.
Marker interface to indicate that this ImageServer generates tiles on request.
ROI based on Java Topology Suite Geometry objects.
Convert between QuPath
ROI objects and Java Topology Suite Geometry objects.Builder to help define how ROIs and Geometry objects should be converted.
Helper class to represent a project hosted on GitHub.
Helper class to represent a GitHub repository.
Simple class used for storing information related to GridLines that may be painted over an image.
An overlay used to show a (counting) grid on top of an image.
Auto completion support for Groovy.
Category class for enhanced Groovy scripting with OpenCV.
Class for the representation of the Groovy programming language in QuPath.
Styling to apply to a
CodeArea, based on Groovy or Java syntax.Helper class providing Gson instances with type adapters registered to serialize
several key classes.
A
TypeAdapterFactory that is suitable for handling class hierarchies.Assorted static methods to help with JavaFX and QuPath GUI-related tasks.
Kinds of snapshot image that can be created for QuPath.
Static methods for computing Haralick texture features.
Helper class for computing Haralick features given a cooccurrence matrix.
Plugin for calculating Haralick texture features, within or around detections or tiles.
An overlay capable of painting a
PathObjectHierarchy, except for any
TMA grid (which is handled by TMAGridOverlay).Class for storing histogram data & basic statistics.
JavaFX chart for displaying histograms.
Enum to specify how the counts are displayed.
Display mode for the histogram.
Helper class for representing data that may be visualized with a
HistogramChart.Wrapper close to enable the generation and display of histograms relating to a data table.
Marker interface that indicates an executable language renders HTML.
Factory class for creating icons.
Default icons for QuPath commands.
QuPath extension & associated static helper methods used to support integration of ImageJ with QuPath.
Commands to install with the ImageJ extension.
Collection of static methods to help with using ImageJ with QuPath.
The name and display color for a single image channel.
Class that brings together the main data in connection with the analysis of a single image.
Enum representing possible image types.
Request pixels from an image, potentially applying further transforms.
An
ImageServer that wraps an ImageData.A panel used for displaying basic info about an image, e.g.
Class used to look after the color transforms that may be applied to an image,
including brightness/contrast settings.
A simple class to store the main information needed by QuPath to display an image,
in a JSON-friendly form.
Supported interpolation methods when displaying images.
QuPath plugin for running ImageJ macros & returning detected regions.
Class to generate a
PixelProcessor when using ImageJ for the primary image representation.ImageServer that uses ImageJ's image-reading capabilities.
Builder for ImageServers that use ImageJ to read images.
An operation that may be applied to a
Mat.Create and use
ImageOp and ImageDataOp objects.Channel and color operations.
Core operations.
Filtering operations.
Machine learning operations.
Normalization operations.
Abstract
ImageOp to simplify the process of handling padding.Thresholding operations.
Helper class to store z-slice and time point indices, optionally along with a channel index as well.
Class for defining an image region.
Interface for painting regions of an
ImageServer onto a Graphics object.Factory for creating an ImageRegionStore.
Helper methods related to image region storage.
Interface for objects capable of converting a
BufferedImage for rendering using Graphics2D.Generic ImageServer, able to return pixels and metadata.
Helper class for creating ImageServers from a given URI and optional argument list.
Abstract ServerBuilder implementation that handles metadata.
Default
ImageServerBuilder.ServerBuilder that requires a URI and (optional) array of String arguments to create an ImageServer
with the help of a ImageServerBuilder.Interface that defines a class encapsulating all that is required to build an ImageServer.
Helper class to summarize which ImageServers can be build by a particular
ImageServerBuilder
for a given URI, and a level of confidence.Class for storing primary ImageServer metadata fields.
Builder to create a new
ImageServerMetadata object.Enum representing possible channel (band) types for an image.
Width and height of each resolution in a multi-level image pyramid.
Builder to create a list of
ImageServerMetadata.ImageResolutionLevel to represent pyramidal resolutions.Service provider for creating ImageServers from a given path - which may be a file path or URL.
Helper class for working with
ImageServer objects.A functional interface for supplying an image region for processing.
Interface for defining class that can write images.
Static methods to access
ImageWriter objects and write images.An immutable alternative to Java's AWT Dimension.
An informative message that should be shown to the user.
The type of message, which can be used for styling.
Plugin for calculating intensity-based features, including Haralick textures, within or around detections or tiles.
Static methods to import object(s) from different sources.
Methods to help with requesting interpolated values.
Parameter to represent an integer numeric value.
Command to show javadocs in a
WebView.ImageWriter implementation to write JPEG images using ImageIO.
ImageServerBuilder that constructs an ImageServer from a JSON representation.
Class for the representation of JSON syntax in QuPath.
Styling to apply to a
CodeArea, based on JSON syntax.Structure used to store data related to generating Kaplan-Meier survival curves.
Simple class to store event time and censored flag.
A special ImageServer implementation that doesn't have a backing image, but rather
constructs tiles from a
PathObjectHierarchy where pixel values are integer labels corresponding
stored and classified annotations.Helper class for building a
LabeledImageServer.ROI representing a straight line, defined by its end points.
Create commands for displaying pixel classifiers and density maps.
Initial test implementation of Local Binary Patterns.
Calculate local binary pattern features.
Methods to normalize the local image intensity within an image, to have (approximately) zero mean and unit variance.
Helper class to store local normalization parameters.
Local normalization type.
2D or 3D Gaussian scale.
Manage logging levels.
Available log levels.
Helper class to apply a log-rank test.
Simple structure used to manage the result of a log rank test.
Helper class for logging.
A viewer for log messages.
Class for the representation of JSON syntax in QuPath.
Styling to apply to a
CodeArea, based on Markdown syntax.A functional interface for supplying a mask corresponding to an image.
Basic interface to define a measurement.
Dialog box to export measurements
Helper class for exporting the measurements of one or more entries in a project.
Deprecated.
Interface defining a feature measurement list, consisting of key value pairs.
Enum representing different types of measurement list, with different priorities regarding
flexibility and efficiency.
Factory for creating new measurement lists.
Component used for displaying measurement maps, whereby detection objects are recolored
according to measurement values.
Helpers class that can be used to map an object's measurement to a color (packed RGB int).
Create
PixelProcessor instances that make measurements from objects.Interface for calculating one custom measurement from an image, using
Parameters.Functions for calculating measurements from an array of pixels.
Methods to create custom measurements.
Common interface to define the contents of a menu in terms of actions.
Generate actions for installation in QuPath's main menubar.
Static methods to help with creating and populating JavaFX menus.
Interface that may be used to indicate that a
PathObject (or other object) can store metadata.Command to open a small viewer window, which displays a detail from
the current image depending on where the cursor is over the image.
A manager for one or more mini-viewers, where the 'more' means a separate viewer per channel.
Implementation of morphological reconstruction for ImageJ.
Implementation of 2D morphological reconstruction, using 8-connectivity & a hybrid method.
The MoveTool is used for quite a lot of things, movement-related:
movement around an image (panning), moving ROIs (translating) and moving individual
'handles' of ROIs (resizing/reshaping)
Helper class for panning a
QuPathViewer (reasonably) smoothly.Calculate pixel-based features in both 2D and 3D.
Helper class for storing and computing pixel features from Hessian matrices.
Hessian matrix values for 2D images.
Hessian matrix values for 3D images (z-stacks).
Image features, dependent on Gaussian scale.
Helper-class for computing pixel-features at a specified scale.
Helper map implementation that provides access to
MultiscaleFeatures.Hessian if needed.Methods for normalizing features.
Class to help with simple feature normalization, by adding an offset and then multiplying by a scaling factor.
Abstract parameter to represent a numeric value.
Read .npy and .npz files from NumPy.
Interface defining object classifiers, which assign PathClasses to PathObjects.
Command used to create and show a suitable dialog box for interactive display of OpenCV classifiers.
Command to apply a pre-trained object classifier to an image.
Helper class for creating ObjectClassifiers.
Builder to create a simple
ObjectClassifier that assigns a classification based upon whether the
measurement of an object is above, equal to or below a specified threshold.TypeAdapterFactory to help with serializing ObjectClassifiers to and from JSON.Wraps a pane used to display an object description, if one is available.
Minimal interface that may be used to plugins that perform detection within a specified ROI
and using a specified ImageData with set parameters.
Experimental class to generate object measurements.
Cell compartments.
Requested intensity measurements.
Standard measurements that may be computed from shapes.
Helper class for merging objects using different criteria.
Simple browser for exploring fields (including private fields) within an object by reflection.
A table data model to supply observable measurements of PathObjects.
This class can parse raw bytes into a
BufferedImage.Builder for instances of
OMEPixelParser.Write OME-TIFF files based on QuPath ImageServers.
Builder class to define parameters when exporting an image region as OME-TIFF,
possibly as an image pyramid.
Enum representing different ways in which channels may be written to a file.
Preferred compression type when using Bio-Formats.
Class representing a single series to write to an OME-TIFF.
OME TIFF writer command capable of exporting image pyramids based on QuPath ImageServers.
ImageWriter for writing OME-TIFF images.QuPath wrappers for OpenCV classifiers, which are instances of StatModel.
Classifier based on
Boost.Classifier based on
DTrees.Clusterer based on
EM.Classifier based on
LogisticRegression.Classifier based on
NormalBayesClassifier.Wrapper class for a
StatModel, which standardizes how training may be performed and
parameters can be set.Classifier based on
RTrees.Classifier based on
SVM.Classifier based on
SVMSGD.Wrapper for an OpenCV Net, including essential metadata about how it should be used.
Helper class to build an
OpenCVDnn.Enum representing different classes of
Model supported by OpenCV.A
DnnModelBuilder implementation that uses OpenCV's DNN module
to build a Net.An
ObjectClassifier that uses an OpenCVClassifiers.OpenCVStatModel for classification.Initial implementation of a patch-based
ObjectClassifier using an OpenCV-compatible DNN.Class to generate a
PixelProcessor when using OpenCV for the primary image representation.Collection of static methods to help with using OpenCV from Java.
Class representing the indices of a pixel and its value.
Helper classes for combining OpenCV's JSON serialization with Gson's.
TypeAdapter that helps include OpenCV-based objects within a Java object being serialized to JSON.
TypeAdapterFactory that helps make OpenCV's serialization methods more compatible with custom JSON/Gson serialization.
Minimal Java wrapper for OpenSlide.
Exception thrown whenever a request is made after the OpenSlide object has been closed.
ImageServer implementation using OpenSlide.
JNA interface for OpenSlide.
Static helper class to manage loading the OpenSlide library.
Builder for Openslide ImageServer.
A functional interface for handling the output of a
Processor.Actions that interact with
OverlayOptions.Default class for storing overlay display options.
Display modes for cells and other detections.
Requested padding for a 2D image.
Deprecated.
since v0.5.0;
GridPaneUtils contains many of the features.A temporary object, used during parallel processing to represent a tile currently being used for object
detection.
Current processing status for the tile.
Interface defining algorithm parameters, which need to be displayed to users somehow.
Interface for objects that need to be notified when parameters have their values changed.
Interface for indicating that the implementing class takes adjustable parameters.
A collection of Parameters, which can be used for analysis & queried to construct appropriate GUIs.
A panel for displaying a list of parameters suitably to aid with creating JavaFX GUIs.
Parameters for use with a
PixelProcessor.Builder class for
Parameters.Parameters required to build a classifier that operates on an image patch.
Builder class to create
PatchClassifierParams.An annotation PathObject.
A subclass of a PathDetectionObject, which also supports storing an (optional) extra ROI to represent
the cell nucleus.
Representation of an object's classification - which can be defined using any unique string
identifier (e.g.
Enum representing standard classifications.
Deprecated.
since v0.4.0 in favor of methods added to
PathClass directly.Enum representing standard classifications.
Static methods for use with
PathClass objects.A detection PathObject.
A special
ImageServer implementation that doesn't have a backing image, but rather
constructs tiles on request from a PathObjectHierarchy and its detection objects.Interface used when needing to associate pixel data with information regarding the image from which it was obtained.
Interface to define a PathPlugin that requires a list of (user-adjustable) parameters.
Primary class for loading/saving
ImageData objects.Options to customize the export of PathObjects as GeoJSON.
Fundamental object of interest in QuPath.
Interface defining a basic structure to represent relationships between PathObjects that do not fit with
the parent-child idea of the PathObjectHierarchy.
Data structure for storing multiple PathObjectConnectionGroups.
Enumeration of filters (predicates) that can be used to select objects based on their type.
Grid display of objects.
A basic hierarchy in which to store PathObjects.
An event class for passing on information about modifications to a PathObjectHierarchy.
Enum representing different ways in which the hierarchy may have been updated.
A listener for modifications to a
PathObjectHierarchy (i.e.Component for showing a tree-based view of the object hierarchy.
Create standardized
ListCell and TreeCell instances for displaying a PathObject,
or a generic pane to use elsewhere.Manage a small pane that can be used to display a
PathObject.Static methods to assist with painting PathObjects.
Classes to define JSON-serializable
Predicates for PathObjects.A JSON-serializable
Predicate for use with PathObjects.Interface for classes capable of reading PathObjects from some source.
Helper class to create
PathObject.A listener to selection changes within a PathObjectSelectionModel.
Model for handling selection of single and multiple PathObjects.
A collection of static methods to help work with PathObjects.
Interface defining an overlay to paint on top of a viewer.
Primary interface for defining a 'plugin' command.
Central storage of QuPath preferences.
Options for automatic updating checking of QuPath and/or extensions.
Enum for different ways that detections can be displayed in lists and trees.
Enum to control font size.
Enum defining how setting the image type should be handled for new images.
Abstract class used for PathObjects that have ROIs associated with them.
The root object used at the base of a PathObjectHierarchy.
Interface defining a table model that enables measurement names to be mapped to string or numeric values (as appropriate).
Helper interface to define plugin tasks that require post-processing on a specific thread
(i.e.
A subclass of PathDetectionObject, generally used to represent an image region that doesn't
(in itself) correspond to any particularly interesting structure.
Interface defining how a toolbar tool interacts with a viewer.
Default
PathTool implementations.Class used to represent pixel sizes.
Builder class for
PixelCalibration objects.ImageServer that delivers pixels derived from applying a PixelClassifier to another ImageServer.
Helper class to compute area-based measurements for regions of interest based on pixel classification.
PathOverlay that gives the results of pixel classification.Interface defining a pixel classifier.
Open GUI for the current viewer to train a new pixel classifier.
Metadata to control the behavior of a pixel classifier.
Builder to create
PixelClassifierMetadata objects.Main user interface for interactively training a
PixelClassifier.Static methods and classes for working with pixel classifiers.
Helper methods for working with pixel classification.
Options when creating objects from a pixel classifier.
Helper class for training a pixel classifier.
Wrapper for training data.
Helper class for generating standardized UI components for pixel classification.
Very simple wrapper that allows some non-ImageJ-oriented QuPath commands to access ImageProcessor pixel values.
A class for tiled image processing.
Builder class for a
PixelProcessorUtility functions to help with the
PixelProcessor class.Image bit-depths and types.
Class for the representation of plain text in QuPath.
Styling for plain text (which really means no styling).
ImageWriter implementation to write PNG images using ImageIO.
Simple interface defining a point.
A 2D point (x & y coordinates).
Helper class for reading/writing point objects in terms of their x,y coordinates.
ROI representing a collection of 2D points (distinct x,y coordinates).
ROI representing an arbitrary closed polygon.
ROI representing an arbitrary open polyline.
Alternative implementation of
WatershedCellDetection that automatically applies 1 or 3 intensity thresholds to classify cells.Simple command to detect regions with positive staining.
Prediction function, typically used with a deep learning framework.
QuPath's preference pane, giving a means to modify many of the properties within PathPrefs.
Core QuPath preferences.
Helper class for preprocessing input for machine learning algorithms using OpenCV Mats.
Helper class to apply PCA projection.
Static methods to enable existing code for watershed transforms and morphological reconstruction
to be applied to OpenCV images.
General-purpose processing and machine learning commands.
Commands based on OpenCV.
A generic processor designed to work with
Parameters and provide an output.Data structure to manage images and associated data in QuPath.
Component for previewing and selecting images within a project.
Class to help with formatting text fields for entering pixel and object classifier names.
Helper class implementing simple 'single-method' commands related to projects.
Dialogs specifically related to managing projects.
Class to represent an image entry within a project.
Read QuPath projects.
Static methods to help when working with Projects.
Class for the representation of properties and config files in QuPath.
Styling to apply to a
CodeArea, based on Java .properties and .cfg file syntax.Auto completion support for Python.
Styling to apply to a
CodeArea, based on Python syntax.Collection of static methods that are useful for scripting.
Alternative to QP offering static methods of use for scripting,
along with some extra methods that require access of GUI features.
Main QuPath launcher.
ImageJ plugin for sending back all the ROIs on an ImageJ overlay to QuPath.
ImageJ plugin for sending back the active ROI from ImageJ to QuPath.
Launcher application to start QuPath.
Simple interface for QuPath extensions.
Main GUI for QuPath, written using JavaFX.
Helper class for managing pressure-sensitive input.
Interface defining minimal behavior for a pen input device.
Load strings from the default resource bundle.
Class to facilitate the use of different styles within QuPath.
Available font families.
Interface defining a style that may be applied to QuPath.
Standalone viewer for looking at TMA summary results.
JavaFX component for viewing a (possibly large) image, along with overlays.
Interface for defining a listener that needs to know whenever the data
related to a QuPathViewer has changed in some way - such as by changing
the underlying ImageData, or by moving the field of view.
A whole slide viewer with optional extras...
Simple image server to swap the red and blue channels of an RGB image.
Helper class when classifying PathObjects.
ROI representing a square or rectangle (unrotated).
Plugin to create new annotations by expanding the size of existing annotations.
Define the area of an image to which pixel classification should be applied.
Standard classification regions (hopefully all you will ever need).
Class for defining an image region that can also be used to request these region from an
ImageServer.An ImageServer that can display a rendered image, with optional overlays.
Builder to create an ImageServer to display rendered images, with optional overlay layers.
Manage the storage and retrieval of resources with a
ResourceManager.Simple manager to handle saving and retrieving resources of different kinds, for example from projects
or a user directory.
Rich script editor for QuPath, which can be used for handling different languages.
QuPath extension to add a more attractive script editor with syntax highlighting,
making use of RichTextFX, Copyright (c) 2013-2014, Tomas Mikula (BSD 2-clause license).
Base interface for defining regions of interest (ROIs) within QuPath.
Enum representing the major different types of ROI.
Helper class for interactively modifying existing ROIs.
Collection of static methods to help work with ROIs, binary & labelled images in ImageJ.
This class consists exclusively of static methods that operate on or return regions of interest (ROIs).
A collection of static methods for working with ROIs.
Methods of combining two ROIs.
ImageServer that wraps another ImageServer, but intercepts region requests to
effectively rotate the image by 90, 180 or 270 degrees.
Enum for rotations in increments of 90 degrees.
Helper class for computing basic statistics from values as they are added.
WorkflowStep for running a saved PathObjectClassifier.
Small JavaFX pane to support saving object/pixel classifiers and density maps within a project in a standardized way.
A WorkflowStep that can also return some Javascript that, if run, would perform the step.
Default attributes that can be set when running scripts.
Interface for classes that implement auto-completion (e.g.
Minimal interface for a script editor that the GUI can call.
Basic script editor control using JavaFX.
Abstract class to represent languages supported by the script editor.
Class with static methods to fetch all the available ScriptLanguages.
Class that stores key information that is useful for running scripts.
Builder class for
ScriptParameters.Interface for classes that apply some styling to a RichTextFX's
CodeArea.Class with static methods to fetch all the available
ScriptStylers.Interface for classes that apply some syntax formatting to an
EditableText.Class with static methods to fetch all the available ScriptSyntaxes.
Class representing a script tab (e.g.
Helper class for managing items when only one of them may be selected.
Component to show measurements for a currently-selected object.
Helper class for selecting one image server out of a collection.
Static methods helpful when dealing with ImageServers.
Add shape measurements
Helper methods for simplifying shapes, such removing polygon points while retaining the a similar overall
shape at a coarser level.
Manager to simplify submitting short tasks in background threads using a shared
ExecutorService.A minimal interface for accessing pixel values in a single-channel image.
Create
SimpleImage instances for basic pixel processing.A simple viewer for a single image, with options to save or copy.
A minimal interface to define a means to provide access to pixel values from a 2D, 1-channel image.
Updated version of DefaultPluginWorkflowStep, adapted to use Externalizable and to avoid storing the plugin class as a class object
(preferring a String instead).
Class for monitoring the process of a plugin and displaying feedback to the user.
Apply simple thresholding to an image via the pixel classification framework to support
thresholding at any resolution, optionally with visual feedback via an overlay.
Collection of static methods to threshold images, either with single global thresholds or
using the pixel values of a second image.
Very basic global thresholding command to identify tissue regions.
ChannelDisplayInfo that determines colors based upon a single value for each pixel.Command to (sub)classify objects based on a single measurement.
An implementation of SLIC superpixels, as described at http://ivrl.epfl.ch/research/superpixels
A simple viewer for a slide label, tied to the current viewer.
Plugin to supplement the measurements for detection objects with the weighted sum of measurements
from nearby objects, using weights derived from a 2D Gaussian function.
An ImageServer that combines regions from multiple separate ImageServers,
repositioning these as necessary to generate one larger field of view.
Builder to create a new
SparseImageServer.Helper class for SparseImageServers, capable of returning the appropriate ImageServer for
different ImageRegions and different resolutions.
Command to split annotations using lines.
Plugin to create new annotations by expanding the size of existing annotations.
Divide a project into training, validation and test sets but flagging individual image entries.
Representation of a color deconvolution stain vector, defined in terms of RGB optical densities.
Enum representing default stains.
Static methods for computing statistics from images, with or without a corresponding labeled image.
Parameter to represent a String value.
Experimental plugin to help with the quantification of subcellular structures.
A subcommand for the command line interface.
Show a summary table for an object of a particular type (annotation, detection, TMA core...)
Extension for SVG image export.
Helper class for writing SVG images, in particular rendered PathObjects to create high-quality figures.
Builder class to enable the export of rendered QuPath objects as SVG images.
Enum defining ways in which raster images may be included in the SVG file.
Helper class for managing
MenuBar.useSystemMenuBarProperty() values based upon a property value.Enum specifying when and where the system menubar should be used.
A minimal interface for a class capable of running tasks in parallel, giving feedback to the user.
Plugin runner that takes care of showing progress (in the appropriate thread) using JavaFX components.
A utility class to help with the creation of
TaskRunner instances.Marker interface used to indicate that child objects shouldn't be added to any cache for display.
Interface to indicate anything for which text can be appended.
Simple text area control (JavaFX) with basic operations and no styling support.
Implementation of the 3D binary thinning algorithm of
Lee et al.
Create a thread factory that supports adding a prefix to the name and setting daemon status.
ImageWriter implementation to write TIFF images using ImageJ.
Plugin to merge classified tiles into annotation objects.
Helper class for exporting image tiles, typically for further analysis elsewhere or for training up an AI algorithm.
Interface for anything that needs to know when image tiles become available.
Enum representing the possible alignments for tiles.
A wrapper for a
RegionRequest, useful to precisely specify image tiles at a particular resolution.Helper class to manage tile requests from an
ImageServer.Simple plugin to create square tiles, which may later have measurements added.
Helper class to time code execution.
Class representing a named checkpoint with a timestamp in nanoseconds.
Helper class implementing simple 'single-method' commands related to tissue microarrays for easy inclusion in the GUI.
A special PathObject used exclusively to represent TMA cores.
Static methods for exporting TMA data, optionally with small images.
Static methods used by the TMA dearrayer plugin.
Plugin for automatically dearraying tissue microarrays (TMAs).
The aim of this is to enable the exploration of TMA data from multiple images in a project.
Interface defining a (rectangular) TMA grid.
An overlay capable of painting a TMA Grid.
Helper class for importing data in connection with TMA slides.
Deprecated.
since v0.4.0
Manage (drawing) tool selection in a QuPath UI.
Helper class for creating an
ImageServer that applies one or more transforms to another (wrapped) ImageServer.An ImageServer implementation used to apply transforms to another ImageServer.
Helper class to add undo/redo support to QuPath.
Helper class to query for updates using GitHub's web API.
Class to represent a release version.
Fix broken URIs by using relative paths or prompting the user to select files.
Interface for objects that depend upon URIs.
Helper class for updating URIs, for example whenever files have moved or projects have been transferred between computers.
Wrapper for a URI, providing access to a
Path if available.Enum representing the status of a URI, i.e.
Class to return core QuPath URLs centrally.
Helper class for managing a user directory, and associated subdirectories.
Helper class for working with semantic versioning.
Actions that interact with one or more viewers.
Class to manage multiple
QuPathViewer instances in a UI region.A group of properties determining what should be displayed for each viewer.
Default ViewTracker implementation.
Panel for viewing ViewTracker controls.
Class for storing the values of a data map as well as generating a proper
BufferedImage with the appropriate pixel type.Wand tool, which acts rather like the brush - except that it expands regions
(sometimes rather too eagerly?) based upon local pixel values.
Enum reflecting different color images that may be used by the Wand tool.
Implementation of 2D watershed transform for ImageJ.
Implementation of 2D watershed transform.
Default command for cell detection within QuPath, assuming either a nuclear or cytoplasmic staining.
Cell detection that takes into consideration membrane staining.
Alternative (incomplete) attempt at nucleus segmentation.
Helper class for creating a
WebView in a standardized way.Welcome page when launching QuPath.
A collection of steps that relate to how an image has been - or should be - processed.
Show logged commands, and optionally generate a script.
Interface for listening to changes in Workflows, e.g.
Basic interface for a loggable workflow step.
Implementation of an
ImageServer that simply wraps an existing BufferedImage.Class for representing XML in QuPath.
Styling to apply to a
CodeArea for XML.Class for the representation of YAML syntax in QuPath.
Styling to apply to a
CodeArea, based on YAML syntax.ImageWriter implementation to write zipped TIFF images using ImageJ.