Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## ij.process
Class ImageProcessor

    java.lang.Object
      ij.process.ImageProcessor

Direct Known Subclasses:
  ByteProcessor, ColorProcessor, FloatProcessor, ShortProcessor

public abstract class ImageProcessor
extends java.lang.Object

This abstract class is the superclass for classes that process the four data types (byte, short, float and RGB) supported by ImageJ.

See Also:
  `ByteProcessor`, `ShortProcessor`, `FloatProcessor`, `ColorProcessor`

Field Summary
`protected boolean` | `antialiasedText`
`protected java.awt.image.ColorModel` | `baseCM`
`static int` | `BLACK` Value of pixels included in masks.
`static int` | `BLACK_AND_WHITE_LUT`
`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 java.awt.image.ColorModel` | `cm`
`protected java.awt.image.ColorModel` | `cm2`
`protected float[]` | `cTable`
`protected int` | `cx`
`protected int` | `cy`
`protected static java.awt.image.IndexColorModel` | `defaultColorModel`
`protected java.awt.Color` | `drawingColor`
`protected java.awt.Font` | `font`
`protected java.awt.FontMetrics` | `fontMetrics`
`protected byte[]` | `gLUT1`
`protected byte[]` | `gLUT2`
`protected int` | `height`
`protected double` | `histogramMax`
`protected double` | `histogramMin`
`protected int` | `histogramSize`
`protected java.awt.image.BufferedImage` | `image`
`protected java.awt.Image` | `img`
`protected boolean` | `interpolate`
`protected boolean` | `inversionTested`
`protected boolean` | `invertedLut`
`protected int` | `justification`
`static int` | `LEFT_JUSTIFY` Left justify text.
`protected int` | `lineWidth`
`protected boolean` | `lutAnimation`
`protected int` | `lutUpdateMode`
`protected double` | `maxThreshold`
`protected double` | `minThreshold`
`protected boolean` | `newPixels`
`static int` | `NO_LUT_UPDATE`
`static double` | `NO_THRESHOLD` Value returned by getMinThreshold() when thresholding is not enabled.
`static int` | `OVER_UNDER_LUT`
`protected java.awt.image.WritableRaster` | `raster`
`static int` | `RED_LUT`
`static int` | `RIGHT_JUSTIFY` Right justify text.
`protected byte[]` | `rLUT1`
`protected byte[]` | `rLUT2`
`protected int` | `roiHeight`
`protected int` | `roiWidth`
`protected int` | `roiX`
`protected int` | `roiY`
`protected java.awt.image.SampleModel` | `sampleModel`
`protected int` | `snapshotHeight`
`protected int` | `snapshotWidth`
`protected java.awt.image.MemoryImageSource` | `source`
`protected int` | `width`
`protected int` | `xMax`
`protected int` | `xMin`
`protected int` | `yMax`
`protected int` | `yMin`

Constructor Summary
`ImageProcessor()`

Method Summary
`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'.
`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` | `convertToByte(boolean doScaling)` Returns an 8-bit version of this image as a ByteProcessor.
`ImageProcessor` | `convertToFloat()` 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.
`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 java.awt.Image` | `createImage()` Returns a copy of this image is the form of an AWT Image.
`abstract ImageProcessor` | `createProcessor(int width, int height)` Returns a new, blank processor with the specified width and height.
`abstract ImageProcessor` | `crop()` Creates a new processor containing an image that corresponds to the current ROI.
`abstract void` | `dilate()` Dilates the image or ROI using a 3x3 minimum filter.
`void` | `drawDot(int xcenter, int ycenter)` Draws a dot using the current line width and fill/draw value.
`void` | `drawDot2(int x, int y)` Obsolete
`void` | `drawLine(int x1, int y1, int x2, int y2)` Draws a line from (x1,y1) to (x2,y2).
`void` | `drawOval(int x, int y, int width, int height)` Draws an elliptical shape.
`abstract void` | `drawPixel(int x, int y)` Sets the pixel at (x,y) to the current fill/draw value.
`void` | `drawPolygon(java.awt.Polygon p)` Draws a polygon.
`void` | `drawRect(int x, int y, int width, int height)` Draws a rectangle.
`void` | `drawString(java.lang.String s)` Draws a string at the current location using the current fill/draw value.
`void` | `drawString(java.lang.String s, int x, int y)` Draws a string at the specified location using the current fill/draw value.
`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 and part of the mask (i.e.
`void` | `fillOval(int x, int y, int width, int height)` Fills an elliptical shape.
`void` | `fillPolygon(java.awt.Polygon p)` Fills a polygon.
`abstract void` | `filter(int type)` A 3x3 filter operation, where the argument (BLUR_MORE, FIND_EDGES, etc.) 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.
`int` | `getBestIndex(java.awt.Color c)` Returns the LUT index that's the best match for this color.
`float[]` | `getCalibrationTable()` Returns the calibration table or null.
`java.awt.image.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).
`java.awt.image.ColorModel` | `getCurrentColorModel()` Returns the current color model, which may have been modified by setMinAndMax() or setThreshold().
`java.awt.image.IndexColorModel` | `getDefaultColorModel()` Returns the default grayscale IndexColorModel.
`abstract float` | `getf(int index)`
`abstract float` | `getf(int x, int y)`
`float[][]` | `getFloatArray()`
`java.awt.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.
`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 java.awt.image.SampleModel` | `getIndexSampleModel()`
`int[][]` | `getIntArray()`
`boolean` | `getInterpolate()` Returns the value of the interpolate field.
`abstract double` | `getInterpolatedPixel(double x, double y)` Uses bilinear interpolation 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).
`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` | `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 the mask byte 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.
`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 java.lang.Object` | `getPixels()` Returns a reference to this image's pixel array.
`abstract java.lang.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).
`java.awt.Rectangle` | `getRoi()` Returns a Rectangle that represents the current region of interest.
`void` | `getRow(int x, int y, int[] data, int length)` Returns the pixel values along the horizontal line starting at (x,y).
`abstract java.lang.Object` | `getSnapshotPixels()` Returns a reference to the snapshot (undo) buffer, or null.
`int` | `getStringWidth(java.lang.String s)` Returns the width in pixels of the specified string.
`int` | `getWidth()` Returns the width of this image in pixels.
`protected void` | `hideProgress()`
`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` | `isColorLut()` Returns true if this image uses a color LUT.
`boolean` | `isInvertedLut()` Returns true if this image uses an inverting LUT that displays zero as white and 255 as black.
`boolean` | `isKillable()` Obsolete.
`boolean` | `isPseudoColorLut()` Returns true if this image uses a pseudocolor or grayscale LUT, in other words, is this an image that can be filtered.
`void` | `lineTo(int x2, int y2)` Draws a line from the current drawing location to (x,y).
`void` | `log()` Performs a log transform on the image or ROI.
`protected void` | `makeDefaultColorModel()`
`protected java.lang.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 range)` Adds random noise to the 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, 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)` Creates a new ImageProcessor containing a scaled copy of this image or ROI, with the aspect ratio maintained.
`abstract ImageProcessor` | `resize(int dstWidth, int dstHeight)` Creates a new ImageProcessor containing a scaled copy of this image or ROI.
`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.
`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.
`abstract void` | `setBackgroundValue(double value)` Sets the background fill value used by the rotate() and scale() methods.
`void` | `setCalibrationTable(float[] cTable)` Set a lookup table used by getPixelValue(), getLine() and convertToFloat() to calibrate pixel values.
`void` | `setClipRect(java.awt.Rectangle clipRect)` Updates the clipping rectangle used by lineTo(), drawLine(), drawDot() and drawPixel().
`abstract void` | `setColor(java.awt.Color color)` Sets the default fill/draw value to the pixel value closest to the specified color.
`void` | `setColor(int value)` Obsolete (use setValue)
`void` | `setColorModel(java.awt.image.ColorModel cm)` Sets the color model.
`abstract void` | `setf(int index, float value)`
`abstract void` | `setf(int x, int y, float value)`
`void` | `setFloatArray(float[][] a)`
`void` | `setFont(java.awt.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)`
`void` | `setInterpolate(boolean interpolate)` Setting 'interpolate' true causes scale(), resize(), rotate() and getLine() to do bilinear interpolation.
`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` | `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.
`abstract void` | `setPixels(int channelNumber, FloatProcessor fp)` Sets the pixels (of one color channel for RGB images) from a FloatProcessor.
`abstract void` | `setPixels(java.lang.Object pixels)` Sets a new pixel array for the image.
`void` | `setProgressBar(ProgressBar pb)` Assigns a progress bar to this processor.
`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(java.awt.Polygon roi)` Defines a polygonal region of interest that will consist of a rectangular ROI and a mask.
`void` | `setRoi(java.awt.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` | `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(java.lang.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.
`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.
`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.
`java.lang.String` | `toString()` Returns a string containing information about this ImageProcessor.
`void` | `xor(int value)` Binary exclusive OR of each pixel in the image or ROI with 'value'.

Methods inherited from class java.lang.Object
`clone, 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

### 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 java.awt.Font font

### fontMetrics

    protected java.awt.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 java.awt.image.ColorModel baseCM

### cm

    protected java.awt.image.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

### 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 java.awt.image.MemoryImageSource source

### img

    protected java.awt.Image img

### newPixels

    protected boolean newPixels

### drawingColor

    protected java.awt.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 java.awt.image.WritableRaster raster

### image

    protected java.awt.image.BufferedImage image

### cm2

    protected java.awt.image.ColorModel cm2

### sampleModel

    protected java.awt.image.SampleModel sampleModel

### defaultColorModel

    protected static java.awt.image.IndexColorModel defaultColorModel

### 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()

### getWidth

    public int getWidth()

  Returns the width of this image in pixels.

### getHeight

    public int getHeight()

  Returns the height of this image in pixels.

### getColorModel

    public java.awt.image.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 java.awt.image.ColorModel getCurrentColorModel()

  Returns the current color model, which may have been modified by setMinAndMax() or setThreshold().

### setColorModel

    public void setColorModel(java.awt.image.ColorModel cm)

  Sets the color model. Must be an IndexColorModel (aka LUT) for all processors except the ColorProcessor.

### 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(java.awt.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.

### 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.

### setColor

    public abstract void setColor(java.awt.Color color)

  Sets the default fill/draw value to the pixel value closest to the specified color.

### setColor

    public void setColor(int value)

  Obsolete (use setValue)

### 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.

### 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.

### 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.

### 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.

### setRoi

    public void setRoi(java.awt.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(java.awt.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 java.awt.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 the mask byte 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)

  Setting 'interpolate' true causes scale(), resize(), rotate() and getLine() to do bilinear interpolation.

### getInterpolate

    public boolean getInterpolate()

  Returns the value of the interpolate field.

### isKillable

    public boolean isKillable()

  Obsolete.

### 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). For byte and short images, returns calibrated values if a calibration table has been set using setCalibrationTable().

  See Also:
    `setInterpolate(boolean)`

### getRow

    public void getRow(int x,
                       int y,
                       int[] 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).

### 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().

### lineTo

    public void lineTo(int x2,
                       int y2)

  Draws a line from the current drawing location to (x,y).

### drawLine

    public void drawLine(int x1,
                         int y1,
                         int x2,
                         int y2)

  Draws a line from (x1,y1) to (x2,y2).

### drawRect

    public void drawRect(int x,
                         int y,
                         int width,
                         int height)

  Draws 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(java.awt.Polygon p)

  Draws a polygon.

### fillPolygon

    public void fillPolygon(java.awt.Polygon p)

  Fills a polygon.

### drawDot2

    public void drawDot2(int x,
                         int y)

  Obsolete

### drawDot

    public void drawDot(int xcenter,
                        int ycenter)

  Draws a dot using the current line width and fill/draw value.

### drawString

    public void drawString(java.lang.String s)

  Draws a string at the current location using the current fill/draw value. Draws multiple lines if the string contains newline characters.

### drawString

    public void drawString(java.lang.String s,
                           int x,
                           int y)

  Draws a string at the specified location using the current fill/draw value.

### 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(java.awt.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 Java 2 and 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(java.lang.String s)

  Returns the width in pixels of the specified string.

### getFontMetrics

    public java.awt.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 java.lang.String toString()

  Returns a string containing information about this ImageProcessor.

### fill

    public void fill()

  Fills the image or ROI bounding rectangle with the current fill/draw value. Use fill(mask) to fill non-rectangular selections.

  See Also:
    `fill(ImageProcessor)`

### fill

    public abstract void fill(ImageProcessor mask)

  Fills pixels that are within the ROI and part of the mask (i.e. pixels that have a value=BLACK in the mask array). Throws and IllegalArgumentException if the mask is null or the size of the mask is not the same as the size of the 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.

### 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 java.lang.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 java.lang.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)

### getf

    public abstract float getf(int index)

### setf

    public abstract void setf(int x,
                              int y,
                              float value)

### setf

    public abstract void setf(int index,
                              float value)

### getIntArray

    public int[][] getIntArray()

### setIntArray

    public void setIntArray(int[][] a)

### getFloatArray

    public float[][] getFloatArray()

### setFloatArray

    public void setFloatArray(float[][] a)

### 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 bilinear interpolation to find the pixel value at real coordinates (x,y).

### 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.

### 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 clipped. 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(java.lang.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.

### multiply

    public void multiply(double value)

  Multiplies each pixel in the image or ROI by 'value'.

### 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()

  Performs a log transform on 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 java.awt.Image createImage()

  Returns a copy of this image is the form of an AWT Image.

### 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.

### 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(java.lang.Object pixels)

  Sets a new pixel array for the snapshot (undo) buffer.

### getSnapshotPixels

    public abstract java.lang.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, etc.) 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 range)

  Adds random noise to the image or ROI.

  Parameters:
    `range` - the range of random numbers

### crop

    public abstract ImageProcessor crop()

  Creates 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)

  Creates a new ImageProcessor containing a scaled copy of this image or ROI.

  See Also:
    `setInterpolate(boolean)`

### resize

    public ImageProcessor resize(int dstWidth)

  Creates a new ImageProcessor containing a scaled copy of this image or ROI, with the aspect ratio maintained.

### rotate

    public abstract void rotate(double angle)

  Rotates the image or selection 'angle' degrees clockwise.

  See Also:
    `setInterpolate(boolean)`

### 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.

### 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.

### 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(java.awt.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 java.lang.String maskSizeError(ImageProcessor mask)

### getIndexSampleModel

    protected java.awt.image.SampleModel getIndexSampleModel()

### getDefaultColorModel

    public java.awt.image.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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD