Examples with TemplateThing ini.trakem2.tree.TemplateThing used on opensource projects

Example 16 with TemplateThing

use of ini.trakem2.tree.TemplateThing in project TrakEM2 by trakem2.

the class Project method getUniqueTypes.

/**
 * Returns a list of existing unique types in the template tree
 * (thus the 'project' type is not included, nor the label).
 * The basic types are guaranteed to be present even if there are no instances in the template tree.
 * As a side effect, this method populates the HashMap of unique TemplateThing types.
 */
public String[] getUniqueTypes() {
    synchronized (ht_unique_tt) {
        // ensure the basic types (pipe, ball, profile, profile_list) are present
        if (!ht_unique_tt.containsKey("profile"))
            ht_unique_tt.put("profile", new TemplateThing("profile"));
        if (!ht_unique_tt.containsKey("profile_list")) {
            TemplateThing tpl = new TemplateThing("profile_list");
            tpl.addChild((TemplateThing) ht_unique_tt.get("profile"));
            ht_unique_tt.put("profile_list", tpl);
        }
        if (!ht_unique_tt.containsKey("pipe"))
            ht_unique_tt.put("pipe", new TemplateThing("pipe"));
        if (!ht_unique_tt.containsKey("polyline"))
            ht_unique_tt.put("polyline", new TemplateThing("polyline"));
        if (!ht_unique_tt.containsKey("treeline"))
            ht_unique_tt.put("treeline", new TemplateThing("treeline"));
        if (!ht_unique_tt.containsKey("areatree"))
            ht_unique_tt.put("areatree", new TemplateThing("areatree"));
        if (!ht_unique_tt.containsKey("connector"))
            ht_unique_tt.put("connector", new TemplateThing("connector"));
        if (!ht_unique_tt.containsKey("ball"))
            ht_unique_tt.put("ball", new TemplateThing("ball"));
        if (!ht_unique_tt.containsKey("area_list"))
            ht_unique_tt.put("area_list", new TemplateThing("area_list"));
        if (!ht_unique_tt.containsKey("dissector"))
            ht_unique_tt.put("dissector", new TemplateThing("dissector"));
        // this should be done automagically by querying the classes in the package ... but java can't do that without peeking into the .jar .class files. Buh.
        TemplateThing project_tt = ht_unique_tt.remove("project");
        /* // debug
		for (Iterator it = ht_unique_tt.keySet().iterator(); it.hasNext(); ) {
			Utils.log2("class: " + it.next().getClass().getName());
		} */
        final String[] ut = new String[ht_unique_tt.size()];
        ht_unique_tt.keySet().toArray(ut);
        ht_unique_tt.put("project", project_tt);
        Arrays.sort(ut);
        return ut;
    }
}

Example 17 with TemplateThing

use of ini.trakem2.tree.TemplateThing in project TrakEM2 by trakem2.

the class Project method openDBProject.

/**
 * Open a TrakEM2 project from the database. Queries the database for existing projects and if more than one, asks which one to open.
 */
public static Project openDBProject() {
    if (Utils.wrongImageJVersion())
        return null;
    DBLoader loader = new DBLoader();
    if (!loader.isReady())
        return null;
    // check connection
    if (!loader.isConnected()) {
        Utils.showMessage("Can't talk to database.");
        loader.destroy();
        return null;
    }
    // query the database for existing projects
    Project[] projects = loader.getProjects();
    if (null == projects) {
        Utils.showMessage("Can't talk to database (null list of projects).");
        loader.destroy();
        return null;
    }
    Project project = null;
    if (0 == projects.length) {
        Utils.showMessage("No projects in this database.");
        loader.destroy();
        return null;
    } else if (1 == projects.length) {
        project = projects[0];
    } else {
        // ask to choose one
        String[] titles = new String[projects.length];
        for (int i = 0; i < projects.length; i++) {
            titles[i] = projects[i].title;
        }
        GenericDialog gd = new GenericDialog("Choose");
        gd.addMessage("Choose project to open:");
        gd.addChoice("project: ", titles, titles[titles.length - 1]);
        gd.showDialog();
        if (gd.wasCanceled()) {
            loader.destroy();
            return null;
        }
        project = projects[gd.getNextChoiceIndex()];
    }
    // check if the selected project is open already
    for (final Project p : al_open_projects) {
        if (loader.isIdenticalProjectSource(p.loader) && p.id == project.id && p.title.equals(project.title)) {
            Utils.showMessage("A project with title " + p.title + " and id " + p.id + " from the same database is already open.");
            loader.destroy();
            return null;
        }
    }
    // now, open the selected project
    // assign loader
    project.loader = loader;
    // grab the XML template
    TemplateThing template_root = loader.getTemplateRoot(project);
    if (null == template_root) {
        Utils.showMessage("Failed to retrieve the template tree.");
        project.destroy();
        return null;
    }
    project.template_tree = new TemplateTree(project, template_root);
    synchronized (project.ht_unique_tt) {
        project.ht_unique_tt.clear();
        project.ht_unique_tt.putAll(template_root.getUniqueTypes(new HashMap<String, TemplateThing>()));
    }
    // create the project Thing, to be root of the whole user Thing tree (and load all its objects)
    // to collect all created displayables, and  then reassign to the proper layers.
    HashMap<Long, Displayable> hs_d = new HashMap<Long, Displayable>();
    try {
        // create a template for the project Thing
        TemplateThing project_template = new TemplateThing("project");
        project.ht_unique_tt.put("project", project_template);
        project_template.addChild(template_root);
        project.root_pt = loader.getRootProjectThing(project, template_root, project_template, hs_d);
        // restore parent/child and attribute ownership and values (now that all Things exist)
        project.root_pt.setup();
    } catch (Exception e) {
        Utils.showMessage("Failed to retrieve the Thing tree for the project.");
        IJError.print(e);
        project.destroy();
        return null;
    }
    // create the user objects tree
    project.project_tree = new ProjectTree(project, project.root_pt);
    // restore the expanded state of each node
    loader.restoreNodesExpandedState(project);
    // create the layers templates
    project.createLayerTemplates();
    // fetch the root layer thing and the root layer set (will load all layers and layer sets, with minimal contents of patches; gets the basic objects -profile, pipe, etc.- from the project.root_pt). Will open all existing displays for each layer.
    LayerThing root_layer_thing = null;
    try {
        root_layer_thing = loader.getRootLayerThing(project, project.root_pt, Project.layer_set_template, Project.layer_template);
        if (null == root_layer_thing) {
            project.destroy();
            Utils.showMessage("Could not retrieve the root layer thing.");
            return null;
        }
        // set the child/parent relationships now that everything exists
        root_layer_thing.setup();
        project.layer_set = (LayerSet) root_layer_thing.getObject();
        if (null == project.layer_set) {
            project.destroy();
            Utils.showMessage("Could not retrieve the root layer set.");
            return null;
        }
        // set the active layer to each ZDisplayable
        project.layer_set.setup();
        // debug:
        // Utils.log2("$$$ root_lt: " + root_layer_thing + "   ob: " + root_layer_thing.getObject().getClass().getName() + "\n children: " + ((LayerSet)root_layer_thing.getObject()).getLayers().size());
        project.layer_tree = new LayerTree(project, root_layer_thing);
        project.root_lt = root_layer_thing;
    } catch (Exception e) {
        Utils.showMessage("Failed to retrieve the Layer tree for the project.");
        IJError.print(e);
        project.destroy();
        return null;
    }
    // if all when well, register as open:
    al_open_projects.add(project);
    // create the project control window, containing the trees in a double JSplitPane
    ControlWindow.add(project, project.template_tree, project.project_tree, project.layer_tree);
    // now open the displays that were stored for later, if any:
    Display.openLater();
    return project;
}

Example 18 with TemplateThing

use of ini.trakem2.tree.TemplateThing in project TrakEM2 by trakem2.

the class Project method createSubproject.

/**
 * Create a new subproject for the given layer range and ROI.
 *   Create a new Project using the given project as template. This means the DTD of the given project is copied, as well as the storage and mipmaps folders; everything else is empty in the new project.
 */
public Project createSubproject(final Rectangle roi, final Layer first, final Layer last, final boolean ignore_hidden_patches) {
    try {
        // The order matters.
        final Project pr = new Project(new FSLoader(this.getLoader().getStorageFolder()));
        pr.id = this.id;
        // copy properties
        pr.title = this.title;
        pr.ht_props.putAll(this.ht_props);
        // copy template
        pr.root_tt = this.root_tt.clone(pr, true);
        pr.template_tree = new TemplateTree(pr, pr.root_tt);
        synchronized (pr.ht_unique_tt) {
            pr.ht_unique_tt.clear();
            pr.ht_unique_tt.putAll(root_tt.getUniqueTypes(new HashMap<String, TemplateThing>()));
        }
        TemplateThing project_template = new TemplateThing("project");
        project_template.addChild(pr.root_tt);
        pr.ht_unique_tt.put("project", project_template);
        // create the layers templates
        pr.createLayerTemplates();
        // copy LayerSet and all involved Displayable objects
        // (A two-step process to provide the layer_set pointer and all Layer pointers to the ZDisplayable to copy and crop.)
        pr.layer_set = (LayerSet) this.layer_set.clone(pr, first, last, roi, false, true, ignore_hidden_patches);
        LayerSet.cloneInto(this.layer_set, first, last, pr, pr.layer_set, roi, true);
        // create layer tree
        pr.root_lt = new LayerThing(Project.layer_set_template, pr, pr.layer_set);
        pr.layer_tree = new LayerTree(pr, pr.root_lt);
        // add layer nodes to the layer tree (solving chicken-and-egg problem)
        pr.layer_set.updateLayerTree();
        // copy project tree
        pr.root_pt = this.root_pt.subclone(pr);
        pr.project_tree = new ProjectTree(pr, pr.root_pt);
        // not copying node expanded state.
        // register
        al_open_projects.add(pr);
        // add to gui:
        ControlWindow.add(pr, pr.template_tree, pr.project_tree, pr.layer_tree);
        // Above, the id of each object is preserved from this project into the subproject.
        // The abstract structure should be copied in full regardless, without the basic objects
        // included if they intersect the roi.
        // Regenerate mipmaps (blocks GUI from interaction other than navigation)
        pr.loader.regenerateMipMaps(pr.layer_set.getDisplayables(Patch.class));
        pr.restartAutosaving();
        return pr;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

Example 19 with TemplateThing

use of ini.trakem2.tree.TemplateThing in project TrakEM2 by trakem2.

the class Project method openFSProject.

/**
 * Opens a project from an .xml file. If the path is null it'll be asked for.
 *  Only one project may be opened at a time.
 */
@SuppressWarnings("unchecked")
public static synchronized Project openFSProject(final String path, final boolean open_displays) {
    if (Utils.wrongImageJVersion())
        return null;
    final FSLoader loader = new FSLoader();
    final Object[] data = loader.openFSProject(path, open_displays);
    if (null == data) {
        loader.destroy();
        return null;
    }
    final TemplateThing root_tt = (TemplateThing) data[0];
    final ProjectThing root_pt = (ProjectThing) data[1];
    final LayerThing root_lt = (LayerThing) data[2];
    final HashMap<ProjectThing, Boolean> ht_pt_expanded = (HashMap<ProjectThing, Boolean>) data[3];
    final Project project = (Project) root_pt.getObject();
    project.createLayerTemplates();
    project.template_tree = new TemplateTree(project, root_tt);
    project.root_tt = root_tt;
    project.root_pt = root_pt;
    project.project_tree = new ProjectTree(project, project.root_pt);
    project.layer_tree = new LayerTree(project, root_lt);
    project.root_lt = root_lt;
    project.layer_set = (LayerSet) root_lt.getObject();
    // if all when well, register as open:
    al_open_projects.add(project);
    // create the project control window, containing the trees in a double JSplitPane
    ControlWindow.add(project, project.template_tree, project.project_tree, project.layer_tree);
    // set ProjectThing nodes expanded state, now that the trees exist
    try {
        java.lang.reflect.Field f = JTree.class.getDeclaredField("expandedState");
        f.setAccessible(true);
        Hashtable<Object, Object> ht_exp = (Hashtable<Object, Object>) f.get(project.project_tree);
        for (Map.Entry<ProjectThing, Boolean> entry : ht_pt_expanded.entrySet()) {
            ProjectThing pt = entry.getKey();
            Boolean expanded = entry.getValue();
            // project.project_tree.expandPath(new TreePath(project.project_tree.findNode(pt, project.project_tree).getPath()));
            // WARNING the above is wrong in that it will expand the whole thing, not just set the state of the node!!
            // So the ONLY way to do it is to start from the child-most leafs of the tree, and apply the expanding to them upward. This is RIDICULOUS, how can it be so broken
            // so, hackerous:
            DefaultMutableTreeNode nd = DNDTree.findNode(pt, project.project_tree);
            // else Utils.log2("path: " + new TreePath(nd.getPath()));
            if (null == nd) {
                Utils.log2("Can't find node for " + pt);
            } else {
                ht_exp.put(new TreePath(nd.getPath()), expanded);
            }
        }
        // very important!!
        project.project_tree.updateUILater();
    } catch (Exception e) {
        IJError.print(e);
    }
    // open any stored displays
    if (open_displays) {
        final Bureaucrat burro = Display.openLater();
        if (null != burro) {
            final Runnable ru = new Runnable() {

                public void run() {
                    // wait until the Bureaucrat finishes
                    try {
                        burro.join();
                    } catch (InterruptedException ie) {
                    }
                    // restore to non-changes (crude, but works)
                    project.loader.setChanged(false);
                    Utils.log2("C set to false");
                }
            };
            new Thread() {

                public void run() {
                    setPriority(Thread.NORM_PRIORITY);
                    // avoiding "can't call invokeAndWait from the EventDispatch thread" error
                    try {
                        javax.swing.SwingUtilities.invokeAndWait(ru);
                    } catch (Exception e) {
                        Utils.log2("ERROR: " + e);
                    }
                }
            }.start();
            // SO: WAIT TILL THE END OF TIME!
            new Thread() {

                public void run() {
                    try {
                        // ah, the pain in my veins. I can't take this shitty setup anymore.
                        Thread.sleep(4000);
                        javax.swing.SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {
                                project.getLoader().setChanged(false);
                                Utils.log2("D set to false");
                            }
                        });
                        // repainting to fix gross errors in tree rendering
                        project.getTemplateTree().updateUILater();
                        // idem
                        project.getProjectTree().updateUILater();
                    } catch (Exception ie) {
                    }
                }
            }.start();
        } else {
            // help the helpless users
            Display.createDisplay(project, project.layer_set.getLayer(0));
        }
    }
    project.restartAutosaving();
    return project;
}

Example 20 with TemplateThing

use of ini.trakem2.tree.TemplateThing in project TrakEM2 by trakem2.

the class Loader method askForXMLTemplate.

/**
 * Ask for the user to provide a template XML file to extract a root TemplateThing.
 */
public TemplateThing askForXMLTemplate(final Project project) {
    // ask for an .xml file or a .dtd file
    // fd.setFilenameFilter(new XMLFileFilter(XMLFileFilter.BOTH));
    final OpenDialog od = new OpenDialog("Select XML Template", OpenDialog.getDefaultDirectory(), null);
    final String filename = od.getFileName();
    if (null == filename || filename.toLowerCase().startsWith("null"))
        return null;
    // if there is a path, read it out if possible
    String dir = od.getDirectory();
    if (null == dir)
        return null;
    if (IJ.isWindows())
        dir = dir.replace('\\', '/');
    if (!dir.endsWith("/"))
        dir += "/";
    TemplateThing[] roots;
    try {
        roots = DTDParser.extractTemplate(dir + filename);
    } catch (final Exception e) {
        IJError.print(e);
        return null;
    }
    if (null == roots || roots.length < 1)
        return null;
    if (roots.length > 1) {
        Utils.showMessage("Found more than one root.\nUsing first root only.");
    }
    return roots[0];
}