ImageProcessor.java

package ij.process;

import java.util.*;
import java.awt.*;
import java.awt.image.*;
import java.lang.reflect.*; 
import ij.gui.*;
import ij.util.Java2;

public abstract class ImageProcessor extends Object {

    public static final int BLACK = 0xFF000000;
    
    public static final double NO_THRESHOLD = -808080.0;
        
    public static final int LEFT_JUSTIFY = 0;
    public static final int CENTER_JUSTIFY = 1;
    public static final int RIGHT_JUSTIFY = 2;

    static public final int RED_LUT=0, BLACK_AND_WHITE_LUT=1, NO_LUT_UPDATE=2, OVER_UNDER_LUT=3;
    static final int INVERT=0, FILL=1, ADD=2, MULT=3, AND=4, OR=5,
        XOR=6, GAMMA=7, LOG=8, MINIMUM=9, MAXIMUM=10, SQR=11, SQRT=12;
    static final int BLUR_MORE=0, FIND_EDGES=1, MEDIAN_FILTER=2, MIN=3, MAX=4;
    static final String WRONG_LENGTH = "(width*height) != pixels.length";
    
    int fgColor = 0;
    protected int lineWidth = 1;
    protected int cx, cy; //current drawing coordinates
    protected Font font;
    protected FontMetrics fontMetrics;
    protected boolean antialiasedText;
    protected boolean boldFont;
    static Frame frame;
        
    ProgressBar progressBar;
    boolean pixelsModified;
    protected int width, snapshotWidth;
    protected int height, snapshotHeight;
    protected int roiX, roiY, roiWidth, roiHeight;
    protected int xMin, xMax, yMin, yMax;
    boolean newSnapshot = false; // true if pixels = snapshotPixels
    ImageProcessor mask = null;
    protected ColorModel baseCM; // base color model
    protected ColorModel cm;
    protected byte[] rLUT1, gLUT1, bLUT1; // base LUT
    protected byte[] rLUT2, gLUT2, bLUT2; // LUT as modified by setMinAndMax and setThreshold
    protected boolean interpolate;
    protected double minThreshold=NO_THRESHOLD, maxThreshold=NO_THRESHOLD;
    protected int histogramSize = 256;
    protected double histogramMin, histogramMax;
    protected float[] cTable;
    protected boolean lutAnimation;
    protected MemoryImageSource source;
    protected Image img;
    protected boolean newPixels;
    protected Color drawingColor = Color.black;
    protected int clipXMin, clipXMax, clipYMin, clipYMax; // clip rect used by drawTo, drawLine, drawDot and drawPixel 
    protected int justification = LEFT_JUSTIFY;

        
    protected void showProgress(double percentDone) {
        if (progressBar!=null)
            progressBar.show(percentDone);
    }

    protected void hideProgress() {
        showProgress(1.0);
        newSnapshot = false;
    }
        
    public int getWidth() {
        return width;
    }
    
    public int getHeight() {
        return height;
    }
    
    public ColorModel getColorModel() {
        if (cm==null)
            makeDefaultColorModel();
        if (baseCM!=null)
            return baseCM;
        else
            return cm;
    }

    public void setColorModel(ColorModel cm) {
        if (!(this instanceof ColorProcessor) && !(cm instanceof IndexColorModel))
            throw new IllegalArgumentException("Must be IndexColorModel");
        this.cm = cm;
        baseCM = null;
        rLUT1 = rLUT2 = null;
        newPixels = true;
        inversionTested = false;
        minThreshold = NO_THRESHOLD;
    }

    protected void makeDefaultColorModel() {
        byte[] rLUT = new byte[256];
        byte[] gLUT = new byte[256];
        byte[] bLUT = new byte[256];
        for(int i=0; i<256; i++) {
            rLUT[i]=(byte)i;
            gLUT[i]=(byte)i;
            bLUT[i]=(byte)i;
        }
        cm = new IndexColorModel(8, 256, rLUT, gLUT, bLUT);
    }

    public void invertLut() {
        if (cm==null)
            makeDefaultColorModel();
        IndexColorModel icm = (IndexColorModel)cm;
        int mapSize = icm.getMapSize();
        byte[] reds = new byte[mapSize];
        byte[] greens = new byte[mapSize];
        byte[] blues = new byte[mapSize];   
        byte[] reds2 = new byte[mapSize];
        byte[] greens2 = new byte[mapSize];
        byte[] blues2 = new byte[mapSize];  
        icm.getReds(reds); 
        icm.getGreens(greens); 
        icm.getBlues(blues);
        for (int i=0; i<mapSize; i++) {
            reds2[i] = (byte)(reds[mapSize-i-1]&255);
            greens2[i] = (byte)(greens[mapSize-i-1]&255);
            blues2[i] = (byte)(blues[mapSize-i-1]&255);
        }
        ColorModel cm = new IndexColorModel(8, mapSize, reds2, greens2, blues2); 
        setColorModel(cm);
    }

    public int getBestIndex(Color c) {
        if (cm==null)
            makeDefaultColorModel();
        IndexColorModel icm = (IndexColorModel)cm;
        int mapSize = icm.getMapSize();
        byte[] rLUT = new byte[mapSize];
        byte[] gLUT = new byte[mapSize];
        byte[] bLUT = new byte[mapSize];
        icm.getReds(rLUT); 
        icm.getGreens(gLUT); 
        icm.getBlues(bLUT); 
        int minDistance = Integer.MAX_VALUE;
        int distance;
        int minIndex = 0;
        int r1=c.getRed();
        int g1=c.getGreen();
        int b1=c.getBlue();
        int r2,b2,g2;
        for (int i=0; i<mapSize; i++) {
            r2 = rLUT[i]&0xff; g2 = gLUT[i]&0xff; b2 = bLUT[i]&0xff;
            distance = (r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
            //ij.IJ.write(i+" "+minIndex+" "+distance+" "+(rLUT[i]&255));
            if (distance<minDistance) {
                minDistance = distance;
                minIndex = i;
            }
            if (minDistance==0.0)
                break;
        }
        return minIndex;
    }

    protected boolean inversionTested = false;
    protected boolean invertedLut;
    
    public boolean isInvertedLut() {
        if (inversionTested)
            return invertedLut;
        inversionTested = true;
        if (cm==null || !(cm instanceof IndexColorModel))
            return (invertedLut=false);
        IndexColorModel icm = (IndexColorModel)cm;
        invertedLut = true;
        int v1, v2;
        for (int i=1; i<255; i++) {
            v1 = icm.getRed(i-1)+icm.getGreen(i-1)+icm.getBlue(i-1);
            v2 = icm.getRed(i)+icm.getGreen(i)+icm.getBlue(i);
            if (v1<v2) {
                invertedLut = false;
                break;
            }
        }
        return invertedLut;
    }
    
    public boolean isColorLut() {
        if (cm==null || !(cm instanceof IndexColorModel))
            return false;
        IndexColorModel icm = (IndexColorModel)cm;
        int mapSize = icm.getMapSize();
        byte[] reds = new byte[mapSize];
        byte[] greens = new byte[mapSize];
        byte[] blues = new byte[mapSize];   
        icm.getReds(reds); 
        icm.getGreens(greens); 
        icm.getBlues(blues);
        boolean isColor = false;
        for (int i=0; i<mapSize; i++) {
            if ((reds[i] != greens[i]) || (greens[i] != blues[i])) {
                isColor = true;
                break;
            }
        }
        return isColor;
    }


    public boolean isPseudoColorLut() {
        if (cm==null || !(cm instanceof IndexColorModel))
            return false;
        if (getMinThreshold()!=NO_THRESHOLD)
            return true;
        IndexColorModel icm = (IndexColorModel)cm;
        int mapSize = icm.getMapSize();
        if (mapSize!=256)
            return false;
        byte[] reds = new byte[mapSize];
        byte[] greens = new byte[mapSize];
        byte[] blues = new byte[mapSize];   
        icm.getReds(reds); 
        icm.getGreens(greens); 
        icm.getBlues(blues);
        int r, g, b, d;
        int r2=reds[0]&255, g2=greens[0]&255, b2=blues[0]&255;
        double sum=0.0, sum2=0.0;
        for (int i=0; i<mapSize; i++) {
            r=reds[i]&255; g=greens[i]&255; b=blues[i]&255;
            d=r-r2; sum+=d; sum2+=d*d;
            d=g-g2; sum+=d; sum2+=d*d;
            d=b-b2; sum+=d; sum2+=d*d;
            r2=r; g2=g; b2=b;
        }
        double stdDev = (768*sum2-sum*sum)/768.0;
        if (stdDev>0.0)
            stdDev = Math.sqrt(stdDev/(767.0));
        else
            stdDev = 0.0;
        //ij.IJ.log("isPseudoColorLut: "+(stdDev<10.0) + " " + stdDev);
        return stdDev<20.0;
    }

    public abstract void setColor(Color color);

    public void setColor(int value) {
        fgColor = value;
    }

    public abstract void setValue(double value);

    public abstract double getMin();

    public abstract double getMax();

    public abstract void setMinAndMax(double min, double max);

    public void resetMinAndMax() {}

    public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate) {
        //ij.IJ.write("setThreshold: "+" "+minThreshold+" "+maxThreshold+" "+lutUpdate);
        if (this instanceof ColorProcessor)
            return;
        this.minThreshold = minThreshold;
        this.maxThreshold = maxThreshold;

        if (minThreshold==NO_THRESHOLD) {
            resetThreshold();
            return;
        }

        if (lutUpdate==NO_LUT_UPDATE)
            return;
        if (rLUT1==null) {
            if (cm==null)
                makeDefaultColorModel();
            baseCM = cm;
            IndexColorModel m = (IndexColorModel)cm;
            rLUT1 = new byte[256]; gLUT1 = new byte[256]; bLUT1 = new byte[256];
            m.getReds(rLUT1); m.getGreens(gLUT1); m.getBlues(bLUT1);
            rLUT2 = new byte[256]; gLUT2 = new byte[256]; bLUT2 = new byte[256];
        }
        int t1 = (int)minThreshold;
        int t2 = (int)maxThreshold;
        int index;
        if (lutUpdate==RED_LUT)
            for (int i=0; i<256; i++) {
                if (i>=t1 && i<=t2) {
                    rLUT2[i] = (byte)255;
                    gLUT2[i] = (byte)0;
                    bLUT2[i] = (byte)0;
                } else {
                    rLUT2[i] = rLUT1[i];
                    gLUT2[i] = gLUT1[i];
                    bLUT2[i] = bLUT1[i];
                }
            }
        else if (lutUpdate==BLACK_AND_WHITE_LUT)
            for (int i=0; i<256; i++) {
                if (i>=t1 && i<=t2) {
                    rLUT2[i] = (byte)0;
                    gLUT2[i] = (byte)0;
                    bLUT2[i] = (byte)0;
                } else {
                    rLUT2[i] = (byte)255;
                    gLUT2[i] = (byte)255;
                    bLUT2[i] = (byte)255;
                }
            }
        else
            for (int i=0; i<256; i++) {
                if (i>=t1 && i<=t2) {
                    rLUT2[i] = rLUT1[i];
                    gLUT2[i] = gLUT1[i];
                    bLUT2[i] = bLUT1[i];

                } else if (i>t2) {
                    rLUT2[i] = (byte)0;
                    gLUT2[i] = (byte)255;
                    bLUT2[i] = (byte)0;
                } else { 
                    rLUT2[i] = (byte)0;
                    gLUT2[i] = (byte)0; 
                    bLUT2[i] = (byte)255;
                }
            }

        cm = new IndexColorModel(8, 256, rLUT2, gLUT2, bLUT2);
        newPixels = true;
    }

    public void resetThreshold() {
        minThreshold = NO_THRESHOLD;
        if (baseCM!=null) {
            cm = baseCM;
            baseCM = null;
        }
        rLUT1 = rLUT2 = null;
        inversionTested = false;
        newPixels = true;
    }

    public double getMinThreshold() {
        return minThreshold;
    }

    public double getMaxThreshold() {
        return maxThreshold;
    }

    public void setRoi(Rectangle roi) {
        if (roi==null)
            resetRoi();
        else
            setRoi(roi.x, roi.y, roi.width, roi.height);
    }

    public void setRoi(int x, int y, int rwidth, int rheight) {
        if (x<0 || y<0 || x+rwidth>width || y+rheight>height) {
            //find intersection of roi and this image
            Rectangle r1 = new Rectangle(x, y, rwidth, rheight);
            Rectangle r2 = r1.intersection(new Rectangle(0, 0, width, height));
            if (r2.width<=0 || r2.height<=0) {
                roiX=0; roiY=0; roiWidth=0; roiHeight=0;
                xMin=0; xMax=0; yMin=0; yMax=0;
                mask=null;
                return;
            }
            if (mask!=null && mask.getWidth()==rwidth && mask.getHeight()==rheight) {
                Rectangle r3 = new Rectangle(0, 0, r2.width, r2.height);
                if (x<0) r3.x = -x;
                if (y<0) r3.y = -y;
                mask.setRoi(r3);
                mask = mask.crop();
            }
            roiX=r2.x; roiY=r2.y; roiWidth=r2.width; roiHeight=r2.height;
        } else {
            roiX=x; roiY=y; roiWidth=rwidth; roiHeight=rheight;
        }
        if (mask!=null && (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight))
            mask = null;
        //setup limits for 3x3 filters
        xMin = Math.max(roiX, 1);
        xMax = Math.min(roiX + roiWidth - 1, width - 2);
        yMin = Math.max(roiY, 1);
        yMax = Math.min(roiY + roiHeight - 1, height - 2);
    }
    
    public void setRoi(ij.gui.Roi roi) {
        if (roi==null)
            resetRoi();
        else {
            setMask(roi.getMask());
            setRoi(roi.getBounds());
        }
    }

    public void setRoi(Polygon roi) {
        if (roi==null)
            {resetRoi(); return;}
        Rectangle bounds = roi.getBounds();
        for (int i=0; i<roi.npoints; i++) {
            roi.xpoints[i] -= bounds.x;
            roi.ypoints[i] -= bounds.y;
        }
        PolygonFiller pf = new PolygonFiller();
        pf.setPolygon(roi.xpoints, roi.ypoints, roi.npoints);
        ImageProcessor mask = pf.getMask(bounds.width, bounds.height);
        setMask(mask);
        setRoi(bounds);
        for (int i=0; i<roi.npoints; i++) {
            roi.xpoints[i] += bounds.x;
            roi.ypoints[i] += bounds.y;
        }
    }

    public void resetRoi() {
        roiX=0; roiY=0; roiWidth=width; roiHeight=height;
        xMin=1; xMax=width-2; yMin=1; yMax=height-2;
        mask=null;
        clipXMin=0; clipXMax=width-1; clipYMin=0; clipYMax=height-1; 
    }

    public Rectangle getRoi() {
        return new Rectangle(roiX, roiY, roiWidth, roiHeight);
    }

    public void setMask(ImageProcessor mask) {
        this.mask = mask;
    }

    public ImageProcessor getMask() {
        return mask;
    }

    public byte[] getMaskArray() {
        return mask!=null?(byte[])mask.getPixels():null;
    }

    public void setProgressBar(ProgressBar pb) {
        progressBar = pb;
    }

    public void setInterpolate(boolean interpolate) {
        this.interpolate = interpolate;
    }

    public boolean getInterpolate() {
        return interpolate;
    }

    public boolean isKillable() {
        return false;
    }

    private void process(int op, double value) {
        double SCALE = 255.0/Math.log(255.0);
        int v;
        
        int[] lut = new int[256];
        for (int i=0; i<256; i++) {
            switch(op) {
                case INVERT:
                    v = 255 - i;
                    break;
                case FILL:
                    v = fgColor;
                    break;
                case ADD:
                    v = i + (int)value;
                    break;
                case MULT:
                    v = (int)Math.round(i * value);
                    break;
                case AND:
                    v = i & (int)value;
                    break;
                case OR:
                    v = i | (int)value;
                    break;
                case XOR:
                    v = i ^ (int)value;
                    break;
                case GAMMA:
                    v = (int)(Math.exp(Math.log(i/255.0)*value)*255.0);
                    break;
                case LOG:
                    if (i==0)
                        v = 0;
                    else
                        v = (int)(Math.log(i) * SCALE);
                    break;
                case SQR:
                        v = i*i;
                    break;
                case SQRT:
                        v = (int)Math.sqrt(i);
                    break;
                case MINIMUM:
                    if (i<value)
                        v = (int)value;
                    else
                        v = i;
                    break;
                case MAXIMUM:
                    if (i>value)
                        v = (int)value;
                    else
                        v = i;
                    break;
                 default:
                    v = i;
            }
            if (v < 0)
                v = 0;
            if (v > 255)
                v = 255;
            lut[i] = v;
        }
        applyTable(lut);
    }

    public double[] getLine(double x1, double y1, double x2, double y2) {
        double dx = x2-x1;
        double dy = y2-y1;
        int n = (int)Math.round(Math.sqrt(dx*dx + dy*dy));
        double xinc = dx/n;
        double yinc = dy/n;
        n++;
        double[] data = new double[n];
        double rx = x1;
        double ry = y1;
        if (interpolate)
            for (int i=0; i<n; i++) {
                if (cTable!=null)
                    data[i] = getInterpolatedValue(rx, ry);
                else
                    data[i] = getInterpolatedPixel(rx, ry);
                rx += xinc;
                ry += yinc;
            }
        else
            for (int i=0; i<n; i++) {
                data[i] = getPixelValue((int)(rx+0.5), (int)(ry+0.5));
                rx += xinc;
                ry += yinc;
            }
        return data;
    }
    
    public void getRow(int x, int y, int[] data, int length) {
        for (int i=0; i<length; i++)
            data[i] = getPixel(x++, y);
    }

    public void getColumn(int x, int y, int[] data, int length) {
        for (int i=0; i<length; i++)
            data[i] = getPixel(x, y++);
    }

    public void putRow(int x, int y, int[] data, int length) {
        for (int i=0; i<length; i++)
            putPixel(x++, y, data[i]);
    }
    
    public void putColumn(int x, int y, int[] data, int length) {
        //if (x>=0 && x<width && y>=0 && (y+length)<=height)
        //  ((ShortProcessor)this).putColumn2(x, y, data, length);
        //else 
            for (int i=0; i<length; i++)
                putPixel(x, y++, data[i]);
    }

    public void moveTo(int x, int y) {
        cx = x;
        cy = y;
    }
    
    public void setLineWidth(int width) {
        lineWidth = width;
        if (lineWidth<1) lineWidth = 1;
    }
        
    public void lineTo(int x2, int y2) {
        int dx = x2-cx;
        int dy = y2-cy;
        int absdx = dx>=0?dx:-dx;
        int absdy = dy>=0?dy:-dy;
        int n = absdy>absdx?absdy:absdx;
        double xinc = (double)dx/n;
        double yinc = (double)dy/n;
        double x = cx+0.5;
        double y = cy+0.5;
        n++;
        do {
            if (lineWidth==1)
                drawPixel((int)x, (int)y);
            else if (lineWidth==2)
                drawDot2((int)x, (int)y);
            else
                drawDot((int)x, (int)y);
            x += xinc;
            y += yinc;
        } while (--n>0);
        cx = x2; cy = y2;
    }
        
    public void drawLine(int x1, int y1, int x2, int y2) {
        moveTo(x1, y1);
        lineTo(x2, y2);
    }

    public void drawRect(int x, int y, int width, int height) {
        if (width<1 || height<1)
            return;
        moveTo(x, y);
        lineTo(x+width-1, y);
        lineTo(x+width-1, y+height-1);
        lineTo(x, y+height-1);
        lineTo(x, y);
    }

    public void drawPolygon(Polygon p) {
        moveTo(p.xpoints[0], p.ypoints[0]);
        for (int i=0; i<p.npoints; i++)
            lineTo(p.xpoints[i], p.ypoints[i]);
        lineTo(p.xpoints[0], p.ypoints[0]);
    }

    public void fillPolygon(Polygon p) {
        setRoi(p);
        fill(getMask());
        resetRoi();
    }

    public void drawDot2(int x, int y) {
        drawPixel(x, y);
        drawPixel(x-1, y);
        drawPixel(x, y-1);
        drawPixel(x-1, y-1);
    }
        
    public void drawDot(int xcenter, int ycenter) {
        int r = lineWidth/2;
        int r2 = r*r+1;
        for (int x=-r; x<=r; x++)
            for (int y=-r; y<=r; y++)
                if ((x*x+y*y)<=r2)
                    drawPixel(xcenter+x, ycenter+y);
    }

    private void setupFrame() {
        if (frame==null) {
            frame = new Frame();
            frame.pack();
            frame.setBackground(Color.white);
        }
        if (font==null)
            font = new Font("SansSerif", Font.PLAIN, 12);
        if (fontMetrics==null) {
            frame.setFont(font);
            fontMetrics = frame.getFontMetrics(font);
        }
    }

    public void drawString(String s) {
        if (s.equals(""))
            return;
        setupFrame();
        if (ij.IJ.isMacOSX())
            s += " ";
        int w =  getStringWidth(s);
        int cxx = cx;
        if (justification==CENTER_JUSTIFY)
            cxx -= w/2;
        else if (justification==RIGHT_JUSTIFY)
            cxx -= w;
        //if (antialiasedText)
        //  w = boldFont?(int)(1.15*w):(int)(1.08*w);
        int h =  fontMetrics.getHeight();
        Image img = frame.createImage(w, h);
        Graphics g = img.getGraphics();
        FontMetrics metrics = g.getFontMetrics(font);
        int fontHeight = metrics.getHeight();
        int descent = metrics.getDescent();
        g.setFont(font);

        if (antialiasedText) {
            Java2.setAntialiasedText(g, true);
            setRoi(cxx,cy-h,w,h);
            ImageProcessor ip = crop();
            resetRoi();
            g.drawImage(ip.createImage(), 0, 0, null);
            g.setColor(drawingColor);
            g.drawString(s, 0, h-descent);
            g.dispose();
            ip = new ColorProcessor(img);
            if (this instanceof ByteProcessor) {
                ip = ip.convertToByte(false);
                if (isInvertedLut()) ip.invert();
            }
            //new ij.ImagePlus("ip",ip).show();
            insert(ip, cxx, cy-h);
            cy += h;
            return;
        }
        
        if (ij.IJ.isMacOSX()) {
            Java2.setAntialiasedText(g, false);
            g.setColor(Color.white);
            g.fillRect(0, 0, w, h);
        }
        g.setColor(Color.black);
        g.drawString(s, 0, h-descent);
        g.dispose();
        ImageProcessor ip = new ColorProcessor(img);
        ImageProcessor textMask = ip.convertToByte(false);
        byte[] mpixels = (byte[])textMask.getPixels();
        //new ij.ImagePlus("textmask",textMask).show();
        textMask.invert();
        if (cxx<width && cy-h<height) {
            setMask(textMask);
            setRoi(cxx,cy-h,w,h);
            fill(getMask());
        }
        resetRoi();
        cy += h;
    }

    public void drawString(String s, int x, int y) {
        moveTo(x, y);
        drawString(s);
    }

    public void setJustification(int justification) {
        this.justification = justification;
    }

    public void setFont(Font font) {
        this.font = font;
        fontMetrics = null;
        boldFont = font.isBold();
    }
    
    public void setAntialiasedText(boolean antialiasedText) {
        if (antialiasedText && ij.IJ.isJava2() && ((this instanceof ByteProcessor) || (this instanceof ColorProcessor)))
            this.antialiasedText = true;
        else
            this.antialiasedText = false;
    }

    public int getStringWidth(String s) {
        setupFrame();
        int w;
        if (antialiasedText) {
            Graphics g = frame.getGraphics();
            Java2.setAntialiasedText(g, true);
            w = Java2.getStringWidth(s, fontMetrics, g);
            g.dispose();
        } else
            w =  fontMetrics.stringWidth(s);
        return w;
    }
    
    public FontMetrics getFontMetrics() {
        setupFrame();
        return fontMetrics;
    }

    public void smooth() {
        if (width>1)
            filter(BLUR_MORE);
    }

    public void sharpen() {
        if (width>1) {
            int[] kernel = {-1, -1, -1,
                        -1, 12, -1,
                        -1, -1, -1};
            convolve3x3(kernel);
        }
    }
    
    public void findEdges() {
        if (width>1)
            filter(FIND_EDGES);
    }

    public abstract void flipVertical();
    /* {
        int[] row1 = new int[roiWidth];
        int[] row2 = new int[roiWidth];
        for (int y=0; y<roiHeight/2; y++) {
            getRow(roiX, roiY+y, row1, roiWidth);
            getRow(roiX, roiY+roiHeight-y-1, row2, roiWidth);
            putRow(roiX, roiY+y, row2, roiWidth);
            putRow(roiX, roiY+roiHeight-y-1, row1, roiWidth);
        }
        newSnapshot = false;
    }
    */

    public void flipHorizontal() {
        int[] col1 = new int[roiHeight];
        int[] col2 = new int[roiHeight];
        for (int x=0; x<roiWidth/2; x++) {
            getColumn(roiX+x, roiY, col1, roiHeight);
            getColumn(roiX+roiWidth-x-1, roiY, col2, roiHeight);
            putColumn(roiX+x, roiY, col2, roiHeight);
            putColumn(roiX+roiWidth-x-1, roiY, col1, roiHeight);
        }
        newSnapshot = false;
    }

    public ImageProcessor rotateRight() {
        int width2 = height;
        int height2 = width;
        ImageProcessor ip2 = createProcessor(width2, height2);
        int[] arow = new int[width];
        for (int row=0; row<height; row++) {
            getRow(0, row, arow, width);
            ip2.putColumn(width2-row-1, 0, arow, height2);
        }
        return ip2;
    }
    
    public ImageProcessor rotateLeft() {
        int width2 = height;
        int height2 = width;
        ImageProcessor ip2 = createProcessor(width2, height2);
        int[] arow = new int[width];
        int[] arow2 = new int[width];
        for (int row=0; row<height; row++) {
            getRow(0, row, arow, width);
            for (int i=0; i<width; i++) {
                arow2[i] = arow[width-i-1];
            }
            ip2.putColumn(row, 0, arow2, height2);
        }
        return ip2;
    }

    public void insert(ImageProcessor ip, int xloc, int yloc) {
        copyBits(ip, xloc, yloc, Blitter.COPY);
    }
        
    public String toString() {
        return ("width="+width+", height="+height+", min="+getMin()+", max="+getMax()+", v="+getPixel(0,0));
    }

    public void fill() {
        process(FILL, 0.0);
    }

    public abstract void fill(ImageProcessor mask);

    public void setCalibrationTable(float[] cTable) {
        this.cTable = cTable;
    }

    public void setHistogramSize(int size) {
        histogramSize = size;
    }

    public int getHistogramSize() {
        return histogramSize;
    }

    public void setHistogramRange(double histMin, double histMax) {
        if (histMin>histMax) {
            histMin = 0.0;
            histMax = 0.0;
        }
        histogramMin = histMin;
        histogramMax = histMax;
    }

    public double getHistogramMin() {
        return histogramMin;
    }

    public double getHistogramMax() {
        return histogramMax;
    }

    public abstract Object getPixels();
    
    public abstract Object getPixelsCopy();

    public abstract int getPixel(int x, int y);
    
    public int[] getPixel(int x, int y, int[] iArray) {
        if (iArray==null) iArray = new int[1];
        iArray[0] = getPixel(x, y);
        return iArray;
    }

    public void putPixel(int x, int y, int[] iArray) {
        putPixel(x, y, iArray[0]);
    }

    public abstract double getInterpolatedPixel(double x, double y);

    public double getInterpolatedValue(double x, double y) {
        return getInterpolatedPixel(x, y);
    }

    public abstract void putPixel(int x, int y, int value);
    
    public abstract float getPixelValue(int x, int y);
        
    public abstract void putPixelValue(int x, int y, double value);

    public abstract void drawPixel(int x, int y);
    
    public abstract void setPixels(Object pixels);
    
    public abstract void copyBits(ImageProcessor ip, int xloc, int yloc, int mode);

    public abstract void applyTable(int[] lut);

    public void invert() {process(INVERT, 0.0);}
    
    public void add(int value) {process(ADD, value);}
    
    public void add(double value) {process(ADD, value);}
    
    public void multiply(double value) {process(MULT, value);}
    
    public void and(int value) {process(AND, value);}

    public void or(int value) {process(OR, value);}
    
    public void xor(int value) {process(XOR, value);}
    
    public void gamma(double value) {process(GAMMA, value);}
    
    public void log() {process(LOG, 0.0);}

    public void sqr() {process(SQR, 0.0);}

    public void sqrt() {process(SQRT, 0.0);}

    public void min(double value) {process(MINIMUM, value);}

    public void max(double value) {process(MAXIMUM, value);}

    public abstract Image createImage();
    
    public abstract ImageProcessor createProcessor(int width, int height);
    
    public abstract void snapshot();
    
    public abstract void reset();
    
    public abstract void reset(ImageProcessor mask);
    
    public abstract void convolve3x3(int[] kernel);
    
    public abstract void filter(int type);
    
    public abstract void medianFilter();
    
    public abstract void noise(double range);
    
    public abstract ImageProcessor crop();
    
    public abstract void threshold(int level);

    public ImageProcessor duplicate() {
        Rectangle saveRoi = getRoi();
        ImageProcessor saveMask= getMask();
        resetRoi();
        ImageProcessor ip2 = crop();
        setRoi(saveRoi);
        setMask(saveMask);
        return ip2;
    }

    public abstract void scale(double xScale, double yScale);
    
    public abstract ImageProcessor resize(int dstWidth, int dstHeight);
    
    public abstract void rotate(double angle);
        
    public abstract int[] getHistogram();
    
    public abstract void erode();
    
    public abstract void dilate();
    
    public void setLutAnimation(boolean lutAnimation) {
        this.lutAnimation = lutAnimation;
        newPixels = true;
    }
    
    void resetPixels(Object pixels) {
        if (pixels==null) {
            if (img!=null) {
                img.flush();
                img = null;
            }
            source = null;
        }
        newPixels = true;
    }

    public ImageProcessor convertToByte(boolean doScaling) {
        TypeConverter tc = new TypeConverter(this, doScaling);
        return tc.convertToByte();
    }

    public ImageProcessor convertToShort(boolean doScaling) {
        TypeConverter tc = new TypeConverter(this, doScaling);
        return tc.convertToShort();
    }

    public ImageProcessor convertToFloat() {
        TypeConverter tc = new TypeConverter(this, false);
        return tc.convertToFloat(cTable);
    }
    
    public ImageProcessor convertToRGB() {
        TypeConverter tc = new TypeConverter(this, true);
        return tc.convertToRGB();
    }
    
    public abstract void convolve(float[] kernel, int kernelWidth, int kernelHeight);
    
    public void autoThreshold() {
        threshold(getAutoThreshold());
    }

    public int getAutoThreshold() {
        return getAutoThreshold(getHistogram());
    }

    public int getAutoThreshold(int[] histogram) {
        int level;
        int maxValue = histogram.length - 1;
        double result, sum1, sum2, sum3, sum4;

        histogram[0] = 0; //set to zero so erased areas aren't included
        histogram[maxValue] = 0;
        int min = 0;
        while ((histogram[min]==0) && (min<maxValue))
            min++;
        int max = maxValue;
        while ((histogram[max]==0) && (max>0))
            max--;
        if (min>=max) {
            level = histogram.length/2;
            return level;
        }
        
        int movingIndex = min;
        int inc = Math.min(max/40, 1);
        do {
            sum1=sum2=sum3=sum4=0.0;
            for (int i=min; i<=movingIndex; i++) {
                sum1 += i*histogram[i];
                sum2 += histogram[i];
            }
            for (int i=(movingIndex+1); i<=max; i++) {
                sum3 += i*histogram[i];
                sum4 += histogram[i];
            }           
            result = (sum1/sum2 + sum3/sum4)/2.0;
            movingIndex++;
            if (max>255 && (movingIndex%inc)==0)
                showProgress((double)(movingIndex)/max);
        } while ((movingIndex+1)<=result && movingIndex<max-1);
        
        showProgress(1.0);
        level = (int)Math.round(result);
        return level;
    }
    
    public void setClipRect(Rectangle clipRect) {
        if (clipRect==null) {
            clipXMin=0; 
            clipXMax=width-1; 
            clipYMin=0; 
            clipYMax=height-1; 
        } else {
            clipXMin = clipRect.x; 
            clipXMax = clipRect.x + clipRect.width - 1; 
            clipYMin = clipRect.y; 
            clipYMax = clipRect.y + clipRect.height - 1; 
            if (clipXMin<0) clipXMin = 0;
            if (clipXMax>=width) clipXMax = width-1;
            if (clipYMin<0) clipYMin = 0;
            if (clipYMax>=height) clipYMax = height-1;
        }
    }
    
    protected String maskSizeError(ImageProcessor mask) {
        return "Mask size ("+mask.getWidth()+"x"+mask.getHeight()+") != ROI size ("+
            roiWidth+"x"+roiHeight+")";
    }

}