Release 0.7a

[trakem2.git] / ini / trakem2 / utils / Utils.java

/**

TrakEM2 plugin for ImageJ(C).
Copyright (C) 2005,2006,2007,2008 Albert Cardona and Rodney Douglas.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation (http://www.gnu.org/licenses/gpl.txt )

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 

You may contact Albert Cardona at acardona at ini.phys.ethz.ch
Institute of Neuroinformatics, University of Zurich / ETH, Switzerland.

*/

package ini.trakem2.utils;

import ini.trakem2.ControlWindow;
import ini.trakem2.display.YesNoDialog;
import ini.trakem2.display.Layer;
import ini.trakem2.display.LayerSet;
import ini.trakem2.display.Pipe;
import ini.trakem2.persistence.Loader;
import ini.trakem2.imaging.FloatProcessorT2;
import ini.trakem2.vector.VectorString3D;

import ij.IJ;
import ij.ImagePlus;
import ij.Menus;
import ij.WindowManager;
import ij.gui.GenericDialog;
import ij.gui.YesNoCancelDialog;
import ij.gui.OvalRoi;
import ij.text.TextWindow;
import ij.measure.ResultsTable;
import ij.process.*;
import ij.io.*;
import ij.process.ImageProcessor;
import ij.process.ImageConverter;

import java.awt.Checkbox;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Component;
import java.awt.MenuBar;
import java.awt.Menu;
import java.awt.MenuItem;
import java.io.*;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import java.awt.event.MouseEvent;
import java.awt.event.InputEvent;
import java.awt.Event;
import javax.swing.SwingUtilities;

import java.lang.reflect.Field;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;
import java.util.Calendar;
import java.lang.Iterable;
import java.util.Iterator;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

/** Utils class: stores generic widely used methods. In particular, those for logging text messages (for debugging) and also some math and memory utilities.
 *
 *
 */
public class Utils implements ij.plugin.PlugIn {

        static public String version = "0.7a 2009-04-17";

        static public boolean debug = false;
        static public boolean debug_mouse = false;
        static public boolean debug_sql = false;
        static public boolean debug_event = false;
        static public boolean debug_clip = false; //clip for repainting
        static public boolean debug_thing = false;

        /** The error to use in floating-point or double floating point literal comparisons. */
        static public final double FL_ERROR = 0.0000001;

        static public void debug(String msg) {
                if (debug) IJ.log(msg);
        }

        static public void debugMouse(String msg) {
                if (debug_mouse) IJ.log(msg);
        }

        /** Avoid waiting on the AWT thread repainting ImageJ's log window. */
        static private final class LogDispatcher extends Thread {
                private final StringBuffer cache = new StringBuffer();
                private boolean loading = false;
                private boolean go = true;
                public LogDispatcher() {
                        super("T2-Log-Dispatcher");
                        setPriority(Thread.NORM_PRIORITY);
                        try { setDaemon(true); } catch (Exception e) { e.printStackTrace(); }
                        start();
                }
                public final void quit() {
                        go = false;
                        synchronized (this) { notify(); }
                }
                public final void log(final String msg) {
                        try {
                                synchronized (cache) {
                                        loading = true; // no need to synch, variable setting is atomic
                                        if (0 != cache.length()) cache.append('\n');
                                        cache.append(msg);
                                        loading = false;
                                }
                                Thread.yield();
                                if (loading) return;
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                        try {
                                synchronized (this) { notify(); }
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                public void run() {
                        while (go) {
                                try {
                                        synchronized (this) { wait(); }
                                        String msg = null;
                                        synchronized (cache) {
                                                if (0 != cache.length()) msg = cache.toString();
                                                cache.setLength(0);
                                        }
                                        IJ.log(msg);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
        static private LogDispatcher logger = new LogDispatcher();

        /** Avoid waiting on the AWT thread repainting ImageJ's status bar.
            Waits 100 ms before printing the status message; if too many status messages are being sent, the last one overrides all. */
        static private final class StatusDispatcher extends Thread {
                private String msg = null;
                private boolean loading = false;
                private boolean go = true;
                private double progress = -1;
                public StatusDispatcher() {
                        super("T2-Status-Dispatcher");
                        setPriority(Thread.NORM_PRIORITY);
                        try { setDaemon(true); } catch (Exception e) { e.printStackTrace(); }
                        start();
                }
                public final void quit() {
                        go = false;
                        synchronized (this) { notify(); }
                }
                public final void showStatus(final String msg) {
                        try {
                                synchronized (this) {
                                        this.msg = msg;
                                        notify();
                                }
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                public final void showProgress(final double progress) {
                        try {
                                synchronized (this) {
                                        this.progress = progress;
                                        notify();
                                }
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                public void run() {
                        while (go) {
                                try {
                                        // first part ensures it gets printed even if the notify was issued while not waiting
                                        synchronized (this) {
                                                if (null != msg) {
                                                        IJ.showStatus(msg);
                                                        msg = null;
                                                }
                                                if (-1 != progress) {
                                                        IJ.showProgress(progress);
                                                        progress = -1;
                                                }
                                                wait();
                                        }
                                        // allow some time for overwriting of messages
                                        Thread.sleep(100);
                                        /* // should not be needed
                                        // print the msg if necessary
                                        synchronized (this) {
                                                if (null != msg) {
                                                        IJ.showStatus(msg);
                                                        msg = null;
                                                }
                                        }
                                        */
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
        static private StatusDispatcher status = new StatusDispatcher();

        /** Initialize house keeping threads. */
        static public final void setup(final ControlWindow master) { // the ControlWindow acts as a switch: nobody can controls this because the CW constructor is private
                if (null != status) status.quit();
                status = new StatusDispatcher();
                if (null != logger) logger.quit();
                logger = new LogDispatcher();
        }

        /** Destroy house keeping threads. */
        static public final void destroy(final ControlWindow master) {
                if (null != status) { status.quit(); status = null; }
                if (null != logger) { logger.quit(); logger = null; }
        }

        /** Intended for the user to see. */
        static public final void log(final String msg) {
                if (ControlWindow.isGUIEnabled() && null != logger) {
                        logger.log(msg);
                } else {
                        System.out.println(msg);
                }
        }

        /** Print in all printable places: log window, System.out.println, and status bar.*/
        static public final void logAll(final String msg) {
                if (!ControlWindow.isGUIEnabled()) {
                        System.out.println(msg);
                        return;
                }
                System.out.println(msg);
                if (null != logger) logger.log(msg);
                if (null != status) status.showStatus(msg);
        }

        /** Intended for developers: prints to terminal. */
        static public final void log2(final String msg) {
                System.out.println(msg);
        }

        /** Pretty-print the object, for example arrays as [0, 1, 2]. */
        static public final void log2(final Object ob) {
                Utils.log2(null, ob);
        }
        /** Pretty-print the object, for example arrays as [0, 1, 2]. */
        static public final void log2(final String msg, final Object ob) {
                Utils.log2((null != msg ? msg : "") + ob + "\n\t" + Utils.toString(ob));
        }
        static public final void log2(final String msg, final Object ob1, final Object... ob) {
                final StringBuffer sb = new StringBuffer(null == msg ? "" : msg + "\n");
                sb.append(ob1.toString()).append(" : ").append(Utils.toString(ob1)).append('\n');
                for (int i=0; i<ob.length; i++) sb.append(ob.toString()).append(" : ").append(Utils.toString(ob[i])).append('\n');
                sb.setLength(sb.length()-1);
                Utils.log2(sb.toString());
        }

        /** Print an object; if it's an array, print each element, recursively, as [0, 1, 2] or [[0, 1, 2], [3, 4, 5]], etc, same for Iterable and Map objects. */
        static public final String toString(final Object ob) {
                if (null == ob) return "null";
                // Clojure could do this so much easier with a macro
                final StringBuffer sb = new StringBuffer();
                sb.append('[');
                char closing = ']';
                if (ob instanceof String[]) { // could be done with Object[] and recursive calls, but whatever
                        final String[] s = (String[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof int[]) {
                        final int[] s = (int[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof double[]) {
                        final double[] s = (double[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof float[]) {
                        final float[] s = (float[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof char[]) {
                        final char[] s = (char[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof Object[]) {
                        final Object[] s = (Object[])ob;
                        for (int i=0; i<s.length; i++) sb.append(Utils.toString(s[i])).append(", ");
                } else if (ob instanceof Iterable) {
                        final Iterable s = (Iterable)ob;
                        for (Iterator it = s.iterator(); it.hasNext(); ) sb.append(Utils.toString(it.next())).append(", ");
                } else if (ob instanceof Map) {
                        sb.setCharAt(0, '{');
                        closing = '}';
                        final Map s = (Map)ob;
                        for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) {
                                Map.Entry e = (Map.Entry)it.next();
                                sb.append(Utils.toString(e.getKey())).append(" => ").append(Utils.toString(e.getValue())).append(", ");
                        }
                } else if (ob instanceof long[]) {
                        final long[] s = (long[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof short[]) {
                        final short[] s = (short[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else if (ob instanceof boolean[]) {
                        final boolean[] s = (boolean[])ob;
                        for (int i=0; i<s.length; i++) sb.append(s[i]).append(", ");
                } else {
                        return ob.toString();
                }
                sb.setLength(sb.length()-2);
                sb.append(closing);
                sb.append('\n');
                return sb.toString();
        }

        static public void setDebug(boolean debug) {
                Utils.debug = debug;
        }

        static public void setDebugMouse(boolean debug_mouse) {
                Utils.debug_mouse = debug_mouse;
        }

        static public void setDebugSQL(boolean debug_sql) {
                Utils.debug_sql = debug_sql;
        }

        /** Find out which method from which class called the method where the printCaller is used; for debugging purposes.*/
        static public final void printCaller(Object called_object) {
                StackTraceElement[] elems = new Exception().getStackTrace();
                if (elems.length < 3) {
                        log2("Stack trace too short! No useful info");
                } else {
                        log2( "#### START TRACE ####\nObject " + called_object.getClass().getName() + " called at: " + elems[1].getFileName() + " " + elems[1].getLineNumber() + ": " + elems[1].getMethodName() + "()\n    by: " + elems[2].getClassName() + " " + elems[2].getLineNumber() + ": " + elems[2].getMethodName() + "()");
                        log2("==== END ====");
                }
        }

        static public final void printCaller(Object called_object, int lines) {
                StackTraceElement[] elems = new Exception().getStackTrace();
                if (elems.length < 3) {
                        log2("Stack trace too short! No useful info");
                } else {
                        log2( "#### START TRACE ####\nObject " + called_object.getClass().getName() + " called at: " + elems[1].getFileName() + " " + elems[1].getLineNumber() + ": " + elems[1].getMethodName() + "()\n    by: " + elems[2].getClassName() + " " + elems[2].getLineNumber() + ": " + elems[2].getMethodName() + "()");
                        for (int i=3; i<lines+2 && i<elems.length; i++) {
                                log2("\tby: " + elems[i].getClassName() + " " + elems[i].getLineNumber() + ": " + elems[i].getMethodName() + "()");
                        }
                        log2("==== END ====");
                }
        }

        /** Returns a String representation of the class of the object one step before in the stack trace. */
        static public final String caller(Object called) {
                StackTraceElement[] elems = new Exception().getStackTrace();
                if (elems.length < 3) {
                        log2("Stack trace too short! No useful info");
                        return null;
                } else {
                        return elems[2].getClassName();
                }
        }

        /**Restore ImageJ's MenuBar*/
        static public final void restoreMenuBar() {
                MenuBar menu_bar = Menus.getMenuBar();
                final int n_menus = menu_bar.getMenuCount();
                for (int i=0; i<n_menus;i++) {
                        Menu menu = menu_bar.getMenu(i);
                        restoreMenu(menu);
                }
                //make sure there isn't a null menu bar
                //WindowManager.getCurrentWindow().setMenuBar(menu_bar);
        }

        static private void restoreMenu(final Menu menu) {
                final int n_menuitems = menu.getItemCount();
                for (int i=0; i<n_menuitems; i++) {
                        MenuItem menu_item = menu.getItem(i);
                        if (menu_item instanceof Menu) {
                                restoreMenu((Menu)menu_item);
                        }
                        menu_item.setEnabled(true);
                }
        }

        static public final void showMessage(String msg) {
                if (!ControlWindow.isGUIEnabled()) System.out.println(msg);
                else IJ.showMessage(msg);
        }

        /** Runs the showMessage in a separate Thread. */
        static public final void showMessageT(final String msg) {
                new Thread() {
                        public void run() {
                                setPriority(Thread.NORM_PRIORITY);
                                Utils.showMessage(msg);
                        }
                }.start();
        }

        static public final void showStatus(final String msg, final boolean focus) {
                if (null == IJ.getInstance() || !ControlWindow.isGUIEnabled() || null == status) {
                        System.out.println(msg);
                        return;
                }
                if (focus) IJ.getInstance().toFront();

                status.showStatus(msg);
        }

        static public final void showStatus(final String msg) {
                showStatus(msg, false);
        }

        static private double last_progress = 0;
        static private int last_percent = 0;

        static public final void showProgress(final double p) {
                //IJ.showProgress(p); // never happens, can't repaint even though they are different threads
                if (null == IJ.getInstance() || !ControlWindow.isGUIEnabled() || null == status) {
                        if (0 == p) {
                                last_progress = 0; // reset
                                last_percent = 0;
                                return;
                        }
                        // don't show intervals smaller than 1%:
                        if (last_progress + 0.01 > p ) {
                                int percent = (int)(p * 100);
                                if (last_percent != percent) {
                                        System.out.println(percent + " %");
                                        last_percent = percent;
                                }
                        }
                        last_progress = p;
                        return;
                }

                status.showProgress(p);
        }

        static public void debugDialog() {
                // note: all this could nicely be done using reflection, so adding another boolean variable would be automatically added here (filtering by the prefix "debug").
                GenericDialog gd = new GenericDialog("Debug:");
                gd.addCheckbox("debug", debug);
                gd.addCheckbox("debug mouse", debug_mouse);
                gd.addCheckbox("debug sql", debug_sql);
                gd.addCheckbox("debug event", debug_event);
                gd.addCheckbox("debug clip", debug_clip);
                gd.addCheckbox("debug thing", debug_thing);
                gd.showDialog();
                if (gd.wasCanceled()) {
                        return;
                }
                debug = gd.getNextBoolean();
                debug_mouse = gd.getNextBoolean();
                debug_sql = gd.getNextBoolean();
                debug_event = gd.getNextBoolean();
                debug_clip = gd.getNextBoolean();
                debug_thing = gd.getNextBoolean();
        }


        /** Scan the WindowManager for open stacks.*/
        static public ImagePlus[] findOpenStacks() {
                ImagePlus[] imp = scanWindowManager("stacks");
                if (null == imp) return null;
                return imp;
        }

        /** Scan the WindowManager for non-stack images*/
        static public ImagePlus[] findOpenImages() {
                ImagePlus[] imp = scanWindowManager("images");
                if (null == imp) return null;
                return imp;
        }

        /** Scan the WindowManager for all open images, including stacks.*/
        static public ImagePlus[] findAllOpenImages() {
                return scanWindowManager("all");
        }

        static private ImagePlus[] scanWindowManager(String type) {
                // check if any stacks are opened within ImageJ
                int[] all_ids = WindowManager.getIDList();
                if (null == all_ids) return null;
                ImagePlus[] imp = new ImagePlus[all_ids.length];
                int next = 0;
                for (int i=0; i < all_ids.length; i++) {
                        ImagePlus image = WindowManager.getImage(all_ids[i]);
                        if (type.equals("stacks")) {
                                if (image.getStackSize() <= 1) {
                                        continue;
                                }
                        } else if (type.equals("images")) {
                                if (image.getStackSize() > 1) {
                                        continue;
                                }
                        }
                        // add:
                        imp[next] = image;
                        next++;
                }
                // resize the array if necessary
                if (next != all_ids.length) {
                        ImagePlus[] imp2 = new ImagePlus[next];
                        System.arraycopy(imp, 0, imp2, 0, next);
                        imp = imp2;
                }
                // return what has been found:
                if (0 == next) return null;
                return imp;
        }

        /**The path of the directory from which images have been recently loaded.*/
        static public String last_dir = ij.Prefs.getString(ij.Prefs.DIR_IMAGE);
        /**The path of the last opened file.*/
        static public String last_file = null;

        static public String cutNumber(double d, int n_decimals) {
                return cutNumber(d, n_decimals, false);
        }

        /** remove_trailing_zeros will leave at least one zero after the comma if appropriate. */
        static public final String cutNumber(final double d, final int n_decimals, final boolean remove_trailing_zeros) {
                final String num = new Double(d).toString();
                int i_e = num.indexOf("E-");
                if (-1 != i_e) {
                        final int exp = Integer.parseInt(num.substring(i_e+2));
                        if (n_decimals < exp) {
                                final StringBuffer sb = new StringBuffer("0.");
                                int count = n_decimals;
                                while (count > 0) {
                                        sb.append('0');
                                        count--;
                                }
                                return sb.toString(); // returns 0.000... as many zeros as desired n_decimals
                        }
                        // else move comma
                        StringBuffer sb = new StringBuffer("0.");
                        int count = exp -1;
                        while (count > 0) {
                                sb.append('0');
                                count--;
                        }
                        sb.append(num.charAt(0)); // the single number before the comma
                        // up to here there are 'exp' number of decimals appended
                        int i_end = 2 + n_decimals - exp;
                        if (i_end > i_e) i_end = i_e; // there arent' that ,any, so cut
                        sb.append(num.substring(2, i_end)); // all numbers after the comma
                        return sb.toString();
                }
                // else, there is no scientific notation to worry about
                final int i_dot = num.indexOf('.');
                final StringBuffer sb = new StringBuffer(num.substring(0, i_dot+1));
                for (int i=i_dot+1; i < (n_decimals + i_dot + 1) && i < num.length(); i++) {
                        sb.append(num.charAt(i));
                }
                // remove zeros from the end
                if (remove_trailing_zeros) {
                        for (int i=sb.length()-1; i>i_dot+1; i--) { // leave at least one zero after the comma
                                if ('0' == sb.charAt(i)) {
                                        sb.setLength(i);
                                } else {
                                        break;
                                }
                        }
                }
                return sb.toString();
        }

        static public final boolean check(final String msg) {
                YesNoCancelDialog dialog = new YesNoCancelDialog(IJ.getInstance(), "Execute?", msg);
                if (dialog.yesPressed()) {
                        return true;
                }
                return false;
        }

        static public final boolean checkYN(String msg) {
                YesNoDialog yn = new YesNoDialog(IJ.getInstance(), "Execute?", msg);
                if (yn.yesPressed()) return true;
                return false;
        }

        static public final String d2s(double d, int n_decimals) {
                return IJ.d2s(d, n_decimals);
        }

        static public final String[] getHexRGBColor(Color color) {
                int c = color.getRGB();
                String r = Integer.toHexString(((c&0x00FF0000)>>16));
                if (1 == r.length()) r = "0" + r;
                String g = Integer.toHexString(((c&0x0000FF00)>>8));
                if (1 == g.length()) g = "0" + g;
                String b = Integer.toHexString((c&0x000000FF));
                if (1 == b.length()) b = "0" + b;
                return new String[]{r, g, b};
        }

        static public final Color getRGBColorFromHex(String hex) {
                if (hex.length() < 6) return null;
                return new Color(Integer.parseInt(hex.substring(0, 2), 16), // parse in hexadecimal radix
                                 Integer.parseInt(hex.substring(2, 4), 16),
                                 Integer.parseInt(hex.substring(4, 6), 16));
        }

        static public final int[] get4Ints(final int hex) {
                return new int[]{((hex&0xFF000000)>>24),
                                 ((hex&0x00FF0000)>>16),
                                 ((hex&0x0000FF00)>> 8),
                                   hex&0x000000FF      };
        }

        public void run(String arg) {
                IJ.showMessage("TrakEM2", "TrakEM2 " + Utils.version + "\nCopyright Albert Cardona & Rodney Douglas\nInstitute for Neuroinformatics, Univ. Zurich / ETH");
        }

        static public final File chooseFile(String name, String extension) {
                return Utils.chooseFile(null, name, extension);
        }

        /** Select a file from the file system, for saving purposes. Prompts for overwritting if the file exists, unless the ControlWindow.isGUIEnabled() returns false (i.e. there is no GUI). */
        static public final File chooseFile(String default_dir, String name, String extension) {
                // using ImageJ's JFileChooser or internal FileDialog, according to user preferences.
                String user = System.getProperty("user.name");
                String name2 = null;
                if (null != name && null != extension) name2 = name + extension;
                else if (null != name) name2 = name;
                else if (null != extension) name2 = "untitled" + extension;
                if (null != default_dir) {
                        OpenDialog.setDefaultDirectory(default_dir);
                }
                SaveDialog sd = new SaveDialog("Save",
                                                OpenDialog.getDefaultDirectory(),
                                                name2,
                                                extension);

                String filename = sd.getFileName();
                if (null == filename || filename.toLowerCase().startsWith("null")) return null;
                File f = new File(sd.getDirectory() + "/" + filename);
                if (f.exists() && ControlWindow.isGUIEnabled()) {
                        YesNoCancelDialog d = new YesNoCancelDialog(IJ.getInstance(), "Overwrite?", "File " + filename + " exists! Overwrite?");
                        if (d.cancelPressed()) {
                                return null;
                        } else if (!d.yesPressed()) {
                                return chooseFile(name, extension);
                        }
                        // else if yes pressed, overwrite.
                }
                return f;
        }

        /** Returns null or the selected directory and file. */
        static public final String[] selectFile(String title_msg) {
                OpenDialog od = new OpenDialog("Select file", OpenDialog.getDefaultDirectory(), null);
                String file = od.getFileName();
                if (null == file || file.toLowerCase().startsWith("null")) return null;
                String dir = od.getDirectory();
                File f = null;
                if (null != dir) {
                        dir = dir.replace('\\', '/');
                        if (!dir.endsWith("/")) dir += "/";
                        f = new File(dir + "/" + file); // I'd use File.separator, but in Windows it fails
                }
                if (null == dir || !f.exists()) {
                        Utils.log2("No proper file selected.");
                        return null;
                }
                return new String[]{dir, file};
        }

        static public final boolean saveToFile(File f, String contents) {
                if (null == f) return false;
                try {
                        /*
                        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(f), contents.length()));
                        */
                        OutputStreamWriter dos = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(f), contents.length()), "8859_1"); // encoding in Latin 1 (for macosx not to mess around
                        //dos.writeBytes(contents);
                        dos.write(contents, 0, contents.length());
                        dos.flush();
                } catch (Exception e) {
                        IJError.print(e);
                        Utils.showMessage("ERROR: Most likely did NOT save your file.");
                        return false;
                }
                return true;
        }

        static public final boolean saveToFile(String name, String extension, String contents) {
                if (null == contents) {
                        Utils.log2("Utils.saveToFile: contents is null");
                        return false;
                }
                // save the file
                File f = Utils.chooseFile(name, extension);
                return Utils.saveToFile(f, contents);
        }

        /** Converts sequences of spaces into single space, and trims the ends. */
        static public final String cleanString(String s) {
                s = s.trim();
                while (-1 != s.indexOf("\u0020\u0020")) { // \u0020 equals a single space
                        s = s.replaceAll("\u0020\u0020", "\u0020");
                }
                return s;
        }

        static public final String openTextFile(final String path) {
                if (null == path || !new File(path).exists()) return null;
                final StringBuffer sb = new StringBuffer();
                BufferedReader r = null;
                try {
                        r = new BufferedReader(new FileReader(path));
                        while (true) {
                                String s = r.readLine();
                                if (null == s) break;
                                sb.append(s).append('\n'); // I am sure the reading can be done better
                        }
                } catch (Exception e) {
                        IJError.print(e);
                        if (null != r) try { r.close(); } catch (IOException ioe) { ioe.printStackTrace(); }
                        return null;
                }
                return sb.toString();
        }

        /** Returns the file found at path as an array of lines, or null if not found. */
        static public final String[] openTextFileLines(final String path) {
                if (null == path || !new File(path).exists()) return null;
                final ArrayList al = new ArrayList();
                try {
                        BufferedReader r = new BufferedReader(new FileReader(path));
                        while (true) {
                                String s = r.readLine();
                                if (null == s) break;
                                al.add(s);
                        }
                        r.close();
                } catch (Exception e) {
                        IJError.print(e);
                        return null;
                }
                final String[] sal = new String[al.size()];
                al.toArray(sal);
                return sal;
        }

        static public final char[] openTextFileChars(final String path) {
                File f = null;
                if (null == path || !(f = new File(path)).exists()) {
                        Utils.log("File not found: " + path);
                        return null;
                }
                final char[] src = new char[(int)f.length()]; // assumes file is small enough to fit in integer range!
                try {
                        BufferedReader r = new BufferedReader(new FileReader(path));
                        r.read(src, 0, src.length);
                        r.close();
                } catch (Exception e) {
                        IJError.print(e);
                        return null;
                }
                return src;
        }

        /** The cosinus between two vectors (in polar coordinates), by means of the dot product. */
        static public final double getCos(final double x1, final double y1, final double x2, final double y2) {
                return (x1 * x2 + y1 * y2) / (Math.sqrt(x1*x1 + y1*y1) * Math.sqrt(x2*x2 + y2*y2));
        }

        static public final String removeExtension(final String path) {
                final int i_dot = path.lastIndexOf('.');
                if (-1 == i_dot || i_dot + 4 != path.length()) return path;
                else return path.substring(0, i_dot);
        }

        /** A helper for GenericDialog checkboxes to control other the enabled state of other GUI elements in the same dialog. */
        static public final void addEnablerListener(final Checkbox master, final Component[] enable, final Component[] disable) {
                master.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent ie) {
                                if (ie.getStateChange() == ItemEvent.SELECTED) {
                                        process(enable, true);
                                        process(disable, false);
                                } else {
                                        process(enable, false);
                                        process(disable, true);
                                }
                        }
                        private void process(final Component[] c, final boolean state) {
                                if (null == c) return;
                                for (int i=0; i<c.length; i++) c[i].setEnabled(state);
                        }
                });
        }

        static public final boolean wrongImageJVersion() {
                boolean b = IJ.versionLessThan("1.37g");
                if (b) Utils.showMessage("TrakEM2 requires ImageJ 1.37g or above.");
                return b;
        }

        static public final boolean java3d = isJava3DInstalled();

        static private final boolean isJava3DInstalled() {
                try {
                        Class p3f = Class.forName("javax.vecmath.Point3f");
                } catch (ClassNotFoundException cnfe) {
                        return false;
                }
                return true;
        }

        static public final void addLayerRangeChoices(final Layer selected, final GenericDialog gd) {
                Utils.addLayerRangeChoices(selected, selected, gd);
        }

        static public final void addLayerRangeChoices(final Layer first, final Layer last, final GenericDialog gd) {
                final String[] layers = new String[first.getParent().size()];
                final ArrayList al_layer_titles =  new ArrayList();
                int i = 0;
                for (Iterator it = first.getParent().getLayers().iterator(); it.hasNext(); ) {
                        layers[i] = first.getProject().findLayerThing((Layer)it.next()).toString();
                        al_layer_titles.add(layers[i]);
                        i++;
                }
                final int i_first = first.getParent().indexOf(first);
                final int i_last = last.getParent().indexOf(last);
                gd.addChoice("Start: ", layers, layers[i_first]);
                final Vector v = gd.getChoices();
                final Choice cstart = (Choice)v.get(v.size()-1);
                gd.addChoice("End: ", layers, layers[i_last]);
                final Choice cend = (Choice)v.get(v.size()-1);
                cstart.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent ie) {
                                int index = al_layer_titles.indexOf(ie.getItem());
                                if (index > cend.getSelectedIndex()) cend.select(index);
                        }
                });
                cend.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent ie) {
                                int index = al_layer_titles.indexOf(ie.getItem());
                                if (index < cstart.getSelectedIndex()) cstart.select(index);
                        }
                });
        }

        static public final void addLayerChoice(final String label, final Layer selected, final GenericDialog gd) {
                final String[] layers = new String[selected.getParent().size()];
                final ArrayList al_layer_titles =  new ArrayList();
                int i = 0;
                for (Iterator it = selected.getParent().getLayers().iterator(); it.hasNext(); ) {
                        layers[i] = selected.getProject().findLayerThing((Layer)it.next()).toString();
                        al_layer_titles.add(layers[i]);
                        i++;
                }
                final int i_layer = selected.getParent().indexOf(selected);
                gd.addChoice(label, layers, layers[i_layer]);

        }

        static public final void addRGBColorSliders(final GenericDialog gd, final Color color) {
                gd.addSlider("Red: ", 0, 255, color.getRed());
                gd.addSlider("Green: ", 0, 255, color.getGreen());
                gd.addSlider("Blue: ", 0, 255, color.getBlue());
        }

        /** Converts the ImageProcessor to an ImageProcessor of the given type, or the same if of equal type. */
        static final public ImageProcessor convertTo(final ImageProcessor ip, final int type, final boolean scaling) {
                switch (type) {
                        case ImagePlus.GRAY8:
                                return ip.convertToByte(scaling);
                        case ImagePlus.GRAY16:
                                return ip.convertToShort(scaling);
                        case ImagePlus.GRAY32:
                                return ip.convertToFloat();
                        case ImagePlus.COLOR_RGB:
                                return ip.convertToRGB();
                        case ImagePlus.COLOR_256:
                                ImagePlus imp = new ImagePlus("", ip.convertToRGB());
                                new ImageConverter(imp).convertRGBtoIndexedColor(256);
                                return imp.getProcessor();
                        default:
                                return null;
                }
        }

        /** Will make a new double[] array, then fit in it as many points from the given array as possible according to the desired new length. If the new length is shorter that a.length, it will shrink and crop from the end; if larger, the extra spaces will be set with zeros. */
        static public final double[] copy(final double[] a, final int new_length) {
                final double[] b = new double[new_length];
                final int len = a.length > new_length ? new_length : a.length; 
                System.arraycopy(a, 0, b, 0, len);
                return b;
        }

        static public final double[] copy(final double[] a, final int first, final int new_length) {
                final double[] b = new double[new_length];
                final int len = new_length < a.length - first ? new_length : a.length - first;
                System.arraycopy(a, first, b, 0, len);
                return b;
        }

        /** Reverse in place an array of doubles. */
        static public final void reverse(final double[] a) {
                for (int left=0, right=a.length-1; left<right; left++, right--) {
                        double tmp = a[left];
                        a[left] = a[right];
                        a[right] = tmp;
                }
        }

        static public final double[] toDouble(final int[] a, final int len) {
                final double[] b = new double[len];
                for (int i=0; i<len; i++) b[i] = a[i];
                return b;
        }

        static public final int[] toInt(final double[] a, final int len) {
                final int[] b = new int[len];
                for (int i=0; i<len; i++) b[i] = (int) a[i];
                return b;
        }

        /** OS-agnostic diagnosis of whether the click was for the contextual popup menu. */
        static public final boolean isPopupTrigger(final MouseEvent me) {
                // ImageJ way, in ij.gui.ImageCanvas class, plus an is-windows switch to prevent meta key from poping up for MacOSX
                return (me.isPopupTrigger() && me.getButton() != 0)  || (IJ.isWindows() && 0 != (me.getModifiers() & Event.META_MASK) );
        }

        /** Repaint the given Component on the swing repaint thread (aka "SwingUtilities.invokeLater"). */
        static public final void updateComponent(final Component c) {
                //c.invalidate();
                //c.validate();
                // ALL that was needed: to put it into the swing repaint queue ... couldn't they JUST SAY SO
                SwingUtilities.invokeLater(new Runnable() {
                        public void run() {
                                c.repaint();
                        }
                });
        }
        /** Like calling pack() on a Frame but on a Component. */
        static public final void revalidateComponent(final Component c) {
                SwingUtilities.invokeLater(new Runnable() {
                        public void run() {
                                c.invalidate();
                                c.validate();
                                c.repaint();
                        }
                });
        }

        /** Returns the time as HH:MM:SS */
        static public final String now() {
                /* Java time management is retarded. */
                final Calendar c = Calendar.getInstance();
                final int hour = c.get(Calendar.HOUR_OF_DAY);
                final int min = c.get(Calendar.MINUTE);
                final int sec = c.get(Calendar.SECOND);
                final StringBuffer sb = new StringBuffer();
                if (hour < 10) sb.append('0');
                sb.append(hour).append(':');
                if (min < 10) sb.append('0');
                sb.append(min).append(':');
                if (sec < 10) sb.append(0);
                return sb.append(sec).toString();
        }

        static public final void sleep(final long miliseconds) {
                try { Thread.currentThread().sleep(miliseconds); } catch (Exception e) { e.printStackTrace(); }
        }

        /** Mix colors visually: red + green = yellow, etc.*/
        static public final Color mix(Color c1, Color c2) {
                final float[] b = Color.RGBtoHSB(c1.getRed(), c1.getGreen(), c1.getBlue(), new float[3]);
                final float[] c = Color.RGBtoHSB(c2.getRed(), c2.getGreen(), c2.getBlue(), new float[3]);
                final float[] a = new float[3];
                // find to which side the hue values are closer, since hue space is a a circle
                // hue values all between 0 and 1
                float h1 = b[0];
                float h2 = c[0];
                if (h1 < h2) {
                        float tmp = h1;
                        h1 = h2;
                        h2 = tmp;
                }
                float d1 = h2 - h1;
                float d2 = 1 + h1 - h2;
                if (d1 < d2) {
                        a[0] = h1 + d1 / 2;
                } else {
                        a[0] = h2 + d2 / 2;
                        if (a[0] > 1) a[0] -= 1;
                }

                for (int i=1; i<3; i++) a[i] = (b[i] + c[i]) / 2; // only Saturation and Brightness can be averaged
                return Color.getHSBColor(a[0], a[1], a[2]);
        }

        /** 1 A, 2 B, 3 C  ---  26 - z, 27 AA, 28 AB, 29 AC  --- 26*27 AAA */
        static public final String getCharacter(int i) {
                i--;
                int k = i / 26;
                char c = (char)((i % 26) + 65); // 65 is 'A'
                if (0 == k) return Character.toString(c);
                return new StringBuffer().append(getCharacter(k)).append(c).toString();
        }

        /** Get by reflection a private or protected field in the given object. */
        static public final Object getField(final Object ob, final String field_name) {
                if (null == ob || null == field_name) return null;
                try {
                        Field f = ob.getClass().getDeclaredField(field_name);
                        f.setAccessible(true);
                        return f.get(ob);
                } catch (Exception e) {
                        IJError.print(e);
                }
                return null;
        }

        /** A method that circumvents the findMinAndMax when creating a float processor from an existing processor.  Ignores color calibrations and does no scaling at all. */
        static public final FloatProcessor fastConvertToFloat(final ByteProcessor ip) {
                final byte[] pix = (byte[])ip.getPixels();
                final float[] data = new float[pix.length];
                for (int i=0; i<pix.length; i++) data[i] = pix[i]&0xff;
                final FloatProcessor fp = new FloatProcessorT2(ip.getWidth(), ip.getHeight(), data, ip.getColorModel(), ip.getMin(), ip.getMax());
                return fp;
        }
        /** A method that circumvents the findMinAndMax when creating a float processor from an existing processor.  Ignores color calibrations and does no scaling at all. */
        static public final FloatProcessor fastConvertToFloat(final ShortProcessor ip) {
                final short[] pix = (short[])ip.getPixels();
                final float[] data = new float[pix.length];
                for (int i=0; i<pix.length; i++) data[i] = pix[i]&0xffff;
                final FloatProcessor fp = new FloatProcessorT2(ip.getWidth(), ip.getHeight(), data, ip.getColorModel(), ip.getMin(), ip.getMax());
                return fp;
        }
        /** A method that circumvents the findMinAndMax when creating a float processor from an existing processor.  Ignores color calibrations and does no scaling at all. */
        static public final FloatProcessor fastConvertToFloat(final ImageProcessor ip, final int type) {
                switch (type) {
                        case ImagePlus.GRAY16: return fastConvertToFloat((ShortProcessor)ip);
                        case ImagePlus.GRAY32: return (FloatProcessor)ip;
                        case ImagePlus.GRAY8:
                        case ImagePlus.COLOR_256: return fastConvertToFloat((ByteProcessor)ip);
                        case ImagePlus.COLOR_RGB: return (FloatProcessor)ip.convertToFloat(); // SLOW
                }
                return null;
        }
        static public final FloatProcessor fastConvertToFloat(final ImageProcessor ip) {
                if (ip instanceof ByteProcessor) return fastConvertToFloat((ByteProcessor)ip);
                if (ip instanceof ShortProcessor) return fastConvertToFloat((ShortProcessor)ip);
                return (FloatProcessor)ip.convertToFloat();
        }

        /** Creates a new ResultsTable with the given window title and column titles, and 2 decimals of precision, or if one exists for the given window title, returns it. */
        static public final ResultsTable createResultsTable(final String title, final String[] columns) {
                TextWindow tw = (TextWindow)WindowManager.getFrame(title);
                if (null != tw) {
                        // hacking again ... missing a getResultsTable() method in TextWindow
                        ResultsTable rt = (ResultsTable)Utils.getField(tw.getTextPanel(), "rt");
                        if (null != rt) return rt; // assumes columns will be identical
                }
                // else create a new one
                ResultsTable rt = new ResultsTable();
                rt.setPrecision(2);
                for (int i=0; i<columns.length; i++) rt.setHeading(i, columns[i]);
                //
                return rt;
        }

        static public final ImageProcessor createProcessor(final int type, final int width, final int height) {
                switch (type) {
                        case ImagePlus.GRAY8: return new ByteProcessor(width, height);
                        case ImagePlus.GRAY16: return new ShortProcessor(width, height);
                        case ImagePlus.GRAY32: return new FloatProcessor(width, height);
                        case ImagePlus.COLOR_RGB: return new ColorProcessor(width, height);
                }
                return null;
        }

        /** Paints an approximation of the pipe into the set of slices. */
        public void paint(final Pipe pipe, final Map<Layer,ImageProcessor> slices, final int value, final float scale) {
                VectorString3D vs = pipe.asVectorString3D();
                vs.resample(1); // one pixel
                double[] px = vs.getPoints(0);
                double[] py = vs.getPoints(1);
                double[] pz = vs.getPoints(2);
                double[] pr = vs.getDependent(0);
                // For each point
                for (int i=0; i<px.length-1; i++) {
                        ImageProcessor ip = slices.get(pipe.getLayerSet().getNearestLayer(pz[i]));
                        if (null == ip) continue;
                        OvalRoi ov = new OvalRoi((int)((px[i] - pr[i]) * scale),
                                                 (int)((py[i] - pr[i]) * scale),
                                                 (int)(pr[i]*2*scale), (int)(pr[i]*2*scale));
                        ip.setRoi(ov);
                        ip.setValue(value);
                        ip.fill(ip.getMask());
                }
        }

        static final public boolean matches(final String pattern, final String s) {
                return Pattern.compile(pattern).matcher(s).matches();
        }

        static final public boolean isValidIdentifier(final String s) {
                if (null == s) return false;
                if (!Utils.matches("^[a-zA-Z]+[a-zA-Z1-9_]*$", s)) {
                        Utils.log("Invalid identifier " + s);
                        return false;
                }
                return true;
        }

        /**
        user=> (def pat #"\b[a-zA-Z]+[\w]*\b")
        #'user/pat
        user=>(re-seq pat "abc def 1a334")
        ("abc" "def")
        user=> (re-seq pat "abc def a334")
        ("abc" "def" "a334")

        Then concatenate all good words with underscores.
        Returns null when nothing valid is found in 's'.
        */
        static final public String makeValidIdentifier(final String s) {
                if (null == s) return null;
                // Concatenate all good groups with underscores:
                final Pattern pat = Pattern.compile("\\b[a-zA-Z]+[\\w]*\\b");
                final Matcher m = pat.matcher(s);
                final StringBuffer sb = new StringBuffer();
                while (m.find()) {
                        sb.append(m.group()).append('_');
                }
                if (0 == sb.length()) return null;
                // Remove last underscore
                sb.setLength(sb.length()-1);
                return sb.toString();
        }

        static final public int indexOf(final Object needle, final Object[] haystack) {
                for (int i=0; i<haystack.length; i++) {
                        if (haystack[i].equals(needle)) return i;
                }
                return -1;
        }

        /** Remove the file, or if it's a directory, recursively go down subdirs and remove all contents, but will stop on encountering a non-hidden file that is not an empty dir. */
        static public final boolean removeFile(final File f) {
                return Utils.removeFile(f, true, null);
        }

        // Accumulates removed files (not directories) into removed_paths, if not null.
        static private final boolean removeFile(final File f, final boolean stop_if_dir_not_empty, final ArrayList<String> removed_paths) {
                if (null == f || !f.exists()) return false;
                try {
                        if (!Utils.isTrakEM2Subfile(f)) {
                                Utils.log2("REFUSING to remove file " + f + "\n-->REASON: not in a '/trakem2.' file path");
                                return false;
                        }

                        // If it's not a directory, just delete it
                        if (!f.isDirectory()) {
                                return f.delete();
                        }
                        // Else delete all directories:
                        final ArrayList<File> dirs = new ArrayList<File>();
                        dirs.add(f);
                        // Non-recursive version ... I hate java
                        do {
                                int i = dirs.size() -1;
                                final File fdir = dirs.get(i);
                                Utils.log2("Examining folder for deletion: " + fdir.getName());
                                boolean remove = true;
                                for (final File file : fdir.listFiles()) {
                                        String name = file.getName();
                                        if (name.equals(".") || name.equals("..")) continue;
                                        if (file.isDirectory()) {
                                                remove = false;
                                                dirs.add(file);
                                        } else if (file.isHidden()) {
                                                if (!file.delete()) {
                                                        Utils.log("Failed to delete hidden file " + file.getAbsolutePath());
                                                        return false;
                                                }
                                                if (null != removed_paths) removed_paths.add(file.getAbsolutePath());
                                        } else if (stop_if_dir_not_empty) {
                                                //Utils.log("Not empty: cannot remove dir " + fdir.getAbsolutePath());
                                                return false;
                                        } else {
                                                if (!file.delete()) {
                                                        Utils.log("Failed to delete visible file " + file.getAbsolutePath());
                                                        return false;
                                                }
                                                if (null != removed_paths) removed_paths.add(file.getAbsolutePath());
                                        }
                                }
                                if (remove) {
                                        dirs.remove(i);
                                        if (!fdir.delete()) {
                                                return false;
                                        } else {
                                                Utils.log2("Removed folder " + fdir.getAbsolutePath());
                                        }
                                }
                        } while (dirs.size() > 0);
                        
                        return true;

                } catch (Exception e) {
                        IJError.print(e);
                }
                return false;
        }

        /** Returns true if the file cannonical path contains "/trakem2." (adjusted for Windows as well). */
        static public boolean isTrakEM2Subfile(final File f) throws Exception {
                return isTrakEM2Subpath(f.getCanonicalPath());
        }

        /** Returns true if the path contains "/trakem2." (adjusted for Windows as well). */
        static public boolean isTrakEM2Subpath(String path) {
                if (IJ.isWindows()) path = path.replace('\\', '/');
                return -1 != path.toLowerCase().indexOf("/trakem2.");
        }

        /** Returns true if all files and their subdirectories, recursively, under parent folder have been removed.
         *  For safety reasons, this function will return false immediately if the parent file path does not include a
         *  lowercase "trakem2." in it.
         *  If removed_paths is not null, all removed full paths are added to it.
         */
        static public final boolean removePrefixedFiles(final File parent, final String prefix, final ArrayList<String> removed_paths) {
                if (null == parent || !parent.isDirectory()) return false;

                try {
                        if (!Utils.isTrakEM2Subfile(parent)) {
                                Utils.log2("REFUSING to remove files recursively under folder " + parent + "\n-->REASON: not in a '/trakem2.' file path");
                                return false;
                        }

                        boolean success = true;

                        final File[] list = parent.listFiles(new FilenameFilter() {
                                public boolean accept(File dir, String name) {
                                        if (name.startsWith(prefix)) return true;
                                        return false;
                                }
                        });

                        ArrayList<String> a = null;
                        if (null != removed_paths) a = new ArrayList<String>();

                        if (null != list && list.length > 0) {
                                for (final File f : list) {
                                        if (!Utils.removeFile(f, false, a)) success = false;
                                        if (null != removed_paths) {
                                                removed_paths.addAll(a);
                                                a.clear();
                                        }
                                }
                        }

                        return true;

                } catch (Exception e) {
                        IJError.print(e);
                }
                return false;
        }

        /** The CTRL key functionality is passed over to the COMMAND key (aka META key) in a MacOSX. */
        static public final int getControlModifier() {
                return IJ.isMacOSX() ? InputEvent.META_MASK
                                     : InputEvent.CTRL_MASK;
        }

        /** The CTRL key functionality is passed over to the COMMAND key (aka META key) in a MacOSX. */
        static public final boolean isControlDown(final InputEvent e) {
                return IJ.isMacOSX() ? e.isMetaDown()
                                     : e.isControlDown();
        }
}