ByteProcessor (ImageJ API)

java.lang.Object
- ij.process.ImageProcessor
- - ij.process.ByteProcessor

All Implemented Interfaces:

Cloneable

Direct Known Subclasses:

BinaryProcessor
```
public class ByteProcessor
extends ImageProcessor
```
This is an 8-bit image and methods that operate on that image. Based on the ImageProcessor class from "KickAss Java Programming" by Tonny Espeset.

Field Summary

Fields
Modifier and Type Field Description

protected byte[] pixels

protected byte[] 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, FIND_EDGES, fmGraphics, 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, rnd, roiHeight, roiWidth, roiX, roiY, sampleModel, seed, snapshotHeight, snapshotWidth, source, width, xMax, xMin, yMax, yMin

Fields
Modifier and Type	Field	Description
`protected byte[]`	`pixels`
`protected byte[]`	`snapshotPixels`

Constructor Summary

Constructors
Constructor	Description
`ByteProcessor(int width, int height)`	Creates a blank ByteProcessor of the specified dimensions.
`ByteProcessor(int width, int height, byte[] pixels)`	Creates a ByteProcessor from a byte array.
`ByteProcessor(int width, int height, byte[] pixels, ColorModel cm)`	Creates a ByteProcessor from a pixel array and IndexColorModel.
`ByteProcessor(ImageProcessor ip, boolean scale)`	Creates a ByteProcessor from an ImageProcessor.
`ByteProcessor(Image img)`	Creates a ByteProcessor from an AWT Image.
`ByteProcessor(BufferedImage bi)`	Creates a ByteProcessor from a TYPE_BYTE_GRAY BufferedImage.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`applyLut()`
`void`	`applyTable(int[] lut)`	Transforms the image or ROI using a lookup table.
`void`	`convolve(float[] kernel, int kernelWidth, int kernelHeight)`	Performs a convolution operation using the specified kernel.
`void`	`convolve3x3(int[] kernel)`	Convolves the image or ROI with the specified 3x3 integer convolution kernel.
`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.
`ByteProcessor`	`createMask()`	Returns a binary mask, or null if a threshold is not set.
`ImageProcessor`	`createProcessor(int width, int height)`	Returns a new, blank ByteProcessor 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`	`dilate(int count, int background)`
`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`	`erode(int count, int background)`
`void`	`fill(ImageProcessor mask)`	Sets pixels that are within roi and part of the mask to the foreground color.
`void`	`filter(int type)`	Filters using a 3x3 neighborhood.
`void`	`flipVertical()`	Flips the image or ROI vertically.
`int`	`get(int index)`
`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`	`getBitDepth()`	Returns the bit depth, 8, 16, 24 (RGB) or 32.
`BufferedImage`	`getBufferedImage()`	Returns this image as a BufferedImage.
`float`	`getf(int index)`
`float`	`getf(int x, int y)`	Returns the value of the pixel at (x,y) as a float.
`int[]`	`getHistogram()`	Returns the histogram of the image or ROI.
`int[]`	`getHistogram(ImageProcessor mask)`
`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 the value of the pixel at (x,y).
`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 byte 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).
`Object`	`getSnapshotPixels()`	Returns a reference to the snapshot (undo) buffer, or null.
`boolean`	`isBinary()`	Returns 'true' if this is a binary image (8-bit-image with only 0 and 255).
`void`	`medianFilter()`	A 3x3 median filter.
`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`	`outline()`
`void`	`putPixel(int x, int y, int value)`	Stores the specified value at (x,y).
`void`	`putPixelValue(int x, int y, double value)`	Stores the specified real value at (x,y).
`void`	`reset()`	Reset the image from snapshot.
`void`	`reset(ImageProcessor mask)`	Restore pixels that are within roi but not part of mask.
`void`	`resetMinAndMax()`	Resets this image's LUT.
`ImageProcessor`	`resize(int dstWidth, int dstHeight)`	Creates a new ByteProcessor 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(int index, int value)`
`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)`	Sets the background fill value, where 0<=value<=255.
`void`	`setColor(Color color)`	Sets the foreground drawing color.
`void`	`setf(int index, float value)`
`void`	`setf(int x, int y, float value)`	Sets the value of the pixel at (x,y) to 'value'.
`void`	`setFromFloatArrays(float[][] arrays)`
`void`	`setFromFloatProcessors(FloatProcessor[] fp)`
`void`	`setMinAndMax(double min, double max)`	Maps the entries in this image's LUT from min-max to 0-255.
`void`	`setPixels(int channelNumber, FloatProcessor fp)`	Sets the pixels from a FloatProcessor, no scaling.
`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, where 0<=value<=255.
`void`	`skeletonize()`
`void`	`snapshot()`	Make a snapshot of the current image.
`void`	`swapPixelArrays()`	Swaps the pixel and snapshot (undo) arrays.
`void`	`threshold(int level)`	Sets pixels less than or equal to level to 0 and all other pixels to 255.
`FloatProcessor`	`toFloat(int channelNumber, FloatProcessor fp)`	Returns a FloatProcessor with the same image, no scaling or calibration (pixel values 0 to 255).
`float[][]`	`toFloatArrays()`
`FloatProcessor[]`	`toFloatProcessors()`

Methods inherited from class ij.process.ImageProcessor
abs, add, add, and, applyMacro, autoThreshold, bin, blurGaussian, clone, convertToByte, convertToByteProcessor, convertToByteProcessor, convertToColorProcessor, convertToFloat, convertToFloatProcessor, convertToRGB, convertToShort, convertToShortProcessor, convertToShortProcessor, cubic, draw, drawDot, drawDot2, drawLine, drawLine4, drawOval, drawOverlay, drawPolygon, drawRect, drawRoi, drawString, drawString, drawString, exp, fill, fill, fillOutside, fillOval, fillPolygon, fillRect, findEdges, flipHorizontal, gamma, getAutoThreshold, getAutoThreshold, getBestIndex, getBicubicInterpolatedPixel, getCalibrationTable, getColorModel, 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, getNChannels, getNeighborhood, getOverlay, getPixel, getPixelCount, getProgressIncrement, getRoi, getRow, getRow, getSliceNumber, getStatistics, getStats, getStringBounds, getStringWidth, getThresholdColorModel, getWidth, hideProgress, insert, invert, invertLut, isColorLut, isDefaultLut, isGrayscale, isInvertedLut, isKillable, isPseudoColorLut, isSigned16Bit, lineTo, ln, log, makeDefaultColorModel, maskSizeError, max, maxValue, min, minValue, moveTo, multiply, or, putColumn, putPixel, putRow, putRow, resetBinaryThreshold, resetRoi, resetThreshold, resize, resize, resizeLinearly, rotateLeft, rotateRight, scaleAndSetThreshold, set, 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, setRandomSeed, setRoi, setRoi, setRoi, setRoi, setSliceNumber, setSnapshotCopyMode, setUnderColor, setUseBicubic, sharpen, showProgress, smooth, sqr, sqrt, subtract, toString, translate, translate, updateComposite, xor

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

- Field Detail
  - pixels
```
protected byte[] pixels
```
  - snapshotPixels
```
protected byte[] snapshotPixels
```
- Constructor Detail
  - ByteProcessor
```
public ByteProcessor(Image img)
```
    Creates a ByteProcessor from an AWT Image.
  - ByteProcessor
```
public ByteProcessor(int width,
                     int height)
```
    Creates a blank ByteProcessor of the specified dimensions.
  - ByteProcessor
```
public ByteProcessor(int width,
                     int height,
                     byte[] pixels)
```
    Creates a ByteProcessor from a byte array.
  - ByteProcessor
```
public ByteProcessor(int width,
                     int height,
                     byte[] pixels,
                     ColorModel cm)
```
    Creates a ByteProcessor from a pixel array and IndexColorModel.
  - ByteProcessor
```
public ByteProcessor(BufferedImage bi)
```
    Creates a ByteProcessor from a TYPE_BYTE_GRAY BufferedImage.
  - ByteProcessor
```
public ByteProcessor(ImageProcessor ip,
                     boolean scale)
```
    Creates a ByteProcessor from an ImageProcessor. 16-bit and 32-bit pixel data are scaled from min-max to 0-255 if 'scale' is true.
    
    See Also:
    
    ImageProcessor.convertToByteProcessor(), ImageProcessor.convertToShortProcessor(), ImageProcessor.convertToFloatProcessor(), ImageProcessor.convertToColorProcessor()
- Method Detail
  - 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
  - getBufferedImage
```
public BufferedImage getBufferedImage()
```
    Returns this image as a BufferedImage.
    
    Overrides:
    
    getBufferedImage in class ImageProcessor
  - createProcessor
```
public ImageProcessor createProcessor(int width,
                                      int height)
```
    Returns a new, blank ByteProcessor with the specified width and height.
    
    Specified by:
    
    createProcessor in class ImageProcessor
  - 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
  - snapshot
```
public void snapshot()
```
    Make a snapshot of the current image.
    
    Specified by:
    
    snapshot in class ImageProcessor
    
    See Also:
    
    ImageProcessor.reset(), ImageProcessor.reset(ImageProcessor)
  - reset
```
public void reset()
```
    Reset the image from snapshot.
    
    Specified by:
    
    reset in class ImageProcessor
  - swapPixelArrays
```
public void swapPixelArrays()
```
    Swaps the pixel and snapshot (undo) arrays.
    
    Specified by:
    
    swapPixelArrays in class ImageProcessor
  - reset
```
public void reset(ImageProcessor mask)
```
    Restore pixels that are within roi but not part of mask.
    
    Specified by:
    
    reset 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
  - fill
```
public void fill(ImageProcessor mask)
```
    Sets pixels that are within roi and part of the mask to the foreground color. Does nothing if the mask is not the same size as the ROI.
    
    Specified by:
    
    fill in class ImageProcessor
    
    See Also:
    
    ImageProcessor.setColor(Color), ImageProcessor.setValue(double), ImageProcessor.getMask(), ImageProcessor.fill(Roi)
  - 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.
    
    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 getPixelValue() 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
  - 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
  - getPixelValue
```
public float getPixelValue(int x,
                           int y)
```
    Description copied from class: ImageProcessor
    
    Returns the value of the pixel at (x,y). For byte and short images, returns a calibrated value if a calibration table has been set using setCalibraionTable(). For RGB images, returns the luminance value.
    
    Specified by:
    
    getPixelValue in class ImageProcessor
  - setColor
```
public void setColor(Color color)
```
    Sets the foreground drawing color.
    
    Specified by:
    
    setColor in class ImageProcessor
  - setValue
```
public void setValue(double value)
```
    Sets the default fill/draw value, where 0<=value<=255.
    
    Specified by:
    
    setValue in class ImageProcessor
  - setBackgroundValue
```
public void setBackgroundValue(double value)
```
    Sets the background fill value, where 0<=value<=255.
    
    Specified by:
    
    setBackgroundValue in class ImageProcessor
  - getBackgroundValue
```
public double getBackgroundValue()
```
    Returns the background fill value.
    
    Specified by:
    
    getBackgroundValue in class ImageProcessor
  - putPixelValue
```
public void putPixelValue(int x,
                          int y,
                          double value)
```
    Stores the specified real value at (x,y). Does nothing if (x,y) is outside the image boundary. Values outside the range 0-255 are clamped.
    
    Specified by:
    
    putPixelValue in class ImageProcessor
  - putPixel
```
public final void putPixel(int x,
                           int y,
                           int value)
```
    Stores the specified value at (x,y). Does nothing if (x,y) is outside the image boundary. Values outside the range 0-255 are clamped.
    
    Specified by:
    
    putPixel 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 byte array containing this image's pixel data. To avoid sign extension, the pixel values must be accessed using a mask (e.g. int i = pixels[j]&0xff).
    
    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
  - 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)
```
    Maps the entries in this image's LUT from min-max to 0-255.
    
    Specified by:
    
    setMinAndMax in class ImageProcessor
  - resetMinAndMax
```
public void resetMinAndMax()
```
    Resets this image's LUT.
    
    Overrides:
    
    resetMinAndMax 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
  - 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
  - convolve3x3
```
public void convolve3x3(int[] kernel)
```
    Description copied from class: ImageProcessor
    
    Convolves the image or ROI with the specified 3x3 integer convolution kernel.
    
    Specified by:
    
    convolve3x3 in class ImageProcessor
  - filter
```
public void filter(int type)
```
    Filters using a 3x3 neighborhood. The p1, p2, etc variables, which contain the values of the pixels in the neighborhood, are arranged as follows:
```
                    p1 p2 p3
                    p4 p5 p6
                    p7 p8 p9
                
```
    Specified by:
    
    filter 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
  - erode
```
public void erode(int count,
                  int background)
```
  - dilate
```
public void dilate(int count,
                   int background)
```
  - outline
```
public void outline()
```
  - skeletonize
```
public void skeletonize()
```
  - 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
  - noise
```
public void noise(double standardDeviation)
```
    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
  - 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 ByteProcessor containing a scaled copy of this image or selection.
    
    Specified by:
    
    resize in class ImageProcessor
    
    See Also:
    
    ImageProcessor.setInterpolate(boolean)
  - 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
  - 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)
```
  - threshold
```
public void threshold(int level)
```
    Sets pixels less than or equal to level to 0 and all other pixels to 255.
    
    Specified by:
    
    threshold in class ImageProcessor
  - applyLut
```
public void applyLut()
```
  - convolve
```
public void convolve(float[] kernel,
                     int kernelWidth,
                     int kernelHeight)
```
    Performs a convolution operation using the specified kernel.
    
    Specified by:
    
    convolve in class ImageProcessor
  - toFloatProcessors
```
public FloatProcessor[] toFloatProcessors()
```
  - setFromFloatProcessors
```
public void setFromFloatProcessors(FloatProcessor[] fp)
```
  - toFloatArrays
```
public float[][] toFloatArrays()
```
  - setFromFloatArrays
```
public void setFromFloatArrays(float[][] arrays)
```
  - toFloat
```
public FloatProcessor toFloat(int channelNumber,
                              FloatProcessor fp)
```
    Returns a FloatProcessor with the same image, no scaling or calibration (pixel values 0 to 255). The roi, mask, lut (ColorModel), threshold, min&max are also set for the FloatProcessor
    
    Specified by:
    
    toFloat in class ImageProcessor
    
    Parameters:
    
    channelNumber - Ignored (needed for compatibility with ColorProcessor.toFloat)
    
    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
  - setPixels
```
public void setPixels(int channelNumber,
                      FloatProcessor fp)
```
    Sets the pixels from a FloatProcessor, no scaling. Also the min&max 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.
  - isBinary
```
public boolean isBinary()
```
    Returns 'true' if this is a binary image (8-bit-image with only 0 and 255).
    
    Overrides:
    
    isBinary 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
  - createMask
```
public ByteProcessor createMask()
```
    Returns a binary mask, or null if a threshold is not set.
    
    Overrides:
    
    createMask in class ImageProcessor
    
    See Also:
    
    ImagePlus.createThresholdMask(), ImagePlus.createRoiMask()

Class ByteProcessor

Field Summary

Fields inherited from class ij.process.ImageProcessor

Constructor Summary

Method Summary

Methods inherited from class ij.process.ImageProcessor

Methods inherited from class java.lang.Object

Field Detail

pixels

snapshotPixels

Constructor Detail

ByteProcessor

ByteProcessor

ByteProcessor

ByteProcessor

ByteProcessor

ByteProcessor

Method Detail

createImage

getBufferedImage

createProcessor

crop

duplicate

snapshot

reset

swapPixelArrays

reset

setSnapshotPixels

getSnapshotPixels

fill

getPixel

get

set

get

set

getf

setf

getf

setf

getInterpolatedPixel

getPixelInterpolated

getPixelValue

setColor

setValue

setBackgroundValue

getBackgroundValue

putPixelValue

putPixel

drawPixel

getPixels

getPixelsCopy

setPixels

getMin

getMax

setMinAndMax

resetMinAndMax

setThreshold

copyBits

applyTable

convolve3x3

filter

erode

dilate

erode

dilate

outline

skeletonize

medianFilter

noise

scale

resize

rotate

flipVertical

getHistogram

getHistogram

threshold

applyLut

convolve

toFloatProcessors

setFromFloatProcessors