Package ij.process

# Class FloatProcessor

java.lang.Object
ij.process.ImageProcessor
ij.process.FloatProcessor

All Implemented Interfaces:
  `Cloneable`

public class FloatProcessor extends ImageProcessor
This is an 32-bit floating-point image and methods that operate on that image.

## Field Summary

Fields
Modifier and Type
Field
Description
`protected byte[]`
`pixels8`

### 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, FIND_EDGES, fmImage, font, fontMetrics, gLUT1, gLUT2, height, histogramMax, histogramMin, histogramSize, image, img, interpolate, interpolationMethod, inversionTested, invertedLut, ISODATA, ISODATA2, justification, LEFT_JUSTIFY, lineWidth, lutAnimation, lutUpdateMode, MAX, maxThreshold, MEDIAN_FILTER, MIN, minMaxSet, minThreshold, NEAREST_NEIGHBOR, newPixels, NO_LUT_UPDATE, NO_THRESHOLD, NONE, OVER_UNDER_LUT, raster, RED_LUT, RIGHT_JUSTIFY, rLUT1, rLUT2, roiHeight, roiWidth, roiX, roiY, sampleModel, snapshotHeight, snapshotWidth, source, width, xMax, xMin, yMax, yMin`

## Constructor Summary

Constructors
Constructor
Description
`FloatProcessor(float[][] array)`
Creates a FloatProcessor from a 2D float array using the default LUT.
`FloatProcessor(int[][] array)`
Creates a FloatProcessor from a 2D int array.
`FloatProcessor(int width, int height)`
Creates a blank FloatProcessor using the default grayscale LUT that displays zero as black.
`FloatProcessor(int width, int height, double[] pixels)`
Creates a FloatProcessor from a double array using the default grayscale LUT.
`FloatProcessor(int width, int height, double[] pixels, double fixedMin, double fixedMax)`
Added by TAM (originally added to 138k).
`FloatProcessor(int width, int height, float[] pixels)`
Creates a new FloatProcessor using the specified pixel array.
`FloatProcessor(int width, int height, float[] pixels, ColorModel cm)`
Creates a new FloatProcessor using the specified pixel array and ColorModel.
`FloatProcessor(int width, int height, int[] pixels)`
Creates a FloatProcessor from an int array using the default grayscale LUT.

## Method Summary

Modifier and Type
Method
Description
`void`
`abs()`
If this is a 32-bit or signed 16-bit image, performs an absolute value transform, otherwise does nothing.
`void`
`add(double value)`
Adds 'value' to each pixel in the image or ROI.
`void`
`add(int value)`
Adds 'value' to each pixel in the image or ROI.
`void`
`and(int value)`
Binary AND of each pixel in the image or ROI with 'value'.
`void`
`applyTable(int[] lut)`
Transforms the image or ROI using a lookup table.
`void`
`autoThreshold()`
Not implemented.
`void`
`convolve(float[] kernel, int kernelWidth, int kernelHeight)`
Performs a convolution operation using the specified kernel.
`void`
`convolve3x3(int[] kernel)`
Does 3x3 convolution.
`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.
`protected byte[]`
`create8BitImage()`
`Image`
`createImage()`
Create an 8-bit AWT image by scaling pixels in the range min-max to 0-255.
`ImageProcessor`
`createProcessor(int width, int height)`
Returns a new, blank FloatProcessor with the specified width and height.
`ImageProcessor`
`crop()`
Creates a new processor containing an image that corresponds to the current ROI.
`void`
`dilate()`
Not implemented.
`void`
`drawPixel(int x, int y)`
Draws a pixel in the current foreground color.
`ImageProcessor`
`duplicate()`
Returns a duplicate of this image.
`void`
`erode()`
Not implemented.
`void`
`exp()`
Performs a exponential transform on the image or ROI.
`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)`
Filters using a 3x3 neighborhood.
`void`
`findMinAndMax()`
Calculates the minimum and maximum pixel value for the entire image.
`void`
`flipVertical()`
Flips the image or ROI vertically.
`void`
`gamma(double value)`
Performs gamma correction of the image or ROI.
`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()`
Always returns 0.
`double`
`getBicubicInterpolatedPixel(double x0, double y0, ImageProcessor ip2)`
This method is from Chapter 16 of "Digital Image Processing: An Algorithmic Introduction Using Java" by Burger and Burge (http://www.imagingbook.com/).
`int`
`getBitDepth()`
Returns the bit depth, 8, 16, 24 (RGB) or 32.
`BufferedImage`
`getBufferedImage()`
Returns this image as an 8-bit BufferedImage.
`final float`
`getf(int index)`
`final float`
`getf(int x, int y)`
Returns the value of the pixel at (x,y) as a float.
`int[]`
`getHistogram()`
Not implemented.
`double`
`getInterpolatedPixel(double x, double y)`
Uses the current interpolation method (BILINEAR or BICUBIC) to calculate 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`
`getPixel(int x, int y)`
Returns a pixel value that must be converted using Float.intBitsToFloat().
`int[]`
`getPixel(int x, int y, int[] iArray)`
Returns the value of the pixel at (x,y) in a one element int array.
`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 float array containing this image's pixel data.
`Object`
`getPixelsCopy()`
Returns a copy of the pixel data.
`float`
`getPixelValue(int x, int y)`
Returns the value of the pixel at (x,y) as a float.
`Object`
`getSnapshotPixels()`
Returns a reference to the snapshot (undo) buffer, or null.
`void`
`invert()`
Inverts the image or ROI.
`void`
`log()`
Does a natural logarithmic (base e) transform of the image or ROI.
`void`
`max(double value)`
Pixels greater than 'value' are set to 'value'.
`double`
`maxValue()`
Returns the largest possible positive finite pixel value.
`void`
`medianFilter()`
Not implemented.
`void`
`min(double value)`
Pixels less than 'value' are set to 'value'.
`double`
`minValue()`
Returns the smallest possible positive nonzero pixel value.
`void`
`multiply(double value)`
Multiplies each pixel in the image or ROI by 'value'.
`void`
`noise(double standardDeviation)`
Adds pseudorandom, Gaussian ("normally") distributed values, with mean 0.0 and the specified standard deviation, to this image or ROI.
`void`
`or(int value)`
Binary OR of each pixel in the image or ROI with 'value'.
`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 one element int array.
`void`
`putPixelValue(int x, int y, double value)`
Stores the specified real 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.
`void`
`resetMinAndMax()`
Recalculates the min and max values used to scale pixel values to 0-255 for display.
`ImageProcessor`
`resize(int dstWidth, int dstHeight)`
Creates a new FloatProcessor 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.
`void`
`set(double value)`
Assigns 'value' to each pixel in the image or ROI.
`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`
`setBackgroundValue(double value)`
Does nothing.
`void`
`setColor(Color color)`
Sets the foreground fill/draw color.
`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`
`setMinAndMax(double minimum, double maximum)`
Sets the min and max variables that control how real pixel values are mapped to 0-255 screen values.
`void`
`setPixels(int channelNumber, FloatProcessor fp)`
Sets the pixels, and min&max values from a FloatProcessor.
`void`
`setPixels(Object pixels)`
Sets a new pixel array for the image.
`void`
`setSnapshotPixels(Object pixels)`
Sets a new pixel array for the snapshot (undo) buffer.
`void`
`setThreshold(double minThreshold, double maxThreshold, int lutUpdate)`
Sets the lower and upper threshold levels.
`void`
`setValue(double value)`
Sets the default fill/draw value.
`void`
`snapshot()`
Makes a copy of this image's pixel data that can be later restored using reset() or reset(mask).
`void`
`sqr()`
Performs a square transform on the image or ROI.
`void`
`sqrt()`
Performs a square root transform on the image or ROI.
`void`
`swapPixelArrays()`
Swaps the pixel and snapshot (undo) arrays.
`void`
`threshold(int level)`
Not implemented.
`FloatProcessor`
`toFloat(int channelNumber, FloatProcessor fp)`
Returns this FloatProcessor.
`void`
`xor(int value)`
Binary exclusive OR of each pixel in the image or ROI with 'value'.

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

`addColor, addColor, addPlotString, applyMacro, bin, blurGaussian, clearPlotStrings, clone, convertToByte, convertToByteProcessor, convertToByteProcessor, convertToColorProcessor, convertToFloat, convertToFloatProcessor, convertToRGB, convertToShort, convertToShortProcessor, convertToShortProcessor, cubic, draw, drawDot, drawDot2, drawLine, drawOval, drawOverlay, drawPolygon, drawRect, drawRoi, drawString, drawString, drawString, fill, fillOutside, fillOval, fillPolygon, findEdges, flipHorizontal, getAutoThreshold, getAutoThreshold, getBestIndex, getCalibrationTable, getColorModel, getColumn, getCurrentColorModel, getDefaultColorModel, getFloatArray, getFont, getFontMetrics, getHeight, getHistogramMax, getHistogramMin, getHistogramSize, getIndexSampleModel, getIntArray, getInterpolate, getInterpolatedValue, getInterpolationMethod, getInterpolationMethods, getLine, getLineWidth, getLut, getLutUpdateMode, getMask, getMaskArray, getMaxThreshold, getMinThreshold, getNChannels, getNeighborhood, getOverlay, getPixelCount, getRoi, getRow, getRow, getSliceNumber, getStatistics, getStringWidth, getWidth, hideProgress, insert, invertLut, isBinary, isColorLut, isDefaultLut, isGrayscale, isInvertedLut, isKillable, isPseudoColorLut, lineTo, ln, makeDefaultColorModel, maskSizeError, moveTo, plotStrings, putColumn, putRow, putRow, resetBinaryThreshold, resetRoi, resetThreshold, resize, resize, resizeLinearly, rotateLeft, rotateRight, setAntialiasedText, setAutoThreshold, setAutoThreshold, setAutoThreshold, setAutoThreshold, setAutoThreshold, setBinaryThreshold, setCalibrationTable, setClipRect, setColor, setColor, setColorModel, setFloatArray, setFont, setHistogramRange, setHistogramSize, setIntArray, setInterpolate, setInterpolationMethod, setJustification, setLineWidth, setLut, setLutAnimation, setMask, setOverColor, setOverlay, setProgressBar, setRoi, setRoi, setRoi, setRoi, setSliceNumber, setSnapshotCopyMode, setUnderColor, setUseBicubic, sharpen, showProgress, smooth, subtract, toString, translate, translate, updateComposite`

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

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

## Field Details

### pixels8

protected byte[] pixels8

## Constructor Details

### FloatProcessor

public FloatProcessor(int width, int height, float[] pixels)
Creates a new FloatProcessor using the specified pixel array.

### FloatProcessor

public FloatProcessor(int width, int height, float[] pixels, ColorModel cm)
Creates a new FloatProcessor using the specified pixel array and ColorModel.

### FloatProcessor

public FloatProcessor(int width, int height)
Creates a blank FloatProcessor using the default grayscale LUT that displays zero as black. Call invertLut() to display zero as white.

### FloatProcessor

public FloatProcessor(int width, int height, int[] pixels)
Creates a FloatProcessor from an int array using the default grayscale LUT.

### FloatProcessor

public FloatProcessor(int width, int height, double[] pixels)
Creates a FloatProcessor from a double array using the default grayscale LUT.

### FloatProcessor

public FloatProcessor(float[][] array)
Creates a FloatProcessor from a 2D float array using the default LUT.

### FloatProcessor

public FloatProcessor(int[][] array)
Creates a FloatProcessor from a 2D int array.

### FloatProcessor

public FloatProcessor(int width, int height, double[] pixels, double fixedMin, double fixedMax)
Added by TAM (originally added to 138k). Updated to 149b June 19, 2014.

## Method Details

### findMinAndMax

public void findMinAndMax()
Calculates the minimum and maximum pixel value for the entire image. Returns without doing anything if fixedScale has been set true as a result of calling setMinAndMax(). In this case, getMin() and getMax() return the fixed min and max defined by setMinAndMax(), rather than the calculated min and max.

See Also:
  - `getMin()`
  - `getMin()`

### setMinAndMax

public void setMinAndMax(double minimum, double maximum)
Sets the min and max variables that control how real pixel values are mapped to 0-255 screen values. Use resetMinAndMax() to enable auto-scaling;

Specified by:
  `setMinAndMax` in class `ImageProcessor`
See Also:
  - `ContrastAdjuster`

### resetMinAndMax

public void resetMinAndMax()
Recalculates the min and max values used to scale pixel values to 0-255 for display. This ensures that this FloatProcessor is set up to correctly display the image.

Overrides:
  `resetMinAndMax` 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`

### createImage

public Image createImage()
Create an 8-bit AWT image by scaling pixels in the range min-max to 0-255.

Specified by:
  `createImage` in class `ImageProcessor`

### create8BitImage

protected byte[] create8BitImage()

### getBufferedImage

public BufferedImage getBufferedImage()
Returns this image as an 8-bit BufferedImage.

Overrides:
  `getBufferedImage` in class `ImageProcessor`

### createProcessor

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

Specified by:
  `createProcessor` in class `ImageProcessor`

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

### 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()
Description copied from class: `ImageProcessor`
Returns a reference to the snapshot (undo) buffer, or null.

Specified by:
  `getSnapshotPixels` in class `ImageProcessor`

### getPixel

public int getPixel(int x, int y)
Returns a pixel value that must be converted using Float.intBitsToFloat().

Specified by:
  `getPixel` in class `ImageProcessor`

### 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 getPixel() because no bounds checking is done.

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 value of the pixel at (x,y) in a one element int array. iArray is an optiona 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 one element int array.

Overrides:
  `putPixel` in class `ImageProcessor`

### getInterpolatedPixel

public double getInterpolatedPixel(double x, double y)
Uses the current interpolation method (BILINEAR or BICUBIC) to calculate the pixel value at real coordinates (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). The value is expected to be a float that has been converted to an int using Float.floatToIntBits().

Specified by:
  `putPixel` in class `ImageProcessor`

### putPixelValue

public void putPixelValue(int x, int y, double value)
Stores the specified real value at (x,y).

Specified by:
  `putPixelValue` in class `ImageProcessor`

### getPixelValue

public float getPixelValue(int x, int y)
Returns the value of the pixel at (x,y) as a float.

Specified by:
  `getPixelValue` in class `ImageProcessor`

### 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 float array containing this image's pixel data.

Specified by:
  `getPixels` in class `ImageProcessor`

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

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

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

### invert

public void invert()
Description copied from class: `ImageProcessor`
Inverts the image or ROI.

Overrides:
  `invert` in class `ImageProcessor`

### add

public void add(int value)
Description copied from class: `ImageProcessor`
Adds 'value' to each pixel in the image or ROI.

Overrides:
  `add` in class `ImageProcessor`

### add

public void add(double value)
Description copied from class: `ImageProcessor`
Adds 'value' to each pixel in the image or ROI.

Overrides:
  `add` in class `ImageProcessor`

### set

public void set(double value)
Description copied from class: `ImageProcessor`
Assigns 'value' to each pixel in the image or ROI.

Overrides:
  `set` in class `ImageProcessor`

### multiply

public void multiply(double value)
Description copied from class: `ImageProcessor`
Multiplies each pixel in the image or ROI by 'value'.

Overrides:
  `multiply` in class `ImageProcessor`

### and

public void and(int value)
Description copied from class: `ImageProcessor`
Binary AND of each pixel in the image or ROI with 'value'.

Overrides:
  `and` in class `ImageProcessor`

### or

public void or(int value)
Description copied from class: `ImageProcessor`
Binary OR of each pixel in the image or ROI with 'value'.

Overrides:
  `or` in class `ImageProcessor`

### xor

public void xor(int value)
Description copied from class: `ImageProcessor`
Binary exclusive OR of each pixel in the image or ROI with 'value'.

Overrides:
  `xor` in class `ImageProcessor`

### gamma

public void gamma(double value)
Description copied from class: `ImageProcessor`
Performs gamma correction of the image or ROI.

Overrides:
  `gamma` in class `ImageProcessor`

### log

public void log()
Description copied from class: `ImageProcessor`
Does a natural logarithmic (base e) transform of the image or ROI.

Overrides:
  `log` in class `ImageProcessor`

### exp

public void exp()
Description copied from class: `ImageProcessor`
Performs a exponential transform on the image or ROI.

Overrides:
  `exp` in class `ImageProcessor`

### sqr

public void sqr()
Description copied from class: `ImageProcessor`
Performs a square transform on the image or ROI.

Overrides:
  `sqr` in class `ImageProcessor`

### sqrt

public void sqrt()
Description copied from class: `ImageProcessor`
Performs a square root transform on the image or ROI.

Overrides:
  `sqrt` in class `ImageProcessor`

### abs

public void abs()
Description copied from class: `ImageProcessor`
If this is a 32-bit or signed 16-bit image, performs an absolute value transform, otherwise does nothing.

Overrides:
  `abs` in class `ImageProcessor`

### min

public void min(double value)
Description copied from class: `ImageProcessor`
Pixels less than 'value' are set to 'value'.

Overrides:
  `min` in class `ImageProcessor`

### max

public void max(double value)
Description copied from class: `ImageProcessor`
Pixels greater than 'value' are set to 'value'.

Overrides:
  `max` in class `ImageProcessor`

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

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

### convolve3x3

public void convolve3x3(int[] kernel)
Does 3x3 convolution.

Specified by:
  `convolve3x3` in class `ImageProcessor`

### filter

public void filter(int type)
Filters using a 3x3 neighborhood.

Specified by:
  `filter` in class `ImageProcessor`

### rotate

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

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

### flipVertical

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

Specified by:
  `flipVertical` in class `ImageProcessor`

### noise

public void noise(double standardDeviation)
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`

### crop

public ImageProcessor crop()
Description copied from class: `ImageProcessor`
Creates 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`

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

### resize

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

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

### getBicubicInterpolatedPixel

public double getBicubicInterpolatedPixel(double x0, double y0, ImageProcessor ip2)
This method is from Chapter 16 of "Digital Image Processing: An Algorithmic Introduction Using Java" by Burger and Burge (http://www.imagingbook.com/).

Overrides:
  `getBicubicInterpolatedPixel` in class `ImageProcessor`

### setColor

public void setColor(Color color)
Sets the foreground fill/draw color.

Specified by:
  `setColor` in class `ImageProcessor`

### setValue

public void setValue(double value)
Sets the default fill/draw value.

Specified by:
  `setValue` in class `ImageProcessor`

### setBackgroundValue

public void setBackgroundValue(double value)
Does nothing. The rotate() and scale() methods always zero fill.

Specified by:
  `setBackgroundValue` in class `ImageProcessor`

### getBackgroundValue

public double getBackgroundValue()
Always returns 0.

Specified by:
  `getBackgroundValue` in class `ImageProcessor`

### setThreshold

public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate)
Description copied from class: `ImageProcessor`
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.

Overrides:
  `setThreshold` in class `ImageProcessor`

### convolve

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

Specified by:
  `convolve` in class `ImageProcessor`

### threshold

public void threshold(int level)
Not implemented.

Specified by:
  `threshold` in class `ImageProcessor`

### autoThreshold

public void autoThreshold()
Not implemented.

Overrides:
  `autoThreshold` in class `ImageProcessor`

### medianFilter

public void medianFilter()
Not implemented.

Specified by:
  `medianFilter` in class `ImageProcessor`

### getHistogram

public int[] getHistogram()
Not implemented.

Specified by:
  `getHistogram` in class `ImageProcessor`

### erode

public void erode()
Not implemented.

Specified by:
  `erode` in class `ImageProcessor`

### dilate

public void dilate()
Not implemented.

Specified by:
  `dilate` in class `ImageProcessor`

### toFloat

public FloatProcessor toFloat(int channelNumber, FloatProcessor fp)
Returns this FloatProcessor.

Specified by:
  `toFloat` in class `ImageProcessor`
Parameters:
  `channelNumber` - Ignored (needed for compatibility with ColorProcessor.toFloat)
  `fp` - Ignored (needed for compatibility with the other ImageProcessor types).
Returns:
  This FloatProcessor

### setPixels

public void setPixels(int channelNumber, FloatProcessor fp)
Sets the pixels, and min&max values from a FloatProcessor. Also the values are taken from the FloatProcessor.

Specified by:
  `setPixels` in class `ImageProcessor`
Parameters:
  `channelNumber` - Ignored (needed for compatibility with ColorProcessor.toFloat)
  `fp` - The FloatProcessor where the image data are read from.

### minValue

public double minValue()
Returns the smallest possible positive nonzero pixel value.

Overrides:
  `minValue` in class `ImageProcessor`

### maxValue

public double maxValue()
Returns the largest possible positive finite pixel value.

Overrides:
  `maxValue` in class `ImageProcessor`

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