void tr_delete_task(Task *t)
{
if (t->aln) ma_free(t->aln);
if (t->spec_tree) {
tr_delete_tree_SDIptr(t->tree);
if (t->subtree) tr_delete_tree_SDIptr(t->subtree);
tr_delete_tree(t->spec_tree);
}
if (t->tree) tr_delete_tree_SDIptr(t->tree);
if (t->compared) tr_delete_tree(t->compared);
if (t->subtree && tr_search(t->tree, t->subtree) == 0) /* not a node in t->tree */
tr_delete_tree(t->subtree);
if (t->tree) tr_delete_tree(t->tree);
if (t->cut) free(t->cut);
if (t->ortho) tr_delete_ortho(t->ortho);
if (t->n_con) {
int i;
for (i = 0; i < t->n_con; ++i)
tr_delete_tree(t->constraint[i]);
free(t->constraint);
}
if (t->n_sub) {
int i;
for (i = 0; i < t->n_sub; ++i)
free(t->sub_name[i]);
free(t->sub_name);
}
free(t);
}
int tr_sortleaf_task(int argc, char *argv[])
{
extern Tree *tr_default_spec_tree();
Tree **forest, *tree, *spec_tree;
int i, n;
FILE *fp;
if (argc < 2) return tr_sortleaf_usage();
fp = tr_get_fp(argv[1]);
forest = tr_parse(fp, &n);
fclose(fp);
tree = 0;
if (argc > 2) {
fp = tr_get_fp(argv[2]);
tree = tr_parse_first(fp);
fclose(fp);
}
spec_tree = tr_default_spec_tree();
for (i = 0; i < n; ++i) {
if (tree) cpp_set_leaf_order(tree, forest[i], forest[i]->n_leaf);
else {
tr_SDI(forest[i], spec_tree, 0);
tr_set_spec_leaf_order(forest[i]);
}
tr_order_core(forest[i]);
tr_tree_output(stdout, forest[i], OUTPUT_SDI | OUTPUT_ORI_NHX);
if (tree) tr_delete_tree_SDIptr(forest[i]);
tr_delete_tree(forest[i]);
}
free(forest);
if (tree) tr_delete_tree(tree);
return 0;
}
int tr_treedist_task(int argc, char *argv[])
{
Tree *tree1, *tree2;
FILE *fp1, *fp2;
int ret;
if (argc < 3) return tr_treedist_usage();
fp1 = tr_get_fp(argv[1]);
fp2 = tr_get_fp(argv[2]);
tree1 = tr_parse_first(fp1);
tree2 = tr_parse_first(fp2);
ret = tr_tree_dist(tree1, tree2);
fclose(fp1); fclose(fp2);
tr_delete_tree(tree1); tr_delete_tree(tree2);
printf("%d\t%d\n", ret>>16, ret&0xffff);
return 0;
}
int tr_ortho_task(int argc, char *argv[])
{
extern Tree *tr_default_spec_tree();
Tree **root, *spec_tree;
FILE *fp;
int i, n;
Ortholog *ortho;
if (argc == 1) return tr_ortho_usage();
fp = tr_get_fp(argv[1]);
root = tr_parse(fp, &n);
spec_tree = tr_default_spec_tree();
for (i = 0; i < n; ++i) {
tr_SDI(root[i], spec_tree, 0);
ortho = tr_ortho(root[i], spec_tree, 1);
tr_ortho_output(stdout, ortho, root[i]);
tr_delete_ortho(ortho);
tr_delete_tree_SDIptr(root[i]);
tr_delete_tree(root[i]);
}
tr_delete_tree(spec_tree);
free(root);
return 0;
}
int tr_subtree_task(int argc, char *argv[])
{
char **name;
int n, m, i;
FILE *fp_tree;
Tree **tree;
if (argc < 3) return tr_subtree_usage();
name = tr_get_list(argv[2], &m);
fp_tree = tr_get_fp(argv[1]);
tree = tr_parse(fp_tree, &n);
for (i = 0; i < n; ++i) {
Tree *sub;
sub = cpp_subtree(tree[i], m, name);
tr_tree_output(stdout, sub, OUTPUT_SDI);
tr_delete_tree(sub);
tr_delete_tree(tree[i]);
}
fclose(fp_tree);
for (i = 0; i < m; ++i) free(name[i]);
free(name);
free(tree);
return 0;
}
int tr_fill_tree(Task *task, const char *fn)
{
FILE *fp;
int i, n;
Tree **root;
fp = tr_get_fp(fn);
if (fp == 0) return 1;
root = tr_parse(fp, &n);
if (fp != stdin) fclose(fp);
task->tree = root[0];
for (i = 1; i < n; ++i)
tr_delete_tree(root[i]);
free(root);
return 0;
}
int tr_fill_spec(Task *task, const char *fn)
{
FILE *fp;
Tree **spec;
int i, n;
fp = tr_get_fp(fn);
if (fp == 0) return 1;
spec = tr_parse(fp, &n);
task->spec_tree = spec[0];
for (i = 1; i < n; ++i)
tr_delete_tree(spec[i]);
free(spec);
task->spec_tree = cpp_post_spec_tree(task->spec_tree, 0);
if (fp != stdin) fclose(fp);
return 0;
}
int tr_root_task(int argc, char *argv[])
{
Tree **root;
FILE *fp;
int i, n;
if (argc == 1) return tr_root_usage();
fp = tr_get_fp(argv[1]);
root = tr_parse(fp, &n);
for (i = 0; i < n; ++i) {
root[i] = tr_root_by_min_height(root[i]);
tr_tree_output(stdout, root[i], OUTPUT_SDI | OUTPUT_ORI_NHX);
tr_delete_tree(root[i]);
}
free(root);
if (fp != stdin) fclose(fp);
return 0;
}
int tr_fill_compared(Task *task, const char *fn)
{
FILE *fp;
Tree **p;
int i, n;
fp = tr_get_fp(fn);
if (fp == 0) return 1;
p = tr_parse(fp, &n);
if (p == 0 || n == 0) {
fprintf(stderr, "[tr_fill_compared] fail to open file %s.\n", fn);
return 1;
}
if (fp != stdin) fclose(fp);
task->compared = p[0];
for (i = 1; i < n; ++i)
tr_delete_tree(p[i]);
free(p);
task->out_flag |= OUTPUT_COMPARE;
return 0;
}
int tr_leaf_task(int argc, char *argv[])
{
Tree **node, **root;
int i, m, n;
FILE *fp;
if (argc == 1) return tr_leaf_usage();
fp = tr_get_fp(argv[1]);
root = tr_parse(fp, &n);
node = tr_stack(root[0], Tree*);
m = tr_expand_leaf(root[0], node);
for (i = 0; i < m; ++i) {
if (node[i]->name)
printf("%s\n", node[i]->name);
else printf("NULL\n");
}
for (i = 0; i < n; ++i)
tr_delete_tree(root[i]);
free(root);
free(node);
if (fp != stdin) fclose(fp);
return 0;
}
static double *cal_weight(MultiAlign *ma)
{
int i, n;
double *fweight, f, sum;
Tree *p, *root, **node;
n = ma->n;
fweight = (double*)malloc(sizeof(double) * n);
root = tr_build_tree_from_align(ma, 0, 0, 0, 0, DIST_MM, 0, 0); /* build NJ tree */
node = tr_stack(root, Tree*);
tr_expand_leaf_by_id(root, node);
/* calculate 'order'. Tree::flag should be '0' */
for (i = 0; i < n; ++i) {
p = node[i];
while (p) {
++(p->flag);
p = p->pre;
}
}
/* calculate weight */
for (i = 0, sum = 0.0; i < n; ++i) {
p = node[i];
f = 0.0;
while (p->pre) {
f += p->d / p->flag;
p = p->pre;
}
fweight[i] = f;
sum += f;
}
/* re-scale */
for (i = 0; i < n; ++i)
fweight[i] /= sum;
free(node);
tr_delete_tree(root);
return fweight;
}
int tr_sdi_task(int argc, char *argv[])
{
extern Tree *tr_default_spec_tree();
Tree **root, *spec_tree, **compared, *tmp_tree;
FILE *fp, *fp_comp, *fp_spec;
int i, k, n, m, c, is_reroot, is_sdi_root, is_reorder, is_core;
char **name;
int out_flag = OUTPUT_SDI;
is_core = is_reroot = 0;
is_sdi_root = is_reorder = 1;
fp_comp = 0;
compared = 0;
spec_tree = 0;
m = k = 0;
name = 0;
tmp_tree = 0;
while ((c = getopt(argc, argv, "cRrHm:l:s:")) >= 0) {
switch (c) {
case 'r': is_reroot = 1; break;
case 'H': is_sdi_root = 0; break;
case 'R': is_reorder = 0; break;
case 'c': is_core = 1; break;
case 's': fp_spec = tr_get_fp(optarg);
if (fp_spec) {
spec_tree = tr_parse_first(fp_spec);
fclose(fp_spec);
cpp_post_spec_tree(spec_tree, 0);
}
break;
case 'l': name = tr_get_list_str(optarg, &k); break;
case 'm': fp_comp = tr_get_fp(optarg);
if (!fp_comp) fprintf(stderr, "<tr_sdi_task> fail to open file %s, continue anyway.\n", optarg);
break;
}
}
if (argc == optind) return tr_sdi_usage();
/* if "-l" is applied, all the other functions except "-m" will be turned off. */
if (k) is_reroot = is_sdi_root = is_reorder = 0;
fp = tr_get_fp(argv[optind]);
root = tr_parse(fp, &n);
if (fp_comp) compared = tr_parse(fp_comp, &m);
if (!spec_tree) spec_tree = (is_core)? tr_core_spec_tree() : tr_default_spec_tree();
if (m) out_flag |= OUTPUT_COMPARE;
for (i = 0; i < n; ++i) {
if (is_reroot) {
if (is_sdi_root) root[i] = tr_root_by_sdi(root[i], spec_tree);
else root[i] = tr_root_by_min_height(root[i]);
}
tr_SDI(root[i], spec_tree, 0);
tr_lost_infer(root[i], spec_tree);
if (k) {
Tree *sub = cpp_subtree_spec(root[i], spec_tree, k, name);
tmp_tree = root[i];
root[i] = sub;
}
if (is_reorder) {
tr_set_spec_leaf_order(root[i]);
tr_order_core(root[i]);
}
if (i < m) {
tr_compare_core(compared[i], root[i], 0);
cpp_set_leaf_order(compared[i], root[i], 0);
tr_order_core(root[i]);
}
tr_tree_output(stdout, root[i], out_flag);
if (k) {
/* if "-l" is used, it is tmp_tree that keeps all the allocated pointers,
* while root[i] only keeps part. When tmp_tree->ptr is freed, there is also
* no need to free root[i]->ptr. */
tr_delete_tree_SDIptr(tmp_tree);
tr_delete_tree(tmp_tree);
tr_clear_ptr(root[i]);
} else tr_delete_tree_SDIptr(root[i]);
tr_delete_tree(root[i]);
}
if (compared)
for (i = 0; i < m; ++i)
tr_delete_tree(compared[i]);
tr_delete_tree(spec_tree);
free(root); free(compared);
if (fp_comp && fp_comp != stdin) fclose(fp_comp);
if (fp != stdin) fclose(fp);
if (k)
for (i = 0; i < k; ++i) free(name[i]);
free(name);
return 0;
}
