use of ini.trakem2.display.Tree 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;
}
}
use of ini.trakem2.display.Tree in project TrakEM2 by trakem2.
the class Project method removeAll.
/**
* Remove any set of Displayable objects from the Layer, LayerSet and Project Tree as necessary.
* ASSUMES there aren't any nested LayerSet objects in @param col.
*/
public final boolean removeAll(final Set<Displayable> col, final DefaultMutableTreeNode top_node) {
// 0. Sort into Displayable and ZDisplayable
final Set<ZDisplayable> zds = new HashSet<ZDisplayable>();
final List<Displayable> ds = new ArrayList<Displayable>();
for (final Displayable d : col) {
if (d instanceof ZDisplayable) {
zds.add((ZDisplayable) d);
} else {
ds.add(d);
}
}
// Displayable:
// 1. First the Profile from the Project Tree, one by one,
// while creating a map of Layer vs Displayable list to remove in that layer:
final HashMap<Layer, Set<Displayable>> ml = new HashMap<Layer, Set<Displayable>>();
for (final Iterator<Displayable> it = ds.iterator(); it.hasNext(); ) {
final Displayable d = it.next();
if (d.getClass() == Profile.class) {
if (!project_tree.remove(false, findProjectThing(d), null)) {
// like Profile.remove2
Utils.log("Could NOT delete " + d);
continue;
}
// remove the Profile
it.remove();
continue;
}
// The map of Layer vs Displayable list
Set<Displayable> l = ml.get(d.getLayer());
if (null == l) {
l = new HashSet<Displayable>();
ml.put(d.getLayer(), l);
}
l.add(d);
}
// 2. Then the rest, in bulk:
if (ml.size() > 0) {
for (final Map.Entry<Layer, Set<Displayable>> e : ml.entrySet()) {
e.getKey().removeAll(e.getValue());
}
}
// 3. Stacks
if (zds.size() > 0) {
final Set<ZDisplayable> stacks = new HashSet<ZDisplayable>();
for (final Iterator<ZDisplayable> it = zds.iterator(); it.hasNext(); ) {
final ZDisplayable zd = it.next();
if (zd.getClass() == Stack.class) {
it.remove();
stacks.add(zd);
}
}
layer_set.removeAll(stacks);
}
// 4. ZDisplayable: bulk removal
if (zds.size() > 0) {
// 1. From the Project Tree:
Set<Displayable> not_removed = project_tree.remove(zds, top_node);
// 2. Then only those successfully removed, from the LayerSet:
zds.removeAll(not_removed);
layer_set.removeAll(zds);
}
// TODO
return true;
}
use of ini.trakem2.display.Tree 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;
}
use of ini.trakem2.display.Tree in project TrakEM2 by trakem2.
the class Project method select.
private final void select(final Object ob, final DNDTree tree) {
// Find the Thing that contains the object
final Thing root_thing = (Thing) ((DefaultMutableTreeNode) tree.getModel().getRoot()).getUserObject();
final Thing child_thing = root_thing.findChild(ob);
// find the node that contains the Thing, and select it
DNDTree.selectNode(child_thing, tree);
}
use of ini.trakem2.display.Tree 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;
}
Aggregations