ImageProcessor (ImageJ 1.52d API)

java.lang.Object
- ij.process.ImageProcessor

All Implemented Interfaces:

Cloneable

Direct Known Subclasses:

ByteProcessor, ColorProcessor, FloatProcessor, ShortProcessor
```
public abstract class ImageProcessor
extends Object
implements Cloneable
```
This abstract class is the superclass for classes that process the four data types (byte, short, float and RGB) supported by ImageJ. An ImageProcessor contains the pixel data of a 2D image and some basic methods to manipulate it.

See Also:

ByteProcessor, ShortProcessor, FloatProcessor, ColorProcessor, ImagePlus, ImageStack

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`antialiasedText`
`protected ColorModel`	`baseCM`
`static int`	`BICUBIC` Interpolation methods
`static int`	`BILINEAR` Interpolation methods
`static int`	`BLACK` Value of pixels included in masks.
`static int`	`BLACK_AND_WHITE_LUT`
`static int`	`BLUR_MORE`
`protected byte[]`	`bLUT1`
`protected byte[]`	`bLUT2`
`protected boolean`	`boldFont`
`static int`	`CENTER_JUSTIFY` Center justify text.
`protected int`	`clipXMax`
`protected int`	`clipXMin`
`protected int`	`clipYMax`
`protected int`	`clipYMin`
`protected ColorModel`	`cm`
`protected ColorModel`	`cm2`
`static int`	`CONVOLVE`
`protected float[]`	`cTable`
`protected int`	`cx`
`protected int`	`cy`
`protected static IndexColorModel`	`defaultColorModel`
`protected Color`	`drawingColor`
`static int`	`FIND_EDGES`
`protected Graphics2D`	`fmGraphics`
`protected BufferedImage`	`fmImage`
`protected Font`	`font`
`protected FontMetrics`	`fontMetrics`
`protected byte[]`	`gLUT1`
`protected byte[]`	`gLUT2`
`protected int`	`height`
`protected double`	`histogramMax`
`protected double`	`histogramMin`
`protected int`	`histogramSize`
`protected BufferedImage`	`image`
`protected Image`	`img`
`protected boolean`	`interpolate`
`protected int`	`interpolationMethod`
`protected boolean`	`inversionTested`
`protected boolean`	`invertedLut`
`static int`	`ISODATA` Isodata thresholding method
`static int`	`ISODATA2` Modified isodata method used in Image/Adjust/Threshold tool
`protected int`	`justification`
`static int`	`LEFT_JUSTIFY` Left justify text.
`protected int`	`lineWidth`
`protected boolean`	`lutAnimation`
`protected int`	`lutUpdateMode`
`static int`	`MAX`
`protected double`	`maxThreshold`
`static int`	`MEDIAN_FILTER`
`static int`	`MIN`
`protected boolean`	`minMaxSet`
`protected double`	`minThreshold`
`static int`	`NEAREST_NEIGHBOR` Interpolation methods
`protected boolean`	`newPixels`
`static int`	`NO_LUT_UPDATE`
`static double`	`NO_THRESHOLD` Value returned by getMinThreshold() when thresholding is not enabled.
`static int`	`NONE` Interpolation methods
`static int`	`OVER_UNDER_LUT`
`protected WritableRaster`	`raster`
`static int`	`RED_LUT`
`static int`	`RIGHT_JUSTIFY` Right justify text.
`protected byte[]`	`rLUT1`
`protected byte[]`	`rLUT2`
`protected static Random`	`rnd`
`protected int`	`roiHeight`
`protected int`	`roiWidth`
`protected int`	`roiX`
`protected int`	`roiY`
`protected SampleModel`	`sampleModel`
`protected static double`	`seed`
`protected int`	`snapshotHeight`
`protected int`	`snapshotWidth`
`protected MemoryImageSource`	`source`
`protected int`	`width`
`protected int`	`xMax`
`protected int`	`xMin`
`protected int`	`yMax`
`protected int`	`yMin`

Constructor Summary

Constructors
Constructor and Description

ImageProcessor()

Constructors
Constructor and Description
`ImageProcessor()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`abs()` If this is a 32-bit or signed 16-bit image, performs an absolute value transform, otherwise does nothing.
`void`	`add(double value)` Adds 'value' to each pixel in the image or ROI.
`void`	`add(int value)` Adds 'value' to each pixel in the image or ROI.
`void`	`and(int value)` Binary AND of each pixel in the image or ROI with 'value'.
`void`	`applyMacro(String macro)` Uses the Process/Math/Macro command to apply macro code to this image.
`abstract void`	`applyTable(int[] lut)` Transforms the image or ROI using a lookup table.
`void`	`autoThreshold()` Converts the image to binary using an automatically determined threshold.
`ImageProcessor`	`bin(int shrinkFactor)` Returns a copy of this image that has been reduced in size using binning.
`void`	`blurGaussian(double sigma)` Blurs the image by convolving with a Gaussian function.
`Object`	`clone()` Returns a shallow copy of this ImageProcessor, where this image and the copy share pixel data.
`ImageProcessor`	`convertToByte(boolean doScaling)` Returns an 8-bit version of this image as a ByteProcessor.
`ByteProcessor`	`convertToByteProcessor()` Returns an 8-bit version of this image as a ByteProcessor.
`ByteProcessor`	`convertToByteProcessor(boolean scale)` Returns an 8-bit version of this image as a ByteProcessor.
`ColorProcessor`	`convertToColorProcessor()` Returns an RGB version of this image as a ColorProcessor.
`ImageProcessor`	`convertToFloat()` Returns a 32-bit float version of this image as a FloatProcessor.
`FloatProcessor`	`convertToFloatProcessor()` Returns a 32-bit float version of this image as a FloatProcessor.
`ImageProcessor`	`convertToRGB()` Returns an RGB version of this image as a ColorProcessor.
`ImageProcessor`	`convertToShort(boolean doScaling)` Returns a 16-bit version of this image as a ShortProcessor.
`ShortProcessor`	`convertToShortProcessor()` Returns a 16-bit version of this image as a ShortProcessor.
`ShortProcessor`	`convertToShortProcessor(boolean scale)` Returns a 16-bit version of this image as a ShortProcessor.
`abstract void`	`convolve(float[] kernel, int kernelWidth, int kernelHeight)` Performs a convolution operation using the specified kernel.
`abstract void`	`convolve3x3(int[] kernel)` Convolves the image or ROI with the specified 3x3 integer convolution kernel.
`abstract void`	`copyBits(ImageProcessor ip, int xloc, int yloc, int mode)` Copies the image contained in 'ip' to (xloc, yloc) using one of the transfer modes defined in the Blitter interface.
`abstract Image`	`createImage()` Returns a copy of this image is the form of an AWT Image.
`ByteProcessor`	`createMask()` Returns a binary mask, or null if a threshold is not set or this is an RGB image.
`abstract ImageProcessor`	`createProcessor(int width, int height)` Returns a new, blank processor with the specified width and height.
`abstract ImageProcessor`	`crop()` Returns a new processor containing an image that corresponds to the current ROI.
`static double`	`cubic(double x)`
`abstract void`	`dilate()` Dilates the image or ROI using a 3x3 minimum filter.
`void`	`draw(Roi roi)` Draws the specified ROI on this image using the line width and color defined by ip.setLineWidth() and ip.setColor().
`void`	`drawDot(int xcenter, int ycenter)` Draws a dot using the current line width and fill/draw value.
`void`	`drawDot2(int x, int y)` Deprecated.
`void`	`drawLine(int x1, int y1, int x2, int y2)` Draws a line from (x1,y1) to (x2,y2).
`void`	`drawLine4(int x1, int y1, int x2, int y2)`
`void`	`drawOval(int x, int y, int width, int height)` Draws an elliptical shape.
`void`	`drawOverlay(Overlay overlay)` Draws the specified Overlay on this image.
`abstract void`	`drawPixel(int x, int y)` Sets the pixel at (x,y) to the current fill/draw value.
`void`	`drawPolygon(Polygon p)` Draws a polygon.
`void`	`drawRect(int x, int y, int width, int height)` Draws a rectangle.
`void`	`drawRoi(Roi roi)` Draws the specified ROI on this image using the stroke width, stroke color and fill color defined by roi.setStrokeWidth, roi.setStrokeColor() and roi.setFillColor().
`void`	`drawString(String s)` Draws a string at the current drawing location using the current fill/draw value.
`void`	`drawString(String s, int x, int y)` Draws a string at the specified location using the current fill/draw value.
`void`	`drawString(String s, int x, int y, Color background)` Draws a string at the specified location with a filled background.
`abstract ImageProcessor`	`duplicate()` Returns a duplicate of this image.
`abstract void`	`erode()` Erodes the image or ROI using a 3x3 maximum filter.
`void`	`exp()` Performs a exponential transform on the image or ROI.
`void`	`fill()` Fills the image or ROI bounding rectangle with the current fill/draw value.
`abstract void`	`fill(ImageProcessor mask)` Fills pixels that are within the ROI bounding rectangle and part of the mask (i.e.
`void`	`fill(Roi roi)` Fills the ROI with the current fill/draw value.
`void`	`fillOutside(Roi roi)` Fills outside an Roi.
`void`	`fillOval(int x, int y, int width, int height)` Fills an elliptical shape.
`void`	`fillPolygon(Polygon p)` Fills a polygon.
`void`	`fillRect(int x, int y, int width, int height)` Fills a rectangle.
`abstract void`	`filter(int type)` A 3x3 filter operation, where the argument (BLUR_MORE, FIND_EDGES, MEDIAN_FILTER, MIN or MAX) determines the filter type.
`void`	`findEdges()` Finds edges in the image or ROI using a Sobel operator.
`void`	`flipHorizontal()` Flips the image or ROI horizontally.
`abstract void`	`flipVertical()` Flips the image or ROI vertically.
`void`	`gamma(double value)` Performs gamma correction of the image or ROI.
`abstract int`	`get(int index)`
`abstract int`	`get(int x, int y)` This is a faster version of getPixel() that does not do bounds checking.
`int`	`getAutoThreshold()` Returns a pixel value (threshold) that can be used to divide the image into objects and background.
`int`	`getAutoThreshold(int[] histogram)` This is a version of getAutoThreshold() that uses a histogram passed as an argument.
`abstract double`	`getBackgroundValue()` Returns the background fill value.
`int`	`getBestIndex(Color c)` Returns the LUT index that's the best match for this color.
`double`	`getBicubicInterpolatedPixel(double x0, double y0, ImageProcessor ip2)` This method is from Chapter 16 of "Digital Image Processing: An Algorithmic Introduction Using Java" by Burger and Burge (http://www.imagingbook.com/).
`int`	`getBitDepth()` Returns the bit depth, 8, 16, 24 (RGB) or 32.
`BufferedImage`	`getBufferedImage()` Returns this image as a BufferedImage.
`float[]`	`getCalibrationTable()` Returns the calibration table or null.
`ColorModel`	`getColorModel()` Returns this processor's color model.
`void`	`getColumn(int x, int y, int[] data, int length)` Returns the pixel values down the column starting at (x,y).
`ColorModel`	`getCurrentColorModel()` Returns the current color model, which may have been modified by setMinAndMax() or setThreshold().
`IndexColorModel`	`getDefaultColorModel()` Returns the default grayscale IndexColorModel.
`abstract float`	`getf(int index)`
`abstract float`	`getf(int x, int y)` Returns the value of the pixel at (x,y) as a float.
`float[][]`	`getFloatArray()` Returns a copy of the pixel data as a 2D float array with dimensions [x=0..width-1][y=0..height-1].
`Font`	`getFont()` Returns the current font.
`FontMetrics`	`getFontMetrics()` Returns the current FontMetrics.
`int`	`getHeight()` Returns the height of this image in pixels.
`abstract int[]`	`getHistogram()` Returns the histogram of the image or ROI.
`int[]`	`getHistogram(int nBins)` Returns the histogram of the image or ROI, using the specified number of bins.
`double`	`getHistogramMax()` Returns the maximum histogram value used for histograms of float images.
`double`	`getHistogramMin()` Returns the minimum histogram value used for histograms of float images.
`int`	`getHistogramSize()` Returns the number of float image histogram bins.
`protected SampleModel`	`getIndexSampleModel()`
`int[][]`	`getIntArray()` Returns a copy of the pixel data as a 2D int array with dimensions [x=0..width-1][y=0..height-1].
`boolean`	`getInterpolate()` Returns the value of the interpolate field.
`abstract double`	`getInterpolatedPixel(double x, double y)` Uses the current interpolation method (bilinear or bicubic) to find the pixel value at real coordinates (x,y).
`double`	`getInterpolatedValue(double x, double y)` Uses bilinear interpolation to find the pixel value at real coordinates (x,y).
`int`	`getInterpolationMethod()` Returns the current interpolation method (NONE, BILINEAR or BICUBIC).
`static String[]`	`getInterpolationMethods()`
`double[]`	`getLine(double x1, double y1, double x2, double y2)` Returns an array containing the pixel values along the line starting at (x1,y1) and ending at (x2,y2).
`int`	`getLineWidth()` Returns the current line width.
`LUT`	`getLut()`
`int`	`getLutUpdateMode()` Returns the LUT update mode, which can be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
`ImageProcessor`	`getMask()` For images with irregular ROIs, returns a mask, otherwise, returns null.
`byte[]`	`getMaskArray()` Returns a reference to the mask pixel array, or null if there is no mask.
`abstract double`	`getMax()` Returns the largest displayed pixel value.
`double`	`getMaxThreshold()` Returns the upper threshold level.
`abstract double`	`getMin()` Returns the smallest displayed pixel value.
`double`	`getMinThreshold()` Returns the lower threshold level.
`int`	`getNChannels()` Returns the number of color channels in the image.
`void`	`getNeighborhood(int x, int y, double[][] arr)` Experimental
`Overlay`	`getOverlay()`
`abstract int`	`getPixel(int x, int y)` Returns the value of the pixel at (x,y).
`int[]`	`getPixel(int x, int y, int[] iArray)` Returns the samples for the pixel at (x,y) in an int array.
`int`	`getPixelCount()`
`abstract int`	`getPixelInterpolated(double x, double y)` Uses the current interpolation method to find the pixel value at real coordinates (x,y).
`abstract Object`	`getPixels()` Returns a reference to this image's pixel array.
`abstract Object`	`getPixelsCopy()` Returns a copy of the pixel data.
`abstract float`	`getPixelValue(int x, int y)` Returns the value of the pixel at (x,y).
`protected int`	`getProgressIncrement(int w, int h)`
`Rectangle`	`getRoi()` Returns a Rectangle that represents the current region of interest.
`float[]`	`getRow(int x, int y, float[] data, int length)` Returns the pixel values along the horizontal line starting at (x,y).
`void`	`getRow(int x, int y, int[] data, int length)` Returns the pixel values along the horizontal line starting at (x,y).
`int`	`getSliceNumber()`
`abstract Object`	`getSnapshotPixels()` Returns a reference to the snapshot (undo) buffer, or null.
`ImageStatistics`	`getStatistics()` This method calculates and returns complete uncalibrated statistics for this image or ROI but it is up to 70 times slower than getStats().
`ImageStatistics`	`getStats()` Calculates and returns uncalibrated statistics for this image or ROI, including histogram, area, mean, min and max, standard deviation, and mode.
`Rectangle`	`getStringBounds(String s)` Returns a rectangle enclosing the pixels affected by drawString assuming it is drawn at (x=0, y=0).
`int`	`getStringWidth(String s)` Returns the width in pixels of the specified string, including any background space (whitespace) between the x drawing coordinate and the string, not necessarily including all whitespace at the right.
`int`	`getWidth()` Returns the width of this image in pixels.
`protected void`	`hideProgress()` Deprecated.
`void`	`insert(ImageProcessor ip, int xloc, int yloc)` Inserts the image contained in 'ip' at (xloc, yloc).
`void`	`invert()` Inverts the image or ROI.
`void`	`invertLut()` Inverts the values in this image's LUT (indexed color model).
`boolean`	`isBinary()` Returns 'true' if this is a binary image (8-bit-image with only 0 and 255).
`boolean`	`isColorLut()` Returns true if this image uses a color LUT.
`boolean`	`isDefaultLut()` Returns true if the image is using the default grayscale LUT.
`boolean`	`isGrayscale()` Returns 'true' if this is an image with a grayscale LUT or an RGB image with identical red, green and blue channels.
`boolean`	`isInvertedLut()` Returns true if this image uses an inverting LUT that displays zero as white and 255 as black.
`boolean`	`isKillable()` Deprecated.
`boolean`	`isPseudoColorLut()` Returns true if this image uses a pseudocolor or grayscale LUT, in other words, is this an image that can be filtered.
`boolean`	`isSigned16Bit()` Returns 'true' if this is a signed 16-bit image.
`void`	`lineTo(int x2, int y2)` Draws a line from the current drawing location to (x2,y2).
`void`	`ln()` Does a natural logarithmic (base e) transform of the image or ROI.
`void`	`log()` Does a natural logarithmic (base e) transform of the image or ROI.
`protected void`	`makeDefaultColorModel()`
`protected String`	`maskSizeError(ImageProcessor mask)`
`void`	`max(double value)` Pixels greater than 'value' are set to 'value'.
`double`	`maxValue()` Returns the maximum possible pixel value.
`abstract void`	`medianFilter()` A 3x3 median filter.
`void`	`min(double value)` Pixels less than 'value' are set to 'value'.
`double`	`minValue()` Returns the minimum possible pixel value.
`void`	`moveTo(int x, int y)` Sets the current drawing location.
`void`	`multiply(double value)` Multiplies each pixel in the image or ROI by 'value'.
`abstract void`	`noise(double standardDeviation)` Adds pseudorandom, Gaussian ("normally") distributed values, with mean 0.0 and the specified standard deviation, to this image or ROI.
`void`	`or(int value)` Binary OR of each pixel in the image or ROI with 'value'.
`void`	`putColumn(int x, int y, int[] data, int length)` Inserts the pixels contained in 'data' into a column starting at (x,y).
`abstract void`	`putPixel(int x, int y, int value)` Stores the specified value at (x,y).
`void`	`putPixel(int x, int y, int[] iArray)` Sets a pixel in the image using an int array of samples.
`abstract void`	`putPixelValue(int x, int y, double value)` Stores the specified value at (x,y).
`void`	`putRow(int x, int y, float[] data, int length)` Inserts the pixels contained in 'data' into a horizontal line starting at (x,y).
`void`	`putRow(int x, int y, int[] data, int length)` Inserts the pixels contained in 'data' into a horizontal line starting at (x,y).
`abstract void`	`reset()` Restores the pixel data from the snapshot (undo) buffer.
`abstract void`	`reset(ImageProcessor mask)` Restores pixels from the snapshot buffer that are within the rectangular roi but not part of the mask.
`void`	`resetBinaryThreshold()` Resets the threshold if minThreshold=maxThreshold and lutUpdateMode=NO_LUT_UPDATE.
`void`	`resetMinAndMax()` For short and float images, recalculates the min and max image values needed to correctly display the image.
`void`	`resetRoi()` Sets the ROI (Region of Interest) and clipping rectangle to the entire image.
`void`	`resetThreshold()` Disables thresholding.
`ImageProcessor`	`resize(int dstWidth)` Returns a new ImageProcessor containing a scaled copy of this image or ROI, with the aspect ratio maintained.
`abstract ImageProcessor`	`resize(int dstWidth, int dstHeight)` Returns a new ImageProcessor containing a scaled copy of this image or ROI.
`ImageProcessor`	`resize(int dstWidth, int dstHeight, boolean useAverging)` Returns a new ImageProcessor containing a scaled copy of this image or ROI.
`protected ImageProcessor`	`resizeLinearly(int width2, int height2)` Use linear interpolation to resize images that have a width or height of one.
`abstract void`	`rotate(double angle)` Rotates the image or selection 'angle' degrees clockwise.
`ImageProcessor`	`rotateLeft()` Rotates the entire image 90 degrees counter-clockwise.
`ImageProcessor`	`rotateRight()` Rotates the entire image 90 degrees clockwise.
`abstract void`	`scale(double xScale, double yScale)` Scales the image by the specified factors.
`void`	`scaleAndSetThreshold(double lower, double upper, int lutUpdate)` Set the threshold using a 0-255 range.
`void`	`set(double value)` Assigns 'value' to each pixel in the image or ROI.
`abstract void`	`set(int index, int value)`
`abstract void`	`set(int x, int y, int value)` This is a faster version of putPixel() that does not clip out of range values and does not do bounds checking.
`void`	`setAntialiasedText(boolean antialiasedText)` Specifies whether or not text is drawn using antialiasing.
`void`	`setAutoThreshold(AutoThresholder.Method method, boolean darkBackground)`
`void`	`setAutoThreshold(AutoThresholder.Method method, boolean darkBackground, int lutUpdate)`
`void`	`setAutoThreshold(int method, int lutUpdate)` Automatically sets the lower and upper threshold levels, where 'method' must be ISODATA or ISODATA2 and 'lutUpdate' must be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
`void`	`setAutoThreshold(String method)` Automatically sets the lower and upper threshold levels, where 'method' must be "Default", "Huang", "Intermodes", "IsoData", "IJ_IsoData", "Li", "MaxEntropy", "Mean", "MinError", "Minimum", "Moments", "Otsu", "Percentile", "RenyiEntropy", "Shanbhag", "Triangle" or "Yen".
`void`	`setAutoThreshold(String mString, boolean darkBackground, int lutUpdate)`
`abstract void`	`setBackgroundValue(double value)` Sets the background fill value used by the rotate() and scale() methods.
`void`	`setBinaryThreshold()`
`void`	`setCalibrationTable(float[] cTable)` Set a lookup table used by getPixelValue(), getLine() and convertToFloat() to calibrate pixel values.
`void`	`setClipRect(Rectangle clipRect)` Updates the clipping rectangle used by lineTo(), drawLine(), drawDot() and drawPixel().
`abstract void`	`setColor(Color color)` Sets the default fill/draw value to the pixel value closest to the specified color.
`void`	`setColor(double value)` Sets the default fill/draw value.
`void`	`setColor(int value)` Sets the default fill/draw value.
`void`	`setColorModel(ColorModel cm)` Sets the color model.
`abstract void`	`setf(int index, float value)`
`abstract void`	`setf(int x, int y, float value)` Sets the value of the pixel at (x,y) to 'value'.
`void`	`setFloatArray(float[][] a)` Replaces the pixel data with contents of the specified 2D float array.
`void`	`setFont(Font font)` Sets the font used by drawString().
`void`	`setHistogramRange(double histMin, double histMax)` Set the range used for histograms of float images.
`void`	`setHistogramSize(int size)` Set the number of bins to be used for histograms of float images.
`void`	`setIntArray(int[][] a)` Replaces the pixel data with contents of the specified 2D int array.
`void`	`setInterpolate(boolean interpolate)` This method has been replaced by setInterpolationMethod().
`void`	`setInterpolationMethod(int method)` Use this method to set the interpolation method (NONE, BILINEAR or BICUBIC) used by scale(), resize() and rotate().
`void`	`setJustification(int justification)` Sets the justification used by drawString(), where `justification` is CENTER_JUSTIFY, RIGHT_JUSTIFY or LEFT_JUSTIFY.
`void`	`setLineWidth(int width)` Sets the line width used by lineTo() and drawDot().
`void`	`setLut(LUT lut)`
`void`	`setLutAnimation(boolean lutAnimation)` For 16 and 32 bit processors, set 'lutAnimation' true to have createImage() use the cached 8-bit version of the image.
`void`	`setMask(ImageProcessor mask)` Defines a byte mask that limits processing to an irregular ROI.
`abstract void`	`setMinAndMax(double min, double max)` This image will be displayed by mapping pixel values in the range min-max to screen values in the range 0-255.
`static void`	`setOverColor(int red, int green, int blue)` Sets the upper Over/Under threshold color.
`void`	`setOverlay(Overlay overlay)` This method is used to display virtual stack overlays.
`abstract void`	`setPixels(int channelNumber, FloatProcessor fp)` Sets the pixels (of one color channel for RGB images) from a FloatProcessor.
`abstract void`	`setPixels(Object pixels)` Sets a new pixel array for the image.
`void`	`setProgressBar(ProgressBar pb)` Assigns a progress bar to this processor.
`static void`	`setRandomSeed(double randomSeed)`
`void`	`setRoi(int x, int y, int rwidth, int rheight)` Defines a rectangular region of interest and sets the mask to null if this ROI is not the same size as the previous one.
`void`	`setRoi(Polygon roi)` Defines a polygonal region of interest that will consist of a rectangular ROI and a mask.
`void`	`setRoi(Rectangle roi)` Defines a rectangular region of interest and sets the mask to null if this ROI is not the same size as the previous one.
`void`	`setRoi(Roi roi)` Defines a non-rectangular region of interest that will consist of a rectangular ROI and a mask.
`void`	`setSliceNumber(int slice)` PlugInFilterRunner uses this method to set the slice number.
`void`	`setSnapshotCopyMode(boolean b)` The getPixelsCopy() method returns a reference to the snapshot buffer if it is not null and 'snapshotCopyMode' is true.
`abstract void`	`setSnapshotPixels(Object pixels)` Sets a new pixel array for the snapshot (undo) buffer.
`void`	`setThreshold(double minThreshold, double maxThreshold, int lutUpdate)` Sets the lower and upper threshold levels.
`static void`	`setUnderColor(int red, int green, int blue)` Set the lower Over/Under thresholding color.
`static void`	`setUseBicubic(boolean b)`
`abstract void`	`setValue(double value)` Sets the default fill/draw value.
`void`	`sharpen()` Sharpens the image or ROI using a 3x3 convolution kernel.
`protected void`	`showProgress(double percentDone)`
`void`	`smooth()` Replaces each pixel with the 3x3 neighborhood mean.
`abstract void`	`snapshot()` Makes a copy of this image's pixel data that can be later restored using reset() or reset(mask).
`void`	`sqr()` Performs a square transform on the image or ROI.
`void`	`sqrt()` Performs a square root transform on the image or ROI.
`void`	`subtract(double value)` Subtracts 'value' from each pixel in the image or ROI.
`abstract void`	`swapPixelArrays()` Swaps the pixel and snapshot (undo) buffers.
`abstract void`	`threshold(int level)` Sets pixels less than or equal to level to 0 and all other pixels to 255.
`abstract FloatProcessor`	`toFloat(int channelNumber, FloatProcessor fp)` Returns a FloatProcessor with the image or one color channel thereof.
`String`	`toString()` Returns a string containing information about this ImageProcessor.
`void`	`translate(double xOffset, double yOffset)` Moves the image or selection vertically or horizontally by a specified number of pixels.
`void`	`translate(int xOffset, int yOffset, boolean eraseBackground)` Deprecated. replaced by translate(x,y)
`void`	`updateComposite(int[] rgbPixels, int channel)` CompositeImage calls this method to generate an updated color image.
`void`	`xor(int value)` Binary exclusive OR of each pixel in the image or ROI with 'value'.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - BLACK
```
public static final int BLACK
```
    Value of pixels included in masks.
    
    See Also:
    
    Constant Field Values
  - NO_THRESHOLD
```
public static final double NO_THRESHOLD
```
    Value returned by getMinThreshold() when thresholding is not enabled.
    
    See Also:
    
    Constant Field Values
  - LEFT_JUSTIFY
```
public static final int LEFT_JUSTIFY
```
    Left justify text.
    
    See Also:
    
    Constant Field Values
  - CENTER_JUSTIFY
```
public static final int CENTER_JUSTIFY
```
    Center justify text.
    
    See Also:
    
    Constant Field Values
  - RIGHT_JUSTIFY
```
public static final int RIGHT_JUSTIFY
```
    Right justify text.
    
    See Also:
    
    Constant Field Values
  - ISODATA
```
public static final int ISODATA
```
    Isodata thresholding method
    
    See Also:
    
    Constant Field Values
  - ISODATA2
```
public static final int ISODATA2
```
    Modified isodata method used in Image/Adjust/Threshold tool
    
    See Also:
    
    Constant Field Values
  - NEAREST_NEIGHBOR
```
public static final int NEAREST_NEIGHBOR
```
    Interpolation methods
    
    See Also:
    
    Constant Field Values
  - NONE
```
public static final int NONE
```
    Interpolation methods
    
    See Also:
    
    Constant Field Values
  - BILINEAR
```
public static final int BILINEAR
```
    Interpolation methods
    
    See Also:
    
    Constant Field Values
  - BICUBIC
```
public static final int BICUBIC
```
    Interpolation methods
    
    See Also:
    
    Constant Field Values
  - BLUR_MORE
```
public static final int BLUR_MORE
```
    See Also:
    
    Constant Field Values
  - FIND_EDGES
```
public static final int FIND_EDGES
```
    See Also:
    
    Constant Field Values
  - MEDIAN_FILTER
```
public static final int MEDIAN_FILTER
```
    See Also:
    
    Constant Field Values
  - MIN
```
public static final int MIN
```
    See Also:
    
    Constant Field Values
  - MAX
```
public static final int MAX
```
    See Also:
    
    Constant Field Values
  - CONVOLVE
```
public static final int CONVOLVE
```
    See Also:
    
    Constant Field Values
  - RED_LUT
```
public static final int RED_LUT
```
    See Also:
    
    Constant Field Values
  - BLACK_AND_WHITE_LUT
```
public static final int BLACK_AND_WHITE_LUT
```
    See Also:
    
    Constant Field Values
  - NO_LUT_UPDATE
```
public static final int NO_LUT_UPDATE
```
    See Also:
    
    Constant Field Values
  - OVER_UNDER_LUT
```
public static final int OVER_UNDER_LUT
```
    See Also:
    
    Constant Field Values
  - lineWidth
```
protected int lineWidth
```
  - cx
```
protected int cx
```
  - cy
```
protected int cy
```
  - font
```
protected Font font
```
  - fontMetrics
```
protected FontMetrics fontMetrics
```
  - antialiasedText
```
protected boolean antialiasedText
```
  - boldFont
```
protected boolean boldFont
```
  - width
```
protected int width
```
  - snapshotWidth
```
protected int snapshotWidth
```
  - height
```
protected int height
```
  - snapshotHeight
```
protected int snapshotHeight
```
  - roiX
```
protected int roiX
```
  - roiY
```
protected int roiY
```
  - roiWidth
```
protected int roiWidth
```
  - roiHeight
```
protected int roiHeight
```
  - xMin
```
protected int xMin
```
  - xMax
```
protected int xMax
```
  - yMin
```
protected int yMin
```
  - yMax
```
protected int yMax
```
  - baseCM
```
protected ColorModel baseCM
```
  - cm
```
protected ColorModel cm
```
  - rLUT1
```
protected byte[] rLUT1
```
  - gLUT1
```
protected byte[] gLUT1
```
  - bLUT1
```
protected byte[] bLUT1
```
  - rLUT2
```
protected byte[] rLUT2
```
  - gLUT2
```
protected byte[] gLUT2
```
  - bLUT2
```
protected byte[] bLUT2
```
  - interpolate
```
protected boolean interpolate
```
  - interpolationMethod
```
protected int interpolationMethod
```
  - minThreshold
```
protected double minThreshold
```
  - maxThreshold
```
protected double maxThreshold
```
  - histogramSize
```
protected int histogramSize
```
  - histogramMin
```
protected double histogramMin
```
  - histogramMax
```
protected double histogramMax
```
  - cTable
```
protected float[] cTable
```
  - lutAnimation
```
protected boolean lutAnimation
```
  - source
```
protected MemoryImageSource source
```
  - img
```
protected Image img
```
  - newPixels
```
protected boolean newPixels
```
  - drawingColor
```
protected Color drawingColor
```
  - clipXMin
```
protected int clipXMin
```
  - clipXMax
```
protected int clipXMax
```
  - clipYMin
```
protected int clipYMin
```
  - clipYMax
```
protected int clipYMax
```
  - justification
```
protected int justification
```
  - lutUpdateMode
```
protected int lutUpdateMode
```
  - raster
```
protected WritableRaster raster
```
  - image
```
protected BufferedImage image
```
  - fmImage
```
protected BufferedImage fmImage
```
  - fmGraphics
```
protected Graphics2D fmGraphics
```
  - cm2
```
protected ColorModel cm2
```
  - sampleModel
```
protected SampleModel sampleModel
```
  - defaultColorModel
```
protected static IndexColorModel defaultColorModel
```
  - minMaxSet
```
protected boolean minMaxSet
```
  - seed
```
protected static double seed
```
  - rnd
```
protected static Random rnd
```
  - inversionTested
```
protected boolean inversionTested
```
  - invertedLut
```
protected boolean invertedLut
```
- Constructor Detail
  - ImageProcessor
```
public ImageProcessor()
```
- Method Detail
  - showProgress
```
protected void showProgress(double percentDone)
```
  - hideProgress
```
protected void hideProgress()
```
    Deprecated.
  - getWidth
```
public int getWidth()
```
    Returns the width of this image in pixels.
  - getHeight
```
public int getHeight()
```
    Returns the height of this image in pixels.
  - getBitDepth
```
public int getBitDepth()
```
    Returns the bit depth, 8, 16, 24 (RGB) or 32. RGB images actually use 32 bits per pixel.
  - getColorModel
```
public ColorModel getColorModel()
```
    Returns this processor's color model. For non-RGB processors, this is the base lookup table (LUT), not the one that may have been modified by setMinAndMax() or setThreshold().
  - getCurrentColorModel
```
public ColorModel getCurrentColorModel()
```
    Returns the current color model, which may have been modified by setMinAndMax() or setThreshold().
  - setColorModel
```
public void setColorModel(ColorModel cm)
```
    Sets the color model. Must be an IndexColorModel (aka LUT) for all processors except the ColorProcessor.
  - getLut
```
public LUT getLut()
```
  - setLut
```
public void setLut(LUT lut)
```
  - makeDefaultColorModel
```
protected void makeDefaultColorModel()
```
  - invertLut
```
public void invertLut()
```
    Inverts the values in this image's LUT (indexed color model). Does nothing if this is a ColorProcessor.
  - getBestIndex
```
public int getBestIndex(Color c)
```
    Returns the LUT index that's the best match for this color.
  - isInvertedLut
```
public boolean isInvertedLut()
```
    Returns true if this image uses an inverting LUT that displays zero as white and 255 as black.
  - isGrayscale
```
public boolean isGrayscale()
```
    Returns 'true' if this is an image with a grayscale LUT or an RGB image with identical red, green and blue channels.
  - isColorLut
```
public boolean isColorLut()
```
    Returns true if this image uses a color LUT.
  - isPseudoColorLut
```
public boolean isPseudoColorLut()
```
    Returns true if this image uses a pseudocolor or grayscale LUT, in other words, is this an image that can be filtered.
  - isDefaultLut
```
public boolean isDefaultLut()
```
    Returns true if the image is using the default grayscale LUT.
  - setColor
```
public abstract void setColor(Color color)
```
    Sets the default fill/draw value to the pixel value closest to the specified color.
  - setColor
```
public void setColor(int value)
```
    Sets the default fill/draw value.
  - setColor
```
public void setColor(double value)
```
    Sets the default fill/draw value.
  - setValue
```
public abstract void setValue(double value)
```
    Sets the default fill/draw value.
  - setBackgroundValue
```
public abstract void setBackgroundValue(double value)
```
    Sets the background fill value used by the rotate() and scale() methods.
  - getBackgroundValue
```
public abstract double getBackgroundValue()
```
    Returns the background fill value.
  - getMin
```
public abstract double getMin()
```
    Returns the smallest displayed pixel value.
  - getMax
```
public abstract double getMax()
```
    Returns the largest displayed pixel value.
  - setMinAndMax
```
public abstract void setMinAndMax(double min,
                                  double max)
```
    This image will be displayed by mapping pixel values in the range min-max to screen values in the range 0-255. For byte images, this mapping is done by updating the LUT. For short and float images, it's done by generating 8-bit AWT images. For RGB images, it's done by changing the pixel values.
  - resetMinAndMax
```
public void resetMinAndMax()
```
    For short and float images, recalculates the min and max image values needed to correctly display the image. For ByteProcessors, resets the LUT.
  - setThreshold
```
public void setThreshold(double minThreshold,
                         double maxThreshold,
                         int lutUpdate)
```
    Sets the lower and upper threshold levels. The 'lutUpdate' argument can be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE. Thresholding of RGB images is not supported.
  - setAutoThreshold
```
public void setAutoThreshold(String method)
```
    Automatically sets the lower and upper threshold levels, where 'method' must be "Default", "Huang", "Intermodes", "IsoData", "IJ_IsoData", "Li", "MaxEntropy", "Mean", "MinError", "Minimum", "Moments", "Otsu", "Percentile", "RenyiEntropy", "Shanbhag", "Triangle" or "Yen". The 'method' string may also include the keywords 'dark' (dark background) 'red' (red LUT, the default), 'b&w' (black and white LUT), 'over/under' (over/under LUT) or 'no-lut' (no LUT changes), for example "Huang dark b&w".
    
    See Also:
    
    resetThreshold(), setThreshold(double, double, int), createMask()
  - setAutoThreshold
```
public void setAutoThreshold(String mString,
                             boolean darkBackground,
                             int lutUpdate)
```
  - setAutoThreshold
```
public void setAutoThreshold(AutoThresholder.Method method,
                             boolean darkBackground)
```
  - setAutoThreshold
```
public void setAutoThreshold(AutoThresholder.Method method,
                             boolean darkBackground,
                             int lutUpdate)
```
  - setAutoThreshold
```
public void setAutoThreshold(int method,
                             int lutUpdate)
```
    Automatically sets the lower and upper threshold levels, where 'method' must be ISODATA or ISODATA2 and 'lutUpdate' must be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
  - scaleAndSetThreshold
```
public void scaleAndSetThreshold(double lower,
                                 double upper,
                                 int lutUpdate)
```
    Set the threshold using a 0-255 range.
  - resetThreshold
```
public void resetThreshold()
```
    Disables thresholding.
  - getMinThreshold
```
public double getMinThreshold()
```
    Returns the lower threshold level. Returns NO_THRESHOLD if thresholding is not enabled.
  - getMaxThreshold
```
public double getMaxThreshold()
```
    Returns the upper threshold level.
  - getLutUpdateMode
```
public int getLutUpdateMode()
```
    Returns the LUT update mode, which can be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
  - setBinaryThreshold
```
public void setBinaryThreshold()
```
  - resetBinaryThreshold
```
public void resetBinaryThreshold()
```
    Resets the threshold if minThreshold=maxThreshold and lutUpdateMode=NO_LUT_UPDATE. This removes the invisible threshold set by the MakeBinary and Convert to Mask commands.
    
    See Also:
    
    setBinaryThreshold()
  - setRoi
```
public void setRoi(Rectangle roi)
```
    Defines a rectangular region of interest and sets the mask to null if this ROI is not the same size as the previous one.
    
    See Also:
    
    resetRoi()
  - setRoi
```
public void setRoi(int x,
                   int y,
                   int rwidth,
                   int rheight)
```
    Defines a rectangular region of interest and sets the mask to null if this ROI is not the same size as the previous one.
    
    See Also:
    
    resetRoi()
  - setRoi
```
public void setRoi(Roi roi)
```
    Defines a non-rectangular region of interest that will consist of a rectangular ROI and a mask. After processing, call reset(mask) to restore non-masked pixels. Here is an example:
```
                ip.setRoi(new OvalRoi(50, 50, 100, 50));
                ip.fill();
                ip.reset(ip.getMask());
                
```
    The example assumes snapshot() has been called, which is the case for code executed in the run() method of plugins that implement the PlugInFilter interface.
    See Also:
    
    ImagePlus.getRoi()
  - setRoi
```
public void setRoi(Polygon roi)
```
    Defines a polygonal region of interest that will consist of a rectangular ROI and a mask. After processing, call reset(mask) to restore non-masked pixels. Here is an example:
```
                Polygon p = new Polygon();
                p.addPoint(50, 0); p.addPoint(100, 100); p.addPoint(0, 100);
                ip.setRoi(triangle);
                ip.invert();
                ip.reset(ip.getMask());
                
```
    The example assumes snapshot() has been called, which is the case for code executed in the run() method of plugins that implement the PlugInFilter interface.
    See Also:
    
    Roi.getPolygon(), drawPolygon(java.awt.Polygon), fillPolygon(java.awt.Polygon)
  - resetRoi
```
public void resetRoi()
```
    Sets the ROI (Region of Interest) and clipping rectangle to the entire image.
  - getRoi
```
public Rectangle getRoi()
```
    Returns a Rectangle that represents the current region of interest.
  - setMask
```
public void setMask(ImageProcessor mask)
```
    Defines a byte mask that limits processing to an irregular ROI. Background pixels in the mask have a value of zero.
  - getMask
```
public ImageProcessor getMask()
```
    For images with irregular ROIs, returns a mask, otherwise, returns null. Pixels outside the mask have a value of zero.
  - getMaskArray
```
public byte[] getMaskArray()
```
    Returns a reference to the mask pixel array, or null if there is no mask.
  - setProgressBar
```
public void setProgressBar(ProgressBar pb)
```
    Assigns a progress bar to this processor. Set 'pb' to null to disable the progress bar.
  - setInterpolate
```
public void setInterpolate(boolean interpolate)
```
    This method has been replaced by setInterpolationMethod().
  - setInterpolationMethod
```
public void setInterpolationMethod(int method)
```
    Use this method to set the interpolation method (NONE, BILINEAR or BICUBIC) used by scale(), resize() and rotate().
  - getInterpolationMethod
```
public int getInterpolationMethod()
```
    Returns the current interpolation method (NONE, BILINEAR or BICUBIC).
  - getInterpolationMethods
```
public static String[] getInterpolationMethods()
```
  - getInterpolate
```
public boolean getInterpolate()
```
    Returns the value of the interpolate field.
  - isKillable
```
public boolean isKillable()
```
    Deprecated.
  - getLine
```
public double[] getLine(double x1,
                        double y1,
                        double x2,
                        double y2)
```
    Returns an array containing the pixel values along the line starting at (x1,y1) and ending at (x2,y2). Pixel values are sampled using getInterpolatedValue(double,double) if interpolatiion is enabled or getPixelValue(int,int) if it is not. For byte and short images, returns calibrated values if a calibration table has been set using setCalibrationTable(). The length of the returned array, minus one, is approximately equal to the length of the line.
    
    See Also:
    
    setInterpolate(boolean), getPixelValue(int, int), getInterpolatedValue(double, double)
  - getRow
```
public void getRow(int x,
                   int y,
                   int[] data,
                   int length)
```
    Returns the pixel values along the horizontal line starting at (x,y).
  - getRow
```
public float[] getRow(int x,
                      int y,
                      float[] data,
                      int length)
```
    Returns the pixel values along the horizontal line starting at (x,y).
  - getColumn
```
public void getColumn(int x,
                      int y,
                      int[] data,
                      int length)
```
    Returns the pixel values down the column starting at (x,y).
  - putRow
```
public void putRow(int x,
                   int y,
                   int[] data,
                   int length)
```
    Inserts the pixels contained in 'data' into a horizontal line starting at (x,y).
  - putRow
```
public void putRow(int x,
                   int y,
                   float[] data,
                   int length)
```
    Inserts the pixels contained in 'data' into a horizontal line starting at (x,y).
  - putColumn
```
public void putColumn(int x,
                      int y,
                      int[] data,
                      int length)
```
    Inserts the pixels contained in 'data' into a column starting at (x,y).
  - moveTo
```
public void moveTo(int x,
                   int y)
```
    Sets the current drawing location.
    
    See Also:
    
    lineTo(int, int), drawString(java.lang.String)
  - setLineWidth
```
public void setLineWidth(int width)
```
    Sets the line width used by lineTo() and drawDot().
  - getLineWidth
```
public int getLineWidth()
```
    Returns the current line width.
  - lineTo
```
public void lineTo(int x2,
                   int y2)
```
    Draws a line from the current drawing location to (x2,y2).
  - drawLine
```
public void drawLine(int x1,
                     int y1,
                     int x2,
                     int y2)
```
    Draws a line from (x1,y1) to (x2,y2).
  - drawLine4
```
public void drawLine4(int x1,
                      int y1,
                      int x2,
                      int y2)
```
  - drawRect
```
public void drawRect(int x,
                     int y,
                     int width,
                     int height)
```
    Draws a rectangle.
  - fillRect
```
public void fillRect(int x,
                     int y,
                     int width,
                     int height)
```
    Fills a rectangle.
  - drawOval
```
public void drawOval(int x,
                     int y,
                     int width,
                     int height)
```
    Draws an elliptical shape.
  - fillOval
```
public void fillOval(int x,
                     int y,
                     int width,
                     int height)
```
    Fills an elliptical shape.
  - drawPolygon
```
public void drawPolygon(Polygon p)
```
    Draws a polygon.
  - fillPolygon
```
public void fillPolygon(Polygon p)
```
    Fills a polygon.
  - drawDot2
```
public void drawDot2(int x,
                     int y)
```
    Deprecated.
  - drawDot
```
public void drawDot(int xcenter,
                    int ycenter)
```
    Draws a dot using the current line width and fill/draw value.
  - drawString
```
public void drawString(String s)
```
    Draws a string at the current drawing location using the current fill/draw value. Draws multiple lines if the string contains newline characters. The current x coordinate is the left/center/right end of the string for left/center/right justification. The current y coordinate determines the bottommost position of the string, including the descent of the font (i.e., characters reaching below the baseline) For multi-line strings, the y coordinate applies to the first line. The y of the drawing position is incremented by the height of one text line, i.e. points at the drawing position for the next text line
  - drawString
```
public void drawString(String s,
                       int x,
                       int y)
```
    Draws a string at the specified location using the current fill/draw value. Draws multiple lines if the string contains newline characters. The x coordinate is the left/center/right end of the string for left/center/right justification. The y coordinate determines the bottommost position of the string, including the descent of the font (i.e., characters reaching below the baseline) For multi-line strings, the y coordinate applies to the first line.
  - drawString
```
public void drawString(String s,
                       int x,
                       int y,
                       Color background)
```
    Draws a string at the specified location with a filled background. A JavaScript example is available at http://imagej.nih.gov/ij/macros/js/DrawTextWithBackground.js
  - setJustification
```
public void setJustification(int justification)
```
    Sets the justification used by drawString(), where justification is CENTER_JUSTIFY, RIGHT_JUSTIFY or LEFT_JUSTIFY. The default is LEFT_JUSTIFY.
  - setFont
```
public void setFont(Font font)
```
    Sets the font used by drawString().
  - setAntialiasedText
```
public void setAntialiasedText(boolean antialiasedText)
```
    Specifies whether or not text is drawn using antialiasing. Antialiased test requires an 8 bit or RGB image. Antialiasing does not work with 8-bit images that are not using 0-255 display range.
  - getStringWidth
```
public int getStringWidth(String s)
```
    Returns the width in pixels of the specified string, including any background space (whitespace) between the x drawing coordinate and the string, not necessarily including all whitespace at the right.
  - getStringBounds
```
public Rectangle getStringBounds(String s)
```
    Returns a rectangle enclosing the pixels affected by drawString assuming it is drawn at (x=0, y=0). As drawString draws above the drawing location, the y coordinate of the rectangle is negative.
  - getFont
```
public Font getFont()
```
    Returns the current font.
  - getFontMetrics
```
public FontMetrics getFontMetrics()
```
    Returns the current FontMetrics.
  - smooth
```
public void smooth()
```
    Replaces each pixel with the 3x3 neighborhood mean.
  - sharpen
```
public void sharpen()
```
    Sharpens the image or ROI using a 3x3 convolution kernel.
  - findEdges
```
public void findEdges()
```
    Finds edges in the image or ROI using a Sobel operator.
  - flipVertical
```
public abstract void flipVertical()
```
    Flips the image or ROI vertically.
  - flipHorizontal
```
public void flipHorizontal()
```
    Flips the image or ROI horizontally.
  - rotateRight
```
public ImageProcessor rotateRight()
```
    Rotates the entire image 90 degrees clockwise. Returns a new ImageProcessor that represents the rotated image.
  - rotateLeft
```
public ImageProcessor rotateLeft()
```
    Rotates the entire image 90 degrees counter-clockwise. Returns a new ImageProcessor that represents the rotated image.
  - insert
```
public void insert(ImageProcessor ip,
                   int xloc,
                   int yloc)
```
    Inserts the image contained in 'ip' at (xloc, yloc).
  - toString
```
public String toString()
```
    Returns a string containing information about this ImageProcessor.
    
    Overrides:
    
    toString in class Object
  - fill
```
public void fill()
```
    Fills the image or ROI bounding rectangle with the current fill/draw value. Use fill(Roi) or fill(ip.getMask()) to fill non-rectangular selections.
    
    See Also:
    
    setColor(Color), setValue(double), fill(Roi)
  - fill
```
public abstract void fill(ImageProcessor mask)
```
    Fills pixels that are within the ROI bounding rectangle and part of the mask (i.e. pixels that have a value=BLACK in the mask array). Use ip.getMask() to acquire the mask. Throws and IllegalArgumentException if the mask is null or the size of the mask is not the same as the size of the ROI.
    
    See Also:
    
    setColor(Color), setValue(double), getMask(), fill(Roi)
  - fill
```
public void fill(Roi roi)
```
    Fills the ROI with the current fill/draw value.
    
    See Also:
    
    setColor(Color), setValue(double), fill(Roi)
  - fillOutside
```
public void fillOutside(Roi roi)
```
    Fills outside an Roi.
  - draw
```
public void draw(Roi roi)
```
    Draws the specified ROI on this image using the line width and color defined by ip.setLineWidth() and ip.setColor().
    
    See Also:
    
    drawRoi(ij.gui.Roi)
  - drawRoi
```
public void drawRoi(Roi roi)
```
    Draws the specified ROI on this image using the stroke width, stroke color and fill color defined by roi.setStrokeWidth, roi.setStrokeColor() and roi.setFillColor(). Works with RGB images. Does not work with 16-bit and float images. Requires Java 1.6.
    
    See Also:
    
    draw(ij.gui.Roi), drawOverlay(ij.gui.Overlay)
  - drawOverlay
```
public void drawOverlay(Overlay overlay)
```
    Draws the specified Overlay on this image. Works best with RGB images. Does not work with 16-bit and float images. Requires Java 1.6.
    
    See Also:
    
    drawRoi(ij.gui.Roi)
  - setCalibrationTable
```
public void setCalibrationTable(float[] cTable)
```
    Set a lookup table used by getPixelValue(), getLine() and convertToFloat() to calibrate pixel values. The length of the table must be 256 for byte images and 65536 for short images. RGB and float processors do not do calibration.
    
    See Also:
    
    Calibration.setCTable(float[], java.lang.String)
  - getCalibrationTable
```
public float[] getCalibrationTable()
```
    Returns the calibration table or null.
  - setHistogramSize
```
public void setHistogramSize(int size)
```
    Set the number of bins to be used for histograms of float images.
  - getHistogramSize
```
public int getHistogramSize()
```
    Returns the number of float image histogram bins. The bin count is fixed at 256 for the other three data types.
  - setHistogramRange
```
public void setHistogramRange(double histMin,
                              double histMax)
```
    Set the range used for histograms of float images. The image range is used if both histMin and histMax are zero.
  - getHistogramMin
```
public double getHistogramMin()
```
    Returns the minimum histogram value used for histograms of float images.
  - getHistogramMax
```
public double getHistogramMax()
```
    Returns the maximum histogram value used for histograms of float images.
  - getPixels
```
public abstract Object getPixels()
```
    Returns a reference to this image's pixel array. The array type (byte[], short[], float[] or int[]) varies depending on the image type.
  - getPixelsCopy
```
public abstract Object getPixelsCopy()
```
    Returns a copy of the pixel data. Or returns a reference to the snapshot buffer if it is not null and 'snapshotCopyMode' is true.
    
    See Also:
    
    snapshot(), setSnapshotCopyMode(boolean)
  - getPixel
```
public abstract int getPixel(int x,
                             int y)
```
    Returns the value of the pixel at (x,y). For RGB images, the argb values are packed in an int. For float images, the the value must be converted using Float.intBitsToFloat(). Returns zero if either the x or y coodinate is out of range.
  - getPixelCount
```
public int getPixelCount()
```
  - get
```
public abstract int get(int x,
                        int y)
```
    This is a faster version of getPixel() that does not do bounds checking.
  - get
```
public abstract int get(int index)
```
  - set
```
public abstract void set(int x,
                         int y,
                         int value)
```
    This is a faster version of putPixel() that does not clip out of range values and does not do bounds checking.
  - set
```
public abstract void set(int index,
                         int value)
```
  - getf
```
public abstract float getf(int x,
                           int y)
```
    Returns the value of the pixel at (x,y) as a float. Faster than getPixel() because no bounds checking is done.
  - getf
```
public abstract float getf(int index)
```
  - setf
```
public abstract void setf(int x,
                          int y,
                          float value)
```
    Sets the value of the pixel at (x,y) to 'value'. Does no bounds checking or clamping, making it faster than putPixel(). Due to the lack of bounds checking, (x,y) coordinates outside the image may cause an exception. Due to the lack of clamping, values outside the 0-255 range (for byte) or 0-65535 range (for short) are not handled correctly.
  - setf
```
public abstract void setf(int index,
                          float value)
```
  - getIntArray
```
public int[][] getIntArray()
```
    Returns a copy of the pixel data as a 2D int array with dimensions [x=0..width-1][y=0..height-1]. With RGB images, the returned values are in packed ARGB format. With float images, the returned values must be converted to float using Float.intBitsToFloat().
  - setIntArray
```
public void setIntArray(int[][] a)
```
    Replaces the pixel data with contents of the specified 2D int array.
  - getFloatArray
```
public float[][] getFloatArray()
```
    Returns a copy of the pixel data as a 2D float array with dimensions [x=0..width-1][y=0..height-1].
  - setFloatArray
```
public void setFloatArray(float[][] a)
```
    Replaces the pixel data with contents of the specified 2D float array.
  - getNeighborhood
```
public void getNeighborhood(int x,
                            int y,
                            double[][] arr)
```
    Experimental
  - getPixel
```
public int[] getPixel(int x,
                      int y,
                      int[] iArray)
```
    Returns the samples for the pixel at (x,y) in an int array. RGB pixels have three samples, all others have one. Returns zeros if the the coordinates are not in bounds. iArray is an optional preallocated array.
  - putPixel
```
public void putPixel(int x,
                     int y,
                     int[] iArray)
```
    Sets a pixel in the image using an int array of samples. RGB pixels have three samples, all others have one.
  - getInterpolatedPixel
```
public abstract double getInterpolatedPixel(double x,
                                            double y)
```
    Uses the current interpolation method (bilinear or bicubic) to find the pixel value at real coordinates (x,y).
  - getPixelInterpolated
```
public abstract int getPixelInterpolated(double x,
                                         double y)
```
    Uses the current interpolation method to find the pixel value at real coordinates (x,y). For RGB images, the argb values are packed in an int. For float images, the value must be converted using Float.intBitsToFloat(). Returns zero if the (x, y) is not inside the image.
  - getInterpolatedValue
```
public final double getInterpolatedValue(double x,
                                         double y)
```
    Uses bilinear interpolation to find the pixel value at real coordinates (x,y). Returns zero if the (x, y) is not inside the image.
  - getBicubicInterpolatedPixel
```
public double getBicubicInterpolatedPixel(double x0,
                                          double y0,
                                          ImageProcessor ip2)
```
    This method is from Chapter 16 of "Digital Image Processing: An Algorithmic Introduction Using Java" by Burger and Burge (http://www.imagingbook.com/).
  - cubic
```
public static final double cubic(double x)
```
  - putPixel
```
public abstract void putPixel(int x,
                              int y,
                              int value)
```
    Stores the specified value at (x,y). Does nothing if (x,y) is outside the image boundary. For 8-bit and 16-bit images, out of range values are clamped. For RGB images, the argb values are packed in 'value'. For float images, 'value' is expected to be a float converted to an int using Float.floatToIntBits().
  - getPixelValue
```
public abstract float getPixelValue(int x,
                                    int y)
```
    Returns the value of the pixel at (x,y). For byte and short images, returns a calibrated value if a calibration table has been set using setCalibraionTable(). For RGB images, returns the luminance value.
  - putPixelValue
```
public abstract void putPixelValue(int x,
                                   int y,
                                   double value)
```
    Stores the specified value at (x,y).
  - drawPixel
```
public abstract void drawPixel(int x,
                               int y)
```
    Sets the pixel at (x,y) to the current fill/draw value.
  - setPixels
```
public abstract void setPixels(Object pixels)
```
    Sets a new pixel array for the image. The length of the array must be equal to width*height. Use setSnapshotPixels(null) to clear the snapshot buffer.
  - copyBits
```
public abstract void copyBits(ImageProcessor ip,
                              int xloc,
                              int yloc,
                              int mode)
```
    Copies the image contained in 'ip' to (xloc, yloc) using one of the transfer modes defined in the Blitter interface.
  - applyTable
```
public abstract void applyTable(int[] lut)
```
    Transforms the image or ROI using a lookup table. The length of the table must be 256 for byte images and 65536 for short images. RGB and float images are not supported.
  - invert
```
public void invert()
```
    Inverts the image or ROI.
  - add
```
public void add(int value)
```
    Adds 'value' to each pixel in the image or ROI.
  - add
```
public void add(double value)
```
    Adds 'value' to each pixel in the image or ROI.
  - subtract
```
public void subtract(double value)
```
    Subtracts 'value' from each pixel in the image or ROI.
  - multiply
```
public void multiply(double value)
```
    Multiplies each pixel in the image or ROI by 'value'.
  - set
```
public void set(double value)
```
    Assigns 'value' to each pixel in the image or ROI.
  - and
```
public void and(int value)
```
    Binary AND of each pixel in the image or ROI with 'value'.
  - or
```
public void or(int value)
```
    Binary OR of each pixel in the image or ROI with 'value'.
  - xor
```
public void xor(int value)
```
    Binary exclusive OR of each pixel in the image or ROI with 'value'.
  - gamma
```
public void gamma(double value)
```
    Performs gamma correction of the image or ROI.
  - log
```
public void log()
```
    Does a natural logarithmic (base e) transform of the image or ROI.
  - ln
```
public void ln()
```
    Does a natural logarithmic (base e) transform of the image or ROI.
  - exp
```
public void exp()
```
    Performs a exponential transform on the image or ROI.
  - sqr
```
public void sqr()
```
    Performs a square transform on the image or ROI.
  - sqrt
```
public void sqrt()
```
    Performs a square root transform on the image or ROI.
  - abs
```
public void abs()
```
    If this is a 32-bit or signed 16-bit image, performs an absolute value transform, otherwise does nothing.
  - min
```
public void min(double value)
```
    Pixels less than 'value' are set to 'value'.
  - max
```
public void max(double value)
```
    Pixels greater than 'value' are set to 'value'.
  - createImage
```
public abstract Image createImage()
```
    Returns a copy of this image is the form of an AWT Image.
  - getBufferedImage
```
public BufferedImage getBufferedImage()
```
    Returns this image as a BufferedImage.
  - createProcessor
```
public abstract ImageProcessor createProcessor(int width,
                                               int height)
```
    Returns a new, blank processor with the specified width and height.
  - snapshot
```
public abstract void snapshot()
```
    Makes a copy of this image's pixel data that can be later restored using reset() or reset(mask).
    
    See Also:
    
    reset(), reset(ImageProcessor)
  - reset
```
public abstract void reset()
```
    Restores the pixel data from the snapshot (undo) buffer.
  - swapPixelArrays
```
public abstract void swapPixelArrays()
```
    Swaps the pixel and snapshot (undo) buffers.
  - reset
```
public abstract void reset(ImageProcessor mask)
```
    Restores pixels from the snapshot buffer that are within the rectangular roi but not part of the mask.
  - setSnapshotPixels
```
public abstract void setSnapshotPixels(Object pixels)
```
    Sets a new pixel array for the snapshot (undo) buffer.
  - getSnapshotPixels
```
public abstract Object getSnapshotPixels()
```
    Returns a reference to the snapshot (undo) buffer, or null.
  - convolve3x3
```
public abstract void convolve3x3(int[] kernel)
```
    Convolves the image or ROI with the specified 3x3 integer convolution kernel.
  - filter
```
public abstract void filter(int type)
```
    A 3x3 filter operation, where the argument (BLUR_MORE, FIND_EDGES, MEDIAN_FILTER, MIN or MAX) determines the filter type.
  - medianFilter
```
public abstract void medianFilter()
```
    A 3x3 median filter. Requires 8-bit or RGB image.
  - noise
```
public abstract void noise(double standardDeviation)
```
    Adds pseudorandom, Gaussian ("normally") distributed values, with mean 0.0 and the specified standard deviation, to this image or ROI.
  - crop
```
public abstract ImageProcessor crop()
```
    Returns a new processor containing an image that corresponds to the current ROI.
  - threshold
```
public abstract void threshold(int level)
```
    Sets pixels less than or equal to level to 0 and all other pixels to 255. Only works with 8-bit and 16-bit images.
  - duplicate
```
public abstract ImageProcessor duplicate()
```
    Returns a duplicate of this image.
  - scale
```
public abstract void scale(double xScale,
                           double yScale)
```
    Scales the image by the specified factors. Does not change the image size.
    
    See Also:
    
    setInterpolate(boolean), resize(int, int)
  - resize
```
public abstract ImageProcessor resize(int dstWidth,
                                      int dstHeight)
```
    Returns a new ImageProcessor containing a scaled copy of this image or ROI.
    
    See Also:
    
    setInterpolate(boolean)
  - resize
```
public ImageProcessor resize(int dstWidth)
```
    Returns a new ImageProcessor containing a scaled copy of this image or ROI, with the aspect ratio maintained.
  - resize
```
public ImageProcessor resize(int dstWidth,
                             int dstHeight,
                             boolean useAverging)
```
    Returns a new ImageProcessor containing a scaled copy of this image or ROI.
    
    Parameters:
    
    dstWidth - Image width of the resulting ImageProcessor
    
    dstHeight - Image height of the resulting ImageProcessor
    
    useAverging - True means that the averaging occurs to avoid aliasing artifacts; the kernel shape for averaging is determined by the interpolationMethod. False if subsampling without any averaging should be used on downsizing. Has no effect on upsizing.
    
    See Also:
    
    Author: Michael Schmid
  - resizeLinearly
```
protected ImageProcessor resizeLinearly(int width2,
                                        int height2)
```
    Use linear interpolation to resize images that have a width or height of one.
  - bin
```
public ImageProcessor bin(int shrinkFactor)
```
    Returns a copy of this image that has been reduced in size using binning.
  - rotate
```
public abstract void rotate(double angle)
```
    Rotates the image or selection 'angle' degrees clockwise.
    
    See Also:
    
    setInterpolationMethod(int), setBackgroundValue(double)
  - translate
```
public void translate(double xOffset,
                      double yOffset)
```
    Moves the image or selection vertically or horizontally by a specified number of pixels. Positive x values move the image or selection to the right, negative values move it to the left. Positive y values move the image or selection down, negative values move it up.
  - translate
```
public void translate(int xOffset,
                      int yOffset,
                      boolean eraseBackground)
```
    Deprecated. replaced by translate(x,y)
  - getHistogram
```
public abstract int[] getHistogram()
```
    Returns the histogram of the image or ROI. Returns a luminosity histogram for RGB images and null for float images.
    For 8-bit and 16-bit images, returns an array with one entry for each possible value that a pixel can have, from 0 to 255 (8-bit image) or 0-65535 (16-bit image). Thus, the array size is 256 or 65536, and the bin width in uncalibrated units is 1.
    For RGB images, the brightness is evaluated using the color weights (which would result in a float value) and rounded to an int. This gives 256 bins. FloatProcessor.getHistogram is not implemented (returns null).
  - getHistogram
```
public int[] getHistogram(int nBins)
```
    Returns the histogram of the image or ROI, using the specified number of bins.
  - erode
```
public abstract void erode()
```
    Erodes the image or ROI using a 3x3 maximum filter. Requires 8-bit or RGB image.
  - dilate
```
public abstract void dilate()
```
    Dilates the image or ROI using a 3x3 minimum filter. Requires 8-bit or RGB image.
  - setLutAnimation
```
public void setLutAnimation(boolean lutAnimation)
```
    For 16 and 32 bit processors, set 'lutAnimation' true to have createImage() use the cached 8-bit version of the image.
  - convertToByte
```
public ImageProcessor convertToByte(boolean doScaling)
```
    Returns an 8-bit version of this image as a ByteProcessor.
  - convertToShort
```
public ImageProcessor convertToShort(boolean doScaling)
```
    Returns a 16-bit version of this image as a ShortProcessor.
  - convertToFloat
```
public ImageProcessor convertToFloat()
```
    Returns a 32-bit float version of this image as a FloatProcessor. For byte and short images, converts using a calibration function if a calibration table has been set using setCalibrationTable().
  - convertToRGB
```
public ImageProcessor convertToRGB()
```
    Returns an RGB version of this image as a ColorProcessor.
  - convertToByteProcessor
```
public ByteProcessor convertToByteProcessor()
```
    Returns an 8-bit version of this image as a ByteProcessor. 16-bit and 32-bit pixel data are scaled from min-max to 0-255.
  - convertToByteProcessor
```
public ByteProcessor convertToByteProcessor(boolean scale)
```
    Returns an 8-bit version of this image as a ByteProcessor. 16-bit and 32-bit pixel data are scaled from min-max to 0-255 if 'scale' is true.
  - convertToShortProcessor
```
public ShortProcessor convertToShortProcessor()
```
    Returns a 16-bit version of this image as a ShortProcessor. 32-bit pixel data are scaled from min-max to 0-255.
  - convertToShortProcessor
```
public ShortProcessor convertToShortProcessor(boolean scale)
```
    Returns a 16-bit version of this image as a ShortProcessor. 32-bit pixel data are scaled from min-max to 0-255 if 'scale' is true.
  - convertToFloatProcessor
```
public FloatProcessor convertToFloatProcessor()
```
    Returns a 32-bit float version of this image as a FloatProcessor. For byte and short images, converts using a calibration function if a calibration table has been set using setCalibrationTable().
  - convertToColorProcessor
```
public ColorProcessor convertToColorProcessor()
```
    Returns an RGB version of this image as a ColorProcessor.
  - convolve
```
public abstract void convolve(float[] kernel,
                              int kernelWidth,
                              int kernelHeight)
```
    Performs a convolution operation using the specified kernel. KernelWidth and kernelHeight must be odd.
  - autoThreshold
```
public void autoThreshold()
```
    Converts the image to binary using an automatically determined threshold. For byte and short images, converts to binary using an automatically determined threshold. For RGB images, converts each channel to binary. For float images, does nothing.
  - getAutoThreshold
```
public int getAutoThreshold()
```
    Returns a pixel value (threshold) that can be used to divide the image into objects and background. It does this by taking a test threshold and computing the average of the pixels at or below the threshold and pixels above. It then computes the average of those two, increments the threshold, and repeats the process. Incrementing stops when the threshold is larger than the composite average. That is, threshold = (average background + average objects)/2. This description was posted to the ImageJ mailing list by Jordan Bevic.
  - getAutoThreshold
```
public int getAutoThreshold(int[] histogram)
```
    This is a version of getAutoThreshold() that uses a histogram passed as an argument.
  - setClipRect
```
public void setClipRect(Rectangle clipRect)
```
    Updates the clipping rectangle used by lineTo(), drawLine(), drawDot() and drawPixel(). The clipping rectangle is reset by passing a null argument or by calling resetRoi().
  - maskSizeError
```
protected String maskSizeError(ImageProcessor mask)
```
  - getIndexSampleModel
```
protected SampleModel getIndexSampleModel()
```
  - getDefaultColorModel
```
public IndexColorModel getDefaultColorModel()
```
    Returns the default grayscale IndexColorModel.
  - setSnapshotCopyMode
```
public void setSnapshotCopyMode(boolean b)
```
    The getPixelsCopy() method returns a reference to the snapshot buffer if it is not null and 'snapshotCopyMode' is true.
    
    See Also:
    
    getPixelsCopy(), snapshot()
  - getNChannels
```
public int getNChannels()
```
    Returns the number of color channels in the image. The color channels can be accessed by toFloat(channelNumber, fp) and written by setPixels(channelNumber, fp).
    
    Returns:
    
    1 for grayscale images, 3 for RGB images
  - toFloat
```
public abstract FloatProcessor toFloat(int channelNumber,
                                       FloatProcessor fp)
```
    Returns a FloatProcessor with the image or one color channel thereof. The roi and mask are also set for the FloatProcessor.
    
    Parameters:
    
    channelNumber - Determines the color channel, 0=red, 1=green, 2=blue. Ignored for grayscale images.
    
    fp - Here a FloatProcessor can be supplied, or null. The FloatProcessor is overwritten when converting data (re-using its pixels array improves performance).
    
    Returns:
    
    A FloatProcessor with the converted image data of the color channel selected
  - setPixels
```
public abstract void setPixels(int channelNumber,
                               FloatProcessor fp)
```
    Sets the pixels (of one color channel for RGB images) from a FloatProcessor.
    
    Parameters:
    
    channelNumber - Determines the color channel, 0=red, 1=green, 2=blue.Ignored for grayscale images.
    
    fp - The FloatProcessor where the image data are read from.
  - minValue
```
public double minValue()
```
    Returns the minimum possible pixel value.
  - maxValue
```
public double maxValue()
```
    Returns the maximum possible pixel value.
  - updateComposite
```
public void updateComposite(int[] rgbPixels,
                            int channel)
```
    CompositeImage calls this method to generate an updated color image.
  - setOverColor
```
public static void setOverColor(int red,
                                int green,
                                int blue)
```
    Sets the upper Over/Under threshold color. Can be called from a macro, e.g., call("ij.process.ImageProcessor.setOverColor", 0,255,255).
  - setUnderColor
```
public static void setUnderColor(int red,
                                 int green,
                                 int blue)
```
    Set the lower Over/Under thresholding color.
  - isBinary
```
public boolean isBinary()
```
    Returns 'true' if this is a binary image (8-bit-image with only 0 and 255).
  - isSigned16Bit
```
public boolean isSigned16Bit()
```
    Returns 'true' if this is a signed 16-bit image.
  - setUseBicubic
```
public static void setUseBicubic(boolean b)
```
  - getStats
```
public ImageStatistics getStats()
```
    Calculates and returns uncalibrated statistics for this image or ROI, including histogram, area, mean, min and max, standard deviation, and mode. Use the setRoi(Roi) method to limit statistics to a non-rectangular area.
    
    See Also:
    
    setRoi(java.awt.Rectangle), getStatistics(), ImageStatistics
  - getStatistics
```
public ImageStatistics getStatistics()
```
    This method calculates and returns complete uncalibrated statistics for this image or ROI but it is up to 70 times slower than getStats().
    
    See Also:
    
    setRoi(java.awt.Rectangle), getStats(), ImageStatistics
  - blurGaussian
```
public void blurGaussian(double sigma)
```
    Blurs the image by convolving with a Gaussian function.
  - applyMacro
```
public void applyMacro(String macro)
```
    Uses the Process/Math/Macro command to apply macro code to this image.
  - getSliceNumber
```
public int getSliceNumber()
```
  - setSliceNumber
```
public void setSliceNumber(int slice)
```
    PlugInFilterRunner uses this method to set the slice number.
  - clone
```
public Object clone()
```
    Returns a shallow copy of this ImageProcessor, where this image and the copy share pixel data. Use the duplicate() method to create a copy that does not share the pixel data.
    
    Overrides:
    
    clone in class Object
    
    See Also:
    
    duplicate()
  - setOverlay
```
public void setOverlay(Overlay overlay)
```
    This method is used to display virtual stack overlays.
  - getOverlay
```
public Overlay getOverlay()
```
  - getProgressIncrement
```
protected int getProgressIncrement(int w,
                                   int h)
```
  - setRandomSeed
```
public static void setRandomSeed(double randomSeed)
```
  - createMask
```
public ByteProcessor createMask()
```
    Returns a binary mask, or null if a threshold is not set or this is an RGB image.

Class ImageProcessor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BLACK

NO_THRESHOLD

LEFT_JUSTIFY

CENTER_JUSTIFY

RIGHT_JUSTIFY

ISODATA

ISODATA2

NEAREST_NEIGHBOR

NONE

BILINEAR

BICUBIC

BLUR_MORE

FIND_EDGES

MEDIAN_FILTER

MIN

MAX

CONVOLVE

RED_LUT

BLACK_AND_WHITE_LUT

NO_LUT_UPDATE

OVER_UNDER_LUT

lineWidth

cx

cy

font

fontMetrics

antialiasedText

boldFont

width

snapshotWidth

height

snapshotHeight

roiX

roiY

roiWidth

roiHeight

xMin

xMax

yMin

yMax

baseCM

cm

rLUT1

gLUT1

bLUT1

rLUT2

gLUT2

bLUT2

interpolate

interpolationMethod

minThreshold

maxThreshold

histogramSize

histogramMin

histogramMax

cTable

lutAnimation

source

img

newPixels

drawingColor

clipXMin

clipXMax

clipYMin

clipYMax

justification

lutUpdateMode

raster

image

fmImage

fmGraphics

cm2

sampleModel

defaultColorModel