ImageProcessor (ImageJ API)

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.image.BufferedImage`	`fmImage`
`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`
`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`
`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.
`java.awt.image.BufferedImage`	`getBufferedImage()` Returns this image as a BufferedImage.
`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 (x2,y2).
`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.
`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.
`abstract void`	`setBackgroundValue(double value)` Sets the background fill value used by the rotate(), scale() and translate() 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`	`translate(int xOffset, int yOffset, boolean eraseBackground)` Moves the image or selection vertically or horizontally by a specified number of pixels.
`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

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

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

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

fmImage

protected java.awt.image.BufferedImage fmImage

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(), scale() and translate() 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.

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.

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 (x2,y2).

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.

ij.process Class ImageProcessor

BLACK

NO_THRESHOLD

LEFT_JUSTIFY

CENTER_JUSTIFY

RIGHT_JUSTIFY

ISODATA

ISODATA2

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

minThreshold

maxThreshold

histogramSize

histogramMin

histogramMax

cTable

lutAnimation

source

img

newPixels

drawingColor

clipXMin

clipXMax

clipYMin

clipYMax

justification

lutUpdateMode

raster

image

fmImage

cm2

sampleModel

defaultColorModel

inversionTested

invertedLut

ImageProcessor

showProgress

hideProgress

getWidth

getHeight

getColorModel

getCurrentColorModel

setColorModel

makeDefaultColorModel

invertLut

getBestIndex

isInvertedLut

isColorLut

isPseudoColorLut

setColor

ij.process
Class ImageProcessor