All Classes and Interfaces
Class
Description
A color space specified by its RGB primaries and white point coordinates, all defined
in two-dimensional CIE xy-space.
ImageJ demo plugin making available a selection of adaptive thresholders.
ImageJ plugin showing the use of the
BernsenThresholder class
(see Sec.
ImageJ plugin demonstrating the use of the
NiblackThresholder class.
ImageJ plugin demonstrating the use of the
SauvolaThresholder class.
Common interface to be implemented by all adaptive (i.e., non-global) thresholders.
This color space class is based on the "AdobeRGB1998.icc" profile [1].
This class implements 2D point fitting under affine (three-point) transformations (exact and least-squares).
This class represents an affine transformation in 2D, which can be defined by three pairs of corresponding points.
Represents an algebraic circle with four parameters A, B, C, D in the form A * (x^2 + y^2) + B * x + C * y + D = 0.
Represents an algebraic ellipse with the implicit equation A x^2 + B x y + C y^2 + D x + E y + F = 0.
This class represents an algebraic line of the form A x + B y + C = 0.
This imageJ plugin demonstrates blending of two images and generating a stack of intermediate images.
This class defines static methods implementing arithmetic operations and predicates.
This ImageJ plugin creates a binary region segmentation, calculates the center and major axis and subsequently the
major axis-aligned bounding box for each binary region (connected component).
Represents a major axis-aligned bounding box of a 2D point set.
ColorEnumeration defining a set of selected AWT colors.
This is an implementation of the adaptive thresholder proposed by Bernsen in [1].
Parameters for class
BernsenThresholder.
A
PixelInterpolator implementing bicubic interpolation in 2D.
This ImageJ plugin demonstrates the use of the Bilateral filter.
Common interface for all Bilateral filter implementations.
Parameter bundle for bilateral filters (implementations of
BilateralF).
Scalar (non-separable) version of the Bilateral filter as proposed in [1].
Scalar and separable version of the Bilateral filter as proposed in [1].
Vector (non-separable) version of the Bilateral filter as proposed in [1], for RGB images (
ColorProcessor)
only.
Vector and separable version of the Bilateral filter as proposed in [1], for RGB images (
ColorProcessor)
only.
A
PixelInterpolator implementing bilinear interpolation in 2D.
This class represents a bilinear transformation in 2D with 8 parameters a0, ..., a3, b0, ..., b3 of the form
This plugin implements a binary morphology filter (dilation, erosion, opening, or closing) using a disk-shaped
structuring element whose radius can be specified.
ImageJ plugin implementing a binary morphology filter with an arbitrary structuring element that can be interactively
specified by the user.
Implements a binary morphological closing operation.
Implements a binary morphological dilation operation.
Implements a binary morphological erosion operation.
This class defines a binary mask, as used in filters, for example.
This is the (abstract) super-class for binary morphological filters.
Common interface for all binary morphological operators.
Implements a binary morphological opening operation.
Implements a binary morphological dilation operation.
This class represents a connected component or binary region.
Performs region segmentation on a given binary image.
Implements a binary morphological thinning or "skeletonization" operation, based on the algorithm by Zhang and Suen
[1].
This class implements a true 2D bitmap container, i.e., each 0/1 element occupies only a single bit (unlike
boolean arrays, which require at least 8 bits per element).This interface defines the behavior of bit vectors, i.e., fixed-sized vectors with single bit elements.
This class implements
BitVector with internal 32-bit int data.This class implements
BitVector with internal 64-bit long data.
This class represents a linear chromatic adaptation transform, mapping XYZ color coordinates from a source white
(reference) point to a target white point.
Binary region segmentation based on a breadth-first flood filling algorithm using a queue.
ImageJ plugin, increases the brightness of an indexed color image by 10 units (each color component).
ImageJ plugin, increases the brightness of a RGB color image by 10 units (each color component) using bit operations
(Version 1).
ImageJ plugin, increases the brightness of a RGB color image by 10 units (each color component) without bit
operations (Version 2).
Image accessor for scalar images with 8-bit (byte) values.
ImageJ plugin showing the use of the Canny edge detector in its simplest form.
This class implements a Canny edge detector for grayscale and RGB images.
ImageJ plugin, implementing a "cartoon" or "edge burn-in" effect by controlled darkening of image edges.
A
PixelInterpolator implementing Catmull-Rom interpolation in 2D See Sec.
This ImageJ plugin demonstrates the use of the
ChamferMatcher class.
Instances of this class perform "chamfer" matching on binary images.
A simple ImageJ plugin for validating the 'imagingbook' installation.
Interface to be implemented by chromatic adaptation transforms.
Defines static methods for converting between CIE-XYZ coordinates (3D) and xy chromaticity values (2D).
This class renders the famous CIE xy-chromaticity diagram, also known as the "horeseshoe" curve, delineating the
range of visible colors in the xy-diagram.
ImageJ plugin, performs algebraic circle fitting on the current ROI to find an initial circle, followed by geometric
fitting.
Samples points on a given (ideal) circle and creates a new image with the
sample points marked and also contained in a
PointRoi.
Performs an exact circle fit to 3 given (non-collinear) points.
Common interface for all algebraic circle fits.
Common interface for geometric circle fits.
"Coordinate-based" geometric circle fitter using a nonlinear least-squares (Levenberg-Marquart) optimizer.
"Distance-based" geometric circle fitter using a nonlinear least-squares (Levenberg-Marquart) optimizer.
This is an implementation of the "hyperaccurate" algebraic circle fit proposed by Al-Sharadqah and Chernov in [1],
also described in [2] (Sec.
This is an implementation of the "hyperaccurate" algebraic circle fit proposed by Al-Sharadqah and Chernov in [1],
also described in [2] (Sec.
This is an implementation of the algebraic circle fitting algorithm described in [1].
This is an implementation of the modified Kåsa [1] circle fitting algorithm described in [2, Sec.
This is an improved implementation of the Kåsa [1] circle fitting algorithm described in [2, Sec.
This is an implementation of the algebraic circle fitting algorithm by Pratt [1], as described in [2] (Sec.
This is an implementation of the algebraic circle fitting algorithm by Taubin [1], following the description in [2]
(Sec.
Defines utility methods for picking random points on a given circle.
Defines a circular mask with the specified radius.
Static utility methods related to classes.
Clipboard-related methods from
http://examples.javacodegeeks.com/desktop-java/awt/datatransfer/getting-and-setting-text-on-the-system-clipboard/
This ImageJ plugin implements the Canny edge detector for all types of images.
This ImageJ plugin implements a multi-gradient (DiZenzo/Cumani-style) color edge detector.
This ImageJ plugin implements a simple grayscale edge detector for all types of images.
This is a simple color edge detector based on monochromatic techniques.
This is basically a mirror class of
BasicStroke adding line and fill colors.Interface used for color enum types.
This class calculates a color histogram of a set of colors (i.e., a color image).
This class defines a "color stack" as a subtype of
PixelPack with exactly 3 components (slices), representing
a color image in a specific color space (default is sRGB65ColorSpace).Common interface for color sequencers.
This class represents complex numbers.
This class represents a connected component (i.e., a binary image region).
This class represents a tree of extremal image components.
Enumeration specifying the method (algorithm) for building the component tree.
This class is a re-implementation of the "quasi-linear-time" component tree algorithm which is based on efficient,
tree-based union finding as described in [1].
This class implements the "linear-time" ("local flooding") component tree algorithm described in [1].
ImageJ plugin which calculates and displays (lists) the histogram of a 8-bit grayscale image.
Calculates an approximate closest point on the ellipse for a given 2D point inside or outside the ellipse, using
"confocal conic distance approximation" [1].
A simple progress monitor that only prints the progress of the monitored target task to the console.
This class represents a closed contour as a sequence of pixel coordinates.
This interface defines the functionality of region segmentations that perform contour extraction.
ImageJ plugin, converts a color image with RGB components assumed to be in AdobeRGB
color space to sRGB color space.
This ImageJ plugin shows how to change the type of the current image 'in place', i.e., without copying the image.
This is a simple tool for converting images of a specific type in a given directory to a new type using ImageJ.
ImageJ plugin, converts an RGB color image to a grayscale image using a specific set of component weights (ITU
BR.709) for calculating luminance (luma) values.
ImageJ plugin, converts a sRGB color image to Lab, Luv, HLS, HSV or Linear RGB color space and shows the resulting
components as a image stack (with float values).
This ImageJ plugin demonstrates the use of the
ConvexHull class.
This class calculate the convex hull of a 2D point set.
An implementation of
FontMapper that substitutes unknown fonts with embedded core fonts (Type1).This class represents a 2D corner.
Instances of this class perform matching on scalar-valued images based on the correlation coefficient.
This ImageJ plugin demonstrates the use of the
CorrCoeffMatcher class.
ImageJ plugin, counts the distinct colors in the current color image.
This plugin demonstrates how to create and display a new byte image (to show the histogram of the input image).
ColorEnumeration defining a set of CSS colors (see http://davidbau.com/colors/)Example for a
FiniteRandomColorSequencer which iterates over a subset of CssColor.
A
PixelInterpolator implementing cubic B-spline interpolation in 2D See Sec.22.4.2 of [1] for additional
details.This ImageJ plugin shows how to construct a 3x3 custom generic filter based on class
GenericFilterScalar.This ImageJ plugin shows how to construct a 3x3 custom generic vector filter based on class
GenericFilterVector.This ImageJ plugin shows how data can be communicated from one plugin to another.
This ImageJ plugin shows how data can be communicated from one plugin to another.
Calculates and displays the 2-dimensional DCT after converting the input image to a float image.
Interface specifying all one-dimensional DCT implementations.
Sub-interface for 1D DCT implementations operating on
double data.Sub-interface for 1D DCT implementations operating on
float data.
Calculates the 1D DFT using tabulated cosine values for
float or
double data (see sub-classes Dct1dDirect.Float and
Dct1dDirect.Double, respectively).One-dimensional DCT implementation using
double data.One-dimensional DCT implementation using
float data.
This is fast implementation of the DCT, based on the JTransforms package by
Piotr Wendykier (
https://github.com/wendykierp/JTransforms).
One-dimensional DCT implementation using
double data.One-dimensional DCT implementation using
float data.
Calculates the 1D discrete cosine transform (DFT) on
double data.
Common interface for all 2D DCT implementations.
Sub-interface for 2D DCT implementations operating on
double data.Sub-interface for 2D DCT implementations operating on
float data.
Direct (slow) implementation of the 2-dimensional DCT using tabulated cosine values.
Two-dimensional DCT implementation using
double data.Two-dimensional DCT implementation using
float data.
Fast implementation of the 2-dimensional DCT.
Two-dimensional DCT implementation using
double data.Two-dimensional DCT implementation using
float data.This ImageJ plugin performs corner detection on the active image, applies Delaunay triangulation to the N
strongest corners and displays the result as a vector overlay on top of the same image.
Interface specification for implementations of Delaunay triangulations.
Binary region segmentation based on a depth-first flood filling algorithm using a stack.
ImageJ plugin, continuously desaturates the current image directly in RGB
color space (without conversion to HSV or HSB).
This ImageJ plugin computes the 2-dimensional DFT (magnitude spectrum) from an image of arbitrary size using
float or double data.
Interface to be implemented by all one-dimensional DFT/FFT implementations.
Sub-interface for 1D DFT implementations operating on
double data.Sub-interface for 1D DFT implementations operating on
float data.
Direct (slow) implementation of the 1-dimensional DFT using tabulated sine
and cosine values.
One-dimensional DFT implementation using
double data.One-dimensional DFT implementation using
float data.
FFT (fast) implementation of the DFT, based on the JTransforms package by
Piotr Wendykier (see
https://github.com/wendykierp/JTransforms).
One-dimensional FFT implementation using
double data.One-dimensional FFT implementation using
float data.
Common interface for all 2D DFT/FFT implementations.
Sub-interface for 2D DFT implementations operating on
double data.Sub-interface for 2D DFT implementations operating on
float data.
Direct (slow) implementation of the 2-dimensional DFT using tabulated sine
and cosine values.
Two-dimensional DFT implementation using
double data.Two-dimensional DFT implementation using
float data.
Fast implementation of the 2-dimensional DFT using 1D FFTs.
Two-dimensional DFT implementation using
double data.Two-dimensional DFT implementation using
float data.Utility methods and annotations related to ImageJ's
GenericDialog class.Annotation to specify the number of digits (value) displayed when showing numeric values in dialogs.
Annotation to hide the following parameter field in dialogs.
Annotation to specify a specific 'label' (value) to be shown for following parameter fields.
Annotation to specify the number of "columns" (value) displayed when showing string items in dialogs.
ImageJ plugin implementing a binary dilation by a disk-shaped structuring element with a fixed radius.
This ImageJ plugin shows how to access the one-dimensional pixel array of a 8-bit (= byte) grayscale image.
A color space implementing this interface indicates that it can convert internal color values directly to and from
D65-based XYZ coordinates, without going through the standard (D50-based) Profile Conversion Space (PCS).
Modern-style directory traversal.
Instances of this class calculate an approximate distance transform of a given image which is assumed to be binary
(pixel value 0 = background, non-zero = foreground).
Enum type for different distance norms used to calculate distance transforms.
Exception indicating a floating-point division by zero (or some denominator too small to yield a finite result).
Represents a single "octave" in a hierarchical DoG scale space.
Represents a hierarchical DoG scale space.
This ImageJ plugin draws a test grid in a new image.
This class represents a 2D edge (line segment), specified by its two end-points.
This is the common interface for all color edge detectors.
Represents a chain of connected edge points (integer pixel coordinates).
An implementation of
RealEigenDecomposition, which merely wraps an instance of EigenDecomposition as
provided by the Apache Commons Math library.Eigenvalues and eigenvectors of a real matrix.
Implements an efficient, closed form algorithm for calculating the real eigenvalues (λ) and eigenvectors (x)
of a 2x2 matrix of the form
This plugin creates a new image with an ellipse and a set of random points.
ImageJ plugin, performs algebraic ellipse fitting on the current ROI to find an initial ellipse, followed by
geometric fitting.
Samples points on a given (ideal) circle and creates a new image with the sample points marked and also contained in
a
PointRoi.Performs an exact ellipse fit to 5 given points.
Interface for algebraic ellipse fits.
Algebraic ellipse fit using Fitzgibbon's original method [1], based on simple matrix inversion.
Algebraic ellipse fit based on Fitzgibbon's original method [1], as described in [2] (WITHOUT the additional
numerical improvements).
Algebraic ellipse fit based on Fitzgibbon's method [1], numerically improved as suggested by Halir and Flusser [2].
Interface to be implemented by all geometric ellipse fits.
Algebraic ellipse fit based on Taubin's method [1].
Algebraic ellipse fit based on Taubin's method [1].
"Coordinate-based" geometric ellipse fitter using iterative minimization with the Levenberg-Marquart method.
"Distance-based" geometric ellipse fitter using iterative minimization with the Levenberg-Marquart method.
Abstract superclass for ellipse projectors, used to find the closest "contact" point on an ellipse for some given
target point.
Utility class for picking random points on a given ellipse.
This ImageJ plugin performs linear histogram equalization on the selected grayscale image, which is modified.
Example filter based on
GenericFilterScalar performing linear convolution with a custom 3x3 filter kernel.
Example filter based on
GenericFilterVector performing linear convolution with a custom 3x3 filter kernel.This ImageJ plugin exports the current image and its attached vector graphic overlay (if existent) as a PDF file.
This class defines various static methods for managing
file-based resources and JAR manifest files.
ImageJ plugin for a linear filter with a kernel of arbitrary size and integer coefficients (naive implementation).
ImageJ plugin implementing a simple linear 3×3 "box" filter.
ImageJ plugin for a median filter of arbitrary size.
ImageJ plugin for a simple 3×3 linear smoothing filter.
This class defines a custom filter implementing
GenericFilterVector that reports its progress, which is
queried by a ProgressMonitor in the FilterProgressExample.main(String[]) method.
ImageJ plugin which demonstrates the use of gradient corner detectors (Harris, MOPS, Sho-Tomasi), optionally using
sub-pixel positioning.
This class defines methods for iterating over an ordered set of AWT colors.
Image accessor for scalar images with 32-bit (float) values.
This ImageJ plugin calculates the covariance matrix for the 11-element Flusser moment vectors over a collection of
binary images.
This ImageJ plugin calculates and lists the 11 scale and rotation invariant Flusser moments for the binary regions
contained in the given image.
This ImageJ plugin demonstrates the use of complex invariant Flusser moments for 2D shape matching.
Naive implementation of Flusser's complex invariant moments [1].
This ImageJ plugin visualizes the composition of 2D shapes by superposition of nested ellipses, corresponding to
complex coefficient pairs of elliptic Fourier descriptors.
This ImageJ plugin demonstrates the "trigonometric" construction of elliptic Fourier descriptors.
This class represents elliptic Fourier descriptors.
Defines static methods to create Fourier descriptors directly from 2D polygons without re-sampling or interpolation.
Defines static methods to create Fourier descriptors from uniformly sampled point sequences.
This ImageJ performs simple gamma correction (with fixed γ = 2.8) on
a 8-bit grayscale image, which is modified.
Interface to be implemented by gamma correction classes.
This ImageJ plugin shows how to construct a generic linear filter using the classes
LinearFilter and
Kernel2D.
This ImageJ plugin applies a Gaussian blur filter to selected components in HSV color space.
This plugin performs a Gaussian filter in a user-selectable color space.
This ImageJ plugin shows how to construct a generic linear filter based on classes
LinearFilter and
Kernel2D.This class implements a 2D Gaussian filter by extending
LinearFilter.This class implements a x/y-separated 2D Gaussian filter by extending
LinearFilterSeparable.This class represents a 2D filter kernel.
This class represents a 2D filter kernel.
Represents a single "octave" in a hierarchical Gaussian scale space.
Represents a hierarchical Gaussian scale space.
Solves the generalized eigenproblem of the form A x = λ B x, for square matrices A, B.
Solves the generalized symmetric eigenproblem of the form A x = λ B x, where matrices A, B are symmetric and B
is positive definite (see Sec.
Enumeration defining a set of
ImageResource objects for selected sample images.This ImageJ plugin demonstrates the basic use of
GenericDialog to create a new byte image.
This is the (abstract) root class of the generic filter hierarchy.
This (abstract) class represents a filter which treats all pixel values as scalars.
This (abstract) class represents a generic scalar filter whose pixel-operation is x/y-separable.
This (abstract) class represents a filter which treats all pixel data as vectors.
This (abstract) class represents a generic vector filter whose pixel-operation is x/y-separable.
Defines a primitive mechanism for attaching arbitrary properties to an object dynamically using generic types to
eliminate type casts.
Defines a generic map key to be used with
GenericProperties.The underlying hash map class, to be instantiated by implementing classes.
Represents a geometric circle with center point (xc, yc) and radius r.
Represents an ellipse with major axis length ra, minor axis length rb, center point (xc, yc), and orientation theta.
This plugin rotates the input image.
ImageJ plugin making available a selection of global thresholders.
ImageJ plugin demonstrating the use of the
IsodataThresholder class.
ImageJ plugin demonstrating the use of the
MaxEntropyThresholder class.
ImageJ plugin demonstrating the use of the
MeanThresholder class.
ImageJ plugin showing the use of the
MedianThresholder class.
ImageJ plugin showing the use of the
MinErrorThresholder class.
ImageJ plugin showing the use of the
MinMaxThresholder class.
ImageJ plugin showing the use of the
OtsuThresholder class.
ImageJ plugin showing the use of the
QuantileThresholder class.
Common interface to be implemented by all global thresholders.
Abstract super class for all corner detectors based on the local structure matrix (tensor).
Simple grayscale edge detector for all types of images.
Instances of this class perform the transformation between 2D image coordinates and indexes into the associated 1D
pixel array and vice versa.
This indexer throws an exception if coordinates outside image bounds are accessed.
This indexer returns mirrored image values for coordinates outside the image bounds.
This indexer returns the closest border pixel for coordinates outside the image bounds.
Exception to be thrown by
GridIndexer2D.ExceptionIndexer.This indexer returns -1 for coordinates outside the image bounds, indicating that a (predefined) default value
should be used.
Defines static helper methods related to ImageJ's GUI.
This is an implementation of the Harris/Stephens corner detector, as described in [1].
Hash functions for gradient (Perlin) noise.
Integer hash function proposed by Thomas Wang in [1].
Integer hash function proposed by Thomas Wang in [1].
Hash function proposed by G Ward in [1].
Interface to all hash functions defined in this package.
Permutation-based hash function, similar to the one proposed in [1].
This class represents a straight line in Hessian normal form, i.e., x * cos(angle) + y * sin(angle) = radius.
This abstract class defines a generic hierarchical scale space, consisting of multiple "octaves".
Defines a simple image window to display histograms.
This class defines static methods related to histograms.
Implementation of HLS (hue/lightness/saturation) color space.
This ImageJ plugin demonstrates the use of the
HoughTransformLines class for detecting straight lines in
images (see Sec.
This class represents a straight line of the form (x - xRef) * cos(angle) + (y - yRef) * sin(angle) = radius.
This class implements the "classic" Hough Transform for straight lines.
ImageJ plugin, "rotates" the hue (H) of colors in HSV space by 120 degrees.
Implementation of HSV (hue/saturation/value) color space.
Annotation to specify the menu entry (name) of the associated plugin class.
Annotation to specify the menu path (tree branch) of the associated plugin class or an entire plugin package.
Implementation of
ProgressMonitor which periodically polls the completion state of the associated target task
(ProgressReporter) and sends this information to ImageJ's progress bar (if ImageJ is running).This class defines static utility methods adding to ImageJs functionality.
An 'image accessor' is a wrapper around some
ImageProcessor object to allow unified (read and write) access
to its pixels values.This plugin demonstrates the of class
ScalarAccessor for unified access to scalar-valued images.This plugin demonstrates the of class
ImageAccessor for unified access to scalar and vector-valued images.Used to extract warped images for testing class
LucasKanadeMatcher.
This class defines functionality for drawing anti-aliased "pixel" graphics in images of type
ByteProcessor,
ShortProcessor or ColorProcessor (there is no support for FloatProcessor).This class defines methods to perform arbitrary geometric transformations on images.
This class defines static methods for non-destructive, arithmetic operations on ImageJ's
ImageProcessor
objects.
Interface to be implemented by named image resources.
This class implements incremental orthogonal line fitting to a set of 2D points using eigendecomposition (see
OrthogonalLineFitEigen for a non-incremental version).
ImageJ plugin, converts an indexed color image to a full-color RGB image.
This class provides version information for this library.
This ImageJ plugin calculates the integral image for the current image (8 bit grayscale only) and displays the
resulting first and second order summed area tables (S1, S2) as floating-point images.
This ImageJ plugin first calculates the integral image for the current image (8 bit grayscale only) and uses it to
find the mean and variance inside the specified rectangle (ROI).
This class represents an 'integral image' or 'summed area table' as proposed in [1], See Sec.
Enumeration type listing the most common interpolation methods.
Implementing classes provide an inverse of the associated mapping.
This is an implementation of the global thresholder proposed by Ridler and Calvard [1].
Slow version of the
IsodataThresholder using explicit recalculation of background and foreground means in
every iteration.Implementing classes provide the Jacobian matrix for the associated mapping.
This package-level annotation is used to specify a URL for automatic retrieval of JavaDoc information.
Classes implementing this interface provide a URL that links to the associated JavaDoc page (returned by method
JavaDocHelp.getJavaDocUrl()). ImageJ plugin -
implementation of the "Jitter filter" based on
GenericFilter.
ImageJ plugin -- Jitter filter implemented with
ImageAccessor, allowing uniform access to all image types.
ImageJ plugin which implements a simple version of the Jitter filter, using ImageJ functionality only.
This class represents a 1D filter kernel.
This class represents a 2D filter kernel.
Represents a SIFT key point in hierarchical scale space.
A set of 1070 (actually only 1069 after removing one double) binary shape images downloaded from
https://vision.lems.brown.edu/content/available-software-and-databases
(http://vision.lems.brown.edu/sites/default/files/1070db.tar.gz).
A set of 216 binary shape images downloaded from https://vision.lems.brown.edu/content/available-software-and-databases
(http://vision.lems.brown.edu/sites/default/files/216db.tar.gz).
A set of 99 binary shape images downloaded from https://vision.lems.brown.edu/content/available-software-and-databases
(http://vision.lems.brown.edu/sites/default/files/99db.tar.gz).
Test images composed of shapes from the Kimia data sets (see https://vision.lems.brown.edu/content/available-software-and-databases)
This class implements color quantization using k-means clustering of image pixels in RGB color space.
Method for choosing initial color clusters.
This ImageJ plugin demonstrates the use of the Kuwahara filter, similar to the filter suggested in [1].
Common interface for Kuwahara filter implementations.
Parameter bundle for Kuwahara filters (implementations of
KuwaharaF).
Scalar version of a Kuwahara-type filter, similar to the filter described in [1].
Vector version (applicable to ColorProcessor only) of a Kuwahara-type filter, similar to the filter described in [1].
This class implements the CIELab color space.
A
PixelInterpolator implementing Lanczos interpolation in 2D.
Performs line fitting on the point set specified by the current ROI.
Samples points on a given (ideal) line and creates a new image with the sample points contained in a
PointRoi.
ImageJ demo plugin, performs line fitting to a randomly sampled point set
that is rotated in uniform steps.
This plugin demonstrates linear (alpha) blending between two images, which are supplied as a
ImageStack with
exactly 2 frames.This ImageJ plugin shows how to construct a generic linear filter using the classes
LinearFilter and
Kernel2D.This ImageJ plugin shows how to construct a separable linear filter using the classes
LinearFilterSeparable
and GenericFilter.This class implements a 1D map for arbitrary objects with flexible bottom and top index, similar to an array in
Pascal.
This class represents a 2D linear filter specified by an arbitrary 2D convolution kernel.
This class represents a 2D linear filter that is x/y-separable and specified by two 1D-kernels.
Describes a fitter based on a linear transformation model.
This class represents an arbitrary linear transformation in 2D.
This class implements line fitting by linear regression to a set of 2D points.
Defines a linear RGB space with the same white point and primaries as sRGB.
Interface to be implemented by all 2D line fits.
Instances of this class are used to randomly sample points along a given straight line segment, x/y coordinates being
perturbed with Gaussian noise.
Described a 2D line segment defined by two end points.
Provides functionality to extract local affine frames from a given image.
Provides methods for detecting local maxima or minima in images or 2D data arrays.
A 2D point with integer coordinates and a score value (
LocalMinMaxFinder.ExtremalPoint.q) attached.
This class implements a 2D log-polar mapping transformation.
This class implements a 2D log-polar mapping transformation.
This ImageJ plugin is a minimalistic example of using the Lucas-Kanade matchers.
Lucas-Kanade (forward-additive) matcher [1], as described in [2].
Lucas-Kanade elastic "Inverse Compositional" matcher, as described in [1].
This is the common super-class for different variants of the Lucas-Kanade matcher [1].
Default parameters for the containing class and its sub-classes; a (usually modified) instance of this class is
passed to the constructor of a non-abstract sub-class.
This class implements the CIELuv color space.
This class implements the Mahalanobis distance using the Apache Commons Math library.
ImageJ plugin, shows each region's major axis as a vector scaled by the region's eccentricity.
This ImageJ plugin demonstrates the calculation of horizontal and vertical
projections from a grayscale image.
Fills the active image with uniform noise.
ImageJ plugin, applies a configurable affine transformation to the current image.
ImageJ plugin, applies an affine transformation derived from a pair of triangles P, Q (for the source and target
image, respectively) to the current image.
ImageJ plugin, applies a bilinear transformation derived from a pair of quadrilaterals P, Q (for the source and
target image, respectively) to the current image.
ImageJ plugin demonstrating the use of 2D log-polar mapping.
ImageJ plugin, applies a non-linear "ripple" transformation to the current image.
ImageJ plugin, applies a non-linear "tapestry" transformation to the current image.
ImageJ plugin, applies a non-linear "twirl" transformation to the current image.
This plugin demonstrates the use of geometric mappings, as implemented in the imagingbook library.
ImageJ plugin, rotates the current image by a specified angle around its center.
ImageJ plugin, rotates the current image by a specified angle around the coordinate origin.
ImageJ plugin, applies a continuous translation to the current image.
Common interface to be implemented by all (linear and nonlinear) 2D mappings.
ImageJ plugin, adapts image intensities to match a Gaussian distribution with specified parameters μ, σ
(
Match_Gaussian_Histogram.Mean, Match_Gaussian_Histogram.StdDev).
Adapts image intensities to match a reference histogram that is piecewise-linear.
ImageJ plugin, matches the histograms of the supplied images which are supplied as a
ImageStack with 2 ore
more frames.This class provides some static methods for formatting Java arrays (representing vectors, matrices or measurements)
for copy-pasting to Mathematica.
This class defines a set of static methods for calculations with vectors and matrices using native Java arrays
without any enclosing object structures.
Thrown when the dimensions of matrix/vector arguments do not match.
Thrown when a non-square matrix is encountered where a square matrix is assumed.
Thrown when source and target objects are identical but shouldn't.
Thrown when the length of some vector is zero.
This is an implementation of the global thresholder proposed by Kapur et al.
Exception indicating that some predefined number of iterations was exceeded.
Simple global thresholder which uses the mean pixel value as the threshold.
This is an implementation of Heckbert's median-cut color quantization algorithm [1].
This plugin applies a scalar median filter to all three planes of a RGB color image.
This plugin applies a vector median filter to a RGB color image.
This plugin applies a sharpening vector median filter to a RGB color image.
This is a special case of a
QuantileThresholder with quantile b = 0.5.
ImageJ plugin, performs piecewise affine transformation by triangulation of the input image, as described in Sec.
This is an implementation of the global "minimum error" thresholder proposed by Kittler and Illingworth in [1].
Simple global thresholder which sets the threshold centered between the image's minimum and maximum pixel value.
A
PixelInterpolator implementing Mitchell-Netravali interpolation in 2D See Sec.22.4.3 of [1] for additional
details.
Defines the "modified gamma correction" used for converting linear to non-linear color component values.
This class defines methods for statistical moment calculations on 2D point sets.
Monochromatic edge detector, applicable to color images (
ColorProcessor) only.
This is an implementation of the corner detector described in [1].
ImageJ plugin which runs MSER detection [1] on the current image and shows the result as a vector overlay in a new
image.
Color definitions used in MSER demo plugins.
Defines a container holding the data for calculating MSER properties.
Performs "Maximally Stable Extremal Region" (MSER) detection [1] on gray-scale images.
Parameters for MSER detection.
Multi-Gradient ("DiZenzo/Cumani-style") color edge detector.
Parameters for
MultiGradientEdgeDetector (currently unused, no parameters to set).This is a minimal ImageJ plugin (PlugInFilter) that inverts an 8-bit grayscale (byte) image.
This plugin does the same as
My_Inverter_A but is based on the PlugIn instead of the
PlugInFilter interface.
This plugin demonstrates the 5x5 Nagao-Matsuyama filter, as described in [1]].
Common interface for Nagao-Matsuyama filter implementations.
Parameter bundle for Nagao-Matsuyama filters (implementations of
NagaoMatsuyamaF).
Scalar version of the Nagao-Matsuyama filter.
Vector version of the Nagao-Matsuyama filter.
This enum type wraps a selection of ImageJ's lookup tables (originally defined in class
LutLoader).
This interface is supposed to be implemented by some enum class that specifies the root of a resource tree.
A
PixelInterpolator implementing nearest-neighbor interpolation in 2D.Enum type for different pixel neighborhood types to be used for parameter selection.
This is an implementation of the adaptive thresholder proposed by Niblack in [1].
Implementation of Niblack's adaptive thresholder using a
rectangular (box-shaped) support region
(concrete implementation of abstract class
NiblackThresholder).Implementation of Niblack's adaptive thresholder using a
circular (disk-shaped) support region
(concrete implementation of abstract class
NiblackThresholder).Implementation of Niblack's adaptive thresholder using a
2D Gaussian support region
(concrete implementation of abstract class
NiblackThresholder).Parameters for class
NiblackThresholder.
This class defines static methods for simplified access to nonlinear least-squares solvers in Apache Commons Math,
hiding much of the available configuration options.
Defines static methods for object copying and encoding to strings.
This class implements color quantization based on the octree method.
ImageJ plugin, allows the user to select and open one of the internal sample images.
This plugin shows a trick how to automatically load some pre-defined sample image in the case that no other image is
currently open.
Calculates the closest point on the ellipse for a given 2D point inside or outside the ellipse, using orthogonal
projection of points onto the ellipse.
Calculates the closest point on the ellipse for a given 2D point inside or outside the ellipse, using orthogonal
projection of points onto the ellipse.
This class implements line fitting by orthogonal regression to a set of 2D points using eigendecomposition.
This class implements line fitting by orthogonal regression to a set of 2D points by solving a homogeneous linear
system.
This class implements line fitting by orthogonal regression to a set of 2D points using singular-value decomposition
(SVD).
This is an implementation of the global thresholder proposed by Otsu [1].
ImageJ plugin implementing a binary 'outline' operation using either a 4- or 8-neighborhood.
Enumeration type representing the available strategies for accessing pixel locations outside the image bounds.
Interface to be implemented by local 'Parameters' classes.
This class represents a line in parametric form: x = s + t v, where s is a start point on the line, v is a direction
vector, and t is a real variable.
Exports an
ImagePlus instance, including its vector overly (if existent) to a PDF file.Parameter bundle for class
PdfExporter.
This ImageJ plugin creates a new noise image using a 2D gradient noise generator [1].
Gradient (Perlin) noise implementation (see [1] for a detailed description).
This class implements a 1-dimensional Perlin noise [1] generator.
This class implements a 2D Perlin noise [1] generator.
This class implements an N-dimensional Perlin noise [1] generator.
This ImageJ plugin demonstrates the use of the Perona-Malik filter [1].
This ImageJ plugin is a minimal example for running the Perona-Malik filter [1].
Common interface for Perona-Malik filter implementations.
Parameter bundle for Perona-Malik filters (implementations of
PeronaMalikF).
Scalar version of the Perona-Malik filter, without gradient array.
Vector version (simplified ) with greatly reduced memory requirements.
This class represents a discrete "cumulative distribution function" that is piecewise linear.
This ImageJ plugin demonstrates the use of various pixel interpolation methods and out-of-bounds strategies.
This interface defines the behavior of 2D pixel interpolators for scalar-valued images.
Basically a 2D array of pixels which holds all necessary information about the image geometry, keeps track of which
pixels have been visited and knows how to access neighboring pixels (currently 4-neighborhood only).
This class defines a generic data container for scalar and vector-valued images, using float-values throughout.
ImageJ plugin, takes any RGB color image and plots its color distribution in CIE xy-space, together with the
outline of the xy ("horseshoe") chromaticity curve, sRGB gamut and white point.
The
main() method of this class creates the plugins.config file for a given plugins project, which is
to be included in the associated JAR file.Interface specifying the behavior of simple 2D points.
Immutable 2D point implementation with
double coordinates.Immutable 2D point implementation with
int coordinates.Defines static methods for manipulating 2D points.
This class is used to re-sample 2D polygons by interpolation.
Interface specifying a 2D curve capable of calculating the minimum distance to a given point.
Determines the 'permutation' of a sequence of numbers and keeps it as an array (
perm) of position indexes.This class holds settings to control the precision when printing floating-point numbers, used in particular by
various
toString() methods for vectors and matrices defined in class Matrix (mainly for debugging).
Classes which require a complex
toString() method should implement this interface, which requires the single
method PrintsToStream.printToStream(PrintStream), e.g.,
Implements a 2-dimensional Procrustes fit, using the algorithm described in [1].
This class represents a "progress monitor".
A simple example for how to use
ProgressReporter and ProgressMonitor.The task to be monitored (some slow process).
Interface for defining tasks that may be queried (monitored) to report their current progress status.
This class implements horizontal and vertical projections of scalar-valued images.
This class implements 2D point fitting under projective (4-point) transformations (exact and least-squares).
This class represents a projective transformation in 2D (also known as a "homography").
This is an implementation of the global "quantile" thresholder, described in Sec.
ImageJ plugin, performs Median Cut color quantization using
MedianCutQuantizer.
This ImageJ plugin increases the contrast of the selected grayscale image by 50%.
This ImageJ plugin does the same as the
Raise_Contrast plugin but uses the one-dimensional pixel array to
read and writes pixel values without calling any intermediate access methods, which is obviously more efficient.ColorEnumeration defining a set of RAL colors (see https://en.wikipedia.org/wiki/List_of_RAL_colors)ImageJ plugin, creates a tiled image with random colors obtained by varying hue only.
A convenience random generator for angular values.
An instance of this class randomly draws a set of k unique, non-null elements from a given array of element type T,
which may contain null elements (see method
RandomDraw.drawFrom(Object[], int)).Instances of this class create a sequence of random colors which only differ in hue, with saturation and value fixed.
RANSAC circle detection implemented with imagingbook library class
RansacCircleDetector (see Sec.
RANSAC ellipse detection implemented with imagingbook library class
RansacCircleDetector (see Sec.
RANSAC line detection using imagingbook library class
RansacLineDetector (see Sec.
RANSAC detector for circles.
Nested class extending
RansacDetector.RansacParameters
to specify additional RANSAC parameters.
Generic RANSAC detector for 2D primitives.
Parameters used by all RANSAC types.
Various display settings used in plugins of this package (only).
RANSAC detector for ellipses.
Nested class extending
RansacDetector.RansacParameters
to specify additional RANSAC parameters.
RANSAC detector for straight lines.
Nested class extending
RansacDetector.RansacParameters
to specify additional RANSAC parameters.
Represents a single detection result returned by an implementation of
RansacDetector.Common interface for eigendecompositions capable of delivering solutions when all eigenvalues are real.
ImageJ plugin, performs 4-point projective mapping from a selected polygon ROI to the specified paper proportions (A4
or Letter, in portrait format).
Binary region segmentation based on a recursive (depth-first) flood filling algorithm.
This ImageJ plugin demonstrates the use of the class
RegionContourSegmentation to perform both region labeling and contour
tracing simultaneously.
Performs binary region segmentation, then displays each region's major axis (scaled by eccentricity) and equivalent
ellipse as a vector overlay.
This ImageJ plugin demonstrates the use of various region labeling techniques
provided by the imagingbook "regions" package:
Enum type for various region labeling methods.
Binary region segmentation based on a combined region labeling and contour tracing algorithm as described in [1].
This class defines static methods for accessing resources.
A special vector-valued image accessor for RGB images (direct subclass of
VectorAccessor) with depth = 3
color components.This class defines static methods for manipulating and converting RGB colors.
This ImageJ plugin shows how a subimage is extracted from a given image using the bounding box of the currently
selected region of interest (ROI).
This ImageJ plugin shows how an image operation can be confined to the currently selected region of interest (ROI).
This class defines static ROI-related utility methods to interface with ImageJ.
This class represents a pure 2D rotation about the coordinate origin (as a special case of affine mapping).
This plugin demonstrates how to run another ImageJ "command" (plugin) from our own PlugIn using the IJ.run() method.
This plugin demonstrates how to run another ImageJ command (plugin) from our own PlugInFilter using the IJ.run()
method.
This is an implementation of the adaptive thresholder proposed in [1].
Parameters for class
SauvolaThresholder.The common (abstract) super-class for all image accessors to scalar-valued images.
Ordinary (scalar) median filter for color images implemented by extending the
GenericFilter class.
Represents a single scale level in a generic hierarchical scale space.
Represents a single "octave", which is a stack of scale "levels", in a generic hierarchical scale space.
This class represents a 2D scaling transformation (as a special case of affine transformation).
Scaling mode used for the DFT.
Defines a binary region that is backed by the label array of a region segmentation.
Binary region segmentation based on a two-pass sequential labeling algorithm.
Helper class providing static methods for writing/reading serialized data to/from files.
Sets the font of the IJ.log window to MONOSPACE.
Used to check if AWT shapes produced by
ShapeProducer.getShape() match the underlying curve
(Primitive2d).Implementing classes know how to create an AWT
Shape.
This class represents a 2D shear transformation (as a special case of affine transformation).
This is an implementation of the Shi-Tomasi corner detector, as described in [1].
Image accessor for scalar images with 16-bit (short) values.
This ImageJ plugin creates the component tree of the given image and reconstructs the associated threshold stack by
coloring the individual components.
Demonstrates the use of the
DistanceTransform class.ImageJ plugin, simply displays the histogram and cumulative histogram of a grayscale image in two new windows.
This ImageJ plugin visualizes the hierarchical scale space structures used for SIFT feature detection (see
SiftDetector).
This plugin extracts multi-scale SIFT features [1] from the current image and displays them as M-shaped markers.
This ImageJ plugin demonstrates the use of the SIFT detection and matching framework.
Color definitions used in various SIFT demo plugins.
This class defines a SIFT descriptor.
This class implements the detection of SIFT features from images, as described in [1].
Types of 3D neighborhoods used in min/max detection
Represents a match between two SIFT features.
Instances of this class perform matching between SIFT features.
Default parameters; a (usually modified) instance of this class may be passed to the constructor of
SiftDetector.
Defines the basic "gamma correction" used for converting linear to non-linear color component values.
This class represents a line in slope-intercept form: y = k x + d.
ImageJ plugin implementing a simple Sobel-type edge operator.
Defines a generic container for "comparable" elements that allows sorted insertions without exceeding the predefined
capacity.
A
PixelInterpolator implementing spline interpolation in 2D.
This class implements the sRGBcolor space with D65 white point.
This ImageJ plugin demonstrates how to iterate over the frames (slices) of an image stack.
Enumeration of selected standard illuminants.
This class defines static methods for statistical calculations.
This class defines static methods related to binary structuring elements (kernels).
Common interface for all sub-pixel maximum locator implementations.
Enumeration of different
SubpixelMaxInterpolator methods.
2D interpolator based on least-squares fitting a quadratic polynomial
2D interpolator using second-order Taylor expansion to find the coefficients of the quadratic interpolating
polynomial
2D interpolator based on fitting a 'quartic' (i.e., 4th-order) polynomial
This ImageJ plugin demonstrates morphological thinning on binary images.
Common interface to be implemented by all thresholders (global and adaptive).
Enum type to discriminate if the image background is assumed to be bright or dark.
This class represents a pure 2D translation (as a special case of affine transformation).
Interface specifying a 2D triangle.
Represents a 2D triangle, specified by three corner points.
This is an implementation of the triangulation algorithm described in [1].
This ImageJ plugin demonstrates the use of the Anisotropic Diffusion filter described in [1].
Common interface for Tschumperle-Deriche filter implementations.
Parameter bundle for Tschumperle-Deriche filters (implementations of
TschumperleDericheF).
This class implements the Anisotropic Diffusion filter described in [1].
Elementary implementation of tuples, i.e, ordered sequences of items of arbitrary types.
A tuple with exactly 2 elements of arbitrary types.
A tuple with exactly 3 elements of arbitrary types.
A tuple with exactly 4 elements of arbitrary types.
This class collects the set of 14 Type-1 standard fonts that every PS/PDF reader is supposed to have available by
default.
Creates a 1-page PDF with samples of all 14 standard Type1 fonts embedded.
ImageJ plugin, unlocks the currently active image.
This plugin implements an Unsharp Masking filter similar to Photoshop without thresholds, using a "clean"
(sufficiently large) Gaussian filter.
This ImageJ plugin modifies and re-displays the current image repeatedly.
Accessor for vector-valued images with arbitrary depth (number of components).
Vector median filter for color images implemented by extending the
GenericFilterVector class.
Sharpening vector median filter for color images implemented by extending the
GenericFilterVector class.This class defines various vector norms for calculating the magnitude of a vector and the distance between vectors.
Implementation of the L1 vector norm (Manhattan norm/distance).
Implementation of the L2 vector norm (Euclidean norm/distance).
Implementation of the L-infinity vector norm (maximum norm/distance).
Enumeration type for
VectorNorm to be used as
parameter choice.
Implementation of a D50-based XYZ color space, as a substitute for Java's built-in standard connection space
(obtained with
ColorSpace.getInstance(ColorSpace.CS_CIEXYZ)), with improved accuracy.
Implementation of a D65-based XYZ color space, as a substitute for Java's built-in standard connection space
(obtained with
ColorSpace.getInstance(ColorSpace.CS_CIEXYZ)), with improved accuracy.
This class represents a linear chromatic adaptation transform, mapping XYZ color coordinates from a source white
(reference) point to a target white point.
This class provides ZIP-compression/decompression of byte arrays.
ImageJ plugin, resizes the window of the given image to fit an arbitrary, user-specified magnification factor.
ImageJ plugin, zooms the current image such that the given selection (ROI) fits the image window.