Examples with DirectoryChooser ij.io.DirectoryChooser used on opensource projects

Example 6 with DirectoryChooser

use of ij.io.DirectoryChooser in project TrakEM2 by trakem2.

the class FSLoader method importStackAsPatches.

/**
 * Returns the last Patch.
 */
protected Patch importStackAsPatches(final Project project, final Layer first_layer, final double x, final double y, final ImagePlus imp_stack, final boolean as_copy, final String filepath) {
    Utils.log2("FSLoader.importStackAsPatches filepath=" + filepath);
    String target_dir = null;
    if (as_copy) {
        DirectoryChooser dc = new DirectoryChooser("Folder to save images");
        target_dir = dc.getDirectory();
        // user canceled dialog
        if (null == target_dir)
            return null;
        if (IJ.isWindows())
            target_dir = target_dir.replace('\\', '/');
        if (target_dir.length() - 1 != target_dir.lastIndexOf('/')) {
            target_dir += "/";
        }
    }
    // Double.MAX_VALUE is a flag to indicate "add centered"
    double pos_x = Double.MAX_VALUE != x ? x : first_layer.getLayerWidth() / 2 - imp_stack.getWidth() / 2;
    double pos_y = Double.MAX_VALUE != y ? y : first_layer.getLayerHeight() / 2 - imp_stack.getHeight() / 2;
    final double thickness = first_layer.getThickness();
    final String title = Utils.removeExtension(imp_stack.getTitle()).replace(' ', '_');
    Utils.showProgress(0);
    Patch previous_patch = null;
    final int n = imp_stack.getStackSize();
    final ImageStack stack = imp_stack.getStack();
    final boolean virtual = stack.isVirtual();
    final VirtualStack vs = virtual ? (VirtualStack) stack : null;
    for (int i = 1; i <= n; i++) {
        Layer layer = first_layer;
        double z = first_layer.getZ() + (i - 1) * thickness;
        // will create new layer if not found
        if (i > 1)
            layer = first_layer.getParent().getLayer(z, thickness, true);
        if (null == layer) {
            Utils.log("Display.importStack: could not create new layers.");
            return null;
        }
        String patch_path = null;
        ImagePlus imp_patch_i = null;
        if (virtual) {
            // because we love inefficiency, every time all this is done again
            // VirtualStack vs = (VirtualStack)imp_stack.getStack();
            String vs_dir = vs.getDirectory().replace('\\', '/');
            if (!vs_dir.endsWith("/"))
                vs_dir += "/";
            String iname = vs.getFileName(i);
            patch_path = vs_dir + iname;
            Utils.log2("virtual stack: patch path is " + patch_path);
            releaseToFit(new File(patch_path).length() * 3);
            Utils.log2(i + " : " + patch_path);
            imp_patch_i = openImage(patch_path);
        } else {
            ImageProcessor ip = stack.getProcessor(i);
            if (as_copy)
                ip = ip.duplicate();
            imp_patch_i = new ImagePlus(title + "__slice=" + i, ip);
        }
        String label = stack.getSliceLabel(i);
        if (null == label)
            label = "";
        Patch patch = null;
        if (as_copy) {
            patch_path = target_dir + cleanSlashes(imp_patch_i.getTitle()) + ".zip";
            ini.trakem2.io.ImageSaver.saveAsZip(imp_patch_i, patch_path);
            patch = new Patch(project, label + " " + title + " " + i, pos_x, pos_y, imp_patch_i);
        } else if (virtual) {
            patch = new Patch(project, label, pos_x, pos_y, imp_patch_i);
        } else {
            patch_path = filepath + "-----#slice=" + i;
            // Utils.log2("path is "+ patch_path);
            final AffineTransform atp = new AffineTransform();
            atp.translate(pos_x, pos_y);
            patch = new Patch(project, getNextId(), label + " " + title + " " + i, imp_stack.getWidth(), imp_stack.getHeight(), imp_stack.getWidth(), imp_stack.getHeight(), imp_stack.getType(), false, imp_stack.getProcessor().getMin(), imp_stack.getProcessor().getMax(), atp);
            patch.addToDatabase();
        // Utils.log2("type is " + imp_stack.getType());
        }
        Utils.log2("B: " + i + " : " + patch_path);
        addedPatchFrom(patch_path, patch);
        if (!as_copy && !virtual) {
            if (// each slice separately
            virtual)
                // each slice separately
                cache(patch, imp_patch_i);
            else
                // uses the entire stack, shared among all Patch instances
                cache(patch, imp_stack);
        }
        // submit for regeneration
        if (isMipMapsRegenerationEnabled())
            regenerateMipMaps(patch);
        if (null != previous_patch)
            patch.link(previous_patch);
        layer.add(patch);
        previous_patch = patch;
        Utils.showProgress(i * (1.0 / n));
    }
    Utils.showProgress(1.0);
    // return the last patch
    return previous_patch;
}

Example 7 with DirectoryChooser

use of ij.io.DirectoryChooser in project TrakEM2 by trakem2.

the class FSLoader method parseXMLOptions.

/**
 * Specific options for the Loader which exist as attributes to the Project XML node.
 */
public void parseXMLOptions(final HashMap<String, String> ht_attributes) {
    // Adding some logic to support old projects which lack a storage folder and a mipmaps folder
    // and also to prevent errors such as those created when manualy tinkering with the XML file
    // or renaming directories, etc.
    String ob = ht_attributes.remove("storage_folder");
    if (null != ob) {
        String sf = ob.replace('\\', '/');
        if (isRelativePath(sf)) {
            sf = getParentFolder() + sf;
        }
        if (isURL(sf)) {
            // can't be an URL
            Utils.log2("Can't have an URL as the path of a storage folder.");
        } else {
            File f = new File(sf);
            if (f.exists() && f.isDirectory()) {
                this.dir_storage = sf;
            } else {
                Utils.log2("storage_folder was not found or is invalid: " + ob);
            }
        }
    }
    if (null == this.dir_storage) {
        // select the directory where the xml file lives.
        this.dir_storage = getParentFolder();
        if (null == this.dir_storage || isURL(this.dir_storage))
            this.dir_storage = null;
        if (null == this.dir_storage && ControlWindow.isGUIEnabled()) {
            // tip for headless runners whose program gets "stuck"
            Utils.log2("Asking user for a storage folder in a dialog.");
            DirectoryChooser dc = new DirectoryChooser("REQUIRED: select a storage folder");
            this.dir_storage = dc.getDirectory();
        }
        if (null == this.dir_storage) {
            IJ.showMessage("TrakEM2 requires a storage folder.\nTemporarily your home directory will be used.");
            this.dir_storage = System.getProperty("user.home");
        }
    }
    // fix
    if (null != this.dir_storage) {
        if (IJ.isWindows())
            this.dir_storage = this.dir_storage.replace('\\', '/');
        if (!this.dir_storage.endsWith("/"))
            this.dir_storage += "/";
    }
    Utils.log2("storage folder is " + this.dir_storage);
    // 
    ob = ht_attributes.remove("mipmaps_folder");
    if (null != ob) {
        String mf = ob.replace('\\', '/');
        if (isRelativePath(mf)) {
            mf = getParentFolder() + mf;
        }
        if (isURL(mf)) {
            this.dir_mipmaps = mf;
        // TODO must disable input somehow, so that images are not edited.
        } else {
            File f = new File(mf);
            if (f.exists() && f.isDirectory()) {
                this.dir_mipmaps = mf;
            } else {
                Utils.log2("mipmaps_folder was not found or is invalid: " + ob);
            }
        }
    }
    ob = ht_attributes.remove("mipmaps_regen");
    if (null != ob) {
        this.mipmaps_regen = Boolean.parseBoolean(ob);
    }
    ob = ht_attributes.get("n_mipmap_threads");
    if (null != ob) {
        int n_threads = Math.max(1, Integer.parseInt(ob));
        FSLoader.restartMipMapThreads(n_threads);
    }
    // parse the unuid before attempting to create any folders
    this.unuid = ht_attributes.remove("unuid");
    // Attempt to get an existing UNUId folder, for .xml files that share the same mipmaps folder
    if (ControlWindow.isGUIEnabled() && null == this.unuid) {
        obtainUNUIdFolder();
    }
    if (null == this.dir_mipmaps) {
        // create a new one inside the dir_storage, which can't be null
        createMipMapsDir(dir_storage);
        if (null != this.dir_mipmaps && ControlWindow.isGUIEnabled() && null != IJ.getInstance()) {
            notifyMipMapsOutOfSynch();
        }
    }
    // fix
    if (null != this.dir_mipmaps && !this.dir_mipmaps.endsWith("/"))
        this.dir_mipmaps += "/";
    Utils.log2("mipmaps folder is " + this.dir_mipmaps);
    if (null == unuid) {
        IJ.log("OLD VERSION DETECTED: your trakem2\nproject has been updated to the new format.\nPlease SAVE IT to avoid regenerating\ncached data when reopening it.");
        Utils.log2("Creating unuid for project " + this);
        this.unuid = createUNUId(dir_storage);
        fixStorageFolders();
        Utils.log2("Now mipmaps folder is " + this.dir_mipmaps);
        if (null != dir_masks)
            Utils.log2("Now masks folder is " + this.dir_masks);
    }
    final String s_mipmaps_format = (String) ht_attributes.remove("mipmaps_format");
    if (null != s_mipmaps_format) {
        final int mipmaps_format = Integer.parseInt(s_mipmaps_format.trim());
        if (mipmaps_format >= 0 && mipmaps_format < MIPMAP_FORMATS.length) {
            Utils.log2("Set mipmap format to " + mipmaps_format);
            setMipMapFormat(mipmaps_format);
        }
    }
}

Example 8 with DirectoryChooser

use of ij.io.DirectoryChooser in project TrakEM2 by trakem2.

the class Distortion_Correction method correctImages.

protected String correctImages() {
    if (!sp.applyCorrection) {
        sp.target_dir = System.getProperty("user.dir").replace('\\', '/') + "/distCorr_tmp/";
        System.out.println("Tmp target directory: " + sp.target_dir);
        if (new File(sp.target_dir).exists()) {
            System.out.println("removing old tmp directory!");
            final String[] filesToDelete = new File(sp.target_dir).list();
            for (int i = 0; i < filesToDelete.length; i++) {
                System.out.println(filesToDelete[i]);
                final boolean deleted = new File(sp.target_dir + filesToDelete[i]).delete();
                if (!deleted)
                    IJ.log("Error: Could not remove temporary directory!");
            }
            new File(sp.target_dir).delete();
        }
        try {
            // Create one directory
            final boolean success = (new File(sp.target_dir)).mkdir();
            if (success)
                new File(sp.target_dir).deleteOnExit();
        } catch (final Exception e) {
            IJ.showMessage("Error! Could not create temporary directory. " + e.getMessage());
        }
    }
    if (sp.target_dir == "" || null == sp.target_dir) {
        final DirectoryChooser dc = new DirectoryChooser("Target Directory");
        sp.target_dir = dc.getDirectory();
        if (null == sp.target_dir)
            return null;
        sp.target_dir = sp.target_dir.replace('\\', '/');
        if (!sp.target_dir.endsWith("/"))
            sp.target_dir += "/";
    }
    final String[] namesTarget = new File(sp.target_dir).list(new FilenameFilter() {

        @Override
        public boolean accept(final File dir, final String namesTarget) {
            final int idot = namesTarget.lastIndexOf('.');
            if (-1 == idot)
                return false;
            return namesTarget.contains(namesTarget.substring(idot).toLowerCase());
        }
    });
    if (namesTarget.length > 0)
        IJ.showMessage("Overwrite Message", "There  are already images in that directory. These will be used for evaluation.");
    else {
        IJ.showStatus("Correcting Images");
        final Thread[] threads = MultiThreading.newThreads();
        final AtomicInteger ai = new AtomicInteger(sp.applyCorrection ? 0 : sp.firstImageIndex);
        for (int ithread = 0; ithread < threads.length; ++ithread) {
            threads[ithread] = new Thread() {

                @Override
                public void run() {
                    setPriority(Thread.NORM_PRIORITY);
                    for (int i = ai.getAndIncrement(); i < (sp.applyCorrection ? sp.names.length : (sp.firstImageIndex + sp.numberOfImages)); i = ai.getAndIncrement()) {
                        IJ.log("Correcting image " + sp.names[i]);
                        final ImagePlus imps = new Opener().openImage(sp.source_dir + sp.names[i]);
                        imps.setProcessor(imps.getTitle(), imps.getProcessor().convertToShort(false));
                        final ImageProcessor[] transErg = nlt.transform(imps.getProcessor());
                        imps.setProcessor(imps.getTitle(), transErg[0]);
                        if (!sp.applyCorrection)
                            new File(sp.target_dir + sp.names[i]).deleteOnExit();
                        new FileSaver(imps).saveAsTiff(sp.target_dir + sp.names[i]);
                    }
                }
            };
        }
        MultiThreading.startAndJoin(threads);
    }
    return sp.target_dir;
}

Example 9 with DirectoryChooser

use of ij.io.DirectoryChooser in project TrakEM2 by trakem2.

the class Compare method variabilityAnalysis.

/**
 * @param reference_project If null, then the first one found in the Project.getProjects() lists is used.
 * @param regex A String (can be null) to filter objects by, to limit what gets processed.
 *              If regex is not null, then only ProjectThing nodes with the matching regex are analyzed (shallow: none of their children are questioned, but pipes will be built from them all).
 * @param generate_plots Whether to generate the variability plots at all.
 * @param show_plots If generate_plots, whether to show the plots in a stack image window or to save them.
 * @param show_3D Whether to show any 3D data.
 * @param show_condensed_3D If show_3D, whether to show the condensed vector strings, i.e. the "average" pipes.
 * @param show_sources_3D If show_3D, whether to show the source pipes from which the condensed vector string was generated.
 * @param sources_color_table Which colors to give to the pipes of which Project.
 * @param show_envelope_3D If show_3D, whether to generate the variability envelope.
 * @param envelope_alpha If show_envelope_3D, the envelope takes an alpha value between 0 (total transparency) and 1 (total opacity)
 * @param delta_envelope The delta to resample the envelope to. When smaller than or equal to 1, no envelope resampling occurs.
 * @param show_axes_3D If show_3D, whether to display the reference axes as well.
 * @param heat_map If show_3D, whether to color the variability with a Fire LUT.
 *                 If not show_condensed_3D, then the variability is shown in color-coded 3D spheres placed at the entry point to the neuropile.
 * @param map_condensed If not null, all VectorString3D are put into this map.
 * @param projects The projects to use.
 */
public static Bureaucrat variabilityAnalysis(final Project reference_project, final String regex, final String[] ignore, final boolean show_cata_dialog, final boolean generate_plots, final boolean show_plots, final String plot_dir_, final boolean show_3D, final boolean show_condensed_3D, final boolean show_sources_3D, final Map<Project, Color> sources_color_table, final boolean show_envelope_3D, final float envelope_alpha, final double delta_envelope, final int envelope_type, final boolean show_axes_3D, final boolean heat_map, final Map<String, VectorString3D> map_condensed, final Project[] projects) {
    // gather all open projects
    final Project[] p = null == projects ? Project.getProjects().toArray(new Project[0]) : projects;
    // make the reference_project be the first in the array
    if (null != reference_project && reference_project != p[0]) {
        for (int i = 0; i < p.length; i++) {
            if (reference_project == p[i]) {
                p[i] = p[0];
                p[0] = reference_project;
                break;
            }
        }
    }
    final Worker worker = new Worker("Comparing all to all") {

        @Override
        public void run() {
            startedWorking();
            try {
                Utils.log2("Asking for CATAParameters...");
                final CATAParameters cp = new CATAParameters();
                cp.regex = regex;
                cp.delta_envelope = delta_envelope;
                cp.envelope_type = envelope_type;
                if (show_cata_dialog && !cp.setup(false, regex, true, true)) {
                    finishedWorking();
                    return;
                }
                // so source points are stored in VectorString3D for each resampled and interpolated point
                cp.with_source = true;
                // Store a series of results, depending on options
                final HashMap<String, Display3D> results = new HashMap<String, Display3D>();
                String plot_dir = plot_dir_;
                if (generate_plots && !show_plots) {
                    // Save plots
                    if (null == plot_dir) {
                        final DirectoryChooser dc = new DirectoryChooser("Choose plots directory");
                        plot_dir = dc.getDirectory();
                        if (null == plot_dir) {
                            finishedWorking();
                            return;
                        }
                    }
                    if (IJ.isWindows())
                        plot_dir = plot_dir.replace('\\', '/');
                    if (!plot_dir.endsWith("/"))
                        plot_dir += "/";
                }
                Utils.log2("Gathering chains...");
                // Gather chains that do not match the ignore regexes
                // will transform them as well to the reference found in the first project in the p array
                Object[] ob = gatherChains(p, cp, ignore);
                ArrayList<Chain> chains = (ArrayList<Chain>) ob[0];
                // to keep track of each project's chains
                final ArrayList[] p_chains = (ArrayList[]) ob[1];
                ob = null;
                if (null == chains) {
                    finishedWorking();
                    return;
                }
                Utils.log2("Collecting bundles...");
                final HashMap<Project, HashMap<String, VectorString3D>> axes = new HashMap<Project, HashMap<String, VectorString3D>>();
                // Sort out into groups by unique names of lineage bundles
                final HashMap<String, ArrayList<Chain>> bundles = new HashMap<String, ArrayList<Chain>>();
                for (final Chain chain : chains) {
                    String title = chain.getCellTitle();
                    final String t = title.toLowerCase();
                    // unnamed
                    if (0 == t.indexOf('[') || 0 == t.indexOf('#'))
                        continue;
                    Utils.log("Accepting " + title);
                    title = title.substring(0, title.indexOf(' '));
                    // lineage bundle instance chains
                    ArrayList<Chain> bc = bundles.get(title);
                    if (null == bc) {
                        bc = new ArrayList<Chain>();
                        bundles.put(title, bc);
                    }
                    bc.add(chain);
                }
                Utils.log2("Found " + bundles.size() + " bundles.");
                chains = null;
                if (null != cp.regex && show_axes_3D && axes.size() < 3) {
                    // Must find the Mushroom Body lobes separately
                    final String cp_regex = cp.regex;
                    cp.regex = "mb";
                    final Object[] o = gatherChains(p, cp, ignore);
                    final ArrayList<Chain> lobes = (ArrayList<Chain>) o[0];
                    Utils.logAll("Found " + lobes.size() + " chains for lobes");
                    for (final Chain chain : lobes) {
                        final String t = chain.getCellTitle().toLowerCase();
                        if (-1 != t.indexOf("peduncle") || -1 != t.indexOf("medial lobe") || -1 != t.indexOf("dorsal lobe")) {
                            Utils.logAll("adding " + t);
                            final Project pr = chain.pipes.get(0).getProject();
                            HashMap<String, VectorString3D> m = axes.get(pr);
                            if (null == m) {
                                m = new HashMap<String, VectorString3D>();
                                axes.put(pr, m);
                            }
                            m.put(t, chain.vs);
                            continue;
                        }
                    }
                    cp.regex = cp_regex;
                } else {
                    Utils.logAll("Not: cp.regex = " + cp.regex + "  show_axes_3D = " + show_axes_3D + "  axes.size() = " + axes.size());
                }
                final HashMap<String, VectorString3D> condensed = new HashMap<String, VectorString3D>();
                Utils.log2("Condensing each bundle...");
                // Condense each into a single VectorString3D
                for (final Map.Entry<String, ArrayList<Chain>> entry : bundles.entrySet()) {
                    final ArrayList<Chain> bc = entry.getValue();
                    if (bc.size() < 2) {
                        Utils.log2("Skipping single: " + entry.getKey());
                        continue;
                    }
                    final VectorString3D[] vs = new VectorString3D[bc.size()];
                    for (int i = 0; i < vs.length; i++) vs[i] = bc.get(i).vs;
                    final VectorString3D c = condense(cp, vs, this);
                    c.setCalibration(p[0].getRootLayerSet().getCalibrationCopy());
                    condensed.put(entry.getKey(), c);
                    if (this.hasQuitted())
                        return;
                }
                // Store:
                if (null != map_condensed) {
                    map_condensed.putAll(condensed);
                }
                if (generate_plots) {
                    Utils.log2("Plotting stdDev for each condensed bundle...");
                    // Y axis: the stdDev at each point, computed from the group of points that contribute to each
                    for (final Map.Entry<String, VectorString3D> e : condensed.entrySet()) {
                        final String name = e.getKey();
                        final VectorString3D c = e.getValue();
                        final Plot plot = makePlot(cp, name, c);
                        // FAILS//plot.addLabel(10, cp.plot_height-5, name); // must be added after setting size
                        if (show_plots)
                            plot.show();
                        else if (null != plot_dir)
                            new FileSaver(plot.getImagePlus()).saveAsPng(plot_dir + name.replace('/', '-') + ".png");
                    }
                }
                if (show_3D) {
                    final HashMap<String, Color> heat_table = new HashMap<String, Color>();
                    if (heat_map || show_envelope_3D) {
                        // Create a Fire LUT
                        final ImagePlus lutimp = new ImagePlus("lut", new ByteProcessor(4, 4));
                        IJ.run(lutimp, "Fire", "");
                        final IndexColorModel icm = (IndexColorModel) lutimp.getProcessor().getColorModel();
                        final byte[] reds = new byte[256];
                        final byte[] greens = new byte[256];
                        final byte[] blues = new byte[256];
                        icm.getReds(reds);
                        icm.getGreens(greens);
                        icm.getBlues(blues);
                        final List<String> names = new ArrayList<String>(bundles.keySet());
                        Collections.sort(names);
                        // find max stdDev
                        double max = 0;
                        final HashMap<String, Double> heats = new HashMap<String, Double>();
                        for (final String name : names) {
                            final VectorString3D vs_merged = condensed.get(name);
                            if (null == vs_merged) {
                                Utils.logAll("WARNING could not find a condensed pipe for " + name);
                                continue;
                            }
                            final double[] stdDev = vs_merged.getStdDevAtEachPoint();
                            // double avg = 0;
                            // for (int i=0; i<stdDev.length; i++) avg += stdDev[i];
                            // avg = avg/stdDev.length;
                            Arrays.sort(stdDev);
                            // median is more representative than average
                            final double median = stdDev[stdDev.length / 2];
                            if (max < median)
                                max = median;
                            heats.put(name, median);
                        }
                        for (final Map.Entry<String, Double> e : heats.entrySet()) {
                            final String name = e.getKey();
                            final double median = e.getValue();
                            // scale between 0 and max to get a Fire LUT color:
                            int index = (int) ((median / max) * 255);
                            if (index > 255)
                                index = 255;
                            final Color color = new Color(0xff & reds[index], 0xff & greens[index], 0xff & blues[index]);
                            Utils.log2(new StringBuilder(name).append('\t').append(median).append('\t').append(reds[index]).append('\t').append(greens[index]).append('\t').append(blues[index]).toString());
                            heat_table.put(name, color);
                        }
                    }
                    final LayerSet common_ls = new LayerSet(p[0], -1, "Common", 10, 10, 0, 0, 0, 512, 512, false, 2, new AffineTransform());
                    final Display3D d3d = Display3D.get(common_ls);
                    float env_alpha = envelope_alpha;
                    if (env_alpha < 0) {
                        Utils.log2("WARNING envelope_alpha is invalid: " + envelope_alpha + "\n    Using 0.4f instead");
                        env_alpha = 0.4f;
                    } else if (env_alpha > 1)
                        env_alpha = 1.0f;
                    for (final String name : bundles.keySet()) {
                        final ArrayList<Chain> bc = bundles.get(name);
                        final VectorString3D vs_merged = condensed.get(name);
                        if (null == vs_merged) {
                            Utils.logAll("WARNING: could not find a condensed vs for " + name);
                            continue;
                        }
                        if (show_sources_3D) {
                            if (null != sources_color_table) {
                                final HashSet<String> titles = new HashSet<String>();
                                for (final Chain chain : bc) {
                                    final Color c = sources_color_table.get(chain.getRoot().getProject());
                                    final String title = chain.getCellTitle();
                                    String t = title;
                                    int i = 2;
                                    while (titles.contains(t)) {
                                        t = title + "-" + i;
                                        i += 1;
                                    }
                                    titles.add(t);
                                    Display3D.addMesh(common_ls, chain.vs, t, null != c ? c : Color.gray);
                                }
                            } else {
                                for (final Chain chain : bc) Display3D.addMesh(common_ls, chain.vs, chain.getCellTitle(), Color.gray);
                            }
                        }
                        if (show_condensed_3D) {
                            Display3D.addMesh(common_ls, vs_merged, name + "-condensed", heat_map ? heat_table.get(name) : Color.red);
                        }
                        if (show_envelope_3D) {
                            double[] widths = makeEnvelope(cp, vs_merged);
                            if (cp.delta_envelope > 1) {
                                vs_merged.addDependent(widths);
                                vs_merged.resample(cp.delta_envelope);
                                widths = vs_merged.getDependent(0);
                            }
                            Display3D.addMesh(common_ls, vs_merged, name + "-envelope", heat_map ? heat_table.get(name) : Color.red, widths, env_alpha);
                        } else if (heat_map) {
                            // Show spheres in place of envelopes, at the starting tip (neuropile entry point)
                            final double x = vs_merged.getPoints(0)[0];
                            final double y = vs_merged.getPoints(1)[0];
                            final double z = vs_merged.getPoints(2)[0];
                            final double r = 10;
                            final Color color = heat_table.get(name);
                            if (null == color) {
                                Utils.logAll("WARNING: heat table does not have a color for " + name);
                                continue;
                            }
                            final Content sphere = d3d.getUniverse().addMesh(ij3d.Mesh_Maker.createSphere(x, y, z, r), new Color3f(heat_table.get(name)), name + "-sphere", 1);
                        }
                    }
                    if (show_axes_3D) {
                        for (int i = 0; i < p.length; i++) {
                            final Map<String, VectorString3D> m = axes.get(p[i]);
                            if (null == m) {
                                Utils.log2("No axes found for project " + p[i]);
                                continue;
                            }
                            for (final Map.Entry<String, VectorString3D> e : m.entrySet()) {
                                Display3D.addMesh(common_ls, e.getValue(), e.getKey() + "-" + i, Color.gray);
                            }
                        }
                    }
                    results.put("d3d", Display3D.get(common_ls));
                }
                this.result = results;
                Utils.log2("Done.");
            } catch (final Exception e) {
                IJError.print(e);
            } finally {
                finishedWorking();
            }
        }
    };
    return Bureaucrat.createAndStart(worker, p[0]);
}

Example 10 with DirectoryChooser

use of ij.io.DirectoryChooser in project TrakEM2 by trakem2.

the class Project method newFSProject.

public static Project newFSProject(String arg, TemplateThing template_root, String storage_folder, boolean autocreate_one_layer) {
    if (Utils.wrongImageJVersion())
        return null;
    FSLoader loader = null;
    try {
        String dir_project = storage_folder;
        if (null == dir_project || !new File(dir_project).isDirectory()) {
            DirectoryChooser dc = new DirectoryChooser("Select storage folder");
            dir_project = dc.getDirectory();
            // user cancelled dialog
            if (null == dir_project)
                return null;
            if (!Loader.canReadAndWriteTo(dir_project)) {
                Utils.showMessage("Can't read/write to the selected storage folder.\nPlease check folder permissions.");
                return null;
            }
            if (IJ.isWindows())
                dir_project = dir_project.replace('\\', '/');
        }
        loader = new FSLoader(dir_project);
        Project project = createNewProject(loader, !("blank".equals(arg) || "amira".equals(arg)), template_root);
        // help the helpless users:
        if (autocreate_one_layer && null != project && ControlWindow.isGUIEnabled()) {
            Utils.log2("Creating automatic Display.");
            // add a default layer
            Layer layer = new Layer(project, 0, 1, project.layer_set);
            project.layer_set.add(layer);
            project.layer_tree.addLayer(project.layer_set, layer);
            layer.recreateBuckets();
            Display.createDisplay(project, layer);
        }
        try {
            // waiting cheaply for asynchronous swing calls
            Thread.sleep(200);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
        if ("amira".equals(arg) || "stack".equals(arg)) {
            // forks into a task thread
            loader.importStack(project.layer_set.getLayer(0), null, true);
        }
        project.restartAutosaving();
        return project;
    } catch (Exception e) {
        IJError.print(e);
        if (null != loader)
            loader.destroy();
    }
    return null;
}