/** * Returns the number leaves of the tree. * (Leaves are all vertices with outdegree == 0). * <br> THIS DOES NOT CACHE and always recounts. * * @return number of leaves */ public int getNumTaxa() { int nTaxa = 0; for (TreeNode v : vertices()) { if (v.isLeaf()) nTaxa++; } return nTaxa; }
public void init(List<Tree> sourceTrees) { nameToObject = new HashMap<>(); ppSet = new HashSet<>(); for (Tree tree : sourceTrees) { Set<TreeNode> taxa = new HashSet<>(Arrays.asList(tree.getLeaves())); for (TreeNode treeNode : tree.vertices()) { if (treeNode.isInnerNode() && !treeNode.equals(tree.getRoot())) { ppSet.add(new PPCharacter(treeNode, new HashSet<>(taxa))); } } } }
private void reApplyLabels(List<Tree> trees, Map<TreeNode, String> labels) { for (Tree tree : trees) { for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { node.setLabel(labels.get(node)); } } } }
/** * replaces all '_' with a space * * @param tree the tree */ public static void cleanLabels(Tree tree) { for (TreeNode n : tree.vertices()) { String label = n.getLabel(); if (label != null && label.length() > 0) { label = label.trim(); label = label.replaceAll("_", " "); n.setLabel(label); } } }
protected TreeNode find(String label, Tree tree) { if (label == null) return null; for (TreeNode v : tree.vertices()) { if (v.isLeaf() && label.equals(v.getLabel())) return v; } return null; }
private static Set<TreePartition> getPartitions(Tree tree, Set<String> allTaxa){ Set<TreePartition> partitions = new HashSet<TreePartition>(); for (TreeNode current : tree.vertices()) { if (current.isInnerNode()) { // if (!current.equals(calculated.getRoot())) { TreeNode[] leafes = current.getLeaves(); if ((allTaxa.size() - leafes.length) > 1) partitions.add(new TreePartition(leafes, allTaxa)); // } } } return partitions; }
private Map<TreeNode, Set<Object>> getNodeToLeafMap(Tree tree) { Map<TreeNode, Set<Object>> map = new HashMap<>(tree.getNumTaxa()); for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { Set<Object> leafSet = new HashSet<>(); for (TreeNode taxon : node.getLeaves()) { leafSet.add(nameToObject.get(taxon.getLabel())); } map.put(node, leafSet); } } return map; }
/** * Sets all labels of nodes in the tree to s * * @param s the string the labels are set to */ public void setAllLabels(String s) { for (TreeNode v : vertices()) { if (v.isInnerNode()) { v.setLabel(s); } } }
/** * Count the number of taxa that have the given label in all trees * * @param label the label * @param trees * @return count number of trees that contain the taxon */ private int count(String label, List<Tree> trees) { if (label == null || label.length() <= 0) return 0; Integer alreadyCounted = counterMap.get(label); if (alreadyCounted != null) { return alreadyCounted; } int c = 0; for (Tree tree : trees) { for (TreeNode node : tree.vertices()) { if (node.isLeaf()) { String l = node.getLabel(); if (l != null) { if (l.equals(label)) c++; } } } } counterMap.put(label, c); return c; }
public static boolean containsInnerLabels(Tree tree) { for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { if (!((node.getLabel() == null) || (node.getLabel().equals(TreeNodeProperties.PROPERTY_LABEL)))) { return true; } } } return false; }
private Map<TreeNode, String> removeAndMapInnerLabels(List<Tree> trees) { Map<TreeNode, String> labels = new HashMap(); for (Tree tree : trees) { for (TreeNode treeNode : tree.vertices()) { if (treeNode.isInnerNode()) { String label = treeNode.getLabel(); treeNode.setLabel(null); if (label != null) { labels.put(treeNode, label); } } } } return labels; }
public void addTree(Tree tree) { String name = tree.getName(); this.treeList.add(tree); for (TreeNode treeNode : tree.vertices()) { if (!addInternaleTaxa && treeNode.isLeaf()) taxa.addTaxon(treeNode.getLabel()); } String nn = taxa.translate(name); if (nn == null) { nn = "tree_" + treeList.size(); } this.trees.put(nn, tree); }
/** * Returns the root node of this tree. If the root was not set explicitly, this * searches the tree and returns the first node with in-degree equal to 0. * <p> * The search is only done once and the found root node is cached, so make sure to call * that after the tree is complete (all nodes and edges inserted) or call {@link #setRoot(TreeNode)} * with null to reset the root node cache. * * @return root node of the tree */ public TreeNode getRoot() { if (root == null) { // find root, do a search for the node // with inDegree 0 for (TreeNode v : vertices()) { if (v.getParent() == null) { setRoot(v); } } } return (TreeNode) root; }
/** * Clones the tree and removes al inner vertices on the tree. Due to cloning * the given tree is not modified * * @param sourceTree the source tree * @return clone clone of the soruce treee without any innter vertex labels */ public static Tree deleteInnerLabels(Tree sourceTree) { Tree tree = sourceTree.cloneTree(); for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { node.setLabel(null); } } return tree; }
public static double claculateMinumCharaterDeletionCosts(Tree tree, List<Tree> sourceTrees) { Set<TreeNode> deletedNodes = new HashSet<TreeNode>(); for (Tree sourceTree : sourceTrees) { for (TreeNode treeNode : sourceTree.vertices()) { if (treeNode.isInnerNode() && treeNode != sourceTree.getRoot()) { Set<String> sourceLeafLabels = getLeafLabels(treeNode); Set<TreeNode> superLeafes = getLeafesFromLabels(sourceLeafLabels, tree); TreeNode lca = tree.findLeastCommonAncestor(new ArrayList<TreeNode>(superLeafes)); Set<String> superLeafLabels = getLeafLabels(lca); if (!sourceLeafLabels.equals(superLeafLabels)) { deletedNodes.add(treeNode); } } } } double costs = 0; for (TreeNode deletedNode : deletedNodes) { costs += deletedNode.getDistanceToParent(); } return costs; }
/** * remove the taxon with the given label and prune the tree * * @param merge merge label * @param taxa the taxa * @param trees pruned trees */ protected void removeAndPrune(String merge, List<String> taxa, List<Tree> trees) { for (Tree tree : trees) { for (TreeNode node : tree.vertices()) { if (node.getLabel() != null && taxa.contains(node.getLabel()) && !node.getLabel().equals(merge)) { // remove TreeNode parent = node.getParent(); tree.removeVertex(node); } } TreeUtils.pruneDegreeOneNodes(tree, sumEdgeWeightsWhenPruning, USE_PARENT_WEIGHT); } }
/** * Creates a copy of the given tree and renames all vertices according to the translation table. * If strict pattersn is set, all source names are translated to valid nexus taxon names. * * @param tree the source tree * @param translation the translation table * @param strictPatterns use only valid nexus taxon names * @return tree translated tree */ public static Tree renameNodes(Tree tree, Map<String, String> translation, boolean strictPatterns) { Tree t = tree.cloneTree(); for (TreeNode node : t.vertices()) { if (node.getLabel() != null) { String newName = null; if (strictPatterns) newName = translation.get(NexusTaxaBlock.translate(node.getLabel())); else { newName = translation.get(node.getLabel()); } if (newName != null) { node.setLabel(newName); } } } return t; }
public static Map<Set<String>, TreeNode> getChildrenMap(final Tree tree, final boolean setEdgeweightsToZero) { Map<Set<String>, TreeNode> childrenSets = new HashMap<Set<String>, TreeNode>(tree.vertexCount()); for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { if (node != tree.getRoot()) { if (setEdgeweightsToZero) node.getEdgeToParent().setWeight(0d); childrenSets.put(getLeafLabels(node), node); } } else { if (setEdgeweightsToZero) node.getEdgeToParent().setWeight(0d); } } return childrenSets; }
public static void removeSubtreeFromTree(List<TreeNode> toRemove, Tree tree, boolean sumEdgeWeight, boolean useParentWeight) { // remove for (TreeNode treeNode : toRemove) { if (treeNode.isLeaf()) { tree.removeVertex(treeNode); } else { List<TreeNode> subtreeNodes = new ArrayList<TreeNode>(); // remove complete subtree for (TreeNode node : treeNode.depthFirstIterator()) { subtreeNodes.add(node); } for (TreeNode subtreeNode : subtreeNodes) { tree.removeVertex(subtreeNode); } tree.removeVertex(treeNode); } } // remove leaves with no labels List<TreeNode> inner = new ArrayList<TreeNode>(); for (TreeNode treeNode : tree.vertices()) { if (treeNode.isLeaf() && (treeNode.getLabel() == null || treeNode.getLabel().length() == 0)) { inner.add(treeNode); } } for (TreeNode treeNode : inner) { tree.removeVertex(treeNode); } // prune the tree pruneDegreeOneNodes(tree, sumEdgeWeight, useParentWeight); }