How to use

pruneDegreeOneNodes

method

in

phylo.tree.model.TreeUtils

/**
 * Iterates over the tree and removes all inner vertices with outdegree == 1.
 * The resulting tree is at least binary.
 *
 * @param tree the tree
 */
public static void pruneDegreeOneNodes(Tree tree) {
  pruneDegreeOneNodes(tree, true, false);
}

public static void pruneDegreeOneNodes(Tree tree, boolean sumEdgeWeight) {
  pruneDegreeOneNodes(tree, sumEdgeWeight, false);
}

public static void keepLeafesAndPruneTree(Tree tree, Collection<TreeNode> toKeep) {
  boolean deleted = true;
  while (deleted) {
    deleted = false;
    for (TreeNode node : tree.getLeaves()) {
      if (node.getLabel() == null || !toKeep.contains(node)) {
        tree.removeVertex(node);
        deleted = true;
      }
    }
  }
  pruneDegreeOneNodes(tree);
}

TreeUtils.pruneDegreeOneNodes(supertree);
int innernodesAfter = supertree.vertexCount() - supertree.getNumTaxa();
System.out.println("--------------> " + modifiedCharacters + "clades modified");

/**
 * 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);
  }
}

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

pruneDegreeOneNodes(tree);

TreeUtils.pruneDegreeOneNodes(result);

  TreeUtils.pruneDegreeOneNodes(t, false, false);
} else {
  for (TreeNode child : node.children()) {

/**
 * 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);
}