Example #1
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, 
				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);
}
Example #2
0
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;
}
Example #3
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);
}
Example #4
0
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);
}
Example #5
0
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);
}
Example #6
0
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);
}