/** * Computes the number of the given child for this node. * This number is 0 {@literal <=} childNum {@literal <} 'number of children', if the child is a real child of this node. * It is childNum = 'number of children', if the given child is parent of this node. * * @param child: the child, for that its number has to be computed * @return the child number for the given node */ public int getChildNumber(TreeNode child) { if (this.getParent().equalsNode(child)) { return childCount(); } else if (child.isChildOf(this)) { int num = 0; for (TreeNode nodesChild : this.children()) { if (!nodesChild.equalsNode(child)) { num++; } else { break; } } return num; } else { throw new RuntimeException("Given child is no child of this node!"); } }
private List<String> labels(TreeNode n) { List<String> l = new ArrayList<String>(); for (TreeNode node : n.depthFirstIterator()) { if (node.isLeaf()) { String label = node.getLabel(); if (label != null) { l.add(label); } } } return l; } }
/** * Traverses the tree rooted at this node and counts all inner-vertices/clades . * * @return clades under this node */ public int cladeCount(){ int i = 0; for (TreeNode node : depthFirstIterator()) { if (node.isInnerNode()) i++; } return i; }
/** * Indicates, if this node is a child of the given node. * * @param node: the node, that may be parent of this node * @return true, if this node is a child of the given node, false otherwise */ public boolean isChildOf(TreeNode node) { if (this.getParent().equalsNode(node)) { return true; } else { return false; } }
private static int findMostCompatibleRoot(Tree tree, Tree prunedModel) { List<Set<String>> rootEdges = new ArrayList<>(prunedModel.getRoot().childCount()); //should be 2 otherwise method will not work for (TreeNode child : prunedModel.getRoot().getChildren()) { rootEdges.add(TreeUtils.getLeafLabels(child)); if (node.isInnerNode()) { p1 = TreeUtils.getLeafLabels(node); } else { p1 = new HashSet<>(1); p1.add(node.getLabel()); TreeUtils.reorderingBootstrapLabelsForRooting(bestRoot.getEdgeToParent()); TreeUtils.rerootToOutgroup(tree, bestRoot);
if (treeNode.getLabel() != null && treeNode.getLabel().length() > 0) { nodes.put(treeNode.getLabel(), treeNode); TreeNode newRoot = new TreeNode(); tree.addVertex(newRoot); tree.addEdge(newRoot, tree.getRoot()); parent = new TreeNode(); tree.addVertex(parent); TreeNode lcaParent = lca.getParent(); tree.removeEdge(lcaParent, lca); tree.addEdge(lcaParent, parent); newNode = new TreeNode(singleTaxon.subtree); tree.addVertex(newNode); tree.addEdge(parent, newNode); TreeNode node = subtree.getRoot().getChildAt(0); newNode = addSubtree(tree, parent, node); } else { if (newNode.isLeaf()) { nodes.put(newNode.getLabel(), newNode); } else { for (TreeNode treeNode : newNode.depthFirstIterator()) { if (treeNode.getLabel() != null && treeNode.getLabel().length() > 0) { nodes.put(treeNode.getLabel(), treeNode);
for (TreeNode node : t.getRoot().depthFirstIterator()) { if (node.isLeaf()) { if (!commonLeafes.contains(node.getLabel())) { maxSingleSubtreeRoots.add(node); final int childCount = node.childCount(); List<TreeNode> children = new ArrayList<>(childCount); for (TreeNode child : node.children()) { children.add(child); if (maxSingleSubtreeRoots.contains(child)) Set<String> siblingLeaves = new THashSet<>(); int numOfSiblings = 0; for (TreeNode sibling : node.getParent().children()) { if (!sibling.equals(node)) { numOfSiblings++; if (node.isInnerNode()) { t.removeSubtree(node); } else { for (TreeNode child : node.children()) { stack.push(child);
protected static boolean pruneTraverse(Tree t, TreeNode n, TreeNode parent, Set<String> labels) { if (n.isLeaf()) { if (n.getLabel() != null && labels.contains(n.getLabel())) { TreeNode newNode = new TreeNode(n.getLabel()); edge.setWeight(n.getDistanceToParent()); return true; } else { TreeNode newNode = new TreeNode(); newNode.setLabel(n.getLabel()); edge.setWeight(n.getDistanceToParent()); for (TreeNode child : n.children()) { if (!pruneTraverse(t, child, newNode, labels)) { missed = true; if (newNode.childCount() == 0) { t.removeVertex(newNode); } else if (newNode.childCount() == 1) { TreeNode child = newNode.getChildAt(0); t.removeVertex(newNode); if (parent != null) { edge.setWeight(child.getDistanceToParent());
for (TreeNode node : t2.getRoot().depthFirstIterator()) { if (!node.equals(t2.getRoot())) { Bipartition nodePartition = lcaToLabels2.get(node); if (node.isLeaf()) { numOfTaxa++; String l = node.getLabel(); allLeafes.put(l, numOfTaxa); } else { if (!node.getParent().equals(t2.getRoot())) { TreeNode p = node.getParent(); if (node.isLeaf()) { parentPartition.addChild(numOfTaxa); } else { for (TreeNode node : t1.getRoot().depthFirstIterator()) { if (!node.equals(t1.getRoot())) { Bipartition nodePartition = lcaToLabels1.get(node); if (node.isLeaf()) { index = allLeafes.get(node.getLabel()); indexToLeaf1.put(index, node); } else { if (!node.getParent().equals(t1.getRoot())) { TreeNode p = node.getParent();
if (current.childCount() > 2) { while (j < current.childCount() - 1) { int i = j + 1; TreeNode e1 = current.getChildren().get(j); TreeNode e2 = current.getChildren().get(i); TreeNode newNode = new TreeNode(); if (!current.isLeaf()) { queue.addAll(current.getChildren()); for (TreeNode treeNode : tree.getRoot().depthFirstIterator()) { if (treeNode.isInnerNode()) { while (treeNode.getChildren().size() > 2) { List<TreeNode> list = treeNode.getChildren(); Collections.shuffle(list); TreeNode newNode = new TreeNode(); tree.addVertex(newNode); for (TreeNode treeNode : tree.getRoot().depthFirstIterator()) { if (treeNode.isInnerNode()) { while (treeNode.getChildren().size() > 2) { e1 = treeNode.getChildren().get(0); e2 = treeNode.getChildren().get(1);
if (t == null || order == null || order.size() > t.getRoot().leafCount()) return; for (TreeNode i : t.getRoot().depthFirstIterator()) { List<TreeNode> ns; ns = leveltoTreeNode.get(i.getLevel()); if (ns == null) { ns = new ArrayList<TreeNode>(); leveltoTreeNode.put(i.getLevel(), ns); if (parent.isLeaf()) continue; ArrayList<TreeNode> kids = parent.getChildren(); ArrayList<TreeNode> sortme = new ArrayList<TreeNode>(); ArrayList<TreeNode> neworder = new ArrayList<TreeNode>(); if (!child.isLeaf()) { for (TreeNode newchild : child.getLeaves()) { if (order.contains(newchild.getLabel())) { child = newchild; sortme.add(child); if (order.contains(child.getLabel())) { sortme.add(child); if (label.equals(a.getLabel())) { neworder.add(a);
Set<Object> cladeTaxa = leafMap.get(cladeToCheck); Map<Set<Object>, TreeNode> partition = new HashMap<>(cladeToCheck.childCount()); for (TreeNode child : cladeToCheck.getChildren()) { if (child.isInnerNode()) { partition.put(new HashSet<Object>(leafMap.get(child)), child); } else { Set<Object> s = new HashSet<Object>(); s.add(nameToObject.get(child.getLabel())); partition.put(s, child); TreeNode parent = cladeToCheck.getParent(); if (parent.childCount() > 2) { Collection<TreeNode> toRemove = checkNonBinaryClade(parent, supertree, leafMap); innerNodes.removeAll(toRemove); } else { Set<Object> parentTaxa = new HashSet<>(leafMap.get(cladeToCheck.getParent())); parentTaxa.removeAll(cladeTaxa); checkBinaryClade(cladeToCheck, supertree, parentTaxa, partition, leafMap);
private static void checkForChilds(TreeNode topologyNode, TreeNode treeToMergeNode) { for (TreeNode topologyChild : topologyNode.children()) { if (topologyChild.isLeaf()) { double treeToMergeEdgeWeight = 0; for (TreeNode treeToMergeChild : treeToMergeNode.children()) { if (treeToMergeChild.isLeaf() && treeToMergeChild.getLabel().equalsIgnoreCase(topologyChild.getLabel())) { //found the correct child treeToMergeEdgeWeight = treeToMergeChild.getEdgeToParent().getWeight(); break; } } Edge topologyChildEdgeToParent = topologyChild.getEdgeToParent(); topologyChildEdgeToParent.setWeight(topologyChildEdgeToParent.getWeight() + treeToMergeEdgeWeight); } } }
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; }
if (node.isInnerNode() && node.childCount() == 1) { TreeNode child = node.getChildAt(0); TreeNode parent = node.getParent(); double weight_parent = node.getDistanceToParent(); double weight_child = child.getDistanceToParent(); tree.removeVertex(node); if (parent != null) {
StringBuffer label = new StringBuffer(); StringBuffer nhx = new StringBuffer(); TreeNode n = new TreeNode(); TreeNode x = new TreeNode(); t.addVertex(x); t.addVertex(n); switch (st.ttype) { case '(': c = new TreeNode(); t.addVertex(c); t.addEdge(n, c); setLabel(n, label, nhx); if (d != 1.0) { n.getEdgeToParent().setWeight(d); d = 1.0; n = n.getParent(); break; case ',': setLabel(n, label, nhx); if (d != 1.0) { n.getEdgeToParent().setWeight(d); d = 1.0; c = new TreeNode(); t.addVertex(c); t.addEdge(n.getParent(), c);
if (!a.isLeaf() || !b.isLeaf()) return; if (a.getGraph() != t || b.getGraph() != t) return; List<TreeNode> nodes = ancestor.getChildren(); if (!node.isLeaf()) { for (TreeNode leaf : node.getLeaves()) { if (leaf.equalsNode(a)) posA = x; if (leaf.equalsNode(b)) posB = x; if (node.equalsNode(a)) posA = x; if (node.equalsNode(b)) posB = x; ancestor.removeEdge(t.getEdge(ancestor, node)); x++; if (i == posA) ancestor.addEdge(edges.get(posB)); else if (i == posB) ancestor.addEdge(edges.get(posA)); else ancestor.addEdge(edges.get(i));
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; }
public static boolean moveFakeRoot(Tree tree, TreeNode newRoot) { if (tree.containsVertex(newRoot) && newRoot.isInnerNode()) { TreeNode oldRoot = tree.getRoot(); TreeNode parent = newRoot.getParent(); if (parent != null) { String label = newRoot.getLabel(); newRoot.setLabel(null); stepUp(tree, newRoot, parent, label); tree.setRoot(newRoot); }// if not node is already root } return false; }