How to use

getLeafLabels

method

in

phylo.tree.model.TreeUtils

/**
 * The number of labels of all leafs in the input trees
 *
 * @param trees tree to get leafs from
 * @return number of leafs in this list of trees
 */
public static int getLeafCount(List<Tree> trees) {
  return getLeafLabels(trees).size();
}

/**
 * The set of labels of all leafs in the input trees
 *
 * @param trees tree to get leafs from
 * @return The Set of leaf labels
 */
public static Set<String> getLeafLabels(List<Tree> trees) {
  Set<String> leafs = new HashSet<>();
  for (Tree tree : trees) {
    leafs.addAll(getLeafLabels(tree));
  }
  return leafs;
}

/**
 * The set of labels of all leafs in the input tree
 *
 * @param tree tree to get leafs from
 * @return The Set of leaf labels
 */
public static Set<String> getLeafLabels(Tree tree) {
  return getLeafLabels(tree.getRoot());
}

public static List<WeightedTreePartitions> getBiparts(Tree sourceTree){
  List<WeightedTreePartitions> biparts = new LinkedList<>();
  final TreeNode r = sourceTree.getRoot();
  Set<String> sourceLeafes = getLeafLabels(r);
  for (TreeNode treeNode : sourceTree.getRoot().depthFirstIterator()) {
    if (treeNode != r && treeNode.isInnerNode()) {
      biparts.add(new WeightedTreePartitions(getLeafLabels(treeNode), sourceLeafes));
    }
  }
  return biparts;
}

public static boolean treeEquals(Tree t1, Tree t2) {
  if (t1.equals(t2))
    return true;
  if (t1.vertexCount() != t2.vertexCount())
    return false;
  Set<String> l1 = TreeUtils.getLeafLabels(t1.getRoot());
  Set<String> l2 = TreeUtils.getLeafLabels(t2.getRoot());
  if (!l1.equals(l2))
    return false;
  double[] rates = FN_FP_RateComputer.calculateRates(t1, t2, false);
  if (rates[2] == 0d && rates[3] == 0d) {
    return true;
  }
  return false;
}

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;
}

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));
  Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot());
        p1 = TreeUtils.getLeafLabels(node);
      } else {
        p1 = new HashSet<>(1);

public static Tree addCladewiseSplitFit(List<WeightedTreePartitions> biparts, Tree tree) {
  Map<Set<String>, TreeNode> labelsToClade = getChildrenMap(tree);
  Set<String> all = getLeafLabels(tree);
  Map<WeightedTreePartitions, AtomicDouble> partitionsToConflicts = new HashMap<>(labelsToClade.size());
  for (Set<String> leafesInClade : labelsToClade.keySet()) {
    partitionsToConflicts.put(new WeightedTreePartitions(leafesInClade, all), new AtomicDouble(0));
  }
  double numberOfChars = 0;
  for (WeightedTreePartitions sourcePartition : biparts) {
    numberOfChars += sourcePartition.weight;
    for (Map.Entry<WeightedTreePartitions, AtomicDouble> e : partitionsToConflicts.entrySet()) {
      if (e.getKey().isIncompatible(sourcePartition)) {
        e.getValue().addAndGet(e.getKey().weight);
      }
    }
  }
  for (Map.Entry<WeightedTreePartitions, AtomicDouble> entry : partitionsToConflicts.entrySet()) {
    TreeNode first = labelsToClade.remove(entry.getKey().getGroupA());
    TreeNode second = labelsToClade.remove(entry.getKey().getGroupB());
    String l = String.valueOf(1 - (entry.getValue().doubleValue() / numberOfChars));
    if (first != null)
      first.setLabel(l);
    if (second != null)
      second.setLabel(l);
  }
  return tree;
}

private static int findMostCompatibleFakeRoot(Tree tree, Tree prunedModel) {
  List<Set<String>> rootEdges = new ArrayList<>(prunedModel.getRoot().childCount()); //should be >2 otherwise use the real root method
  for (TreeNode child : prunedModel.getRoot().getChildren()) {
    rootEdges.add(TreeUtils.getLeafLabels(child));
  Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot());
        Set<String> clade = TreeUtils.getLeafLabels(child);
        if (splitsCopy.contains(clade))
          splitsCopy.remove(clade);
        clade.removeAll(TreeUtils.getLeafLabels(node));
        if (splitsCopy.contains(clade))
          splitsCopy.remove(clade);

  rootEdges.add(TreeUtils.getLeafLabels(child));
Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot());
boolean newRootFound = false;
      Set<String> p1;
      if (node.isInnerNode()) {
        p1 = TreeUtils.getLeafLabels(node);
      } else {
        p1 = new HashSet<String>(1);

  rootEdge.add(TreeUtils.getLeafLabels(child));
Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot());
boolean newRootFound = false;
    Set<String> p1;
    if (node.isInnerNode()) {
      p1 = TreeUtils.getLeafLabels(node);
    } else {
      p1 = new HashSet<String>(1);

Set<String> characterTaxa = getLeafLabels(character);
Tree sourceTree = (Tree) character.getGraph();
TreeNode[] sourceTreeTaxa = sourceTree.getLeaves();

  public static void addCladewiseSplitFit(List<Tree> sourceTrees, FlipCutWeights.Weights weighting, Collection<Tree> trees) {
    final SimpleCosts comp;
    if (weighting == FlipCutWeights.Weights.UNIT_COST) {
      comp =  new UnitCostComputer(sourceTrees,null);
    } else {
      comp = new WeightCostComputer(sourceTrees,weighting);
    }

    List<WeightedTreePartitions> biparts = new LinkedList<>();
    for (Tree sourceTree : sourceTrees) {
      final TreeNode r = sourceTree.getRoot();
      Set<String> sourceLeafes = getLeafLabels(r);
      for (TreeNode treeNode : sourceTree.getRoot().depthFirstIterator()) {
        if (treeNode != r && treeNode.isInnerNode()) {
          biparts.add(new WeightedTreePartitions(getLeafLabels(treeNode), sourceLeafes, comp.getEdgeWeight(treeNode)));
        }
      }
    }

    for (Tree tree : trees) {
      addCladewiseSplitFit(biparts, tree);
    }
  }
}

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;
}

if (!sibling.equals(node)) {
  numOfSiblings++;
  siblingLeaves.addAll(TreeUtils.getLeafLabels(sibling));

Set<String> clade = TreeUtils.getLeafLabels(node);
if (clade.size() > 2 && (numTaxa - clade.size()) > 2) {

if (singleTaxon.numOfSiblings == 1) {
  Set<String> s = new THashSet<>(TreeUtils.getLeafLabels(lca));
  s.retainAll(commonLeafes);
  Set<String> s2 = new HashSet<>(singleTaxon.siblingLeaves);