/** * Recursive traverse of tree to determine selections A leaf is selected if rsm is selected. * Nonleaf nodes are selected if all children are selected. * * @param tn node in the tree for which to determine selection * @param nodeidx the ordinal postion in the segments array * @param gsm the graph segments selection model * @param rsm the table row selection model * @return true if given node tn is selected, else false */ private boolean selTraverse( TreeNode tn, int[] nodeidx, ListSelectionModel gsm, ListSelectionModel rsm) { boolean selected = true; if (!tn.isLeaf()) { // A nonleaf node is selected if all its children are selected. for (int i = 0; i < tn.getChildCount(); i++) { TreeNode cn = tn.getChildAt(i); selected &= selTraverse(cn, nodeidx, gsm, rsm); } } else { if (tn instanceof RowCluster) { // get the row index of the leaf node int ri = ((RowCluster) tn).getIndex(); // A leaf is selected if its row is selected in the row selection rsm. selected = rsm.isSelectedIndex(ri); } } // Get the offset into the segments array int idx = nodeidx[0] * segOffset; if (selected) { gsm.addSelectionInterval(idx, idx + (segOffset - 1)); } else { gsm.removeSelectionInterval(idx, idx + (segOffset - 1)); } // Increment the nodeidx in the tree nodeidx[0]++; return selected; }
/** * Return a count of this node and all its descendents. * * @param node A node in the Treemodel. * @return The number of nodes in this branch of the Treemodel. */ private static int getNodeCount(TreeNode tn) { int nc = 1; // this node if (!tn.isLeaf()) { for (int i = 0; i < tn.getChildCount(); i++) { TreeNode cn = tn.getChildAt(i); nc += getNodeCount(cn); } } return nc; }
/** * Return the number of leaf nodes that descend from the given node. * * @param node A node in the Treemodel. * @return The number of leaf nodes that descend from the given node. */ private static int getLeafCount(TreeNode tn) { int lc = 0; if (!tn.isLeaf()) { for (int i = 0; i < tn.getChildCount(); i++) { TreeNode cn = tn.getChildAt(i); lc += getLeafCount(cn); } } else { lc = 1; } return lc; }
/** * Traververse the tree selecting rows coresponding to leaf nodes of the given node tn * * @param tn the node from which to start traversing * @param rsm the selection model in which to mark selected rows */ private void selectTraverse(TreeNode tn, ListSelectionModel rsm) { if (!tn.isLeaf()) { for (int i = 0; i < tn.getChildCount(); i++) { TreeNode cn = tn.getChildAt(i); selectTraverse(cn, rsm); } } else { if (tn instanceof RowCluster) { int ri = ((RowCluster) tn).getIndex(); rsm.addSelectionInterval(ri, ri); } } }
public boolean isLeafEdge() { return tailNode.isLeaf(); }
/** * Traverse the tree creating dendogram graph line segments, a nodemap, and a leafmap. Traversal * is depth first. return child position currentleafcnt * * @param tn the tree node to traverse * @param leafcnt the leafcount prior to this node * @param parentDistance the distance of the parent node * @param nodeidx the current node index, incremented after each node is traversed * @param nodemap an ordered list of nodes traversed * @param leafmap an order list of row indices to the leafnode traversed * @param segs line segments comprising the dendogram * @param childpos position of child node returned to parent * @return the leafcount after traversing this node */ private int traverse( TreeNode tn, int leafcnt, double parentDistance, int[] nodeidx, TreeNode[] nodemap, int[] leafmap, double[] segs, double childpos[]) { int lc = leafcnt; double distance = 0.; double height = 0.; double minChildx = Double.NaN; double maxChildx = Double.NaN; double minChildy = Double.NaN; double maxChildy = Double.NaN; if (tn instanceof Cluster) { distance = ((Cluster) tn).getSimilarity(); } else { distance = ((DefaultMutableTreeNode) tn).getDepth(); } if (!tn.isLeaf()) { for (int i = 0; i < tn.getChildCount(); i++) { TreeNode cn = tn.getChildAt(i); lc = traverse(cn, lc, distance, nodeidx, nodemap, leafmap, segs, childpos); if (Double.isNaN(minChildx) || childpos[0] < minChildx) { minChildx = childpos[0]; } if (Double.isNaN(maxChildx) || childpos[0] > maxChildx) { maxChildx = childpos[0]; } if (Double.isNaN(minChildy) || childpos[1] < minChildy) { minChildy = childpos[1]; } if (Double.isNaN(maxChildy) || childpos[1] > maxChildy) { maxChildy = childpos[1]; } } } else { if (tn instanceof RowCluster) { leafmap[lc] = ((RowCluster) tn).getIndex(); } minChildx = distance; maxChildx = distance; minChildy = lc; maxChildy = lc; lc++; } // offset into segs int offset = nodeidx[0] * segOffset * 4; nodemap[nodeidx[0]] = tn; nodeidx[0]++; if (segs.length < offset + 8) { double tmp[] = segs; segs = new double[offset + 8]; System.arraycopy(tmp, 0, segs, 0, tmp.length); } // segment from minchild to maxchild segs[offset++] = distance; // X segs[offset++] = minChildy; // Y segs[offset++] = distance; // X segs[offset++] = maxChildy; // Y // segment from node to parent of length distance // postision half way between first and last child double y = minChildy + (maxChildy - minChildy) / 2.; segs[offset++] = distance; // X segs[offset++] = y; // Y segs[offset++] = parentDistance; // X segs[offset++] = y; // Y /* System.err.println(tn.toString() + " \tmlc " + leafcnt + " lc " + lc + " pd " + parentDistance + " d " + distance); for (int i = 8, j = leafcnt * 8; i < 8; i++,j++) { System.err.print("\t" + segs[j]); } System.err.println(""); */ // Update return values childpos[0] = distance; childpos[1] = y; return lc; }