tree.addNode("root"); tree.addEdge("root", "V0", edgeId++); tree.addEdge("V0", "V1", edgeId++); tree.addEdge("V0", "V2", edgeId++); tree.addEdge("V1", "V4", edgeId++); tree.addEdge("V2", "V3", edgeId++); tree.addEdge("V2", "V5", edgeId++); tree.addEdge("V4", "V6", edgeId++); tree.addEdge("V4", "V7", edgeId++); tree.addEdge("V3", "V8", edgeId++); tree.addEdge("V6", "V9", edgeId++); tree.addEdge("V4", "V10", edgeId++); tree.addEdge("root", "A0", edgeId++); tree.addEdge("A0", "A1", edgeId++); tree.addEdge("A0", "A2", edgeId++); tree.addEdge("A0", "A3", edgeId++); tree.addEdge("root", "B0", edgeId++); tree.addEdge("B0", "B1", edgeId++); tree.addEdge("B0", "B2", edgeId++); tree.addEdge("B1", "B4", edgeId++); tree.addEdge("B2", "B3", edgeId++); tree.addEdge("B2", "B5", edgeId++); tree.addEdge("B4", "B6", edgeId++); tree.addEdge("B4", "B7", edgeId++); tree.addEdge("B3", "B8", edgeId++); tree.addEdge("B6", "B9", edgeId++);
private Collection<Double> getDepths() { Set<Double> depths = new HashSet<>(); Map<Object, PolarPoint> polarLocations = radialLayoutAlgorithm.getPolarLocations(); for (Object v : graph.nodes()) { PolarPoint pp = polarLocations.get(v); depths.add(pp.radius); } return depths; }
/** * Replaces the subtree of {@code tree} rooted at {@code subRoot} with a node representing that * subtree. * * @param tree the tree whose subtree is to be collapsed * @param subRoot the root of the subtree to be collapsed */ @SuppressWarnings({"unchecked", "rawtypes"}) public static MutableCTreeNetwork collapse(MutableCTreeNetwork tree, Object subRoot) { // get the subtree rooted at subRoot MutableCTreeNetwork subTree = TreeUtils.getSubTree(tree, subRoot); Optional parent = tree.predecessor(subRoot); if (parent.isPresent()) { // subRoot has a parent, so attach its parent to subTree in its place Object parentEdge = Iterables.getOnlyElement(tree.inEdges(subRoot)); // THERE CAN BE ONLY ONE tree.removeNode(subRoot); tree.addEdge(parent.get(), subTree, parentEdge); } else { // subRoot is the root of tree tree.removeNode(subRoot); tree.addNode(subTree); } return subTree; }
@SuppressWarnings({"unchecked", "rawtypes"}) public static MutableCTreeNetwork expand(MutableCTreeNetwork tree, MutableCTreeNetwork subTree) { Optional parent = tree.predecessor(subTree); Object parentEdge = parent.isPresent() ? Iterables.getOnlyElement(tree.inEdges(subTree)) // THERE CAN BE ONLY ONE : null; if (!subTree.root().isPresent()) { // then the subTree is empty, so just return the tree itself return tree; } tree.removeNode(subTree); if (parent.isPresent()) { TreeUtils.addSubTree(tree, subTree, parent.get(), parentEdge); return tree; } else { // then the tree is empty, so just return the subTree itself return subTree; } } }
TreeNetworkBuilder.builder().expectedNodeCount(7).build(); tree.addNode("root"); tree.addEdge("root", "child1", 1); // two kids tree.addEdge("root", "child2", 2); tree.addEdge("child1", "grandchild11", 11); tree.addEdge("child1", "grandchild12", 12); tree.addEdge("child2", "grandchild21", 21); tree.addEdge("child2", "grandchild22", 22); assertEquals(tree.asGraph(), subTree.asGraph()); expectedSubTree.addNode("child1"); expectedSubTree.addEdge("child1", "grandchild11", 11); expectedSubTree.addEdge("child1", "grandchild12", 12); assertEquals(childOneSubTree.asGraph(), expectedSubTree.asGraph());
/** * Connects {@code subTree} to {@code tree} by attaching it as a child of {@code subTreeParent} * with edge {@code connectingEdge}. * * @param <N> the node type * @param <E> the edge type * @param tree the tree to which {@code subTree} is to be added * @param subTree the tree which is to be grafted on to {@code tree} * @param subTreeParent the parent of the root of {@code subTree} in its new position in {@code * tree} * @param connectingEdge the edge used to connect {@code subTreeParent} to {@code subtree}'s root */ public static <N, E> void addSubTree( MutableCTreeNetwork<N, E> tree, CTreeNetwork<N, E> subTree, N subTreeParent, E connectingEdge) { checkNotNull(tree, "tree"); checkNotNull(subTree, "subTree"); checkNotNull(subTreeParent, "subTreeParent"); checkNotNull(connectingEdge, "connectingEdge"); checkArgument(tree.nodes().contains(subTreeParent), "'tree' does not contain 'subTreeParent'"); if (!subTree.root().isPresent()) { // empty subtree; nothing to do return; } N subTreeRoot = subTree.root().get(); tree.addEdge(subTreeParent, subTreeRoot, connectingEdge); addFromSubTree(tree, subTree, subTreeRoot); }
private static <N, E> void addFromSubTree( MutableCTreeNetwork<N, E> tree, CTreeNetwork<N, E> subTree, N subTreeRoot) { checkNotNull(tree, "tree"); checkNotNull(subTree, "subTree"); checkNotNull(subTreeRoot, "subTreeRoot"); for (E edge : subTree.outEdges(subTreeRoot)) { N child = subTree.incidentNodes(edge).target(); tree.addEdge(subTreeRoot, child, edge); addFromSubTree(tree, subTree, child); } } }
/** * Populates <code>subtree</code> with the subtree of <code>tree</code> which is rooted at <code> * root</code>. * * @param <N> the node type * @param <E> the edge type * @param tree the tree whose subtree is to be extracted * @param subTree the tree instance which is to be populated with the subtree of <code>tree</code> * @param root the root of the subtree to be extracted */ // does this need to be a public method? (or even separate?) public static <N, E> void growSubTree( CTreeNetwork<N, E> tree, MutableCTreeNetwork<N, E> subTree, N root) { checkNotNull(tree, "tree"); checkNotNull(subTree, "subTree"); checkNotNull(root, "root"); for (N kid : tree.successors(root)) { E edge = tree.edgesConnecting(root, kid).iterator().next(); // guaranteed to be only one edge subTree.addEdge(root, kid, edge); growSubTree(tree, subTree, kid); } }
tree.addNode("root"); tree.addEdge("root", "V0", edgeId++); tree.addEdge("V0", "V1", edgeId++); tree.addEdge("V0", "V2", edgeId++); tree.addEdge("V1", "V4", edgeId++); tree.addEdge("V2", "V3", edgeId++); tree.addEdge("V2", "V5", edgeId++); tree.addEdge("V4", "V6", edgeId++); tree.addEdge("V4", "V7", edgeId++); tree.addEdge("V3", "V8", edgeId++); tree.addEdge("V6", "V9", edgeId++); tree.addEdge("V4", "V10", edgeId++); tree.addEdge("root", "A0", edgeId++); tree.addEdge("A0", "A1", edgeId++); tree.addEdge("A0", "A2", edgeId++); tree.addEdge("A0", "A3", edgeId++); tree.addEdge("root", "B0", edgeId++); tree.addEdge("B0", "B1", edgeId++); tree.addEdge("B0", "B2", edgeId++); tree.addEdge("B1", "B4", edgeId++); tree.addEdge("B2", "B3", edgeId++); tree.addEdge("B2", "B5", edgeId++); tree.addEdge("B4", "B6", edgeId++); tree.addEdge("B4", "B7", edgeId++); tree.addEdge("B3", "B8", edgeId++); tree.addEdge("B6", "B9", edgeId++);
tree.addNode("root"); tree.addEdge("root", "V0", edgeId++); tree.addEdge("V0", "V1", edgeId++); tree.addEdge("V0", "V2", edgeId++); tree.addEdge("V1", "V4", edgeId++); tree.addEdge("V2", "V3", edgeId++); tree.addEdge("V2", "V5", edgeId++); tree.addEdge("V4", "V6", edgeId++); tree.addEdge("V4", "V7", edgeId++); tree.addEdge("V3", "V8", edgeId++); tree.addEdge("V6", "V9", edgeId++); tree.addEdge("V4", "V10", edgeId++); tree.addEdge("root", "A0", edgeId++); tree.addEdge("A0", "A1", edgeId++); tree.addEdge("A0", "A2", edgeId++); tree.addEdge("A0", "A3", edgeId++); tree.addEdge("root", "B0", edgeId++); tree.addEdge("B0", "B1", edgeId++); tree.addEdge("B0", "B2", edgeId++); tree.addEdge("B1", "B4", edgeId++); tree.addEdge("B2", "B3", edgeId++); tree.addEdge("B2", "B5", edgeId++); tree.addEdge("B4", "B6", edgeId++); tree.addEdge("B4", "B7", edgeId++); tree.addEdge("B3", "B8", edgeId++); tree.addEdge("B6", "B9", edgeId++);
tree.addNode("root"); tree.addEdge("root", "V0", edgeId++); tree.addEdge("V0", "V1", edgeId++); tree.addEdge("V0", "V2", edgeId++); tree.addEdge("V1", "V4", edgeId++); tree.addEdge("V2", "V3", edgeId++); tree.addEdge("V2", "V5", edgeId++); tree.addEdge("V4", "V6", edgeId++); tree.addEdge("V4", "V7", edgeId++); tree.addEdge("V3", "V8", edgeId++); tree.addEdge("V6", "V9", edgeId++); tree.addEdge("V4", "V10", edgeId++); tree.addEdge("root", "A0", edgeId++); tree.addEdge("A0", "A1", edgeId++); tree.addEdge("A0", "A2", edgeId++); tree.addEdge("A0", "A3", edgeId++); tree.addEdge("root", "B0", edgeId++); tree.addEdge("B0", "B1", edgeId++); tree.addEdge("B0", "B2", edgeId++); tree.addEdge("B1", "B4", edgeId++); tree.addEdge("B2", "B3", edgeId++); tree.addEdge("B2", "B5", edgeId++); tree.addEdge("B4", "B6", edgeId++); tree.addEdge("B4", "B7", edgeId++); tree.addEdge("B3", "B8", edgeId++); tree.addEdge("B6", "B9", edgeId++);
tree.addNode("A0"); tree.addEdge("A0", "B0", edgeId++); tree.addEdge("A0", "B1", edgeId++); tree.addEdge("A0", "B2", edgeId++); tree.addEdge("B0", "C0", edgeId++); tree.addEdge("B0", "C1", edgeId++); tree.addEdge("B0", "C2", edgeId++); tree.addEdge("B0", "C3", edgeId++); tree.addEdge("C2", "H0", edgeId++); tree.addEdge("C2", "H1", edgeId++); tree.addEdge("B1", "D0", edgeId++); tree.addEdge("B1", "D1", edgeId++); tree.addEdge("B1", "D2", edgeId++); tree.addEdge("B2", "E0", edgeId++); tree.addEdge("B2", "E1", edgeId++); tree.addEdge("B2", "E2", edgeId++); tree.addEdge("D0", "F0", edgeId++); tree.addEdge("D0", "F1", edgeId++); tree.addEdge("D0", "F2", edgeId++); tree.addEdge("D1", "G0", edgeId++); tree.addEdge("D1", "G1", edgeId++); tree.addEdge("D1", "G2", edgeId++); tree.addEdge("D1", "G3", edgeId++);