FileSaver.java

package ij.io;
import java.awt.*;
import java.io.*;
import java.util.zip.*;
import ij.*;
import ij.process.*;
import ij.measure.Calibration;
import ij.plugin.filter.Analyzer;
import ij.plugin.frame.Recorder;
import javax.swing.*;
import javax.swing.filechooser.*;

public class FileSaver {

    private static String defaultDirectory = null;
    private ImagePlus imp;
    private FileInfo fi;
    private String name;
    private String directory;

    public FileSaver(ImagePlus imp) {
        this.imp = imp;
        fi = imp.getFileInfo();
    }

    public boolean save() {
        //if (imp.getURL()!=null)
            return saveAsTiff();
    }
    
    String getPath(String type, String extension) {
        JFileChooser fc = new JFileChooser();
        if (Opener.defaultDirectory != null) {
            fc.setCurrentDirectory(Opener.defaultDirectory);
        }
        File dummyFile = new File("foobar"+extension);
        for (int i=0; i < Opener.FILE_FILTERS.length; i++) {
            if (Opener.FILE_FILTERS[i].accept(dummyFile)) {
                fc.addChoosableFileFilter(Opener.FILE_FILTERS[i]);
            }
        }
        int returnVal = fc.showSaveDialog(IJ.getInstance());
        
        if (returnVal!=JFileChooser.APPROVE_OPTION) {
            return "";
        }
        String path = fc.getCurrentDirectory().getPath()+File.separator+fc.getSelectedFile();
        return path;
    }
    
    public boolean saveAsTiff() {
        String path = getPath("TIFF", ".tif");
        if (path==null)
            return false;
        if (imp.getStackSize()==1)
            return saveAsTiff(path);
        else
            return saveAsTiffStack(path);
    }
    
    public boolean saveAsTiff(String path) {
        fi.nImages = 1;
        fi.description = getDescriptionString();
        try {
            TiffEncoder file = new TiffEncoder(fi);
            DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
            file.write(out);
            out.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        updateImp(fi, fi.TIFF);
        return true;
    }

    public boolean saveAsTiffStack(String path) {
        return true;
    }

    public boolean saveAsZip() {
        String path = getPath("TIFF/ZIP", ".zip");
        if (path==null)
            return false;
        else
            return saveAsZip(path);
    }
    
    public boolean saveAsZip(String path) {
        //fi.nImages = 1;
        if (!path.endsWith(".zip"))
            path = path+".zip";
        if (name==null)
            name = imp.getTitle();
        if (name.endsWith(".zip"))
            name = name.substring(0,name.length()-4);
        if (!name.endsWith(".tif"))
            name = name+".tif";
        fi.description = getDescriptionString();
        try {
            ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(path));
            DataOutputStream out = new DataOutputStream(new BufferedOutputStream(zos));
            zos.putNextEntry(new ZipEntry(name));
            TiffEncoder te = new TiffEncoder(fi);
            te.write(out);
            out.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        updateImp(fi, fi.TIFF);
        return true;
    }

    public static boolean okForGif(ImagePlus imp) {
        int type = imp.getType();
        if (type==ImagePlus.COLOR_RGB || type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
            return false;
        } else
            return true;
        
    }

    public boolean saveAsGif() {
        if (!okForGif(imp)) {
            IJ.error("To save as Gif, the image must be \"8-bit\" or \"8-bit Color\".");
            return false;
        }
        String path = getPath("GIF", ".gif");
        if (path==null)
            return false;
        else
            return saveAsGif(path);
    }
    
    public boolean saveAsGif(String path) {
        if (!okForGif(imp))
            return false;
        try {
            byte[] pixels = (byte[])imp.getProcessor().getPixels();
            GifEncoder encoder = new GifEncoder(fi.width, fi.height, pixels, fi.reds, fi.greens, fi.blues);
            OutputStream output = new BufferedOutputStream(new FileOutputStream(path));
            encoder.write(output);
            output.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        updateImp(fi, fi.GIF_OR_JPG);
        return true;
    }

    public static boolean okForJpeg(ImagePlus imp) {
        return true;
    }

    public boolean saveAsJpeg() {
        String path = getPath("JPEG", ".jpg");
        if (path==null)
            return false;
        else
            return saveAsJpeg(path);
    }

    public boolean saveAsJpeg(String path) {
        Object jpegWriter = null;
        if (IJ.isJava2())
            IJ.runPlugIn("ij.plugin.JpegWriter", path);
        else
            IJ.runPlugIn("Jpeg_Writer", path);      
        if (!(imp.getType()==ImagePlus.GRAY16 || imp.getType()==ImagePlus.GRAY32))
            updateImp(fi, fi.GIF_OR_JPG);
        return true;
    }

    public boolean saveAsBmp() {
        String path = getPath("BMP", ".bmp");
        if (path==null)
            return false;
        else
            return saveAsBmp(path);
    }

    public boolean saveAsBmp(String path) {
        IJ.runPlugIn("ij.plugin.BMP_Writer", path);
        return true;
    }

    public boolean saveAsPng() {
        if (!IJ.isJava14()) {
            IJ.showMessage("Save As PNG", "Java 1.4 or later required");
            return false;
        }
        String path = getPath("PNG", ".png");
        if (path==null)
            return false;
        else
            return saveAsPng(path);
    }

    public boolean saveAsPng(String path) {
        IJ.runPlugIn("ij.plugin.PNG_Writer", path);
        return true;
    }

    public boolean saveAsRaw() {
        String path = getPath("Raw", ".raw");
        if (path==null)
            return false;
        if (imp.getStackSize()==1)
            return saveAsRaw(path);
        else
            return saveAsRawStack(path);
    }
    
    public boolean saveAsRaw(String path) {
        fi.nImages = 1;
        try {
            ImageWriter file = new ImageWriter(fi);
            OutputStream out = new BufferedOutputStream(new FileOutputStream(path));
            file.write(out);
            out.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        updateImp(fi, fi.RAW);
        return true;
    }

    public boolean saveAsRawStack(String path) {
        return false;
    }

    public boolean saveAsText() {
        String path = getPath("Text", ".txt");
        if (path==null)
            return false;
        return saveAsText(path);
    }
    
    public boolean saveAsText(String path) {
        try {
            Calibration cal = imp.getCalibration();
            int precision = Analyzer.getPrecision();
            TextEncoder file = new TextEncoder(imp.getProcessor(), cal, precision);
            DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
            file.write(out);
            out.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        return true;
    }

    public boolean saveAsLut() {
        if (imp.getType()==ImagePlus.COLOR_RGB) {
            IJ.error("RGB Images do not have a LUT.");
            return false;
        }
        String path = getPath("LUT", ".lut");
        if (path==null)
            return false;
        return saveAsLut(path);
    }
    
    public boolean saveAsLut(String path) {
        LookUpTable lut = imp.createLut();
        int mapSize = lut.getMapSize();
        if (mapSize==0) {
            IJ.error("RGB Images do not have a LUT.");
            return false;
        }
        if (mapSize<256) {
            IJ.error("Cannot save LUTs with less than 256 entries.");
            return false;
        }
        byte[] reds = lut.getReds(); 
        byte[] greens = lut.getGreens();
        byte[] blues = lut.getBlues();
        byte[] pixels = new byte[768];
        for (int i=0; i<256; i++) {
            pixels[i] = reds[i];
            pixels[i+256] = greens[i];
            pixels[i+512] = blues[i];
        }
        FileInfo fi = new FileInfo();
        fi.width = 768;
        fi.height = 1;
        fi.pixels = pixels;

        try {
            ImageWriter file = new ImageWriter(fi);
            OutputStream out = new FileOutputStream(path);
            file.write(out);
            out.close();
        }
        catch (IOException e) {
            showErrorMessage(e);
            return false;
        }
        return true;
    }

    private void updateImp(FileInfo fi, int fileFormat) {
        imp.changes = false;
        if (name!=null) {
            fi.fileFormat = fileFormat;
            fi.fileName = name;
            fi.directory = directory;
            if (fileFormat==fi.TIFF)
                fi.offset = TiffEncoder.IMAGE_START;
            fi.description = null;
            imp.setTitle(name);
            imp.setFileInfo(fi);
        }
    }

    void showErrorMessage(IOException e) {
        IJ.error("An error occured writing the file.\n \n" + e);
    }

    String getDescriptionString() {
        StringBuffer sb = new StringBuffer(100);
        sb.append("ImageJ="+ImageJ.VERSION+"\n");
        if (fi.nImages>1)
            sb.append("images="+fi.nImages+"\n");
        if (fi.unit!=null)
            sb.append("unit="+fi.unit+"\n");
        if (fi.valueUnit!=null) {
            sb.append("cf="+fi.calibrationFunction+"\n");
            if (fi.coefficients!=null) {
                for (int i=0; i<fi.coefficients.length; i++)
                    sb.append("c"+i+"="+fi.coefficients[i]+"\n");
            }
            sb.append("vunit="+fi.valueUnit+"\n");
        }
        
        // get stack z-spacing and fps
        if (fi.nImages>1) {
            if (fi.pixelDepth!=0.0 && fi.pixelDepth!=1.0)
                sb.append("spacing="+fi.pixelDepth+"\n");
            if (fi.frameInterval!=0.0) {
                double fps = 1.0/fi.frameInterval;
                if ((int)fps==fps)
                    sb.append("fps="+(int)fps+"\n");
                else
                    sb.append("fps="+fps+"\n");
            }
        }
        
        // get min and max display values
        ImageProcessor ip = imp.getProcessor();
        double min = ip.getMin();
        double max = ip.getMax();
        int type = imp.getType();
        boolean enhancedLut = (type==ImagePlus.GRAY8 || type==ImagePlus.COLOR_256) && (min!=0.0 || max !=255.0);
        if (enhancedLut || type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
            sb.append("min="+min+"\n");
            sb.append("max="+max+"\n");
        }
        
        // get non-zero origins
        Calibration cal = imp.getCalibration();
        if (cal.xOrigin!=0.0)
            sb.append("xorigin="+cal.xOrigin+"\n");
        if (cal.yOrigin!=0.0)
            sb.append("yorigin="+cal.yOrigin+"\n");
        if (cal.zOrigin!=0.0)
            sb.append("zorigin="+cal.zOrigin+"\n");
        if (cal.info!=null && cal.info.length()<=64 && cal.info.indexOf('=')==-1 && cal.info.indexOf('\n')==-1)
            sb.append("info="+cal.info+"\n");           
        sb.append((char)0);
        return new String(sb);
    }

}