loci.plugins.util

## Class RecordedImageProcessor

- java.lang.Object
- - ij.process.ImageProcessor
  - - loci.plugins.util.RecordedImageProcessor

- All Implemented Interfaces:
    java.lang.Cloneable

      public class RecordedImageProcessor
      extends ij.process.ImageProcessor

  Image processor extension that records commands executed upon it. Allows "recordable virtual stacks" that repeat operations performed on one image plane on other image planes when they are loaded from disk.
  Author:
    Melissa Linkert melissa at glencoesoftware.com

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `(package private) class` | `RecordedImageProcessor.MethodEntry`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private int` | `channelNumber`
    `private boolean` | `doRecording`
    `private java.util.List<RecordedImageProcessor.MethodEntry>` | `methodStack`
    `private ij.process.ImageProcessor[]` | `otherChannels`
    `private ij.process.ImageProcessor` | `proc`

    - ### 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 and Description
    `RecordedImageProcessor(ij.process.ImageProcessor proc)`
    `RecordedImageProcessor(ij.process.ImageProcessor proc, int channelNum, ij.process.ImageProcessor[] otherChannels)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `abs()`
    `void` | `add(double value)`
    `void` | `add(int value)`
    `void` | `and(int value)`
    `void` | `applyMethodStack(java.util.List<RecordedImageProcessor.MethodEntry> stack)`
    `void` | `applyTable(int[] lut)`
    `void` | `autoThreshold()`
    `ij.process.ImageProcessor` | `convertToByte(boolean doScaling)`
    `ij.process.ImageProcessor` | `convertToFloat()`
    `ij.process.ImageProcessor` | `convertToRGB()`
    `ij.process.ImageProcessor` | `convertToShort(boolean doScaling)`
    `void` | `convolve(float[] kernel, int kernelWidth, int kernelHeight)`
    `void` | `convolve3x3(int[] kernel)`
    `void` | `copyBits(ij.process.ImageProcessor ip, int xloc, int yloc, int mode)`
    `java.awt.Image` | `createImage()`
    `ij.process.ImageProcessor` | `createProcessor(int width, int height)`
    `ij.process.ImageProcessor` | `crop()`
    `void` | `dilate()`
    `void` | `drawDot(int xcenter, int ycenter)`
    `void` | `drawLine(int x1, int y1, int x2, int y2)`
    `void` | `drawOval(int x, int y, int width, int height)`
    `void` | `drawPixel(int x, int y)`
    `void` | `drawPolygon(java.awt.Polygon p)`
    `void` | `drawRect(int x, int y, int width, int height)`
    `void` | `drawString(java.lang.String s)`
    `void` | `drawString(java.lang.String s, int x, int y)`
    `ij.process.ImageProcessor` | `duplicate()`
    `void` | `erode()`
    `void` | `exp()`
    `void` | `fill()`
    `void` | `fill(ij.process.ImageProcessor mask)`
    `void` | `fillOval(int x, int y, int width, int height)`
    `void` | `fillPolygon(java.awt.Polygon p)`
    `void` | `filter(int type)`
    `void` | `findEdges()`
    `void` | `flipHorizontal()`
    `void` | `flipVertical()`
    `void` | `gamma(double value)`
    `int` | `get(int index)`
    `int` | `get(int x, int y)`
    `int` | `getAutoThreshold()`
    `int` | `getAutoThreshold(int[] histogram)`
    `double` | `getBackgroundValue()`
    `int` | `getBestIndex(java.awt.Color c)`
    `java.awt.image.BufferedImage` | `getBufferedImage()`
    `float[]` | `getCalibrationTable()`
    `ij.process.ImageProcessor` | `getChild()`
    `java.awt.image.ColorModel` | `getColorModel()`
    `void` | `getColumn(int x, int y, int[] data, int length)`
    `java.awt.image.ColorModel` | `getCurrentColorModel()`
    `java.awt.image.IndexColorModel` | `getDefaultColorModel()`
    `float` | `getf(int index)`
    `float` | `getf(int x, int y)`
    `float[][]` | `getFloatArray()`
    `java.awt.FontMetrics` | `getFontMetrics()`
    `double` | `getForegroundValue()`
    `int` | `getHeight()`
    `int[]` | `getHistogram()`
    `double` | `getHistogramMax()`
    `double` | `getHistogramMin()`
    `int` | `getHistogramSize()`
    `int[][]` | `getIntArray()`
    `boolean` | `getInterpolate()`
    `double` | `getInterpolatedPixel(double x, double y)`
    `double[]` | `getLine(double x1, double y1, double x2, double y2)`
    `int` | `getLutUpdateMode()`
    `ij.process.ImageProcessor` | `getMask()`
    `byte[]` | `getMaskArray()`
    `double` | `getMax()`
    `double` | `getMaxThreshold()`
    `java.util.List<RecordedImageProcessor.MethodEntry>` | `getMethodStack()`
    `double` | `getMin()`
    `double` | `getMinThreshold()`
    `int` | `getNChannels()`
    `int` | `getPixel(int x, int y)`
    `int[]` | `getPixel(int x, int y, int[] iArray)`
    `int` | `getPixelCount()`
    `int` | `getPixelInterpolated(double x, double y)`
    `java.lang.Object` | `getPixels()`
    `java.lang.Object` | `getPixelsCopy()`
    `float` | `getPixelValue(int x, int y)`
    `java.awt.Rectangle` | `getRoi()`
    `void` | `getRow(int x, int y, int[] data, int length)`
    `java.lang.Object` | `getSnapshotPixels()`
    `int` | `getStringWidth(java.lang.String s)`
    `int` | `getWidth()`
    `void` | `insert(ij.process.ImageProcessor ip, int xloc, int yloc)`
    `void` | `invert()`
    `void` | `invertLut()`
    `boolean` | `isColorLut()`
    `boolean` | `isInvertedLut()`
    `boolean` | `isPseudoColorLut()`
    `void` | `lineTo(int x2, int y2)`
    `void` | `log()`
    `void` | `max(double value)`
    `double` | `maxValue()`
    `void` | `medianFilter()`
    `void` | `min(double value)`
    `double` | `minValue()`
    `void` | `moveTo(int x, int y)`
    `void` | `multiply(double value)`
    `void` | `noise(double range)`
    `void` | `or(int value)`
    `void` | `putColumn(int x, int y, int[] data, int length)`
    `void` | `putPixel(int x, int y, int value)`
    `void` | `putPixel(int x, int y, int[] iArray)`
    `void` | `putPixelValue(int x, int y, double value)`
    `void` | `putRow(int x, int y, int[] data, int length)`
    `private void` | `record(java.lang.String method)`
    `private void` | `record(java.lang.String method, java.lang.Object[] v, java.lang.Class<?>[] c)`
    `private void` | `record(java.lang.String method, java.lang.Object v, java.lang.Class<?> c)`
    `void` | `reset()`
    `void` | `reset(ij.process.ImageProcessor mask)`
    `void` | `resetBinaryThreshold()`
    `void` | `resetMinAndMax()`
    `void` | `resetRoi()`
    `void` | `resetThreshold()`
    `ij.process.ImageProcessor` | `resize(int dstWidth)`
    `ij.process.ImageProcessor` | `resize(int dstWidth, int dstHeight)`
    `void` | `rotate(double angle)`
    `ij.process.ImageProcessor` | `rotateLeft()`
    `ij.process.ImageProcessor` | `rotateRight()`
    `void` | `scale(double xScale, double yScale)`
    `void` | `set(int index, int value)`
    `void` | `set(int x, int y, int value)`
    `void` | `setAntialiasedText(boolean antialiased)`
    `void` | `setAutoThreshold(int method, int lutUpdate)`
    `void` | `setBackgroundValue(double value)`
    `void` | `setCalibrationTable(float[] ctable)`
    `void` | `setClipRect(java.awt.Rectangle clipRect)`
    `void` | `setColor(java.awt.Color color)`
    `void` | `setColor(int value)`
    `void` | `setColorModel(java.awt.image.ColorModel cm)`
    `void` | `setDoRecording(boolean doRecording)`
    `void` | `setf(int index, float value)`
    `void` | `setf(int x, int y, float value)`
    `void` | `setFloatArray(float[][] a)`
    `void` | `setFont(java.awt.Font font)`
    `void` | `setHistogramRange(double histMin, double histMax)`
    `void` | `setHistogramSize(int size)`
    `void` | `setIntArray(int[][] a)`
    `void` | `setInterpolate(boolean interpolate)`
    `void` | `setJustification(int justification)`
    `void` | `setLineWidth(int width)`
    `void` | `setLutAnimation(boolean lutAnimation)`
    `void` | `setMask(ij.process.ImageProcessor mask)`
    `void` | `setMinAndMax(double min, double max)`
    `void` | `setPixels(int channelNumber, ij.process.FloatProcessor fp)`
    `void` | `setPixels(java.lang.Object pixels)`
    `void` | `setProgressBar(ij.gui.ProgressBar pb)`
    `void` | `setRoi(int x, int y, int rwidth, int rheight)`
    `void` | `setRoi(java.awt.Polygon roi)`
    `void` | `setRoi(java.awt.Rectangle roi)`
    `void` | `setRoi(ij.gui.Roi roi)`
    `void` | `setSnapshotCopyMode(boolean b)`
    `void` | `setSnapshotPixels(java.lang.Object pixels)`
    `void` | `setThreshold(double minThreshold, double maxThreshold, int lutUpdate)`
    `void` | `setValue(double value)`
    `void` | `sharpen()`
    `void` | `smooth()`
    `void` | `snapshot()`
    `void` | `sqr()`
    `void` | `sqrt()`
    `void` | `swapPixelArrays()`
    `void` | `threshold(int level)`
    `ij.process.FloatProcessor` | `toFloat(int channelNumber, ij.process.FloatProcessor fp)`
    `java.lang.String` | `toString()`
    `void` | `translate(int xOffset, int yOffset)`
    `void` | `updateComposite(int[] rgbPixels, int channel)`
    `void` | `xor(int value)`

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

      `applyMacro, bin, blurGaussian, clone, convertToByteProcessor, convertToByteProcessor, convertToColorProcessor, convertToFloatProcessor, convertToShortProcessor, convertToShortProcessor, createMask, cubic, draw, drawDot2, drawLine4, drawOverlay, drawRoi, drawString, fill, fillOutside, fillRect, fillValueSet, getBicubicInterpolatedPixel, getBitDepth, getColumn, getFont, getHistogram, getIndexSampleModel, getInterpolatedValue, getInterpolationMethod, getInterpolationMethods, getLineWidth, getLut, getNeighborhood, getOverlay, getProgressIncrement, getRow, getSliceNumber, getStatistics, getStats, getStringBounds, getThresholdColorModel, getValue, hideProgress, isBinary, isDefaultLut, isGrayscale, isKillable, isSigned16Bit, isThreshold, ln, makeDefaultColorModel, maskSizeError, putColumn, putRow, resize, resizeLinearly, scaleAndSetThreshold, set, setAutoThreshold, setAutoThreshold, setAutoThreshold, setAutoThreshold, setBackgroundColor, setBinaryThreshold, setColor, setColor, setFontSize, setGlobalBackgroundColor, setGlobalForegroundColor, setInterpolationMethod, setLut, setOverColor, setOverlay, setRandomSeed, setSliceNumber, setThreshold, setUnderColor, setUseBicubic, showProgress, subtract, threshold, translate, translate`

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

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

- - ### Field Detail

    - #### proc

          private ij.process.ImageProcessor proc

    - #### doRecording

          private boolean doRecording

    - #### methodStack

          private java.util.List<RecordedImageProcessor.MethodEntry> methodStack

    - #### channelNumber

          private int channelNumber

    - #### otherChannels

          private ij.process.ImageProcessor[] otherChannels

  - ### Constructor Detail

    - #### RecordedImageProcessor

          public RecordedImageProcessor(ij.process.ImageProcessor proc)

    - #### RecordedImageProcessor

          public RecordedImageProcessor(ij.process.ImageProcessor proc,
                                        int channelNum,
                                        ij.process.ImageProcessor[] otherChannels)

  - ### Method Detail

    - #### setDoRecording

          public void setDoRecording(boolean doRecording)

    - #### getMethodStack

          public java.util.List<RecordedImageProcessor.MethodEntry> getMethodStack()

    - #### applyMethodStack

          public void applyMethodStack(java.util.List<RecordedImageProcessor.MethodEntry> stack)

    - #### getChild

          public ij.process.ImageProcessor getChild()

    - #### abs

          public void abs()

      Overrides:
        `abs` in class `ij.process.ImageProcessor`

    - #### add

          public void add(double value)

      Overrides:
        `add` in class `ij.process.ImageProcessor`

    - #### add

          public void add(int value)

      Overrides:
        `add` in class `ij.process.ImageProcessor`

    - #### and

          public void and(int value)

      Overrides:
        `and` in class `ij.process.ImageProcessor`

    - #### applyTable

          public void applyTable(int[] lut)

      Specified by:
        `applyTable` in class `ij.process.ImageProcessor`

    - #### autoThreshold

          public void autoThreshold()

      Overrides:
        `autoThreshold` in class `ij.process.ImageProcessor`

    - #### convertToByte

          public ij.process.ImageProcessor convertToByte(boolean doScaling)

      Overrides:
        `convertToByte` in class `ij.process.ImageProcessor`

    - #### convertToFloat

          public ij.process.ImageProcessor convertToFloat()

      Overrides:
        `convertToFloat` in class `ij.process.ImageProcessor`

    - #### convertToRGB

          public ij.process.ImageProcessor convertToRGB()

      Overrides:
        `convertToRGB` in class `ij.process.ImageProcessor`

    - #### convertToShort

          public ij.process.ImageProcessor convertToShort(boolean doScaling)

      Overrides:
        `convertToShort` in class `ij.process.ImageProcessor`

    - #### convolve

          public void convolve(float[] kernel,
                               int kernelWidth,
                               int kernelHeight)

      Specified by:
        `convolve` in class `ij.process.ImageProcessor`

    - #### convolve3x3

          public void convolve3x3(int[] kernel)

      Specified by:
        `convolve3x3` in class `ij.process.ImageProcessor`

    - #### copyBits

          public void copyBits(ij.process.ImageProcessor ip,
                               int xloc,
                               int yloc,
                               int mode)

      Specified by:
        `copyBits` in class `ij.process.ImageProcessor`

    - #### createImage

          public java.awt.Image createImage()

      Specified by:
        `createImage` in class `ij.process.ImageProcessor`

    - #### createProcessor

          public ij.process.ImageProcessor createProcessor(int width,
                                                           int height)

      Specified by:
        `createProcessor` in class `ij.process.ImageProcessor`

    - #### crop

          public ij.process.ImageProcessor crop()

      Specified by:
        `crop` in class `ij.process.ImageProcessor`

    - #### dilate

          public void dilate()

      Specified by:
        `dilate` in class `ij.process.ImageProcessor`

    - #### drawDot

          public void drawDot(int xcenter,
                              int ycenter)

      Overrides:
        `drawDot` in class `ij.process.ImageProcessor`

    - #### drawLine

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

      Overrides:
        `drawLine` in class `ij.process.ImageProcessor`

    - #### drawOval

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

      Overrides:
        `drawOval` in class `ij.process.ImageProcessor`

    - #### drawPixel

          public void drawPixel(int x,
                                int y)

      Specified by:
        `drawPixel` in class `ij.process.ImageProcessor`

    - #### drawPolygon

          public void drawPolygon(java.awt.Polygon p)

      Overrides:
        `drawPolygon` in class `ij.process.ImageProcessor`

    - #### drawRect

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

      Overrides:
        `drawRect` in class `ij.process.ImageProcessor`

    - #### drawString

          public void drawString(java.lang.String s)

      Overrides:
        `drawString` in class `ij.process.ImageProcessor`

    - #### drawString

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

      Overrides:
        `drawString` in class `ij.process.ImageProcessor`

    - #### duplicate

          public ij.process.ImageProcessor duplicate()

      Specified by:
        `duplicate` in class `ij.process.ImageProcessor`

    - #### erode

          public void erode()

      Specified by:
        `erode` in class `ij.process.ImageProcessor`

    - #### exp

          public void exp()

      Overrides:
        `exp` in class `ij.process.ImageProcessor`

    - #### fill

          public void fill()

      Overrides:
        `fill` in class `ij.process.ImageProcessor`

    - #### fill

          public void fill(ij.process.ImageProcessor mask)

      Specified by:
        `fill` in class `ij.process.ImageProcessor`

    - #### fillOval

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

      Overrides:
        `fillOval` in class `ij.process.ImageProcessor`

    - #### fillPolygon

          public void fillPolygon(java.awt.Polygon p)

      Overrides:
        `fillPolygon` in class `ij.process.ImageProcessor`

    - #### filter

          public void filter(int type)

      Specified by:
        `filter` in class `ij.process.ImageProcessor`

    - #### findEdges

          public void findEdges()

      Overrides:
        `findEdges` in class `ij.process.ImageProcessor`

    - #### flipHorizontal

          public void flipHorizontal()

      Overrides:
        `flipHorizontal` in class `ij.process.ImageProcessor`

    - #### flipVertical

          public void flipVertical()

      Specified by:
        `flipVertical` in class `ij.process.ImageProcessor`

    - #### gamma

          public void gamma(double value)

      Overrides:
        `gamma` in class `ij.process.ImageProcessor`

    - #### get

          public int get(int index)

      Specified by:
        `get` in class `ij.process.ImageProcessor`

    - #### get

          public int get(int x,
                         int y)

      Specified by:
        `get` in class `ij.process.ImageProcessor`

    - #### getAutoThreshold

          public int getAutoThreshold()

      Overrides:
        `getAutoThreshold` in class `ij.process.ImageProcessor`

    - #### getBackgroundValue

          public double getBackgroundValue()

      Specified by:
        `getBackgroundValue` in class `ij.process.ImageProcessor`

    - #### getForegroundValue

          public double getForegroundValue()

      Specified by:
        `getForegroundValue` in class `ij.process.ImageProcessor`

    - #### getAutoThreshold

          public int getAutoThreshold(int[] histogram)

      Overrides:
        `getAutoThreshold` in class `ij.process.ImageProcessor`

    - #### getBestIndex

          public int getBestIndex(java.awt.Color c)

      Overrides:
        `getBestIndex` in class `ij.process.ImageProcessor`

    - #### getBufferedImage

          public java.awt.image.BufferedImage getBufferedImage()

      Overrides:
        `getBufferedImage` in class `ij.process.ImageProcessor`

    - #### getCalibrationTable

          public float[] getCalibrationTable()

      Overrides:
        `getCalibrationTable` in class `ij.process.ImageProcessor`

    - #### getColorModel

          public java.awt.image.ColorModel getColorModel()

      Overrides:
        `getColorModel` in class `ij.process.ImageProcessor`

    - #### getColumn

          public void getColumn(int x,
                                int y,
                                int[] data,
                                int length)

      Overrides:
        `getColumn` in class `ij.process.ImageProcessor`

    - #### getCurrentColorModel

          public java.awt.image.ColorModel getCurrentColorModel()

      Overrides:
        `getCurrentColorModel` in class `ij.process.ImageProcessor`

    - #### getDefaultColorModel

          public java.awt.image.IndexColorModel getDefaultColorModel()

      Overrides:
        `getDefaultColorModel` in class `ij.process.ImageProcessor`

    - #### getf

          public float getf(int index)

      Specified by:
        `getf` in class `ij.process.ImageProcessor`

    - #### getf

          public float getf(int x,
                            int y)

      Specified by:
        `getf` in class `ij.process.ImageProcessor`

    - #### getFloatArray

          public float[][] getFloatArray()

      Overrides:
        `getFloatArray` in class `ij.process.ImageProcessor`

    - #### getFontMetrics

          public java.awt.FontMetrics getFontMetrics()

      Overrides:
        `getFontMetrics` in class `ij.process.ImageProcessor`

    - #### getHeight

          public int getHeight()

      Overrides:
        `getHeight` in class `ij.process.ImageProcessor`

    - #### getHistogram

          public int[] getHistogram()

      Specified by:
        `getHistogram` in class `ij.process.ImageProcessor`

    - #### getHistogramMax

          public double getHistogramMax()

      Overrides:
        `getHistogramMax` in class `ij.process.ImageProcessor`

    - #### getHistogramMin

          public double getHistogramMin()

      Overrides:
        `getHistogramMin` in class `ij.process.ImageProcessor`

    - #### getHistogramSize

          public int getHistogramSize()

      Overrides:
        `getHistogramSize` in class `ij.process.ImageProcessor`

    - #### getIntArray

          public int[][] getIntArray()

      Overrides:
        `getIntArray` in class `ij.process.ImageProcessor`

    - #### getInterpolate

          public boolean getInterpolate()

      Overrides:
        `getInterpolate` in class `ij.process.ImageProcessor`

    - #### getInterpolatedPixel

          public double getInterpolatedPixel(double x,
                                             double y)

      Specified by:
        `getInterpolatedPixel` in class `ij.process.ImageProcessor`

    - #### getLine

          public double[] getLine(double x1,
                                  double y1,
                                  double x2,
                                  double y2)

      Overrides:
        `getLine` in class `ij.process.ImageProcessor`

    - #### getLutUpdateMode

          public int getLutUpdateMode()

      Overrides:
        `getLutUpdateMode` in class `ij.process.ImageProcessor`

    - #### getMask

          public ij.process.ImageProcessor getMask()

      Overrides:
        `getMask` in class `ij.process.ImageProcessor`

    - #### getMaskArray

          public byte[] getMaskArray()

      Overrides:
        `getMaskArray` in class `ij.process.ImageProcessor`

    - #### getMax

          public double getMax()

      Specified by:
        `getMax` in class `ij.process.ImageProcessor`

    - #### getMaxThreshold

          public double getMaxThreshold()

      Overrides:
        `getMaxThreshold` in class `ij.process.ImageProcessor`

    - #### getMin

          public double getMin()

      Specified by:
        `getMin` in class `ij.process.ImageProcessor`

    - #### getMinThreshold

          public double getMinThreshold()

      Overrides:
        `getMinThreshold` in class `ij.process.ImageProcessor`

    - #### getNChannels

          public int getNChannels()

      Overrides:
        `getNChannels` in class `ij.process.ImageProcessor`

    - #### getPixel

          public int getPixel(int x,
                              int y)

      Specified by:
        `getPixel` in class `ij.process.ImageProcessor`

    - #### getPixel

          public int[] getPixel(int x,
                                int y,
                                int[] iArray)

      Overrides:
        `getPixel` in class `ij.process.ImageProcessor`

    - #### getPixelInterpolated

          public int getPixelInterpolated(double x,
                                          double y)

      Specified by:
        `getPixelInterpolated` in class `ij.process.ImageProcessor`

    - #### getPixelCount

          public int getPixelCount()

      Overrides:
        `getPixelCount` in class `ij.process.ImageProcessor`

    - #### getPixels

          public java.lang.Object getPixels()

      Specified by:
        `getPixels` in class `ij.process.ImageProcessor`

    - #### getPixelsCopy

          public java.lang.Object getPixelsCopy()

      Specified by:
        `getPixelsCopy` in class `ij.process.ImageProcessor`

    - #### getPixelValue

          public float getPixelValue(int x,
                                     int y)

      Specified by:
        `getPixelValue` in class `ij.process.ImageProcessor`

    - #### getRoi

          public java.awt.Rectangle getRoi()

      Overrides:
        `getRoi` in class `ij.process.ImageProcessor`

    - #### getRow

          public void getRow(int x,
                             int y,
                             int[] data,
                             int length)

      Overrides:
        `getRow` in class `ij.process.ImageProcessor`

    - #### getSnapshotPixels

          public java.lang.Object getSnapshotPixels()

      Specified by:
        `getSnapshotPixels` in class `ij.process.ImageProcessor`

    - #### getStringWidth

          public int getStringWidth(java.lang.String s)

      Overrides:
        `getStringWidth` in class `ij.process.ImageProcessor`

    - #### getWidth

          public int getWidth()

      Overrides:
        `getWidth` in class `ij.process.ImageProcessor`

    - #### insert

          public void insert(ij.process.ImageProcessor ip,
                             int xloc,
                             int yloc)

      Overrides:
        `insert` in class `ij.process.ImageProcessor`

    - #### invert

          public void invert()

      Overrides:
        `invert` in class `ij.process.ImageProcessor`

    - #### invertLut

          public void invertLut()

      Overrides:
        `invertLut` in class `ij.process.ImageProcessor`

    - #### isColorLut

          public boolean isColorLut()

      Overrides:
        `isColorLut` in class `ij.process.ImageProcessor`

    - #### isInvertedLut

          public boolean isInvertedLut()

      Overrides:
        `isInvertedLut` in class `ij.process.ImageProcessor`

    - #### isPseudoColorLut

          public boolean isPseudoColorLut()

      Overrides:
        `isPseudoColorLut` in class `ij.process.ImageProcessor`

    - #### lineTo

          public void lineTo(int x2,
                             int y2)

      Overrides:
        `lineTo` in class `ij.process.ImageProcessor`

    - #### log

          public void log()

      Overrides:
        `log` in class `ij.process.ImageProcessor`

    - #### max

          public void max(double value)

      Overrides:
        `max` in class `ij.process.ImageProcessor`

    - #### maxValue

          public double maxValue()

      Overrides:
        `maxValue` in class `ij.process.ImageProcessor`

    - #### medianFilter

          public void medianFilter()

      Specified by:
        `medianFilter` in class `ij.process.ImageProcessor`

    - #### min

          public void min(double value)

      Overrides:
        `min` in class `ij.process.ImageProcessor`

    - #### minValue

          public double minValue()

      Overrides:
        `minValue` in class `ij.process.ImageProcessor`

    - #### moveTo

          public void moveTo(int x,
                             int y)

      Overrides:
        `moveTo` in class `ij.process.ImageProcessor`

    - #### multiply

          public void multiply(double value)

      Overrides:
        `multiply` in class `ij.process.ImageProcessor`

    - #### noise

          public void noise(double range)

      Specified by:
        `noise` in class `ij.process.ImageProcessor`

    - #### or

          public void or(int value)

      Overrides:
        `or` in class `ij.process.ImageProcessor`

    - #### putColumn

          public void putColumn(int x,
                                int y,
                                int[] data,
                                int length)

      Overrides:
        `putColumn` in class `ij.process.ImageProcessor`

    - #### putPixel

          public void putPixel(int x,
                               int y,
                               int value)

      Specified by:
        `putPixel` in class `ij.process.ImageProcessor`

    - #### putPixel

          public void putPixel(int x,
                               int y,
                               int[] iArray)

      Overrides:
        `putPixel` in class `ij.process.ImageProcessor`

    - #### putPixelValue

          public void putPixelValue(int x,
                                    int y,
                                    double value)

      Specified by:
        `putPixelValue` in class `ij.process.ImageProcessor`

    - #### putRow

          public void putRow(int x,
                             int y,
                             int[] data,
                             int length)

      Overrides:
        `putRow` in class `ij.process.ImageProcessor`

    - #### reset

          public void reset()

      Specified by:
        `reset` in class `ij.process.ImageProcessor`

    - #### reset

          public void reset(ij.process.ImageProcessor mask)

      Specified by:
        `reset` in class `ij.process.ImageProcessor`

    - #### resetBinaryThreshold

          public void resetBinaryThreshold()

      Overrides:
        `resetBinaryThreshold` in class `ij.process.ImageProcessor`

    - #### resetMinAndMax

          public void resetMinAndMax()

      Overrides:
        `resetMinAndMax` in class `ij.process.ImageProcessor`

    - #### resetRoi

          public void resetRoi()

      Overrides:
        `resetRoi` in class `ij.process.ImageProcessor`

    - #### resetThreshold

          public void resetThreshold()

      Overrides:
        `resetThreshold` in class `ij.process.ImageProcessor`

    - #### resize

          public ij.process.ImageProcessor resize(int dstWidth)

      Overrides:
        `resize` in class `ij.process.ImageProcessor`

    - #### resize

          public ij.process.ImageProcessor resize(int dstWidth,
                                                  int dstHeight)

      Specified by:
        `resize` in class `ij.process.ImageProcessor`

    - #### rotate

          public void rotate(double angle)

      Specified by:
        `rotate` in class `ij.process.ImageProcessor`

    - #### rotateLeft

          public ij.process.ImageProcessor rotateLeft()

      Overrides:
        `rotateLeft` in class `ij.process.ImageProcessor`

    - #### rotateRight

          public ij.process.ImageProcessor rotateRight()

      Overrides:
        `rotateRight` in class `ij.process.ImageProcessor`

    - #### scale

          public void scale(double xScale,
                            double yScale)

      Specified by:
        `scale` in class `ij.process.ImageProcessor`

    - #### set

          public void set(int index,
                          int value)

      Specified by:
        `set` in class `ij.process.ImageProcessor`

    - #### set

          public void set(int x,
                          int y,
                          int value)

      Specified by:
        `set` in class `ij.process.ImageProcessor`

    - #### setAntialiasedText

          public void setAntialiasedText(boolean antialiased)

      Overrides:
        `setAntialiasedText` in class `ij.process.ImageProcessor`

    - #### setAutoThreshold

          public void setAutoThreshold(int method,
                                       int lutUpdate)

      Overrides:
        `setAutoThreshold` in class `ij.process.ImageProcessor`

    - #### setBackgroundValue

          public void setBackgroundValue(double value)

      Specified by:
        `setBackgroundValue` in class `ij.process.ImageProcessor`

    - #### setCalibrationTable

          public void setCalibrationTable(float[] ctable)

      Overrides:
        `setCalibrationTable` in class `ij.process.ImageProcessor`

    - #### setClipRect

          public void setClipRect(java.awt.Rectangle clipRect)

      Overrides:
        `setClipRect` in class `ij.process.ImageProcessor`

    - #### setColor

          public void setColor(java.awt.Color color)

      Specified by:
        `setColor` in class `ij.process.ImageProcessor`

    - #### setColor

          public void setColor(int value)

      Overrides:
        `setColor` in class `ij.process.ImageProcessor`

    - #### setColorModel

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

      Overrides:
        `setColorModel` in class `ij.process.ImageProcessor`

    - #### setf

          public void setf(int index,
                           float value)

      Specified by:
        `setf` in class `ij.process.ImageProcessor`

    - #### setf

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

      Specified by:
        `setf` in class `ij.process.ImageProcessor`

    - #### setFloatArray

          public void setFloatArray(float[][] a)

      Overrides:
        `setFloatArray` in class `ij.process.ImageProcessor`

    - #### setFont

          public void setFont(java.awt.Font font)

      Overrides:
        `setFont` in class `ij.process.ImageProcessor`

    - #### setHistogramRange

          public void setHistogramRange(double histMin,
                                        double histMax)

      Overrides:
        `setHistogramRange` in class `ij.process.ImageProcessor`

    - #### setHistogramSize

          public void setHistogramSize(int size)

      Overrides:
        `setHistogramSize` in class `ij.process.ImageProcessor`

    - #### setIntArray

          public void setIntArray(int[][] a)

      Overrides:
        `setIntArray` in class `ij.process.ImageProcessor`

    - #### setInterpolate

          public void setInterpolate(boolean interpolate)

      Overrides:
        `setInterpolate` in class `ij.process.ImageProcessor`

    - #### setJustification

          public void setJustification(int justification)

      Overrides:
        `setJustification` in class `ij.process.ImageProcessor`

    - #### setLineWidth

          public void setLineWidth(int width)

      Overrides:
        `setLineWidth` in class `ij.process.ImageProcessor`

    - #### setLutAnimation

          public void setLutAnimation(boolean lutAnimation)

      Overrides:
        `setLutAnimation` in class `ij.process.ImageProcessor`

    - #### setMask

          public void setMask(ij.process.ImageProcessor mask)

      Overrides:
        `setMask` in class `ij.process.ImageProcessor`

    - #### setMinAndMax

          public void setMinAndMax(double min,
                                   double max)

      Specified by:
        `setMinAndMax` in class `ij.process.ImageProcessor`

    - #### setPixels

          public void setPixels(int channelNumber,
                                ij.process.FloatProcessor fp)

      Specified by:
        `setPixels` in class `ij.process.ImageProcessor`

    - #### setPixels

          public void setPixels(java.lang.Object pixels)

      Specified by:
        `setPixels` in class `ij.process.ImageProcessor`

    - #### setProgressBar

          public void setProgressBar(ij.gui.ProgressBar pb)

      Overrides:
        `setProgressBar` in class `ij.process.ImageProcessor`

    - #### setRoi

          public void setRoi(int x,
                             int y,
                             int rwidth,
                             int rheight)

      Overrides:
        `setRoi` in class `ij.process.ImageProcessor`

    - #### setRoi

          public void setRoi(java.awt.Polygon roi)

      Overrides:
        `setRoi` in class `ij.process.ImageProcessor`

    - #### setRoi

          public void setRoi(java.awt.Rectangle roi)

      Overrides:
        `setRoi` in class `ij.process.ImageProcessor`

    - #### setRoi

          public void setRoi(ij.gui.Roi roi)

      Overrides:
        `setRoi` in class `ij.process.ImageProcessor`

    - #### setSnapshotCopyMode

          public void setSnapshotCopyMode(boolean b)

      Overrides:
        `setSnapshotCopyMode` in class `ij.process.ImageProcessor`

    - #### setSnapshotPixels

          public void setSnapshotPixels(java.lang.Object pixels)

      Specified by:
        `setSnapshotPixels` in class `ij.process.ImageProcessor`

    - #### setThreshold

          public void setThreshold(double minThreshold,
                                   double maxThreshold,
                                   int lutUpdate)

      Overrides:
        `setThreshold` in class `ij.process.ImageProcessor`

    - #### setValue

          public void setValue(double value)

      Specified by:
        `setValue` in class `ij.process.ImageProcessor`

    - #### sharpen

          public void sharpen()

      Overrides:
        `sharpen` in class `ij.process.ImageProcessor`

    - #### smooth

          public void smooth()

      Overrides:
        `smooth` in class `ij.process.ImageProcessor`

    - #### snapshot

          public void snapshot()

      Specified by:
        `snapshot` in class `ij.process.ImageProcessor`

    - #### sqr

          public void sqr()

      Overrides:
        `sqr` in class `ij.process.ImageProcessor`

    - #### sqrt

          public void sqrt()

      Overrides:
        `sqrt` in class `ij.process.ImageProcessor`

    - #### swapPixelArrays

          public void swapPixelArrays()

      Specified by:
        `swapPixelArrays` in class `ij.process.ImageProcessor`

    - #### threshold

          public void threshold(int level)

      Specified by:
        `threshold` in class `ij.process.ImageProcessor`

    - #### toFloat

          public ij.process.FloatProcessor toFloat(int channelNumber,
                                                   ij.process.FloatProcessor fp)

      Specified by:
        `toFloat` in class `ij.process.ImageProcessor`

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `ij.process.ImageProcessor`

    - #### translate

          public void translate(int xOffset,
                                int yOffset)

    - #### updateComposite

          public void updateComposite(int[] rgbPixels,
                                      int channel)

      Overrides:
        `updateComposite` in class `ij.process.ImageProcessor`

    - #### xor

          public void xor(int value)

      Overrides:
        `xor` in class `ij.process.ImageProcessor`

    - #### record

          private void record(java.lang.String method)

    - #### record

          private void record(java.lang.String method,
                              java.lang.Object v,
                              java.lang.Class<?> c)

    - #### record

          private void record(java.lang.String method,
                              java.lang.Object[] v,
                              java.lang.Class<?>[] c)

Copyright © 2026 Open Microscopy Environment