void process_tree(struct rooted_tree *tree, struct parameters params) { struct llist *outgroup_nodes = get_outgroup_nodes(tree, params.labels); if (! params.deroot) { /* re-root according to outgroup nodes */ enum reroot_status result = reroot(tree, outgroup_nodes, params.i_node_lbl_as_support); switch (result) { case REROOT_OK: dump_newick(tree->root); break; case LCA_IS_TREE_ROOT: if (params.try_ingroup) try_ingroup(tree, params); else { fprintf (stderr, "ERROR: Outgroup's LCA is tree's root " "- cannot reroot. Try -l.\n"); } break; case NOT_PHYLOGRAM: fprintf (stderr, "ERROR: Tree must be a phylogram, but some " "branch lengths are not defined - aborting.\n"); break; default: assert(0); } destroy_all_rnodes(NULL); destroy_tree(tree); } else { enum deroot_status result = deroot(tree); switch (result) { case DEROOT_OK: dump_newick(tree->root); break; case NOT_BIFURCATING: fprintf (stderr, "ERROR: tree is already unrooted, or root" " has only 1 child - cannot deroot.\n"); break; case BALANCED: fprintf (stderr, "ERROR: can't decide which of root's " "children is the outgroup.\n"); break; case MEM_PROB: perror(NULL); break; default: assert(0); } destroy_all_rnodes(NULL); destroy_tree(tree); } destroy_llist(outgroup_nodes); }
int main(int argc, char *argv[]) { struct rooted_tree *tree; struct parameters params; static struct rooted_tree * (*process_tree)(struct rooted_tree *, set_t *); params = get_params(argc, argv); switch (params.mode) { case PRUNE_DIRECT: process_tree = process_tree_direct; break; case PRUNE_REVERSE: process_tree = process_tree_reverse; break; default: assert (0); } while (NULL != (tree = parse_tree())) { tree = process_tree(tree, params.prune_labels); dump_newick(tree->root); destroy_all_rnodes(NULL); destroy_tree(tree); } destroy_set(params.prune_labels); return 0; }
void process_tree(struct rooted_tree *tree, struct parameters params) { struct llist *outgroup_nodes = get_outgroup_nodes(tree, params.labels); if (! params.deroot) { /* re-root according to outgroup nodes */ enum reroot_status result = reroot(tree, outgroup_nodes); switch (result) { case REROOT_OK: dump_newick(tree->root); break; case LCA_IS_TREE_ROOT: if (params.try_ingroup) try_ingroup(tree, params); else { fprintf (stderr, "Outgroup's LCA is tree's root " "- cannot reroot. Try -l.\n"); } break; default: assert(0); } destroy_tree_cb(tree, NULL); } else { enum deroot_status result = deroot(tree); switch (result) { case DEROOT_OK: dump_newick(tree->root); break; case NOT_BIFURCATING: fprintf (stderr, "WARNING: tree is already unrooted, or root" " has only 1 child - cannot deroot.\n"); break; case BALANCED: fprintf (stderr, "WARNING: can't decide which of root's " "children is the outgroup.\n"); break; default: assert(0); } destroy_tree_cb(tree, NULL); } destroy_llist(outgroup_nodes); }
void process_tree(struct rooted_tree *tree, struct hash *rename_map, struct parameters params) { /* visit each node, and change name if needed */ struct list_elem *elem; for (elem = tree->nodes_in_order->head; NULL != elem; elem = elem->next) { struct rnode *current = (struct rnode *) elem->data; if (params.only_leaves && ! is_leaf(current)) { continue; } char *label = current->label; char *new_label = hash_get(rename_map, label); if (NULL != new_label) { current->label = strdup(new_label); free(label); } } dump_newick(tree->root); }
void try_ingroup(struct rooted_tree *tree, struct parameters params) { /* we will try to insert the root above the ingroup - for this we'll * need all leaves that are NOT in the outgroup. */ // TODO: why just leaves? struct llist *ingroup_leaves; ingroup_leaves = get_ingroup_leaves(tree, params.labels); enum reroot_status result = reroot(tree, ingroup_leaves); switch (result) { case REROOT_OK: dump_newick(tree->root); break; case LCA_IS_TREE_ROOT: fprintf (stderr, "LCA is still tree's root " "- be sure to include ALL outgroup " "leaves with -l"); break; } destroy_llist(ingroup_leaves); }
void try_ingroup(struct rooted_tree *tree, struct parameters params) { /* we will try to insert the root above the ingroup - for this we'll * need all leaves that are NOT in the outgroup. We don't need the * inner nodes, though, since tha leaves are sufficient for determining * the ingroup's LCA. This also works if some leaf labels are empty * (see test case 'nolbl_ingrp' in test_nw_reroot_args) */ struct llist *ingroup_leaves; ingroup_leaves = get_ingroup_leaves(tree, params.labels); enum reroot_status result = reroot(tree, ingroup_leaves, params.i_node_lbl_as_support); switch (result) { case REROOT_OK: dump_newick(tree->root); break; case LCA_IS_TREE_ROOT: fprintf (stderr, "LCA is still tree's root " "- be sure to include ALL outgroup " "leaves with -l"); break; } destroy_llist(ingroup_leaves); }