ImagePlus.java

package ij;

import java.awt.*;
import java.awt.image.*;
import java.net.URL;
import java.util.*;
import ij.process.*;
import ij.io.*;
import ij.gui.*;
import ij.measure.*;
import ij.plugin.filter.Analyzer;
import ij.util.Tools;

public class ImagePlus implements ImageObserver, Measurements {

    public static final int GRAY8 = 0;
    
    public static final int GRAY16 = 1;
    
    public static final int GRAY32 = 2;
    
    public static final int COLOR_256 = 3;
    
    public static final int COLOR_RGB = 4;
    
    public boolean changes;
    
    public double pixelWidth = 1.0;
    
    public double pixelHeight = 1.0;
    
    public double pixelDepth = 1.0;

    public String unit = "pixel";
    
    public String units = "pixels";
    
    public boolean sCalibrated;

    protected Image img;
    protected ImageProcessor ip;
    private ImageJ ij = IJ.getInstance();
    private String title;
    private String url;
    private FileInfo fileInfo;
    protected int width;
    protected int height;
    private int imageType = GRAY8;
    private int currentSlice;
    private Roi roi;
    protected boolean locked = false;
    private static int currentID = -1;
    private int ID;
    private static Component comp;
    private boolean imageLoaded;
    private int imageUpdateY, imageUpdateW;
    private Properties properties;
    private long startTime;
    private Calibration calibration;
    private static Calibration globalCalibration;
    private boolean activated;
    private boolean ignoreFlush;
    private boolean errorLoadingImage;
    protected ImageCanvas imageCanvas;

    public ImagePlus() {
        ID = --currentID;
        title="null";
    }
    
    public ImagePlus(String title, Image img) {
        this.title = title;
        ID = --currentID;
        if (img!=null)
            setImage(img);
    }
    
    public ImagePlus(String title, ImageProcessor ip) {
        setProcessor(title, ip);
        ID = --currentID;
    }
    
    public ImagePlus(String pathOrURL) {
        Opener opener = new Opener();
        ImagePlus imp = null;
        boolean isURL = pathOrURL.indexOf("://")>0;
        if (isURL)
            imp = opener.openURL(pathOrURL);
        else
            imp = opener.openImage(pathOrURL);
        if (imp!=null) {
            setProcessor(imp.getTitle(), imp.getProcessor());
            setCalibration(imp.getCalibration());
            properties = imp.getProperties();
            if (isURL)
                this.url = pathOrURL;
            ID = --currentID;
        }
    }

   
    public synchronized boolean lock() {
        if (locked) {
            IJ.beep();
            IJ.showStatus("\"" + title + "\" is locked");
            if (IJ.macroRunning()) {
                IJ.error("Image is locked");
            }
            return false;
        } else {
            locked = true;
            if (IJ.debugMode) IJ.log(title + ": lock");
            return true;
        }
    }
    
    public synchronized boolean lockSilently() {
        if (locked)
            return false;
        else {
            locked = true;
            if (IJ.debugMode) IJ.log(title + ": lock silently");
            return true;
        }
    }
    
    public synchronized void unlock() {
        locked = false;
        if (IJ.debugMode) IJ.log(title + ": unlock");
    }
        
    private void waitForImage(Image img) {
        if (comp==null) {
            comp = IJ.getInstance();
            if (comp==null)
                comp = new Canvas();
        }
        imageLoaded = false;
        if (!comp.prepareImage(img, this)) {
            double progress;
            while (!imageLoaded && !errorLoadingImage) {
                //IJ.showStatus(imageUpdateY+" "+imageUpdateW);
                IJ.wait(30);
                if (imageUpdateW>1) {
                    progress = (double)imageUpdateY/imageUpdateW;
                    if (!(progress<1.0)) {
                        progress = 1.0 - (progress-1.0);
                        if (progress<0.0) progress = 0.9;
                    }
                    IJ.showProgress(progress);
                }
            }
            IJ.showProgress(1.0);
        }
    }
    
    public void draw(){
        ij.getContentPane().repaint();
    }
    
    public void draw(int x, int y, int width, int height){
        ImageCanvas ic = getCanvas();
        double mag = ic.getMagnification();
        x = ic.screenX(x);
        y = ic.screenY(y);
        width = (int)(width*mag);
        height = (int)(height*mag);
        ic.repaint(x, y, width, height);
    }
    
    public void updateAndDraw() {
        if (ip != null) {
            getCanvas().setImageUpdated();
            draw();
        }
    }
    
    public void repaintWindow() {
            draw();
    }
        
    public void updateAndRepaintWindow() {
        updateAndDraw();
    }
        
    public void updateImage() {
        if (ip!=null)
            img = ip.createImage();
    }

    
    public void show() {
        show("");
    }

    public void show(String statusMessage) {
        ij.setImagePlus(this);
    }
    

    public void setActivated() {
        activated = true;
    }
        
    public Image getImage() {
        if (img==null && ip!=null)
            img = ip.createImage();
        return img;
    }
    
    public int getID() {
        return ID;
    }
    
    public void setImage(Image img) {
        roi = null;
        errorLoadingImage = false;
        waitForImage(img);
        if (errorLoadingImage)
            throw new IllegalStateException ("Error loading image");
        this.img = img;
        int newWidth = img.getWidth(ij);
        int newHeight = img.getHeight(ij);
        boolean dimensionsChanged = (newWidth!=width) || (newHeight!=height);
        width = newWidth;
        height = newHeight;
        ip = null;
        LookUpTable lut = new LookUpTable(img);
        int type;
        if (lut.getMapSize() > 0) {
            if (lut.isGrayscale())
                type = GRAY8;
            else
                type = COLOR_256;
        } else
            type = COLOR_RGB;
        setType(type);
        setupProcessor();
        this.img = ip.createImage();
    }
    
    public void setProcessor(String title, ImageProcessor ip) {
        setProcessor2(title, ip);
    }
    
    void setProcessor2(String title, ImageProcessor ip) {
        if (title!=null) setTitle(title);
        this.ip = ip;
        if (ij!=null) ip.setProgressBar(ij.getProgressBar());
        img = null;
        boolean dimensionsChanged = width!=ip.getWidth() || height!=ip.getHeight();
        if (dimensionsChanged)
            roi = null;
        int type;
        if (ip instanceof ByteProcessor)
            type = GRAY8;
        else if (ip instanceof ColorProcessor)
            type = COLOR_RGB;
        else if (ip instanceof ShortProcessor)
            type = GRAY16;
        else
            type = GRAY32;
        if (width==0)
            imageType = type;
        else
            setType(type);
        width = ip.getWidth();
        height = ip.getHeight();

    }

   
    public void setFileInfo(FileInfo fi) {
        if (fi!=null)
            fi.pixels = null;
        fileInfo = fi;
    }
        
    
    public void setColor(Color c) {
        if (ip!=null)
            ip.setColor(c);
    }
    
    void setupProcessor() {
        if (imageType==COLOR_RGB) {
            if (ip == null || ip instanceof ByteProcessor) {
                ip = new ColorProcessor(getImage());
                if (IJ.debugMode) IJ.log(title + ": new ColorProcessor");
            }
        }
        else if (ip==null || (ip instanceof ColorProcessor)) {
            ip = new ByteProcessor(getImage());
            if (IJ.debugMode) IJ.log(title + ": new ByteProcessor");
        }
        if (roi!=null && roi.isArea())
            ip.setRoi(roi.getBounds());
        else
            ip.resetRoi();
    }
    
    public boolean isProcessor() {
        return ip!=null;
    }
    
    public ImageProcessor getProcessor() {
        if (ip==null && img==null)
            return null;
        setupProcessor();
        ip.setLineWidth(Line.getWidth());
        if (ij!=null) {
            //setColor(Toolbar.getForegroundColor());
            ip.setProgressBar(ij.getProgressBar());
        }
        return ip;
    }
    
    public synchronized void trimProcessor() {
        if (ip!=null && !locked) {
            if (ip!=null && IJ.debugMode) IJ.log(title + ": trimProcessor");
            ip.setPixels(ip.getPixels()); // sets snapshot buffer to null
        }
    }
    
    public void killProcessor() {
    }
    
    public ImageProcessor getMask() {
        if (roi==null) {
            if (ip!=null) ip.resetRoi();
            return null;
        }
        ImageProcessor mask = roi.getMask();
        if (mask==null)
            return null;
        if (ip!=null) {
            ip.setMask(mask);
            ip.setRoi(roi.getBounds());
        }
        return mask;
    }

    public ImageStatistics getStatistics() {
        return getStatistics(AREA+MEAN+MODE+MIN_MAX);
    }
    
    public ImageStatistics getStatistics(int mOptions) {
        return getStatistics(mOptions, 256, 0.0, 0.0);
    }
    
    public ImageStatistics getStatistics(int mOptions, int nBins) {
        return getStatistics(mOptions, nBins, 0.0, 0.0);
    }

    public ImageStatistics getStatistics(int mOptions, int nBins, double histMin, double histMax) {
        setupProcessor();
        ip.setMask(getMask());
        ip.setHistogramSize(nBins);
        ip.setHistogramRange(histMin, histMax);
        ImageStatistics stats = ImageStatistics.getStatistics(ip, mOptions, getCalibration());
        ip.setHistogramSize(256);
        ip.setHistogramRange(0.0, 0.0);
        return stats;
    }
    
    public String getTitle() {
        if (title==null)
            return "";
        else
            return title;
    }

    public String getShortTitle() {
        String title = getTitle();
        int index = title.indexOf(' ');
        if (index>-1)
            title = title.substring(0,index);
        return title;
    }

    public void setTitle(String title) {
        if (title==null)
            return;
        String scale = "";
        ImageCanvas ic = getCanvas();
        if (ic != null) {
            double magnification = ic.getMagnification();
            if (magnification!=1.0) {
                double percent = magnification*100.0;
                if (percent==(int)percent)
                    scale = " (" + IJ.d2s(percent,0) + "%)";
                else
                    scale = " (" + IJ.d2s(percent,1) + "%)";
            }
        }
        this.title = title;
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }
    
    public int getStackSize() {
        return 1;
    }
    
    public int getType() {
        return imageType;
    }

    public int getBitDepth() {
        int bitDepth = 0;
        switch (imageType) {
            case GRAY8: case COLOR_256: bitDepth=8; break;
            case GRAY16: bitDepth=16; break;
            case GRAY32: bitDepth=32; break;
            case COLOR_RGB: bitDepth=24; break;
        }
        return bitDepth;
    }
    
    protected void setType(int type) {
        if ((type<0) || (type>COLOR_RGB))
            return;
        int previousType = imageType;
        imageType = type;
        if (imageType!=previousType) {
            Menus.updateMenus();
            if (calibration!=null || globalCalibration!=null)
                getCalibration().setImage(this);
        }
    }

    public void setProperty(String key, Object value) {
        if (properties==null)
            properties = new Properties();
        properties.put(key, value);
    }
        
    public Object getProperty(String key) {
        if (properties==null)
            return null;
        else
            return properties.get(key);
    }
    
    public Properties getProperties() {
            return properties;
    }
        
    public LookUpTable createLut() {
        if (getImage()!=null)
            return new LookUpTable(img);
        else
            return null;
    }
    
    public boolean isInvertedLut() {
        if (ip==null) {
            if (img==null)
                return false;
            setupProcessor();
        }
        return ip.isInvertedLut();
    }
    
    private int[] pvalue = new int[4];

    public int[] getPixel(int x, int y) {
        pvalue[0]=pvalue[1]=pvalue[2]=pvalue[3]=0;
        if (img == null)
            return pvalue;
        switch (imageType) {
            case GRAY8: case COLOR_256:
                int index;
                if (ip!=null)
                    index = ip.getPixel(x, y);
                else {
                    byte[] pixels8;
                    PixelGrabber pg = new PixelGrabber(img,x,y,1,1,false);
                    try {pg.grabPixels();}
                    catch (InterruptedException e){return pvalue;};
                    pixels8 = (byte[])(pg.getPixels());
                    index = pixels8!=null?pixels8[0]&0xff:0;
                }
                if (imageType!=COLOR_256) {
                    pvalue[0] = index;
                    return pvalue;
                }
                pvalue[3] = index;
                // fall through to get rgb values
            case COLOR_RGB:
                int[] pixels32 = new int[1];
                ImageCanvas ic = getCanvas();
                PixelGrabber pg = new PixelGrabber(img, x, y, 1, 1, pixels32, 0, width);
                try {pg.grabPixels();}
                catch (InterruptedException e){return pvalue;};
                int c = pixels32[0];
                int r = (c&0xff0000)>>16;
                int g = (c&0xff00)>>8;
                int b = c&0xff;
                pvalue[0] = r;
                pvalue[1] = g;
                pvalue[2] = b;
                break;
            case GRAY16: case GRAY32:
                if (ip!=null) pvalue[0] = ip.getPixel(x, y);
                break;
        }
        return pvalue;
    }
    

    void undoFilter() {
        if (ip!=null) {
            ip.reset();
            updateAndDraw();
        }
    }

    public Roi getRoi() {
        return roi;
    }
    
    public void setRoi(Roi roi) {
        killRoi();
        if (roi==null)
            return;
        Rectangle bounds = roi.getBounds();
        if (bounds.width==0 && bounds.height==0)
            return;
        this.roi = roi;
        if (ip!=null) {
            ip.setMask(null);
            ip.setRoi(bounds);
        }
        this.roi.setImage(this);
        draw();
    }
    
    public void setRoi(int x, int y, int width, int height) {
        setRoi(new Rectangle(x, y, width, height));
    }

    public void setRoi(Rectangle r) {
        if (r==null)
            {killRoi(); return;}
        killRoi();
        roi = new Roi(r.x, r.y, r.width, r.height);
        roi.setImage(this);
        if (ip!=null) {
            ip.setMask(null);
            ip.setRoi(r);
        }
        draw();
    }
    
    public void createNewRoi(int x, int y) {
        killRoi();
        switch (Toolbar.getToolId()) {
            case Toolbar.RECTANGLE:
                roi = new Roi(x, y, this);
                break;
            case Toolbar.OVAL:
                roi = new OvalRoi(x, y, this);
                break;
            case Toolbar.POLYGON:
            case Toolbar.POLYLINE:
            case Toolbar.ANGLE:
                roi = new PolygonRoi(x, y, this);
                break;
            case Toolbar.FREEROI:
            case Toolbar.FREELINE:
                roi = new FreehandRoi(x, y, this);
                break;
            case Toolbar.LINE:
                roi = new Line(x, y, this);
                break;
            case Toolbar.TEXT:
                roi = new TextRoi(x, y, this);
                break;
        }
    }

    public void killRoi() {
        if (roi!=null) {
            saveRoi();
            roi = null;
            if (ip!=null)
            ip.resetRoi();
            draw();
        } 
    }
    
    void saveRoi() {
        if (roi!=null) {
            roi.endPaste();
            Rectangle r = roi.getBounds();
            if (r.width>0 && r.height>0) {
                Roi.previousRoi = (Roi)roi.clone();
                if (IJ.debugMode) IJ.log("saveRoi: "+roi);
            }
        }
    }
    
    public void restoreRoi() {
        if (Roi.previousRoi!=null) {
            Roi pRoi = Roi.previousRoi;
            Rectangle r = pRoi.getBounds();
            if (r.width<=width || r.height<=height) { // will it fit in this window?
                roi = (Roi)pRoi.clone();
                roi.setImage(this);
                if ((r.x+r.width)>width || (r.y+r.height)>height) // does it need to be moved?
                    roi.setLocation((width-r.width)/2, (height-r.height)/2);
                draw();
            }
        }
    }
    
    void revert() {
        if (roi!=null)
            roi.endPaste();
        trimProcessor();
        FileInfo fi = getOriginalFileInfo();
        if (fi!=null && fi.fileFormat!=FileInfo.UNKNOWN)
            new FileOpener(fi).revertToSaved(this);
        else if (url!=null) {
            IJ.showStatus("Loading: " + url);
            Opener opener = new Opener();
            try {
                ImagePlus imp = opener.openURL(url);
                if (imp!=null)
                    setProcessor(null, imp.getProcessor());
            } catch (Exception e) {} 
            if (getType()==COLOR_RGB && getTitle().endsWith(".jpg"))
                Opener.convertGrayJpegTo8Bits(this);
        }
        if (getProperty("FHT")!=null) {
            properties.remove("FHT");
            if (getTitle().startsWith("FFT of "))
                setTitle(getTitle().substring(6));
        }
        repaintWindow();
        IJ.showStatus("");
    }
    
    public FileInfo getFileInfo() {
        FileInfo fi = new FileInfo();
        fi.width = width;
        fi.height = height;
        fi.whiteIsZero = isInvertedLut();
        fi.intelByteOrder = false;
        setupProcessor();
        fi.pixels = ip.getPixels();
        Calibration cal = getCalibration();
        if (cal.scaled()) {
            fi.pixelWidth = cal.pixelWidth;
            fi.pixelHeight = cal.pixelHeight;
            fi.unit = cal.getUnit();
        }
        fi.frameInterval = cal.frameInterval;
        if (cal.calibrated()) {
            fi.calibrationFunction = cal.getFunction();
            fi.coefficients = cal.getCoefficients();
            fi.valueUnit = cal.getValueUnit();
        }
        switch (imageType) {
            case GRAY8: case COLOR_256:
                LookUpTable lut = createLut();
                if (imageType==COLOR_256 || !lut.isGrayscale())
                    fi.fileType = FileInfo.COLOR8;
                else
                    fi.fileType = FileInfo.GRAY8;
                fi.lutSize = lut.getMapSize();
                fi.reds = lut.getReds();
                fi.greens = lut.getGreens();
                fi.blues = lut.getBlues();
                break;
            case GRAY16:
                fi.fileType = fi.GRAY16_UNSIGNED;
                break;
            case GRAY32:
                fi.fileType = fi.GRAY32_FLOAT;
                break;
            case COLOR_RGB:
                fi.fileType = fi.RGB;
                break;
            default:
        }
        return fi;
    }
        
    public FileInfo getOriginalFileInfo() {
        return fileInfo;
    }

    public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h) {
        imageUpdateY = y;
        imageUpdateW = w;
        if ((flags & ERROR) != 0) {
            errorLoadingImage = true;
            return false;
        }
        imageLoaded = (flags & (ALLBITS|FRAMEBITS|ABORT)) != 0;
        return !imageLoaded;
    }

    public synchronized void flush() {
        if (locked || ignoreFlush)
            return;
        if (ip!=null) {
            ip.setPixels(null);
            ip = null;
        }
        if (roi!=null)
            roi.setImage(null);
        img = null;
        System.gc();
    }
    
    public void setIgnoreFlush(boolean ignoreFlush) {
        this.ignoreFlush = ignoreFlush;
    }
    
    public ImagePlus createImagePlus() {
        ImagePlus imp2 = new ImagePlus();
        imp2.setType(getType());
        imp2.setCalibration(getCalibration());
        return imp2;
    }

    public void copyScale(ImagePlus imp) {
        if (imp!=null && globalCalibration==null)
            setCalibration(imp.getCalibration());
    }

    public void startTiming() {
        startTime = System.currentTimeMillis();
    }

    public long getStartTime() {
        return startTime;
    }

    public Calibration getCalibration() {
        //IJ.log("getCalibration: "+globalCalibration+" "+calibration);
        if (globalCalibration!=null)
            return globalCalibration.copy();
        else {
            if (calibration==null)
                calibration = new Calibration(this);
            return calibration;
        }
    }

    public void setCalibration(Calibration cal) {
        //IJ.write("setCalibration: "+cal);
        if (cal==null)
            calibration = null;
        else {
            calibration = cal.copy();
            calibration.setImage(this);
        }
   }

    public void setGlobalCalibration(Calibration global) {
        //IJ.log("setGlobalCalibration ("+getTitle()+"): "+global);
        if (global==null)
            globalCalibration = null;
        else
            globalCalibration = global.copy();
    }
    
    public void mouseMoved(int x, int y) {
        IJ.showStatus(getLocationAsString(x,y) + getValueAsString(x,y));
        savex=x; savey=y;
    }
    
    private int savex, savey;
    
    public void updateStatusbarValue() {
        IJ.showStatus(getLocationAsString(savex,savey) + getValueAsString(savex,savey));
    }

    String getFFTLocation(int x, int y, Calibration cal) {
        double center = width/2.0;
        double r = Math.sqrt((x-center)*(x-center) + (y-center)*(y-center));
        if (r<1.0) r = 1.0;
        double theta = Math.atan2(y-center, x-center);
        theta = theta*180.0/Math.PI;
        if (theta<0) theta = 360.0+theta;
        String s = "r=";
        if (cal.scaled())
            s += IJ.d2s((width/r)*cal.pixelWidth,2) + " " + cal.getUnit() + "/c (" + IJ.d2s(r,0) + ")";
        else
            s += IJ.d2s(width/r,2) + " p/c (" + IJ.d2s(r,0) + ")";
        s += ", theta= " + IJ.d2s(theta,2) + IJ.degreeSymbol;
        return s;
    }

    public String getLocationAsString(int x, int y) {
        Calibration cal = getCalibration();
        if (getProperty("FHT")!=null)
            return getFFTLocation(x, height-y-1, cal);
        y = Analyzer.updateY(y, height);
        if (cal.scaled() && !IJ.altKeyDown()) {
            String s = " x="+IJ.d2s(cal.getX(x)) + ", y=" + IJ.d2s(cal.getY(y));
            return s;
        } else {
            String s =  " x="+x+", y=" + y;
            return s;
        }
    }
    
    private String getValueAsString(int x, int y) {
        Calibration cal = getCalibration();
        int[] v = getPixel(x, y);
        switch (getType()) {
            case GRAY8: case GRAY16:
                double cValue = cal.getCValue(v[0]);
                if (cValue==v[0])
                    return(", value=" + v[0]);
                else
                    return(", value=" + IJ.d2s(cValue) + " ("+v[0]+")");
            case GRAY32:
                return(", value=" + Float.intBitsToFloat(v[0]));
            case COLOR_256:
                return(", index=" + v[3] + ", value=" + v[0] + "," + v[1] + "," + v[2]);
            case COLOR_RGB:
                return(", value=" + v[0] + "," + v[1] + "," + v[2]);
            default: return("");
        }
    }
    
    public String toString() {
        return getTitle()+" "+width+"x"+height;
    }

    public ImageCanvas getCanvas() {
        return imageCanvas;
    }

    public void setCanvas(ImageCanvas ic) {
        imageCanvas = ic;
    }


}