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