use of ini.trakem2.display.Pipe in project TrakEM2 by trakem2.
the class Graph method extractAndShowGraph.
/**
* Shows a dialog to pick which classes is one interested in.
*/
public static final void extractAndShowGraph(final LayerSet ls) {
GenericDialog gd = new GenericDialog("Graph elements");
Class<Displayable>[] c = new Class[] { AreaList.class, AreaTree.class, Ball.class, Connector.class, Patch.class, Pipe.class, Polyline.class, Profile.class, DLabel.class, Treeline.class };
String[] types = new String[] { "AreaList", "AreaTree", "Ball", "Connector", "Image", "Pipe", "Polyline", "Profile", "Text", "Treeline" };
boolean[] states = new boolean[] { true, true, false, false, false, false, true, true, false, true };
assert (c.length == types.length && types.length == states.length);
for (int i = 0; i < c.length; i++) {
if (ZDisplayable.class.isAssignableFrom(c[i])) {
if (!ls.contains(c[i]))
states[i] = false;
} else if (!ls.containsDisplayable(c[i]))
states[i] = false;
}
gd.addCheckboxGroup(types.length, 1, types, states, new String[] { "Include only:" });
gd.showDialog();
if (gd.wasCanceled())
return;
HashSet<Class<Displayable>> only = new HashSet<Class<Displayable>>();
for (int i = 0; i < types.length; i++) {
if (gd.getNextBoolean())
only.add(c[i]);
}
Graph.extractAndShowGraph(ls, only);
}
use of ini.trakem2.display.Pipe 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.Pipe 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.Pipe in project TrakEM2 by trakem2.
the class TMLHandler method makeLayerThing.
private LayerThing makeLayerThing(String type, final HashMap<String, String> ht_attributes) {
try {
type = type.toLowerCase();
if (0 == type.indexOf("t2_")) {
type = type.substring(3);
}
// long id = -1;
// final String sid = ht_attributes.get("id");
// if (null != sid) id = Long.parseLong(sid);
long oid = -1;
final String soid = ht_attributes.get("oid");
if (null != soid)
oid = Long.parseLong(soid);
if (type.equals("node")) {
if (null == last_tree) {
throw new NullPointerException("Can't create a node for null last_tree!");
}
final Node<?> node = last_tree.newNode(ht_attributes);
taggables.add(node);
// Put node into the list of nodes with that layer id, to update to proper Layer pointer later
final long ndlid = Long.parseLong(ht_attributes.get("lid"));
List<Node<?>> list = node_layer_table.get(ndlid);
if (null == list) {
list = new ArrayList<Node<?>>();
node_layer_table.put(ndlid, list);
}
list.add(node);
// Set node as root node or add as child to last node in the stack
if (null == last_root_node) {
last_root_node = node;
} else {
final String sconf = ht_attributes.get("c");
nodes.getLast().add((Node) node, null == sconf ? Node.MAX_EDGE_CONFIDENCE : Byte.parseByte(sconf));
}
// color?
final String scolor = ht_attributes.get("color");
if (null != scolor) {
final Color color = Utils.getRGBColorFromHex(scolor);
Collection<Node<?>> nodes = node_colors.get(color);
if (null == nodes) {
nodes = new ArrayList<Node<?>>();
node_colors.put(color, nodes);
}
nodes.add(node);
}
// Put node into stack of nodes (to be removed on closing the tag)
nodes.add(node);
} else if (type.equals("profile")) {
Profile profile = new Profile(this.project, oid, ht_attributes, ht_links);
profile.addToDatabase();
ht_displayables.put(oid, profile);
addToLastOpenLayer(profile);
last_displayable = profile;
return null;
} else if (type.equals("pipe")) {
Pipe pipe = new Pipe(this.project, oid, ht_attributes, ht_links);
pipe.addToDatabase();
ht_displayables.put(new Long(oid), pipe);
ht_zdispl.put(new Long(oid), pipe);
last_displayable = pipe;
addToLastOpenLayerSet(pipe);
return null;
} else if (type.equals("polyline")) {
Polyline pline = new Polyline(this.project, oid, ht_attributes, ht_links);
pline.addToDatabase();
last_displayable = pline;
ht_displayables.put(new Long(oid), pline);
ht_zdispl.put(new Long(oid), pline);
addToLastOpenLayerSet(pline);
return null;
} else if (type.equals("connector")) {
final Connector con = new Connector(this.project, oid, ht_attributes, ht_links);
if (ht_attributes.containsKey("origin")) {
legacy.add(new Runnable() {
public void run() {
con.readLegacyXML(al_layer_sets.get(al_layer_sets.size() - 1), ht_attributes, ht_links);
}
});
}
con.addToDatabase();
last_connector = con;
last_tree = con;
last_displayable = con;
ht_displayables.put(new Long(oid), con);
ht_zdispl.put(new Long(oid), con);
addToLastOpenLayerSet(con);
return null;
} else if (type.equals("path")) {
if (null != reca) {
reca.add(ht_attributes.get("d"));
return null;
}
return null;
} else if (type.equals("area")) {
reca = new ReconstructArea();
if (null != last_area_list) {
last_area_list_layer_id = Long.parseLong(ht_attributes.get("layer_id"));
}
return null;
} else if (type.equals("area_list")) {
AreaList area = new AreaList(this.project, oid, ht_attributes, ht_links);
// why? This looks like an onion
area.addToDatabase();
last_area_list = area;
last_displayable = area;
ht_displayables.put(new Long(oid), area);
ht_zdispl.put(new Long(oid), area);
addToLastOpenLayerSet(area);
return null;
} else if (type.equals("tag")) {
Taggable t = taggables.getLast();
if (null != t) {
Object ob = ht_attributes.get("key");
// defaults to 't'
int keyCode = KeyEvent.VK_T;
// KeyEvent.VK_U is char U, not u
if (null != ob)
keyCode = (int) ((String) ob).toUpperCase().charAt(0);
Tag tag = al_layer_sets.get(al_layer_sets.size() - 1).putTag(ht_attributes.get("name"), keyCode);
// could be null if name is not found
if (null != tag)
t.addTag(tag);
}
} else if (type.equals("ball_ob")) {
// add a ball to the last open Ball
if (null != last_ball) {
last_ball.addBall(Double.parseDouble(ht_attributes.get("x")), Double.parseDouble(ht_attributes.get("y")), Double.parseDouble(ht_attributes.get("r")), Long.parseLong(ht_attributes.get("layer_id")));
}
return null;
} else if (type.equals("ball")) {
Ball ball = new Ball(this.project, oid, ht_attributes, ht_links);
ball.addToDatabase();
last_ball = ball;
last_displayable = ball;
ht_displayables.put(new Long(oid), ball);
ht_zdispl.put(new Long(oid), ball);
addToLastOpenLayerSet(ball);
return null;
} else if (type.equals("stack")) {
Stack stack = new Stack(this.project, oid, ht_attributes, ht_links);
stack.addToDatabase();
last_stack = stack;
last_displayable = stack;
ht_displayables.put(new Long(oid), stack);
ht_zdispl.put(new Long(oid), stack);
addToLastOpenLayerSet(stack);
} else if (type.equals("treeline")) {
Treeline tline = new Treeline(this.project, oid, ht_attributes, ht_links);
tline.addToDatabase();
last_treeline = tline;
last_tree = tline;
last_treeline_data = new StringBuilder();
last_displayable = tline;
ht_displayables.put(oid, tline);
ht_zdispl.put(oid, tline);
addToLastOpenLayerSet(tline);
} else if (type.equals("areatree")) {
AreaTree art = new AreaTree(this.project, oid, ht_attributes, ht_links);
art.addToDatabase();
last_areatree = art;
last_tree = art;
last_displayable = art;
ht_displayables.put(oid, art);
ht_zdispl.put(oid, art);
addToLastOpenLayerSet(art);
} else if (type.equals("dd_item")) {
if (null != last_dissector) {
last_dissector.addItem(Integer.parseInt(ht_attributes.get("tag")), Integer.parseInt(ht_attributes.get("radius")), ht_attributes.get("points"));
}
} else if (type.equals("label")) {
DLabel label = new DLabel(project, oid, ht_attributes, ht_links);
label.addToDatabase();
ht_displayables.put(new Long(oid), label);
addToLastOpenLayer(label);
last_displayable = label;
return null;
} else if (type.equals("annot")) {
last_annotation = new StringBuilder();
return null;
} else if (type.equals("patch")) {
Patch patch = new Patch(project, oid, ht_attributes, ht_links);
patch.addToDatabase();
ht_displayables.put(new Long(oid), patch);
addToLastOpenLayer(patch);
last_patch = patch;
last_displayable = patch;
checkAlphaMasks(patch);
return null;
} else if (type.equals("filter")) {
last_patch_filters.add(newFilter(ht_attributes));
} else if (type.equals("dissector")) {
Dissector dissector = new Dissector(this.project, oid, ht_attributes, ht_links);
dissector.addToDatabase();
last_dissector = dissector;
last_displayable = dissector;
ht_displayables.put(new Long(oid), dissector);
ht_zdispl.put(new Long(oid), dissector);
addToLastOpenLayerSet(dissector);
} else if (type.equals("layer")) {
// find last open LayerSet, if any
for (int i = al_layer_sets.size() - 1; i > -1; ) {
LayerSet set = al_layer_sets.get(i);
Layer layer = new Layer(project, oid, ht_attributes);
layer.addToDatabase();
set.addSilently(layer);
al_layers.add(layer);
Object ot = ht_attributes.get("title");
return new LayerThing(template_layer_thing, project, -1, (null == ot ? null : (String) ot), layer, null);
}
} else if (type.equals("layer_set")) {
LayerSet set = new LayerSet(project, oid, ht_attributes, ht_links);
last_displayable = set;
set.addToDatabase();
ht_displayables.put(new Long(oid), set);
al_layer_sets.add(set);
addToLastOpenLayer(set);
Object ot = ht_attributes.get("title");
return new LayerThing(template_layer_set_thing, project, -1, (null == ot ? null : (String) ot), set, null);
} else if (type.equals("calibration")) {
// find last open LayerSet if any
for (int i = al_layer_sets.size() - 1; i > -1; ) {
LayerSet set = al_layer_sets.get(i);
set.restoreCalibration(ht_attributes);
return null;
}
} else if (type.equals("prop")) {
// Add property to last created Displayable
if (null != last_displayable) {
last_displayable.setProperty(ht_attributes.get("key"), ht_attributes.get("value"));
}
} else if (type.equals("linked_prop")) {
// Add linked property to last created Displayable. Has to wait until the Displayable ids have been resolved to instances.
if (null != last_displayable) {
putLinkedProperty(last_displayable, ht_attributes);
}
} else {
Utils.log2("TMLHandler Unknown type: " + type);
}
} catch (Exception e) {
IJError.print(e);
}
// default:
return null;
}
use of ini.trakem2.display.Pipe in project TrakEM2 by trakem2.
the class ProjectTree method insertSegmentations.
/* // makes no sense, because there may be multiple projects open and thus the viewport and position may interfere with each other across multiple projects. Saving the collapsed node state suffices.
public void exportXML(final StringBuffer sb_body, String indent, JScrollPane jsp) {
Point p = jsp.getViewport().getViewPosition();
Dimension d = jsp.getSize(null);
sb_body.append(indent).append("<t2_tree")
.append(" width=\"").append(d.width).append('\"')
.append(" height=\"").append(d.height).append('\"')
.append(" viewport_x=\"").append(p.e).append('\"')
.append(" viewport_y=\"").append(p.y).append('\"')
;
sb_body.append("\n").append(indent).append("</t2_tree>\n");
}
*/
/**
* Creates a new node of basic type for each AreaList, Ball, Pipe or Polyline present in the ArrayList. Other elements are ignored.
*/
public void insertSegmentations(final Collection<? extends Displayable> al) {
final TemplateThing tt_root = (TemplateThing) project.getTemplateTree().getRoot().getUserObject();
// create a new abstract node called "imported_segmentations", if not there
final String imported_labels = "imported_labels";
if (!project.typeExists(imported_labels)) {
// create it
// yes I know I should check for the project of each Displayable in the ArrayList
TemplateThing tet = new TemplateThing(imported_labels, project);
project.addUniqueType(tet);
DefaultMutableTreeNode root = project.getTemplateTree().getRoot();
tt_root.addChild(tet);
DefaultMutableTreeNode child_node = addChild(tet, root);
DNDTree.expandNode(project.getTemplateTree(), child_node);
// JTree is serious pain
}
// it's the same as 'tet' above, unless it existed
TemplateThing tt_is = project.getTemplateThing(imported_labels);
// create a project node from "imported_segmentations" template under a new top node
final DefaultMutableTreeNode project_node = project.getProjectTree().getRoot();
ProjectThing project_pt = (ProjectThing) project_node.getUserObject();
final ProjectThing ct = project_pt.createChild(tt_root.getType());
ProjectThing pt_is = ct.createChild(imported_labels);
// addChild(pt_is, ctn);
final DefaultMutableTreeNode node_pt_is = new DefaultMutableTreeNode(pt_is);
final HashMap<Class<?>, String> types = new HashMap<Class<?>, String>();
types.put(AreaList.class, "area_list");
types.put(Pipe.class, "pipe");
types.put(Polyline.class, "polyline");
types.put(Ball.class, "ball");
types.put(Treeline.class, "treeline");
types.put(AreaTree.class, "areatree");
types.put(Connector.class, "connector");
// now, insert a new ProjectThing if of type AreaList, Ball and/or Pipe under node_child
for (final Displayable d : al) {
final String type = types.get(d.getClass());
if (null == type) {
Utils.log("insertSegmentations: ignoring " + d);
continue;
}
try {
final TemplateThing tt = getOrCreateChildTemplateThing(tt_is, type);
ProjectThing one = new ProjectThing(tt, project, d);
pt_is.addChild(one);
// addChild(one, node_pt_is);
// at the end
node_pt_is.add(new DefaultMutableTreeNode(one));
// Utils.log2("one parent : " + one.getParent());
} catch (Exception e) {
IJError.print(e);
}
}
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
DefaultMutableTreeNode ctn = addChild(ct, project_node);
ctn.add(node_pt_is);
try {
ProjectTree.this.scrollPathToVisible(new TreePath(node_pt_is.getPath()));
} catch (Exception e) {
e.printStackTrace();
}
}
});
DNDTree.expandNode(this, node_pt_is);
}
Aggregations