Module ij
Package ij.process

# Class ColorProcessor

java.lang.Object
ij.process.ImageProcessor
ij.process.ColorProcessor

All Implemented Interfaces:
  `Cloneable`

Direct Known Subclasses:
  `IntProcessor`

public class ColorProcessor extends ImageProcessor
This is an 32-bit RGB image and methods that operate on that image.. Based on the ImageProcessor class from "KickAss Java Programming" by Tonny Espeset (1996).

## Field Summary

Fields
Modifier and Type
Field
Description
`protected int`
`max`
`protected int`
`min`
`protected int[]`
`pixels`
`static final int`
`RGB_DILATE`
`static final int`
`RGB_ERODE`
`static final int`
`RGB_FIND_EDGES`
`static final int`
`RGB_MAX`
`static final int`
`RGB_MEDIAN`
`static final int`
`RGB_MIN`
`static final int`
`RGB_NOISE`
`static final int`
`RGB_RESIZE`
`static final int`
`RGB_ROTATE`
`static final int`
`RGB_SCALE`
`static final int`
`RGB_THRESHOLD`
`static final int`
`RGB_TRANSLATE`
`protected int[]`
`snapshotPixels`

### Fields inherited from class ij.process.ImageProcessor

`antialiasedText, baseCM, BICUBIC, BILINEAR, BLACK, BLACK_AND_WHITE_LUT, BLUR_MORE, bLUT1, bLUT2, boldFont, CENTER_JUSTIFY, clipXMax, clipXMin, clipYMax, clipYMin, cm, cm2, CONVOLVE, cTable, cx, cy, defaultColorModel, drawingColor, fillValueSet, FIND_EDGES, fmGraphics, fmImage, font, fontMetrics, gLUT1, gLUT2, height, histogramMax, histogramMin, histogramSize, image, img, interpolate, interpolationMethod, inversionTested, INVERT_PROJECTION, invertedLut, ISODATA, ISODATA2, justification, LEFT_JUSTIFY, lineWidth, lutAnimation, lutUpdateMode, MAX, MAX_PROJECTION, maxThreshold, MEDIAN_FILTER, MIN, MIN_PROJECTION, minMaxSet, minThreshold, NEAREST_NEIGHBOR, newPixels, NO_LUT_UPDATE, NO_THRESHOLD, NONE, OVER_UNDER_LUT, raster, RED_LUT, RIGHT_JUSTIFY, rLUT1, rLUT2, rnd, roiHeight, roiWidth, roiX, roiY, sampleModel, seed, SET_FIRST_CHANNEL, snapshotHeight, snapshotWidth, source, SUM_PROJECTION, UPDATE_BLUE, UPDATE_GREEN, UPDATE_RED, width, xMax, xMin, yMax, yMin`

## Constructor Summary

Constructors
Constructor
Description
`ColorProcessor(int width, int height)`
Creates a blank ColorProcessor of the specified dimensions.
`ColorProcessor(int width, int height, int[] pixels)`
Creates a ColorProcessor from a pixel array.
`ColorProcessor(Image img)`
Creates a ColorProcessor from an AWT Image or BufferedImage.

## Method Summary

Modifier and Type
Method
Description
`void`
`applyTable(int[] lut)`
Transforms the image or ROI using a lookup table.
`void`
`applyTable(int[] lut, int channels)`
`void`
`autoThreshold()`
Converts the image to binary using an automatically determined threshold.
`boolean`
`caSnapshot()`
Used by the ContrastAdjuster
`void`
`caSnapshot(boolean set)`
Used by the ContrastAdjuster
`void`
`convolve(float[] kernel, int kernelWidth, int kernelHeight)`
Performs a convolution operation using the specified kernel.
`void`
`convolve3x3(int[] kernel)`
3x3 convolution contributed by Glynne Casteel.
`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.
`Image`
`createImage()`
Returns a copy of this image is the form of an AWT Image.
`ImageProcessor`
`createProcessor(int width, int height)`
Returns a new, blank ColorProcessor with the specified width and height.
`ImageProcessor`
`crop()`
Returns a new processor containing an image that corresponds to the current ROI.
`void`
`dilate()`
Dilates the image or ROI using a 3x3 minimum filter.
`void`
`drawPixel(int x, int y)`
Draws a pixel in the current foreground color.
`ImageProcessor`
`duplicate()`
Returns a duplicate of this image.
`void`
`erode()`
Erodes the image or ROI using a 3x3 maximum filter.
`void`
`fill()`
Fills the current rectangular ROI.
`void`
`fill(ImageProcessor mask)`
Fills pixels that are within roi and part of the mask.
`void`
`filter(int type)`
A 3x3 filter operation, where the argument (ImageProcessor.BLUR_MORE, FIND_EDGES, MEDIAN_FILTER, MIN or MAX) determines the filter type.
`void`
`filterRGB(int type, double arg)`
Performs the specified filter on the red, green and blue planes of this image.
`void`
`findEdges()`
Finds edges in the image or ROI using a Sobel operator.
`void`
`flipVertical()`
Flips the image or ROI vertically.
`final int`
`get(int index)`
`final int`
`get(int x, int y)`
This is a faster version of getPixel() that does not do bounds checking.
`double`
`getBackgroundValue()`
Returns the background fill value.
`int`
`getBestIndex(Color c)`
Always returns 0 since RGB images do not use LUTs.
`int`
`getBitDepth()`
Returns the bit depth, 8, 16, 24 (RGB) or 32.
`FloatProcessor`
`getBrightness()`
Returns brightness as a FloatProcessor.
`byte[]`
`getChannel(int channel)`
Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a byte array.
`ByteProcessor`
`getChannel(int channel, ByteProcessor bp)`
Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a ByteProcessor.
`Color`
`getColor(int x, int y)`
`final float`
`getf(int index)`
`final float`
`getf(int x, int y)`
Returns the value of the pixel at (x,y) as a float.
`double`
`getForegroundValue()`
Returns the foreground fill/draw value.
`int[]`
`getHistogram()`
Returns the histogram of the image or ROI.
`int[]`
`getHistogram(ImageProcessor mask)`
`void`
`getHSB(byte[] H, byte[] S, byte[] B)`
Returns hue, saturation and brightness in 3 byte arrays.
`void`
`getHSB(float[] H, float[] S, float[] B)`
Returns hue, saturation and brightness in 3 float arrays.
`ImageStack`
`getHSB32Stack()`
Returns an ImageStack with three 32-bit slices, representing hue, saturation and brightness
`ImageStack`
`getHSBStack()`
Returns an ImageStack with three 8-bit slices, representing hue, saturation and brightness
`double`
`getInterpolatedPixel(double x, double y)`
Calls getPixelValue(x,y).
`int`
`getInterpolatedRGBPixel(double x, double y)`
Uses bilinear interpolation to find the pixel value at real coordinates (x,y).
`double`
`getMax()`
Returns the largest displayed pixel value.
`double`
`getMin()`
Returns the smallest displayed pixel value.
`int`
`getNChannels()`
Returns the number of color channels (3).
`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 3 samples for the pixel at (x,y) in an array of int.
`final int`
`getPixelInterpolated(double x, double y)`
Uses the current interpolation method to find the pixel value at real coordinates (x,y).
`Object`
`getPixels()`
Returns a reference to the int array containing this image's pixel data.
`Object`
`getPixelsCopy()`
Returns a copy of the pixel data.
`float`
`getPixelValue(int x, int y)`
Converts the specified pixel to grayscale using the formula g=(r+g+b)/3 and returns it as a float.
`void`
`getRGB(byte[] R, byte[] G, byte[] B)`
Returns the red, green and blue planes as 3 byte arrays.
`double[]`
`getRGBWeights()`
Returns the values set by setRGBWeights(), or null if setRGBWeights() has not been called.
`Object`
`getSnapshotPixels()`
Returns a reference to the snapshot pixel array.
`static double[]`
`getWeightingFactors()`
Returns the three weighting factors used by getPixelValue(), getHistogram() and convertToByte() to do color conversions.
`void`
`invertLut()`
Does nothing since RGB images do not use LUTs.
`final boolean`
`isGrayscale()`
Returns 'true' if this is a grayscale image.
`boolean`
`isInvertedLut()`
Always returns false since RGB images do not use LUTs.
`ImageProcessor`
`makeThumbnail(int width2, int height2, double smoothFactor)`
Uses averaging to creates a new ColorProcessor containing a downsized copy of this image or selection.
`void`
`medianFilter()`
A 3x3 median filter.
`void`
`noise(double range)`
Adds pseudorandom, Gaussian ("normally") distributed values, with mean 0.0 and the specified standard deviation, to this image or ROI.
`final void`
`putPixel(int x, int y, int value)`
Stores the specified value at (x,y).
`final void`
`putPixel(int x, int y, int[] iArray)`
Sets a pixel in the image using a 3 element (R, G and B) int array of samples.
`void`
`putPixelValue(int x, int y, double value)`
Stores the specified real grayscale value at (x,y).
`void`
`reset()`
Restores the pixel data from the snapshot (undo) buffer.
`void`
`reset(ImageProcessor mask)`
Restores pixels from the snapshot buffer that are within the rectangular roi but not part of the mask.
`ImageProcessor`
`resize(int dstWidth, int dstHeight)`
Creates a new ColorProcessor containing a scaled copy of this image or selection.
`void`
`rotate(double angle)`
Rotates the image or ROI 'angle' degrees clockwise.
`void`
`scale(double xScale, double yScale)`
Scales the image or selection using the specified scale factors.
`final void`
`set(int index, int value)`
`final 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`
`setBackgroundColor(Color color)`
Sets the background fill/draw color.
`void`
`setBackgroundValue(double value)`
Sets the background fill value, where `value` is interpreted as an RGB int.
`void`
`setBrightness(FloatProcessor fp)`
Updates the brightness using the pixels in the specified FloatProcessor).
`void`
`setChannel(int channel, ByteProcessor bp)`
Sets the pixels of one color channel from a ByteProcessor.
`void`
`setColor(int color)`
Sets the fill/draw color, where `color` is an RGB int.
`void`
`setColor(Color color)`
Sets the foreground color.
`void`
`setColorModel(ColorModel cm)`
Sets the color model.
`final void`
`setf(int index, float value)`
`final void`
`setf(int x, int y, float value)`
Sets the value of the pixel at (x,y) to 'value'.
`void`
`setHSB(byte[] H, byte[] S, byte[] B)`
Sets the current pixels from 3 byte arrays (hue, saturation and brightness).
`void`
`setHSB(float[] H, float[] S, float[] B)`
Sets the current pixels from 3 float arrays (hue, saturation and brightness).
`void`
`setMinAndMax(double min, double max)`
Uses a table look-up to map the pixels in this image from min-max to 0-255.
`void`
`setMinAndMax(double min, double max, int channels)`
`void`
`setPixels(int channelNumber, FloatProcessor fp)`
Sets the pixels of one color channel from a FloatProcessor.
`void`
`setPixels(Object pixels)`
Sets a new pixel array for the image.
`void`
`setRGB(byte[] R, byte[] G, byte[] B)`
Sets the current pixels from 3 byte arrays (reg, green, blue).
`void`
`setRGBWeights(double[] weights)`
This is a thread-safe (non-static) version of setWeightingFactors().
`void`
`setRGBWeights(double rweight, double gweight, double bweight)`
This is a thread-safe (non-static) version of setWeightingFactors().
`void`
`setSnapshotPixels(Object pixels)`
Sets a new pixel array for the snapshot (undo) buffer.
`void`
`setValue(double value)`
Sets the default fill/draw value, where `value` is interpreted as an RGB int.
`static void`
`setWeightingFactors(double rFactor, double gFactor, double bFactor)`
Sets the weighting factors used by getPixelValue(), getHistogram() and convertToByte() to do color conversions.
`void`
`snapshot()`
Makes a copy of this image's pixel data that can be later restored using reset() or reset(mask).
`void`
`swapPixelArrays()`
Swaps the pixel and snapshot (undo) arrays.
`void`
`threshold(int level)`
Not implemented.
`FloatProcessor`
`toFloat(int channelNumber, FloatProcessor fp)`
Returns a FloatProcessor with one color channel of the image.
`void`
`updateComposite(int[] rgbPixels, int channel)`
This method is used by CompositeImage.updateImage() to create RGB images (for display) of a multi-channel composite images.
`boolean`
`weightedHistogram()`

### Methods inherited from class ij.process.ImageProcessor

`abs, add, add, and, applyMacro, bin, blurGaussian, clone, convertToByte, convertToByteProcessor, convertToByteProcessor, convertToColorProcessor, convertToFloat, convertToFloatProcessor, convertToRGB, convertToShort, convertToShortProcessor, convertToShortProcessor, createMask, cubic, draw, drawDot, drawDot2, drawLine, drawLine4, drawOval, drawOverlay, drawPolygon, drawRect, drawRoi, drawString, drawString, drawString, exp, fill, fillOutside, fillOval, fillPolygon, fillRect, fillValueSet, flipHorizontal, gamma, getAutoThreshold, getAutoThreshold, getBicubicInterpolatedPixel, getBufferedImage, getCalibrationTable, getColorModel, getColumn, getColumn, getCurrentColorModel, getDefaultColorModel, getFloatArray, getFont, getFontMetrics, getHeight, getHistogram, getHistogramMax, getHistogramMin, getHistogramSize, getIndexSampleModel, getIntArray, getInterpolate, getInterpolatedValue, getInterpolationMethod, getInterpolationMethods, getLine, getLineWidth, getLut, getLutUpdateMode, getMask, getMaskArray, getMaxThreshold, getMinThreshold, getNeighborhood, getOverlay, getPixelCount, getProgressIncrement, getRoi, getRow, getRow, getSliceNumber, getStatistics, getStats, getStringBounds, getStringWidth, getThresholdColorModel, getValue, getWidth, hideProgress, insert, invert, isBinary, isColorLut, isDefaultLut, isKillable, isPseudoColorLut, isSigned16Bit, isThreshold, lineTo, ln, log, makeDefaultColorModel, maskSizeError, max, maxValue, min, minValue, moveTo, multiply, or, putColumn, putColumn, putRow, putRow, resetBinaryThreshold, resetMinAndMax, resetRoi, resetThreshold, resize, resize, resizeLinearly, rotateLeft, rotateRight, scaleAndSetThreshold, set, setAntialiasedText, setAutoThreshold, setAutoThreshold, setAutoThreshold, setAutoThreshold, setAutoThreshold, setBinaryThreshold, setCalibrationTable, setClipRect, setColor, setColor, setFloatArray, setFont, setFontSize, setGlobalBackgroundColor, setGlobalForegroundColor, setHistogramRange, setHistogramSize, setIntArray, setInterpolate, setInterpolationMethod, setJustification, setLineWidth, setLut, setLutAnimation, setMask, setOverColor, setOverlay, setProgressBar, setRandomSeed, setRoi, setRoi, setRoi, setRoi, setSliceNumber, setSnapshotCopyMode, setThreshold, setThreshold, setUnderColor, setUseBicubic, sharpen, showProgress, smooth, sqr, sqrt, subtract, threshold, toString, translate, translate, xor`

### Methods inherited from class java.lang.Object

`equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

## Field Details

### pixels

protected int[] pixels

### snapshotPixels

protected int[] snapshotPixels

### min

protected int min

### max

protected int max

### RGB_NOISE

public static final int RGB_NOISE

See Also:
  - Constant Field Values

### RGB_MEDIAN

public static final int RGB_MEDIAN

See Also:
  - Constant Field Values

### RGB_FIND_EDGES

public static final int RGB_FIND_EDGES

See Also:
  - Constant Field Values

### RGB_ERODE

public static final int RGB_ERODE

See Also:
  - Constant Field Values

### RGB_DILATE

public static final int RGB_DILATE

See Also:
  - Constant Field Values

### RGB_THRESHOLD

public static final int RGB_THRESHOLD

See Also:
  - Constant Field Values

### RGB_ROTATE

public static final int RGB_ROTATE

See Also:
  - Constant Field Values

### RGB_SCALE

public static final int RGB_SCALE

See Also:
  - Constant Field Values

### RGB_RESIZE

public static final int RGB_RESIZE

See Also:
  - Constant Field Values

### RGB_TRANSLATE

public static final int RGB_TRANSLATE

See Also:
  - Constant Field Values

### RGB_MIN

public static final int RGB_MIN

See Also:
  - Constant Field Values

### RGB_MAX

public static final int RGB_MAX

See Also:
  - Constant Field Values

## Constructor Details

### ColorProcessor

public ColorProcessor(Image img)
Creates a ColorProcessor from an AWT Image or BufferedImage.

### ColorProcessor

public ColorProcessor(int width, int height)
Creates a blank ColorProcessor of the specified dimensions.

### ColorProcessor

public ColorProcessor(int width, int height, int[] pixels)
Creates a ColorProcessor from a pixel array.

## Method Details

### createImage

public Image createImage()
Description copied from class: `ImageProcessor`
Returns a copy of this image is the form of an AWT Image.

Specified by:
  `createImage` in class `ImageProcessor`

### setColorModel

public void setColorModel(ColorModel cm)
Description copied from class: `ImageProcessor`
Sets the color model. Must be an IndexColorModel (aka LUT) for all processors except the ColorProcessor.

Overrides:
  `setColorModel` in class `ImageProcessor`

### createProcessor

public ImageProcessor createProcessor(int width, int height)
Returns a new, blank ColorProcessor with the specified width and height.

Specified by:
  `createProcessor` in class `ImageProcessor`

### getColor

public Color getColor(int x, int y)

### setColor

public void setColor(Color color)
Sets the foreground color.

Specified by:
  `setColor` in class `ImageProcessor`

### setBackgroundColor

public void setBackgroundColor(Color color)
Sets the background fill/draw color.

Overrides:
  `setBackgroundColor` in class `ImageProcessor`

### setColor

public void setColor(int color)
Sets the fill/draw color, where `color` is an RGB int.

Overrides:
  `setColor` in class `ImageProcessor`

### setValue

public void setValue(double value)
Sets the default fill/draw value, where `value` is interpreted as an RGB int.

Specified by:
  `setValue` in class `ImageProcessor`

### getForegroundValue

public double getForegroundValue()
Returns the foreground fill/draw value.

Specified by:
  `getForegroundValue` in class `ImageProcessor`

### setBackgroundValue

public void setBackgroundValue(double value)
Sets the background fill value, where `value` is interpreted as an RGB int.

Specified by:
  `setBackgroundValue` in class `ImageProcessor`

### getBackgroundValue

public double getBackgroundValue()
Returns the background fill value.

Specified by:
  `getBackgroundValue` in class `ImageProcessor`

### getMin

public double getMin()
Returns the smallest displayed pixel value.

Specified by:
  `getMin` in class `ImageProcessor`

### getMax

public double getMax()
Returns the largest displayed pixel value.

Specified by:
  `getMax` in class `ImageProcessor`

### setMinAndMax

public void setMinAndMax(double min, double max)
Uses a table look-up to map the pixels in this image from min-max to 0-255.

Specified by:
  `setMinAndMax` in class `ImageProcessor`
See Also:
  - `IJ.setMinAndMax(ij.ImagePlus,double,double)`

### setMinAndMax

public void setMinAndMax(double min, double max, int channels)

### snapshot

public void snapshot()
Description copied from class: `ImageProcessor`
Makes a copy of this image's pixel data that can be later restored using reset() or reset(mask).

Specified by:
  `snapshot` in class `ImageProcessor`
See Also:
  - `ImageProcessor.reset()`
  - `ImageProcessor.reset(ImageProcessor)`

### reset

public void reset()
Description copied from class: `ImageProcessor`
Restores the pixel data from the snapshot (undo) buffer.

Specified by:
  `reset` in class `ImageProcessor`

### reset

public void reset(ImageProcessor mask)
Description copied from class: `ImageProcessor`
Restores pixels from the snapshot buffer that are within the rectangular roi but not part of the mask.

Specified by:
  `reset` in class `ImageProcessor`

### caSnapshot

public void caSnapshot(boolean set)
Used by the ContrastAdjuster

### caSnapshot

public boolean caSnapshot()
Used by the ContrastAdjuster

### swapPixelArrays

public void swapPixelArrays()
Swaps the pixel and snapshot (undo) arrays.

Specified by:
  `swapPixelArrays` in class `ImageProcessor`

### setSnapshotPixels

public void setSnapshotPixels(Object pixels)
Description copied from class: `ImageProcessor`
Sets a new pixel array for the snapshot (undo) buffer.

Specified by:
  `setSnapshotPixels` in class `ImageProcessor`

### getSnapshotPixels

public Object getSnapshotPixels()
Returns a reference to the snapshot pixel array. Used by the ContrastAdjuster.

Specified by:
  `getSnapshotPixels` in class `ImageProcessor`

### fill

public void fill(ImageProcessor mask)
Fills pixels that are within roi and part of the mask. Does nothing if the mask is not the same as the the ROI.

Specified by:
  `fill` in class `ImageProcessor`
See Also:
  - `ImageProcessor.setColor(Color)`
  - `ImageProcessor.setValue(double)`
  - `ImageProcessor.getMask()`
  - `ImageProcessor.fill(Roi)`

### getPixelsCopy

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

Specified by:
  `getPixelsCopy` in class `ImageProcessor`
See Also:
  - `ImageProcessor.snapshot()`
  - `ImageProcessor.setSnapshotCopyMode(boolean)`

### getPixel

public int getPixel(int x, int y)
Description copied from class: `ImageProcessor`
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. Use getValue(x,y) to get calibrated values from 8-bit and 16-bit images, to get intensity values from RGB images and to get float values from 32-bit images.

Specified by:
  `getPixel` in class `ImageProcessor`
See Also:
  - `ImageProcessor.getValue(int, int)`

### get

public final int get(int x, int y)
Description copied from class: `ImageProcessor`
This is a faster version of getPixel() that does not do bounds checking.

Specified by:
  `get` in class `ImageProcessor`

### set

public final void set(int x, int y, int value)
Description copied from class: `ImageProcessor`
This is a faster version of putPixel() that does not clip out of range values and does not do bounds checking.

Specified by:
  `set` in class `ImageProcessor`

### get

public final int get(int index)

Specified by:
  `get` in class `ImageProcessor`

### set

public final void set(int index, int value)

Specified by:
  `set` in class `ImageProcessor`

### getf

public final float getf(int x, int y)
Description copied from class: `ImageProcessor`
Returns the value of the pixel at (x,y) as a float. Faster than getPixelValue() but does no bounds checking and does not return calibrated values.

Specified by:
  `getf` in class `ImageProcessor`

### setf

public final void setf(int x, int y, float value)
Description copied from class: `ImageProcessor`
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.

Specified by:
  `setf` in class `ImageProcessor`

### getf

public final float getf(int index)

Specified by:
  `getf` in class `ImageProcessor`

### setf

public final void setf(int index, float value)

Specified by:
  `setf` in class `ImageProcessor`

### getPixel

public int[] getPixel(int x, int y, int[] iArray)
Returns the 3 samples for the pixel at (x,y) in an array of int. Returns zeros if the the coordinates are not in bounds. iArray is an optional preallocated array.

Overrides:
  `getPixel` in class `ImageProcessor`

### putPixel

public final void putPixel(int x, int y, int[] iArray)
Sets a pixel in the image using a 3 element (R, G and B) int array of samples.

Overrides:
  `putPixel` in class `ImageProcessor`

### getInterpolatedPixel

public double getInterpolatedPixel(double x, double y)
Calls getPixelValue(x,y).

Specified by:
  `getInterpolatedPixel` in class `ImageProcessor`

### getPixelInterpolated

public final int getPixelInterpolated(double x, double y)
Description copied from class: `ImageProcessor`
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.

Specified by:
  `getPixelInterpolated` in class `ImageProcessor`

### putPixel

public final void putPixel(int x, int y, int value)
Stores the specified value at (x,y).

Specified by:
  `putPixel` in class `ImageProcessor`

### putPixelValue

public void putPixelValue(int x, int y, double value)
Stores the specified real grayscale value at (x,y). Does nothing if (x,y) is outside the image boundary. The value is clamped to be in the range 0-255.

Specified by:
  `putPixelValue` in class `ImageProcessor`

### getPixelValue

public float getPixelValue(int x, int y)
Converts the specified pixel to grayscale using the formula g=(r+g+b)/3 and returns it as a float. Call setWeightingFactors() to specify different conversion factors.

Specified by:
  `getPixelValue` in class `ImageProcessor`
See Also:
  - `ImageProcessor.getPixel(int, int)`
  - `ImageProcessor.getValue(int, int)`
  - `ImageProcessor.getf(int, int)`

### drawPixel

public void drawPixel(int x, int y)
Draws a pixel in the current foreground color.

Specified by:
  `drawPixel` in class `ImageProcessor`

### getPixels

public Object getPixels()
Returns a reference to the int array containing this image's pixel data.

Specified by:
  `getPixels` in class `ImageProcessor`

### setPixels

public void setPixels(Object pixels)
Description copied from class: `ImageProcessor`
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.

Specified by:
  `setPixels` in class `ImageProcessor`

### getHSB

public void getHSB(byte[] H, byte[] S, byte[] B)
Returns hue, saturation and brightness in 3 byte arrays.

### getHSB

public void getHSB(float[] H, float[] S, float[] B)
Returns hue, saturation and brightness in 3 float arrays.

### getHSBStack

public ImageStack getHSBStack()
Returns an ImageStack with three 8-bit slices, representing hue, saturation and brightness

### getHSB32Stack

public ImageStack getHSB32Stack()
Returns an ImageStack with three 32-bit slices, representing hue, saturation and brightness

### getBrightness

public FloatProcessor getBrightness()
Returns brightness as a FloatProcessor.

### getRGB

public void getRGB(byte[] R, byte[] G, byte[] B)
Returns the red, green and blue planes as 3 byte arrays.

### getChannel

public byte[] getChannel(int channel)
Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a byte array.

### getChannel

public ByteProcessor getChannel(int channel, ByteProcessor bp)
Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a ByteProcessor.

### setChannel

public void setChannel(int channel, ByteProcessor bp)
Sets the pixels of one color channel from a ByteProcessor.

Parameters:
  `channel` - Determines the color channel, 1=red, 2=green, 3=blue, 4=alpha
  `bp` - The ByteProcessor where the image data are read from.

### setRGB

public void setRGB(byte[] R, byte[] G, byte[] B)
Sets the current pixels from 3 byte arrays (reg, green, blue).

### setHSB

public void setHSB(byte[] H, byte[] S, byte[] B)
Sets the current pixels from 3 byte arrays (hue, saturation and brightness).

### setHSB

public void setHSB(float[] H, float[] S, float[] B)
Sets the current pixels from 3 float arrays (hue, saturation and brightness).

### setBrightness

public void setBrightness(FloatProcessor fp)
Updates the brightness using the pixels in the specified FloatProcessor).

### copyBits

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

Specified by:
  `copyBits` in class `ImageProcessor`

### applyTable

public void applyTable(int[] lut)
Description copied from class: `ImageProcessor`
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.

Specified by:
  `applyTable` in class `ImageProcessor`

### applyTable

public void applyTable(int[] lut, int channels)

### fill

public void fill()
Fills the current rectangular ROI.

Overrides:
  `fill` in class `ImageProcessor`
See Also:
  - `ImageProcessor.setColor(Color)`
  - `ImageProcessor.setValue(double)`
  - `ImageProcessor.fill(Roi)`

### filterRGB

public void filterRGB(int type, double arg)
Performs the specified filter on the red, green and blue planes of this image.

### noise

public void noise(double range)
Description copied from class: `ImageProcessor`
Adds pseudorandom, Gaussian ("normally") distributed values, with mean 0.0 and the specified standard deviation, to this image or ROI.

Specified by:
  `noise` in class `ImageProcessor`

### medianFilter

public void medianFilter()
Description copied from class: `ImageProcessor`
A 3x3 median filter. Requires 8-bit or RGB image.

Specified by:
  `medianFilter` in class `ImageProcessor`

### findEdges

public void findEdges()
Description copied from class: `ImageProcessor`
Finds edges in the image or ROI using a Sobel operator.

Overrides:
  `findEdges` in class `ImageProcessor`

### erode

public void erode()
Description copied from class: `ImageProcessor`
Erodes the image or ROI using a 3x3 maximum filter. Requires 8-bit or RGB image.

Specified by:
  `erode` in class `ImageProcessor`

### dilate

public void dilate()
Description copied from class: `ImageProcessor`
Dilates the image or ROI using a 3x3 minimum filter. Requires 8-bit or RGB image.

Specified by:
  `dilate` in class `ImageProcessor`

### autoThreshold

public void autoThreshold()
Description copied from class: `ImageProcessor`
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.

Overrides:
  `autoThreshold` in class `ImageProcessor`

### scale

public void scale(double xScale, double yScale)
Scales the image or selection using the specified scale factors.

Specified by:
  `scale` in class `ImageProcessor`
See Also:
  - `ImageProcessor.setInterpolate(boolean)`

### crop

public ImageProcessor crop()
Description copied from class: `ImageProcessor`
Returns a new processor containing an image that corresponds to the current ROI.

Specified by:
  `crop` in class `ImageProcessor`

### duplicate

public ImageProcessor duplicate()
Returns a duplicate of this image.

Specified by:
  `duplicate` in class `ImageProcessor`

### getInterpolatedRGBPixel

public int getInterpolatedRGBPixel(double x, double y)
Uses bilinear interpolation to find the pixel value at real coordinates (x,y).

### resize

public ImageProcessor resize(int dstWidth, int dstHeight)
Creates a new ColorProcessor containing a scaled copy of this image or selection.

Specified by:
  `resize` in class `ImageProcessor`
See Also:
  - `ImageProcessor.setInterpolate(boolean)`

### makeThumbnail

public ImageProcessor makeThumbnail(int width2, int height2, double smoothFactor)
Uses averaging to creates a new ColorProcessor containing a downsized copy of this image or selection.

### rotate

public void rotate(double angle)
Rotates the image or ROI 'angle' degrees clockwise.

Specified by:
  `rotate` in class `ImageProcessor`
See Also:
  - `ImageProcessor.setInterpolationMethod(int)`

### flipVertical

public void flipVertical()
Description copied from class: `ImageProcessor`
Flips the image or ROI vertically.

Specified by:
  `flipVertical` in class `ImageProcessor`

### convolve3x3

public void convolve3x3(int[] kernel)
3x3 convolution contributed by Glynne Casteel.

Specified by:
  `convolve3x3` in class `ImageProcessor`

### filter

public void filter(int type)
A 3x3 filter operation, where the argument (ImageProcessor.BLUR_MORE, FIND_EDGES, MEDIAN_FILTER, MIN or MAX) determines the filter type.

Specified by:
  `filter` in class `ImageProcessor`

### getHistogram

public int[] getHistogram()
Description copied from class: `ImageProcessor`
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).

Specified by:
  `getHistogram` in class `ImageProcessor`

### getHistogram

public int[] getHistogram(ImageProcessor mask)

### weightedHistogram

public boolean weightedHistogram()

### convolve

public void convolve(float[] kernel, int kernelWidth, int kernelHeight)
Performs a convolution operation using the specified kernel.

Specified by:
  `convolve` in class `ImageProcessor`

### setWeightingFactors

public static void setWeightingFactors(double rFactor, double gFactor, double bFactor)
Sets the weighting factors used by getPixelValue(), getHistogram() and convertToByte() to do color conversions. The default values are 1/3, 1/3 and 1/3. Check "Weighted RGB Conversions" in Edit/Options/Conversions to use 0.299, 0.587 and 0.114.

See Also:
  - `getWeightingFactors()`
  - `setRGBWeights(double, double, double)`

### getWeightingFactors

public static double[] getWeightingFactors()
Returns the three weighting factors used by getPixelValue(), getHistogram() and convertToByte() to do color conversions.

See Also:
  - `setWeightingFactors(double, double, double)`
  - `getRGBWeights()`

### setRGBWeights

public void setRGBWeights(double rweight, double gweight, double bweight)
This is a thread-safe (non-static) version of setWeightingFactors().

### setRGBWeights

public void setRGBWeights(double[] weights)
This is a thread-safe (non-static) version of setWeightingFactors().

### getRGBWeights

public double[] getRGBWeights()
Returns the values set by setRGBWeights(), or null if setRGBWeights() has not been called.

### isInvertedLut

public boolean isInvertedLut()
Always returns false since RGB images do not use LUTs.

Overrides:
  `isInvertedLut` in class `ImageProcessor`

### isGrayscale

public final boolean isGrayscale()
Returns 'true' if this is a grayscale image.

Overrides:
  `isGrayscale` in class `ImageProcessor`

### getBestIndex

public int getBestIndex(Color c)
Always returns 0 since RGB images do not use LUTs.

Overrides:
  `getBestIndex` in class `ImageProcessor`

### invertLut

public void invertLut()
Does nothing since RGB images do not use LUTs.

Overrides:
  `invertLut` in class `ImageProcessor`

### updateComposite

public void updateComposite(int[] rgbPixels, int channel)
Description copied from class: `ImageProcessor`
This method is used by CompositeImage.updateImage() to create RGB images (for display) of a multi-channel composite images.

Overrides:
  `updateComposite` in class `ImageProcessor`

### threshold

public void threshold(int level)
Not implemented.

Specified by:
  `threshold` in class `ImageProcessor`

### getNChannels

public int getNChannels()
Returns the number of color channels (3).

Overrides:
  `getNChannels` in class `ImageProcessor`
Returns:
  1 for grayscale images, 3 for RGB images

### toFloat

public FloatProcessor toFloat(int channelNumber, FloatProcessor fp)
Returns a FloatProcessor with one color channel of the image. The roi and mask are also set for the FloatProcessor.

Specified by:
  `toFloat` in class `ImageProcessor`
Parameters:
  `channelNumber` - Determines the color channel, 0=red, 1=green, 2=blue
  `fp` - Here a FloatProcessor can be supplied, or null. The FloatProcessor is overwritten by this method (re-using its pixels array improves performance).
Returns:
  A FloatProcessor with the converted image data of the color channel selected

### setPixels

public void setPixels(int channelNumber, FloatProcessor fp)
Sets the pixels of one color channel from a FloatProcessor.

Specified by:
  `setPixels` in class `ImageProcessor`
Parameters:
  `channelNumber` - Determines the color channel, 0=red, 1=green, 2=blue
  `fp` - The FloatProcessor where the image data are read from.

### getBitDepth

public int getBitDepth()
Description copied from class: `ImageProcessor`
Returns the bit depth, 8, 16, 24 (RGB) or 32. RGB images actually use 32 bits per pixel.

Overrides:
  `getBitDepth` in class `ImageProcessor`