| blob | a0b785431524998ee63933a2148679d9245a0822 |
1 /**
3 TrakEM2 plugin for ImageJ(C).
4 Copyright (C) 2009 Albert Cardona.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation (http://www.gnu.org/licenses/gpl.txt )
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 You may contact Albert Cardona at acardona at ini.phys.ethz.ch
20 Institute of Neuroinformatics, University of Zurich / ETH, Switzerland.
21 **/
113 // To remove the warnings, both the Node and the Tree would have to know about the type of Node used.
114 // So: a recursive declaration of Node<T, N extends Node<T,N>> is required.
116 /** A sequence of points ordered in a set of connected branches. */
127 }
129 /** Reconstruct from XML. */
130 protected Tree(final Project project, final long id, final HashMap<String,String> ht_attr, final HashMap<Displayable,String> ht_links) {
132 }
134 /** For cloning purposes, does not call addToDatabase(), neither creates any root node. */
135 protected Tree(final Project project, final long id, final String title, final float width, final float height, final float alpha, final boolean visible, final Color color, final boolean locked, final AffineTransform at) {
140 }
142 /** Get a copy of the {@link Set} of {@link Node} that exist at {@param layer}; the {@link Node} instances are the originals.
143 * Returns an empty {@link Set} if none found. */
148 }
149 }
152 return getNodesToPaint(active_layer, active_layer.getParent().getColorCueLayerRange(active_layer));
153 }
155 final protected Set<Node<T>> getNodesToPaint(final Layer active_layer, final List<Layer> color_cue_layers) {
157 // Determine which layers to paint
161 // All layers
170 }
171 }
172 }
174 }
175 // Else, just the active layer, if any
178 }
179 }
181 @Override
182 final public void paint(final Graphics2D g, final Rectangle srcRect, final double magnification, final boolean active, final int channels, final Layer active_layer, final List<Layer> layers) {
183 paint(g, srcRect, magnification, active, channels, active_layer, layers, layer_set.paint_arrows, layer_set.paint_tags);
184 }
185 final public void paint(final Graphics2D g, final Rectangle srcRect, final double magnification, final boolean active, final int channels, final Layer active_layer, final List<Layer> layers, final boolean with_arrows, final boolean with_tags) {
189 }
202 }
205 // Determine which layers to paint
208 // Filter nodes outside the srcRect
209 // The DisplayNavigator and the snapshot panels call paint with the full srcRect
210 // so avoid filtering for them:
215 final Rectangle localRect = this.at.createInverse().createTransformedShape(srcRect).getBounds();
220 }
223 }
224 }
225 // Arrange transparency
229 }
230 // Clear transform and stroke
246 final Runnable task = nd.paint(g, active_layer, active, srcRect, magnification, nodes, this, to_screen, with_arrows, with_tags, layer_set.paint_edge_confidence_boxes, true, above, below);
258 }
260 }
265 }
266 }
267 }
268 }
270 // restore
274 }
276 //Transparency: fix alpha composite back to original.
279 }
280 }
289 }
290 }
292 }
294 @Override
302 }
311 }
312 }
313 }
315 // Call always from within a synchronized (node_layer_map) block.
321 }
323 }
325 @Override
333 }
341 // No need to translate
343 }
346 // now adjust points to make min_x,min_y be the x,y
350 }
351 this.at.translate(box.x, box.y); // not using super.translate(...) because a preConcatenation is not needed; here we deal with the data.
356 }
357 }
359 /**Repaints in the given ImageCanvas only the area corresponding to the bounding box of this Pipe. */
361 //TODO: this could be further optimized to repaint the bounding box of the last modified segments, i.e. the previous and next set of interpolated points of any given backbone point. This would be trivial if each segment of the Bezier curve was an object.
366 }
368 /**Make this object ready to be painted.*/
370 // TODO
371 }
373 @Override
377 // Area to local coords
380 // find layers between z_first and z_last
386 }
387 }
388 }
391 }
392 }
394 }
396 @Override
403 }
404 }
411 }
412 }
416 }
417 }
419 @Override
422 // Obtain local copy and clear 'tolink':
427 }
436 }
437 }
442 }
444 }
446 /** Create a new instance, intialized with same ZDisplayable-level parameters (affine, color, title, etc.). */
451 /** Create a new node, copying some properties from the modelNode such as radius or color.
452 * The modelNode should be the node that will become the parent of the new node,
453 * but it doesn't have to be. */
454 protected Node<T> createNewNode(final float lx, final float ly, final Layer layer, final Node<?> modelNode) {
459 }
461 /** To reconstruct from XML. */
464 @Override
467 }
469 /** Exports to type t2_treeline. */
470 static public void exportDTD(final StringBuilder sb_header, final HashSet<String> hs, final String indent) {
483 ;
484 }
486 @Override
487 public void exportXML(final StringBuilder sb_body, final String indent, final XMLOptions options) {
493 sb_body.append(in).append("style=\"fill:none;stroke-opacity:").append(alpha).append(";stroke:#").append(RGB[0]).append(RGB[1]).append(RGB[2]).append(";stroke-width:1.0px;stroke-opacity:1.0\"\n");
498 }
500 /** One day, java will get tail-call optimization (i.e. no more stack overflow errors) and I will laugh at this function. */
501 private final void exportXML(final Tree<T> tree, final String indent_base, final StringBuilder sb, final Node<T> root) {
502 // Simulating recursion
503 //
504 // write depth-first, closing as children get written
514 // Processing end point
521 // Never yet processed a child, add first
528 // Are there any more children to process?
530 // No more children to process
536 // Process the next child
539 }
540 }
541 }
542 }
543 }
545 private final void dataNodeXML(final Tree<T> tree, final StringBuilder indent, final StringBuilder sb, final Node<T> node) {
550 ;
554 }
559 }
563 // ... so accumulated potentially extra chars are 3: \">\n
573 }
581 }
584 }
586 }
587 abstract protected boolean exportXMLNodeAttributes(StringBuilder indent, StringBuilder sb, Node<T> node);
588 abstract protected boolean exportXMLNodeData(StringBuilder indent, StringBuilder sb, Node<T> node);
590 private final void exportTags(final Node<T> node, final StringBuilder sb, final StringBuilder indent) {
594 }
595 }
599 }
601 /** @see generateSkeleton */
602 @Deprecated
603 public List<Point3f> generateTriangles(final double scale_, final int parallels, final int resample) {
605 }
607 /** @return a CustomLineMesh.PAIRWISE list for a LineMesh. */
608 public MeshData generateSkeleton(final double scale_, final int parallels, final int resample) {
613 // Simulate recursion
625 // A few performance tests are needed:
626 // 1 - if the map caching of points helps or recomputing every time is cheaper than lookup
627 // 2 - if removing no-longer-needed points from the map helps lookup or overall slows down
628 //
629 // The method, by the way, is very parallelizable: each is independent.
638 // Add children to todo list if any
641 }
643 // Get node's 3D coordinate
653 }
655 // Create a line to the parent
666 }
669 }
671 // node.parent point no longer needed (last child just processed)
673 }
674 }
675 }
676 //Utils.log2("Skeleton MeshData lists of same length: " + (list.size() == colors.size()));
678 }
680 @Override
683 }
685 @Override
688 }
695 }
696 @Override
705 }
707 }
708 }
710 /** Reroots at the point closest to the x,y,layer_id world coordinate.
711 * @return true on success. */
717 }
719 // Search within the nodes in layer
724 }
726 // Find a node near the coordinate
731 }
734 }
735 }
737 /** @param nd A node of this Tree. */
747 }
750 }
752 /** Split the Tree into new Tree at the point closest to the x,y,layer world coordinate.
753 * @return null if no node was found near the x,y,layer point with precision dependent on magnification. */
754 public List<Tree<T>> splitNear(float x, float y, final Layer layer, final double magnification) {
760 }
762 // Search within the nodes in layer
767 }
769 // Find a node near the coordinate
774 }
778 }
780 }
783 }
785 }
787 /** @param nd A node of this Tree. */
793 // Sanity check:
796 // Cache the children of 'nd'
798 // Remove any review stacks for the nodes in the subtree
801 }
802 // Remove all children nodes of found node 'nd' from the Tree cache arrays:
804 // Set the found node 'nd' as a new root: (was done by removeNode/Node.remove anyway)
806 // With the found nd, now a root, create a new Tree
810 // ... and fill its cache arrays
812 // Recompute bounds -- TODO: must translate the second properly, or apply the transforms and then recalculate bounding boxes and transforms.
814 // Done!
818 }
823 }
825 }
829 }
837 }
839 /** Take @param nodes and add them to @param end_nodes and @param node_layer_map as appropriate. */
840 private final void cache(final Iterable<Node<T>> nodes, final Collection<Node<T>> end_nodes, final Map<Layer,Set<Node<T>>> node_layer_map) {
847 }
849 }
850 }
852 /** Update the internal {@link Node} cache; you want to invoke this operation
853 * after altering programmatically the {@link Layer} pointers of any of the
854 * {@link Node} of this {@link Tree}.
855 */
861 }
862 }
864 /** Returns true if the given point falls within a certain distance of any of the treeline segments,
865 * where a segment is defined as the line between a clicked point and the next. */
866 @Override
878 }
881 }
882 }
884 protected boolean isAnyNear(final Collection<Node<T>> nodes, final float lx, final float ly, final float radius) {
887 }
889 }
893 }
904 }
906 }
908 public Coordinate<Node<T>> findPreviousBranchOrRootPoint(final float x, final float y, final Layer layer, final DisplayCanvas dc) {
912 }
913 /** If the node found near x,y,layer is a branch point, returns it; otherwise the next down
914 * the chain; on reaching an end point, returns it. */
915 public Coordinate<Node<T>> findNextBranchOrEndPoint(final float x, final float y, final Layer layer, final DisplayCanvas dc) {
919 }
921 protected Coordinate<Node<T>> findNearAndGetNext(float x, float y, final Layer layer, final DisplayCanvas dc) {
930 }
931 // else, find the closest child edge
936 }
940 }
941 protected Coordinate<Node<T>> findNearAndGetPrevious(final float x, final float y, final Layer layer, final DisplayCanvas dc) {
947 }
951 }
954 }
956 /** Find an edge near the world coords x,y,layer with precision depending upon magnification,
957 * and adjust its confidence to @param confidence.
958 * @return the node whose parent edge is altered, or null if none found. */
965 }
966 }
968 /** Expects world coordinates. */
969 protected Node<T> adjustEdgeConfidence(final int inc, final float x, final float y, final Layer layer, final DisplayCanvas dc) {
977 }
978 }
981 }
983 /** Find the node whose confidence box for the parent edge is closest to x,y,layer, if any. */
984 private Node<T> findNodeConfidenceBox(float x, float y, final Layer layer, final double magnification) {
1000 final float d = (float)(Math.pow((nd.parent.x + nd.x)/2 - x, 2) + Math.pow((nd.parent.y + nd.y)/2 - y, 2));
1004 }
1005 }
1007 }
1009 /** Find a node in @param layer near the local coords lx,ly, with precision depending on magnification. */
1010 public Node<T> findNode(final float lx, final float ly, final Layer layer, final double magnification) {
1013 }
1014 }
1016 /** Expects world coords; with precision depending on magnification. */
1017 public Node<T> findClosestNodeW(final float wx, final float wy, final Layer layer, final double magnification) {
1023 }
1024 }
1026 /** Expects world coords; with precision depending on magnification. */
1027 public Node<T> findClosestNodeW(final Collection<Node<T>> nodes, final float wx, final float wy, final double magnification) {
1034 }
1036 }
1038 /** Also sets the last visited and the receiver node. This is a GUI method. */
1039 protected Layer toClosestPaintedNode(final Layer active_layer, final float wx, final float wy, final double magnification) {
1044 }
1046 }
1048 /** Expects local coords; with precision depending on magnification. */
1049 public Node<T> findClosestNode(final Collection<Node<T>> nodes, final float lx, final float ly, final double magnification) {
1060 }
1061 }
1063 }
1065 /** Find the spatially closest node, in calibrated coords; expects local coords. */
1070 return findNearestNode(lx, ly, (float)layer.getZ(), layer.getParent().getCalibration(), nodes);
1071 }
1072 }
1074 private final Node<T> findNearestNode(final float lx, final float ly, final float lz, final Calibration cal, final Collection<Node<T>> nodes) {
1076 // A distance map would help here
1082 final float d = (float) (Math.pow(pixelWidth * (nd.x - lx), 2) + Math.pow(pixelHeight * (nd.y -ly), 2) + Math.pow(pixelWidth * (nd.la.getZ() - lz), 2));
1086 }
1087 }
1089 }
1091 /** Find the spatially closest node, in calibrated coords. */
1094 return findNearestNode(lx, ly, (float)layer.getZ(), layer.getParent().getCalibration(), end_nodes);
1095 }
1096 }
1098 public boolean insertNode(final Node<T> parent, final Node<T> child, final Node<T> in_between, final byte confidence) {
1104 // cache
1107 // If child was in end_nodes, remains there
1110 }
1114 }
1116 /** Considering only the set of consecutive layers currently painted, find a point near an edge
1117 * with accuracy depending upon magnification.
1118 * @return null if none of the edges is close enough, or an array of parent and child describing the edge. */
1119 public Node<T>[] findNearestEdge(final float x_pl, final float y_pl, final Layer layer, final double magnification) {
1121 // Don't traverse all, just look into nodes currently being painted according to layer_set.n_layers_color_cue
1124 //
1129 //
1132 // Examine if the point is closer to the 2D-projected edge than any other so far:
1133 // TODO it's missing edges with parents beyond the set of painted layers,
1134 // and it's doing edges to children beyond the set of painted layers.
1143 }
1144 }
1145 }
1148 }
1150 /** In projected 2D only, since that's the perspective of the user. */
1164 }
1165 }
1167 }
1169 /** Will call calculateBoundingBox and repaint. */
1179 }
1184 }
1186 }
1189 }
1199 }
1200 }
1208 }
1209 }
1211 }
1213 }
1215 /** Remove a node only (not its subtree).
1216 * @return true on success. Will return false when the node has 2 or more children.
1217 * The new edge confidence is that of the parent to the @param node. */
1221 // End node:
1226 // Make its child the new root
1235 }
1238 }
1244 }
1245 }
1247 /** If the tree is a cyclic graph, it may destroy all. */
1250 }
1258 // if not an end-point, update cached lists
1265 }
1266 }
1271 }
1274 }
1275 // Update receiver:
1277 // Finally, remove from parent node
1279 }
1281 }
1286 }
1288 }
1290 /** Check if it is possible to join all given Trees into this,
1291 * by using the first one as the receiver (which should be this),
1292 * and all the others as the ones to be merged into the receiver.
1293 * Requires each Tree to have a non-null marked Node; otherwise, returns false. */
1298 }
1302 }
1306 }
1312 }
1316 }
1320 }
1321 }
1323 }
1325 /* Requires each Tree to have a non-null marked Node; otherwise, returns false. */
1328 // Preconditions passed: all Tree in ts have a marked node and are of the same kind
1332 // transform nodes from there to here
1339 }
1350 // Remove review stack if any
1352 }
1353 addNode(this.marked, tl.marked, Node.MAX_EDGE_CONFIDENCE); // will calculateBoundingBox, hence at_inv has to be recomputed every time
1354 // Remove from tl pointers
1357 // Remove from tl cache
1360 }
1362 }
1364 // Don't clear this.marked
1369 }
1371 protected Node<T> findNodeNear(final float x, final float y, final Layer layer, final DisplayCanvas dc) {
1373 }
1375 /** Expects world coordinates. If no node is near x,y but there is only one node in the current Display view of the layer, then it returns that node. */
1376 protected Node<T> findNodeNear(float x, float y, final Layer layer, final DisplayCanvas dc, final boolean use_receiver_when_null) {
1381 }
1383 // Search within the nodes in layer
1388 }
1389 // Find a node near the coordinate
1391 // If that fails, try any node show all by itself in the display:
1394 // Is there only one node within the srcRect?
1401 }
1406 count++;
1410 }
1411 }
1412 }
1413 }
1421 }
1422 }
1424 /*
1425 if (null == nd) {
1426 Utils.log("No node near " + x + ", " + y + ", " + layer + ", mag=" + magnification);
1427 return null;
1428 }
1429 */
1431 }
1432 }
1439 }
1441 // Search within the nodes in layer
1446 }
1448 // Find a node near the coordinate
1453 }
1456 }
1457 }
1462 }
1464 }
1466 /** The node currently being dragged or edited in some way. */
1469 }
1470 /** The node currently being dragged or edited in some way. */
1476 }
1480 }
1484 }
1485 /** The node that paints in green, which is the receiver of events. */
1488 }
1492 }
1496 }
1498 @Override
1501 }
1511 }
1514 }
1517 // clear:
1519 }
1521 /** The Node double-clicked on, for join operations. */
1523 /** The Node clicked on, for mouse operations. */
1525 /** The last added node */
1527 /** The last edited node, which will be the last added as well until some other node is edited. */
1529 /** The last visited node, either navigating or editing.
1530 * It's the only node that can receive new children by clicking*/
1533 // TODO: last_visited and receiver overlap TOTALLY
1542 }
1544 @Override
1545 public void mousePressed(final MouseEvent me, final Layer layer, final int x_p, final int y_p, final double mag) {
1548 }
1551 // transform the x_p, y_p to the local coordinates
1558 }
1568 }
1571 // Remove point and its subtree
1574 // Just remove the slab point, joining parent with child
1576 Utils.log("Can't pop out branch point!\nUse shift+control+alt+click to remove a branch point and its subtree.");
1579 }
1580 }
1581 repaint(false, layer); // keep larger size for repainting, will call calculateBoundingBox on mouseRelesed
1584 }
1589 }
1592 }
1593 // Add new point
1600 }
1604 Utils.showMessage("Before adding a new node, please activate an existing node\nby clicking on it, or pushing 'g' on it.");
1606 }
1607 // Find the point closest to any other starting or ending point in all branches
1608 //Node<T> nearest = findNearestEndNode(x_pl, y_pl, layer); // at least the root exists, so it has to find a node, any node
1609 // append new child; inherits radius from parent
1614 }
1616 }
1618 // First point
1619 root = createNewNode(x_p, y_p, layer, null); // world coords, so calculateBoundingBox will do the right thing
1622 }
1623 }
1625 @Override
1626 public void mouseDragged(final MouseEvent me, final Layer la, final int x_p, final int y_p, final int x_d, final int y_d, final int x_d_old, final int y_d_old) {
1628 }
1630 @Override
1631 public void mouseReleased(final MouseEvent me, final Layer la, final int x_p, final int y_p, final int x_d, final int y_d, final int x_r, final int y_r) {
1638 }
1644 }
1646 private final void translateActive(final MouseEvent me, final Layer la, int x_d, int y_d, int x_d_old, int y_d_old) {
1648 // shiftDown is ok: when dragging a newly branched node.
1650 // transform to the local coordinates
1658 }
1663 }
1671 @Override
1679 // Reject
1681 }
1690 // Can only add a tag for A-Z or numbers!
1691 if (! (Character.isLetterOrDigit((char)keyCode) && (Character.isDigit((char)keyCode) || Character.isUpperCase((char)keyCode)))) { // VK_F1, F2 ... are lower case letters! Evil!
1692 // Cancel tagging
1698 }
1700 // force dialogs for next key
1704 }
1715 if (layer_set.askToRemoveTag(keyCode)) { // if removed from tag namespace, it will be removed from all nodes that have it
1717 }
1724 }
1725 }
1728 }
1735 }
1736 // Ask to chose one, if more than one
1739 // nothing to untag
1741 }
1743 // if the target_tags has only one tag for the given keycode, just remove it
1749 count++;
1751 }
1752 }
1754 // just remove it
1758 }
1759 }
1768 }
1769 i++;
1773 }
1775 @Override
1782 }
1783 });
1784 }
1790 @Override
1799 }
1802 }
1803 });
1805 // Show the popup on the Display, under the node
1818 }
1825 }
1826 }
1830 // Set confidence of the receiver node
1835 }
1837 }
1853 }
1856 }
1908 }
1911 }
1913 }
1914 }
1915 if (ProjectToolbar.PEN == ProjectToolbar.getToolId() && 0 == (modifiers ^ Event.SHIFT_MASK) && KeyEvent.VK_C == keyCode) {
1920 }
1924 }
1925 }
1928 }
1929 }
1942 @Override
1946 }
1947 };
1951 final String[] choices = {"this node only", "nodes until next branch or end node", "entire subtree"};
1958 }
1964 // this node only: already done
1967 // the downstream slab:
1970 }
1973 // the entire subtree:
1974 for (final Node<T> node: new Node.NodeCollection<T>(nd, Node.BreadthFirstSubtreeIterator.class)) {
1976 }
1980 }
1984 }
1986 }
1988 @Override
2005 }
2006 }
2008 /** Used when reconstructing from XML. */
2014 }
2015 }
2017 @Override
2018 public void paintSnapshot(final Graphics2D g, final Layer layer, final List<Layer> layers, final Rectangle srcRect, final double mag) {
2021 // Paint without arrows
2028 }
2029 }
2033 }
2035 /** Fly-through image stack from source node to mark node.
2036 * @param type is ImagePlus.GRAY8 or .COLOR_RGB */
2037 public ImagePlus flyThroughMarked(final int width, final int height, final double magnification, final int type, final String dir) {
2040 }
2042 public LinkedList<Region<Node<T>>> generateRegions(final Node<T> first, final Node<T> last, final int width, final int height, final double magnification) {
2054 node));
2057 }
2059 }
2061 /** Fly-through image stack from first to last node. If first is not lower order than last, then start to last is returned.
2062 * @param type is ImagePlus.GRAY8 or .COLOR_RGB */
2063 public ImagePlus flyThrough(final Node<T> first, final Node<T> last, final int width, final int height, final double magnification, final int type, final String dir) {
2064 return project.getLoader().createFlyThrough(generateRegions(first, last, width, height, magnification), magnification, type, dir);
2065 }
2067 /** Measures number of branch points and end points, and total cable length.
2068 * Cable length is measured as:
2069 * Cable length: the sum of all distances between all consecutive pairs of nodes.
2070 * Lower-bound cable length: the sum of all distances between all end points to branch points, branch points to other branch points, and first branch point to root. */
2071 @Override
2088 // Skip the root node
2090 //
2098 // Lower bound cable length:
2105 }
2112 }
2113 }
2114 }
2115 }
2117 if (null == rt) rt = Utils.createResultsTable("Tree results", new String[]{"id", "N branch points", "N end points", "Cable length", "LB Cable length"});
2127 }
2129 /** Expects Rectangle in world coords. */
2130 @Override
2135 return null != findFirstIntersectingNode(nodes, new Area(r).createTransformedArea(this.at.createInverse()));
2138 }
2140 }
2141 /** Expects Area in world coords. */
2142 @Override
2145 }
2146 /** Expects Area in world coords.
2147 * @return The first {@link Node} that intersects the {@param area} at the given {@param layer}, or null if none do. */
2155 }
2157 }
2159 /** Expects an Area in local coordinates. */
2163 }
2165 @Override
2170 }
2171 }
2173 @Override
2179 }
2180 }
2181 }
2182 }
2186 /** Create a GUI to list, in three tabs: starting point, branch points, end points, and all points.
2187 * The table has columns for X, Y, Z, data (radius or area), Layer, and tags.
2188 * Double-click on a row positions the front display at that coordinate.
2189 * An extra tab has a search field, to list nodes for a given typed-in (regex) tag. */
2202 }
2205 }
2207 }
2208 }});
2209 }
2215 }
2216 }
2221 }
2222 }
2224 @Override
2231 }
2232 }
2234 }
2236 }
2241 endnodes,*/
2242 allnodes,
2243 searchnodes;
2249 model_endnodes,
2250 model_allnodes,
2251 model_searchnodes;
2258 }
2260 @Override
2261 public Component getTableCellRendererComponent(final JTable table, final Object value, final boolean isSelected, final boolean hasFocus, final int row, final int column) {
2262 final Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
2263 // Colorize visited review cells
2264 if (8 == column && visited_reviews.contains(((NodeTableModel)table.getModel()).nodes.get(row))) {
2274 }
2275 }
2277 }
2278 }
2285 @Override
2286 public void mouseClicked(final MouseEvent me) { // mousePressed would fail to repaint due to asynch issues
2294 }
2295 });
2297 @Override
2306 }
2317 final JMenuItem mark_as_reviewed = new JMenuItem("Mark selected as reviewed"); popup.add(mark_as_reviewed);
2318 final JMenuItem clear_visited_reviews = new JMenuItem("Unmark all reviewed"); popup.add(clear_visited_reviews);
2319 //
2321 @Override
2328 }
2330 }
2334 }
2336 }
2341 }
2344 }
2348 }
2349 }
2353 }
2355 // Get multiple selection
2361 }
2362 }
2364 }
2365 }
2366 };
2377 }
2378 }
2379 });
2381 @Override
2388 // If there is a review stack, open it
2390 } else if (keyCode == KeyEvent.VK_W && (0 == (Utils.getControlModifier() ^ ke.getModifiers()))) {
2392 }
2393 }
2394 });
2395 }
2396 /*
2397 Node<T> getNode(int row) {
2398 return ((NodeTableModel)this.getModel()).nodes.get(row);
2399 }
2400 */
2401 /*
2402 String getNodeTags(int row) {
2403 NodeTableModel m = (NodeTableModel)this.getModel();
2404 Node<T> nd = m.nodes.get(row);
2405 return m.getNodeData(nd).tags;
2406 }
2407 */
2416 }
2417 }
2421 }
2426 }
2430 }
2431 }
2438 }
2441 // See if there are any tags
2446 }
2447 // Find a review tag, if any
2453 }
2454 }
2458 }
2460 // Find a stack for the review tag, and open it
2463 }
2469 }
2471 }
2472 }
2477 }
2481 @Override
2484 }
2485 });
2494 @Override
2498 }
2499 }
2500 });
2503 @Override
2506 }
2507 });
2542 }
2547 allnodes;
2549 allnodes = null == root ? new ArrayList<Node<T>>() : new ArrayList<Node<T>>(root.getSubtreeNodes());
2550 }
2556 }
2557 }
2558 // Remove nodes no longer present:
2561 // Swap:
2562 /*
2563 this.branchnodes = branchnodes;
2564 this.endnodes = endnodes;
2565 */
2588 }
2589 }
2592 }
2602 }});
2603 }
2607 }
2611 }});
2612 }
2619 final Pattern pat = Pattern.compile(sb.toString(), Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
2628 }
2629 }
2630 }
2635 }
2636 }
2637 }
2649 // Assumes only RadiusNode and AreaNode exist
2656 * cal.pixelWidth * cal.pixelHeight, 1)).append(' ').append(cal.getUnits()).append('^').append(2).toString();
2658 this.data = new StringBuilder(Utils.cutNumber(((Treeline.RadiusNode)nd).getData(), 1)).append(' ').append(cal.getUnits()).toString();
2659 }
2661 //
2670 }
2677 }
2678 }
2679 }
2688 }
2694 }
2695 @Override
2708 }
2709 }
2710 @Override
2712 @Override
2728 }
2729 }
2730 @Override
2734 }
2741 }
2743 }
2744 }
2745 @Override
2748 }
2749 @Override
2754 @Override
2760 }
2764 // Replace empty strings with a row of z
2767 }
2769 }
2770 });
2774 }
2779 }
2781 }
2782 }
2784 @Override
2790 }
2807 // split: the first child remains as root:
2811 // ... and the rest of children become children of the new root
2816 }
2818 }
2823 // add all its children to the parent
2827 }
2828 }
2830 }
2831 }
2835 }
2837 @Override
2838 public boolean apply(final Layer la, final Area roi, final mpicbg.models.CoordinateTransform ict) throws Exception {
2850 }
2851 }
2853 }
2854 }
2857 }
2858 @Override
2867 }
2868 }
2871 }
2873 @Override
2879 }
2880 }
2881 @Override
2885 }
2886 }
2888 /** In world coordinates. Returns an empty area when there aren't any nodes in @param layer. */
2889 @Override
2898 }
2899 }
2901 /** Fast and dirty, never returns a false negative but may return a false positive. */
2902 @Override
2910 // May not be enough for lots of corner cases
2911 // such as:
2912 // * parent and child node outside, but paint inside
2913 // * data of an outside node spills inside the box
2914 //
2915 // if (local.contains((int)nd.x, (int)nd.y)) return true;
2917 // A bit more careful:
2919 }
2924 }
2925 }
2926 }
2928 /** Retain the data within the layer range, and through out all the rest.
2929 * Does NOT call calculateBoundingBox or updateBucket; that is your responsibility. */
2930 @Override
2933 // Iterate nodes and when a node sits on a Layer that doesn't belong to the range, then remove it and give its children, if any, to the parent node.
2935 for (final Iterator<Map.Entry<Layer,Set<Node<T>>>> it = node_layer_map.entrySet().iterator(); it.hasNext(); ) {
2939 // Else, remove the set of nodes for that layer
2941 // ... and remove all nodes from their parents, merging their children
2943 // if end node, just remove it from its parent
2945 // The current root:
2950 // First child as new root:
2953 // ... and gets any other children of the root
2957 }
2958 }
2960 // Remove from its parent
2963 // ... and handle its children:
2965 // An end point
2968 // Else, add all its children to its parent
2972 }
2973 }
2974 }
2975 }
2976 }
2977 }
2980 }
2981 }
2983 /** Open an image in a separate thread and returns the thread. Frees up to 1 Gb for it. */
2986 @Override
2992 }
2993 project.getLoader().releaseToFit(1000000000L); // 1 Gb : can't tell for jpegs and tif-jpg, TODO would have to read the header.
3004 @Override
3008 // Go to the node
3009 // Slices are 1-based: 1<=i<=N
3020 }
3021 // next cycle
3022 count--;
3024 };
3025 }
3026 }
3027 }
3028 @Override
3032 }
3033 }
3034 @Override
3038 }
3039 }
3040 });
3042 }
3046 }
3048 }
3049 });
3050 }
3054 }
3058 @Override
3062 // Find all end nodes and branch nodes
3063 // Add review tags to end nodes and branch nodes, named: "#R-<x>", where <x> is a number.
3064 // Generate a fly-through stack from each found node to its previous branch point or root
3067 // Above, use maximum 4 threads. I/O bound operations don't deal well with more.
3069 // Disable window
3077 // Remove all reviews, if any
3081 }
3092 @Override
3099 }
3100 }
3101 createReviewStack(nd.findPreviousBranchOrRootPoint(), nd, tag, filepath, 512, 512, 1.0, ImagePlus.COLOR_RGB);
3102 }
3103 };
3104 k++;
3105 }
3107 // Now that all tags exists (and will get painted), generate the stacks
3116 }
3118 }
3120 /** The behavior is undefined if @param last is not a descendant of @param first. */
3121 public void createReviewStack(final Node<T> first, final Node<T> last, final Tag tag, final String filepath, final int width, final int height, final double magnification, final int image_type) {
3123 final ImagePlus imp = project.getLoader().createLazyFlyThrough(generateRegions(first, last, width, height, magnification), magnification, image_type, this);
3131 }
3132 }
3136 // Remove the "#" from the tag name
3137 return getProject().getLoader().getUNUIdFolder() + "tree.review.stacks/" + getId() + "/" + tag.toString().substring(1) + ".zip";
3138 }
3152 }
3153 }
3154 // Remove tag:
3159 }
3160 }
3161 }
3163 }
3166 @Override
3169 // Remove all review tags
3170 // Remove all .zip stacks for this Treeline
3176 }
3177 }
3178 final File f = new File(getProject().getLoader().getUNUIdFolder() + "tree.review.stacks/" + getId());
3180 // Remove directory (even if not empty)
3183 Utils.log("Could not delete some review stacks.\n --> Directory remains: " + f.getAbsolutePath());
3184 }
3188 }
3190 public Map<Node<T>,Collection<Displayable>> findIntersecting(final Class<?> c) throws Exception {
3191 final HashMap<Node<T>,Collection<Displayable>> m = new HashMap<Node<T>,Collection<Displayable>>();
3194 @Override
3202 }
3204 }
3205 });
3207 }
3209 /** Returns an array of two Collection of connectors: the first one has the outgoing connectors, and the second one has the incoming connectors. */
3217 @Override
3221 final Collection<Displayable> col = layer_set.findZDisplayables(Connector.class, nd.la, a, false, false);
3223 // Outgoing or incoming?
3228 }
3232 }
3233 }
3234 }
3236 }
3237 });
3238 }
3240 }
3242 @Override
3245 if (null != title && !getClass().getSimpleName().toLowerCase().equals(title.toLowerCase())) return title;
3248 return new StringBuilder("Root: x=").append(p.x).append(", y=" + p.y).append(" z=").append(p.z).toString();
3249 }
3254 }
3256 /** Return the {@link Node} as a point in space.
3257 * @param nd The Node to extract coordinates from.
3258 * @param calibrated Whether to calibrate or not the point.
3259 * @return The Point3f representing the node. */
3262 }
3264 /** Expects a non-null float[] for reuse, and modifies @param p in place. */
3276 }
3278 }
3280 /** Takes a collection of Tree instances and creates duplicate siblings of the target class.
3281 * Will ignore any non-tree Displayable instances in the Collection.
3282 * The duplicated trees are added to the ProjectTree as siblings of the originals, and to the LayerSet.
3283 * @return The map of original trees vs copies in target class form. */
3284 public static Map<Tree<?>,Tree<?>> duplicateAs(final Collection<Displayable> col, final Class<? extends Tree<?>> target) throws Exception {
3290 }
3294 }
3299 }
3301 /*
3302 // Specific for a target Treeline:
3304 final Treeline t = new Treeline(src.project, src.title);
3305 t.at.setTransform(src.at);
3307 final Map<Node<?>,Treeline.RadiusNode> rel = new HashMap<Node<?>,Treeline.RadiusNode>();
3308 final LinkedList<Node<?>> todo = new LinkedList<Node<?>>();
3309 //t.root = new Treeline.RadiusNode(src.root.x, src.root.y, src.root.la);
3310 todo.add(src.root);
3311 while (!todo.isEmpty()) {
3312 final Node<?> a = todo.removeLast();
3313 // Put all children nodes to the end of the todo list
3314 if (null != a.children)
3315 for (final Node<?> child : a.children)
3316 todo.add(child);
3317 // Copy the content of the 'a' node
3318 Treeline.RadiusNode copy = new Treeline.RadiusNode(a.x, a.y, a.la);
3319 copy.copyProperties(a);
3320 // Store relationship between original and copy
3321 rel.put(a, copy);
3322 // Find parent if any
3323 if (null == a.parent) continue;
3324 // .. and if found, add the copy to the copied parent:
3325 rel.get(a.parent).add(copy, copy.confidence);
3326 }
3327 */
3334 }
3339 Utils.log("Could not add " + src.getClass().getSimpleName() + " as " + target.getSimpleName());
3342 }
3343 }
3344 }
3346 }
3348 /** Can copy a Treeline to an AreaTree and viceversa.
3349 * Copies the transform, the nodes (with tags and confidence), and the color. The transparency, locked stated and links are not copied. */
3350 static public<A extends Tree<?>, B extends Node<?>> A copyAs(final Tree<?> src, final Class<A> tree_class, final Class<B> node_class) throws Exception {
3352 final A t = tree_class.getConstructor(Project.class, String.class).newInstance(src.project, title);
3360 //t.root = new Treeline.RadiusNode(src.root.x, src.root.y, src.root.la);
3364 // Put all children nodes to the end of the todo list
3368 // Copy the content of the 'a' node
3369 final B copy = node_class.getConstructor(Float.TYPE, Float.TYPE, Layer.class).newInstance(a.x, a.y, a.la);
3371 // Store relationship between original and copy
3373 // Find parent if any
3375 // Set the copy as the root
3378 }
3379 // .. and if found, add the copy to the copied parent:
3381 }
3382 // create internals
3385 }
3387 /** One color per vertex. */
3394 }
3395 }
3397 private Node<T> guiFindNode(final float x, final float y, final Layer layer, final double magnification) {
3401 }
3405 }
3409 }
3411 }
3413 /** @return null if no node is near @param x, @param y */
3414 public Bureaucrat generateReviewStackForSlab(final float x, final float y, final Layer layer, final double magnification) {
3416 }
3418 public Bureaucrat generateSubtreeReviewStacks(final int x, final int y, final Layer layer, final double magnification) {
3420 }
3422 /** Generate a review stack from the previous branch node or root, to the next branch node or end node. */
3425 @Override
3430 // Check if 'last' already has a review tag
3438 }
3439 }
3444 }
3445 }
3452 }
3460 firsty;
3471 }
3475 }
3476 return new Point3f(fpB[0], fpB[1], (float)(path.get(path.size()-1).la.getZ() * cal.pixelWidth));
3477 }
3480 }
3481 /** @throws an Exception if a path cannot be found between @param a and @param b. */
3482 private MeasurePathDistance(final Tree<I> tree, final Node<I> a, final Node<I> b, final List<Node<I>> path) {
3489 //
3496 //
3499 //
3503 }
3504 //
3515 // prepare next iteration
3520 }
3521 }
3522 /** Reuses @param rt unless it is null, in which case it creates a new one. */
3524 if (null == rt) rt = Utils.createResultsTable("Tree path measurements", new String[]{"id", "XA", "YA", "Layer A", "XB", "YB", "Layer B", "distance", "N nodes", "N branch points"});
3538 }
3539 }
3541 /** Reuses @param rt unless it is null, in which case it creates a new one.
3542 * Will check if both nodes belong to this tree.
3543 * @return The used ResultsTable instance. */
3544 public ResultsTable measurePathDistance(final Node<T> a, final Node<T> b, final ResultsTable rt) {
3546 // Do both nodes belong to this Tree?
3551 }
3556 }
3561 }
3563 }
3564 }
3565 /** Measure the distance, in calibrated units, between nodes a and b of this tree.
3566 * Does not check if the nodes really belong to this tree. */
3569 }
3571 /** Search all nodes for unique tags and returns them. */
3580 }
3581 }
3582 }
3584 }
3586 @Override
3590 }
3595 }
3600 }
3604 }
3606 static private final<T> Collection<Vertex<Node<T>>> findNeighbors(final Node<T> node, final HashMap<Node<T>,Vertex<Node<T>>> m) {
3612 }
3614 }
3616 /** Return a representation of this Tree with Vertex instead of Node. */
3620 // Create one Vertex per Node<T>
3623 }
3624 // Determine the neighbors of that Vertex
3627 }
3629 }
3631 /** Computes betweenness centrality of each node in the tree,
3632 * using Ulrik Brandes betweenness centrality algorithm. */
3642 }
3644 }
3660 }
3662 }
3663 }
3676 }
3684 }
3686 }
3687 }
3690 /** Two nodes of a tree; there is a unique path that goes from a to b. */
3696 }
3698 /** The calibrated distance from a to b. */
3701 }
3703 /** The list of associated data element with each node. */
3708 }
3710 }
3712 /** The list of data elements associated with each node in the path, ordered from a to b (both included). */
3715 }
3716 }
3719 /** The ordered list of nodes from a to b, both included. */
3724 }
3726 /** Assumes that a is the first element in path, and b the last,
3727 * and that a has a lower degree than b (that is, a is upstream of b). */
3731 }
3735 }
3736 }
3739 {
3740 /** The calibrated path distance between nodes a and b, measured
3741 * as the sum of all the distances between all consecutive pairs
3742 * of nodes between a and b. */
3744 /** The ordered list of calibrated data elements of each node in the path
3745 * of nodes between a and b, both included. */
3747 /** The ordered list of calibrated coordinates of all nodes in the path
3748 * of nodes between a and b, both included. */
3753 }
3766 }
3767 }
3769 abstract public ResultsTable toResultsTable(ResultsTable rt, int index, double scale, int resample);
3772 @Override
3775 }
3776 @Override
3779 }
3780 /** Concatenate the affine of the Tree and an affine that expresses the x,y calibration. */
3786 }
3787 }
3803 }
3808 }
3809 }
3811 }
3817 }
3819 }
3821 /** Drop all tags from the nodes of this tree. */
3826 }
3827 }
3828 }