How to use

phylo.tree.model.TreeNode

constructor

/**
 * If not done allready, this creates a new TreeNode 
 * representing this bipartiton. This is used to create 
 * the consensus tree in the NConsensus Algorithm
 * 
 * @param tree the Tree for the node
 * @return TreeNode the node
 */
public TreeNode getNode(Tree tree, double count) {
  if(node == null){
    node = new TreeNode();
    tree.addVertex(node);
    if(label != null)
      node.setLabel(label);
    else if (count >= 0d)
      node.setLabel(Double.toString(count));
  }
  return node;		
}

/**
 * Clones this node.
 *
 * @return node the new node
 */
public TreeNode cloneNode() {
  TreeNode n = new TreeNode();
  n.setLabel(getLabel());
  n.setIndex(getIndex());
  return n;
}

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

TreeNode nuLcaParent = new TreeNode();
t.addVertex(nuLcaParent);
t.addEdge(nuLcaParent, lca);
TreeNode nuLcaParent = new TreeNode();
t.addVertex(nuLcaParent);
t.addEdge(nuLcaParent, lca);

  if (lca == null || lca == tree.getRoot()) {
    TreeNode newRoot = new TreeNode();
    tree.addVertex(newRoot);
    tree.addEdge(newRoot, tree.getRoot());
  } else {
    parent = new TreeNode();
    tree.addVertex(parent);
    TreeNode lcaParent = lca.getParent();
if (!singleTaxon.subtree.endsWith(";")) {
  newNode = new TreeNode(singleTaxon.subtree);
  tree.addVertex(newNode);
  tree.addEdge(parent, newNode);

  id = p[i].getLeavesIterator().next();
  newNode = new TreeNode(id.toString());
  result.addVertex(newNode);
  result.addEdge(node, newNode);
case 2:
  newNode = new TreeNode();
  result.addVertex(newNode);
  result.addEdge(node, newNode);
    id = it.next();
    TreeNode l = new TreeNode(id.toString());//n2.getLabel());
    result.addVertex(l);
    result.addEdge(newNode, l);
default:
  newNode = new TreeNode();
  result.addVertex(newNode);
  result.addEdge(node, newNode);

TreeNode root = new TreeNode();
tree.addVertex(root);
tree.addEdge(root, oldRoot);
    TreeNode nn = new TreeNode(s);
    tree.addVertex(nn);
    tree.addEdge(root, nn);
TreeNode np = new TreeNode();
tree.addVertex(np);
tree.addEdge(p, np);
  TreeNode nn = new TreeNode(s);
  tree.addVertex(nn);
  tree.addEdge(np, nn);
TreeNode root = new TreeNode();
tree.addVertex(root);
tree.setRoot(root);
for (String s : merged) {
  TreeNode nn = new TreeNode(s);
  tree.addVertex(nn);
  tree.addEdge(root, nn);
  TreeNode old = new TreeNode(root.getLabel());
  root.setLabel(null);
  tree.addVertex(old);
  tree.addEdge(root, old);

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);
            c = new TreeNode();
            t.addVertex(c);
            t.addEdge(n.getParent(), c);

TreeNode nuLca = new TreeNode();
t1.addVertex(nuLca);

TreeNode e2 = current.getChildren().get(i);
TreeNode newNode = new TreeNode();
TreeNode e2 = list.get(1);
TreeNode newNode = new TreeNode();
tree.addVertex(newNode);
TreeNode newNode = new TreeNode();
tree.addVertex(newNode);

TreeNode cRoot = new TreeNode();
result.addVertex(cRoot);
result.setRoot(cRoot);

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

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());
    TreeNode newNode = new TreeNode();
    newNode.setLabel(n.getLabel());