/** * Adds an edge from n1 to n2. This {@link EdgeType} is ignored as rooted * trees use directed edges. */ public Edge<TreeNode> addEdge(TreeNode n1, TreeNode n2, EdgeType type) { return addEdge(n1, n2); }
private Tree addCompatibleCladesToBackboneTree(Tree backboneTree, Collection<Bipartition> partitionsToInsert) { for (Bipartition partition : partitionsToInsert) { Set<TreeNode> leafes = new HashSet<>(); for (int i = partition.partition.nextSetBit(0); i >= 0; i = partition.partition.nextSetBit(i + 1)) { leafes.add(indexToLeaf1.get(i)); } TreeNode lca = backboneTree.findLeastCommonAncestor(new ArrayList<>(leafes)); TreeNode nuLca = new TreeNode(); backboneTree.addVertex(nuLca); for (TreeNode child : lca.getChildren()) { TreeNode leaf; if (child.isInnerNode()) { leaf = child.depthFirstIterator().iterator().next(); } else { leaf = child; } if (leafes.contains(leaf)) { backboneTree.removeEdge(lca, child); backboneTree.addEdge(nuLca, child); } } backboneTree.addEdge(lca, nuLca); } return backboneTree; }
/** * Inserts node to specific position. Shifts any subsequent nodes to the right. * * @param tree the tree * @param i the position */ private static void insertNode(Tree tree, TreeNode parent, TreeNode node, int i) { if (i < 0) { throw new IndexOutOfBoundsException("Index is smaller than 0"); } ArrayList<TreeNode> children = parent.getChildren(); children.add(i, node); tree.addVertex(node); for (TreeNode child : parent.getChildren()) { tree.removeEdge(parent, child); } for (TreeNode child : children) { tree.addEdge(parent, child); } }
TreeNode pp = p.getParent(); supertree.removeEdge(p, toLiftUp); supertree.addEdge(pp, toLiftUp); leafMap.get(p).removeAll(set);
public static Tree deleteRootNode(Tree sourceTree, boolean clone) { if (clone) sourceTree = sourceTree.cloneTree(); TreeNode r = sourceTree.getRoot(); if (r.childCount() == 2) { List<TreeNode> children = r.getChildren(); sourceTree.removeVertex(r); TreeNode c1 = children.get(0); TreeNode c2 = children.get(1); if (c1.isInnerNode()) { sourceTree.addEdge(c1, c2); sourceTree.setRoot(c1); } else if (c2.isInnerNode()) { sourceTree.addEdge(c2, c1); sourceTree.setRoot(c2); } else { System.out.println("Could not unroot tree. Tree seems not to be a tree!"); return null; } } return sourceTree; }
TreeNode nuLcaParent = new TreeNode(); t.addVertex(nuLcaParent); t.addEdge(nuLcaParent, lca); t.addEdge(lcaParent, nuLcaParent); t.removeEdge(lcaParent, lca); lca = nuLcaParent; TreeNode nuLcaParent = new TreeNode(); t.addVertex(nuLcaParent); t.addEdge(nuLcaParent, lca); t.setRoot(nuLcaParent); lca = nuLcaParent; TreeNode nuNode = st.insertionPoint; t.addVertex(nuNode); t.addEdge(lca, nuNode);
for (TreeNode child : node.getChildren()) { t1.removeEdge(node, child); t1.addEdge(parent, child);
public Tree buildTree() { TIntObjectMap<TreeNode> nodeMap = new TIntObjectHashMap<>(); Tree tree = new Tree(); Iterator<Edge> it = supertreeEdges.iterator(); while (it.hasNext()) { Edge edge = it.next(); nodeMap.put(edge.treeNode, new TreeNode(edge.treeNodeLabel)); tree.addVertex(nodeMap.get(edge.treeNode)); if (edge.parentNode == 0) { tree.setRoot(nodeMap.get(edge.treeNode)); it.remove(); } } for (Edge edge : supertreeEdges) { tree.addEdge(nodeMap.get(edge.parentNode), nodeMap.get(edge.treeNode)); } tree.setName(String.valueOf(currentscore)); return tree; }
if (node.getParentPartition() != null) { TreeNode n1 = node.getParentPartition().getNode(result); result.addEdge(n1, n);
private static void connectParent(Tree tree, TreeNode newRoot, TreeNode parent, double weight) { TreeNode next = parent.getParent(); double nextWeight = 1; if (next != null) { nextWeight = tree.getEdge(next, parent).getWeight(); tree.removeEdge(next, parent); } tree.addEdge(newRoot, parent).setWeight(weight); if (next != null) { connectParent(tree, parent, next, nextWeight); } }
tree.addEdge(newRoot, tree.getRoot()); tree.setRoot(newRoot); parent = newRoot; TreeNode lcaParent = lca.getParent(); tree.removeEdge(lcaParent, lca); tree.addEdge(lcaParent, parent); tree.addEdge(parent, lca); tree.addEdge(parent, newNode); } else { Tree subtree = Newick.getTreeFromString(singleTaxon.subtree);
/** * Add subtree to existing tree, recursive iteration over the subtree to add * * @param tree the target tree * @param parent the parent node * @param newNode the current node to be added to the parent * @return node added node */ private TreeNode addSubtree(Tree tree, TreeNode parent, TreeNode newNode) { TreeNode nn = newNode.cloneNode(); nn.setIndex(-1); tree.addVertex(nn); tree.addEdge(parent, nn); for (TreeNode child : newNode.children()) { addSubtree(tree, nn, child); } return nn; }
@SuppressWarnings("unchecked") private void hangIn(TreeNode newParent, TreeNode oldParent, Tree tree) { for (TreeNode n : oldParent.children()) { TreeNode newNode = n.cloneNode(); newNode.setIndex(-1); tree.addVertex(newNode); Edge edge = tree.addEdge(newParent, newNode); edge.setWeight(n.getDistanceToParent()); hangIn(newNode, n, tree); } }
private static void stepUp(Tree tree, TreeNode child, TreeNode parent, String oldChildLabel) { TreeNode newParent = parent.getParent(); String newOldLabel = parent.getLabel(); double weight = child.getDistanceToParent(); tree.removeEdge(parent, child); tree.addEdge(child, parent).setWeight(weight); parent.setLabel(oldChildLabel); if (newParent != null) { stepUp(tree, parent, newParent, newOldLabel); } }
tree.addEdge(currentRoot, target).setWeight(w); tree.removeEdge(source.getParent(), source); tree.addEdge(currentRoot, source).setWeight(sourceWeight); tree.addEdge(last, node).setWeight(path.get(node)); last = node; tree.removeEdge(rchild.getParent(), rchild); tree.addEdge(rootchild, rchild).setWeight(w);
newNode.correspondingNode = n; if (parent != null) { t.addEdge(parent, newNode); } else { t.addVertex(newNode); newNode.correspondingNode = n; if (parent != null) { t.addEdge(parent, newNode); } else { t.addVertex(newNode); t.removeVertex(newNode); if (parent != null) { t.addEdge(parent, child); } else { t.addVertex(child);
Edge<TreeNode> edge = t.addEdge(parent, newNode); edge.setWeight(n.getDistanceToParent()); return true; if (parent != null) { Edge<TreeNode> edge = t.addEdge(parent, newNode); edge.setWeight(n.getDistanceToParent()); if (parent != null) { Edge<TreeNode> edge = t.addEdge(parent, child); edge.setWeight(child.getDistanceToParent());
/** * Reroot tree with the new root placed at the incomming edge of the given outgroup * * @param tree the tree * @param outgroup the outgroup taxon */ public static void rerootToOutgroup(Tree tree, TreeNode outgroup, double edgeLengthToOutgroup) { TreeNode parent = outgroup.getParent(); if (parent == null) return; TreeNode newRoot = new TreeNode(); // add outgroup to new root tree.addVertex(newRoot); double oldWeight = tree.getEdge(parent, outgroup).getWeight(); tree.removeEdge(parent, outgroup); final Edge<TreeNode> edge = tree.addEdge(newRoot, outgroup); edge.setWeight(edgeLengthToOutgroup); // connect parent connectParent(tree, newRoot, parent, oldWeight - edgeLengthToOutgroup); tree.setRoot(newRoot); pruneDegreeOneNodes(tree); }
tree.removeVertex(node); if (parent != null) { Edge<TreeNode> e = tree.addEdge(parent, child); if (sumEdgeWeight) { e.setWeight(weight_child + weight_parent);