BioPerl

-internal_node_id => 'bootstrap'

use Bio::TreeIO;

# parse in newick/new hampshire format
my $input = new Bio::TreeIO(-file   => "tree.tre",
                            -format => "newick");
my $tree = $input->next_tree;

use Bio::TreeIO;

my $treeio = Bio::TreeIO->new(-format => 'newick',
			      -file => $file);
while( my $tree = $treeio->next_tree ) {
  for my $node ( $tree->get_nodes ) {
  printf "id: %s bootstrap: %s\n", 
         $node->id || '', 
         $node->bootstrap || '', 
         "\n";
  }
}

(((A:5,B:5)90:2,C:4)25:3,D:10);

use Bio::TreeIO;

my $treeio = Bio::TreeIO->new(-format => 'newick',
			      -file => $file,
			      -internal_node_id => 'bootstrap');

while ( $tree = $treeio->next_tree ) {
  for my $node ( $tree->get_nodes ) {
    printf "id: %s bootstrap: %s\n", 
            $node->id || '', 
            $node->bootstrap || '', 
            "\n";
    }
}

(((A:5,B:5)90:2,C:4)25:3,D:10);

use Bio::TreeIO;

my $treeio = Bio::TreeIO->new(-format => 'newick',
			                        -file => $file);
while ( $tree = $treeio->next_tree ) {
  $tree->move_id_to_bootstrap;
    for my $node ( $tree->get_nodes ) {
      printf "id: %s bootstrap: %s\n", 
              $node->id || '', 
              $node->bootstrap || '', 
              "\n";
    }
}

(((A:5,B:5)90:2,C:4)25:3,D:10);

use warnings;
use strict;
use Bio::TreeIO;
use IO::String;

my $string = "(A,(B,C));";
my $io = IO::String->new($string);
my $treeio = Bio::TreeIO->new(-fh => $io,
                              -format => 'newick');
while ( my $tree = $treeio->next_tree ) {
  # get a tree
  print "node count is ", scalar $tree->get_nodes, "\n";
}

my @taxa = $tree->get_leaf_nodes;

my $root = $tree->get_root_node;

my $total_length = $tree->total_branch_length;

# find all the nodes named 'node1' (there should be only one)
my @nodes = $tree->find_node(-id => 'node1');
# find all the nodes which have description 'BMP'
my @nodes = $tree->find_node(-description => 'BMP');
# find all the nodes with bootstrap value of 70
my @nodes = $tree->find_node(-bootstrap => 70);

my @nodes = grep { $_->bootstrap > 70 } $tree->get_nodes;

# provide the node object to remove from the Tree
$tree->remove_Node($node);
# or specify the node Name to remove
$tree->remove_Node('Node12');

# provide the node objects to remove from the Tree
$tree->splice(-remove_id => $node->id, -preserve_lengths => 1);
# or specify the Names of nodes to keep and/or remove
# this will remove all nodes with an id() of '1'.
$tree->splice(-remove_id => [1, 2], -keep_id => [2])

# Provide a list of Nodes (strictly, they don't have to be in this tree)
my $lca = $tree->get_lca(-nodes => @nodes);

my $distances = $tree->distance(-nodes => [$node1, $node2]);

# $internal_nodes is an array reference
if( $tree->is_monophyletic(-nodes    => $internal_nodes,
                           -outgroup => $outgroup) ) {
print "these nodes are monophyletic: ",
       join(",",map { $_->id } @internal_nodes ), "\n";
}

# $internal_nodes is an array reference
if( $tree->is_paraphyletic(-nodes    => $internal_nodes,
                           -outgroup => $outgroup) > 0 ) {
  print "these nodes are monophyletic: ",
        join(",",map { $_->id } @internal_nodes ), "\n";
}

# node can either be a Leaf node in which case it becomes the
# outgroup and its ancestor is the new root of the tree
# or it can be an internal node which will become the new
# root of the Tree
$tree->reroot($node);

use Bio::TreeIO;

my $treeio = Bio::TreeIO->new(-format => 'newick',
                              -file => $file);
if ( my $tree = $treeio->next_tree ) {
  my $node = $tree->find_node(-id => 'x');
  print $node->id, " each_Descendent\n";
  for my $child ( $node->each_Descendent ) {
    print $child->id, "\n";
  }
  print $node->id, " get_all_Descendents\n";
  for my $child ( $node->get_all_Descendents ) {
    print $child->id, "\n";
  }
}

(((A:5,B:5)z:2,(C:4,D:4)y:1)x:3,D:10);

use Bio::TreeIO;

my $in = new Bio::TreeIO(-file => 'input',
                         -format => 'newick');
my $out = new Bio::TreeIO(-file => '>mytree.svg',
                          -format => 'svggraph');
while( my $tree = $in->next_tree ) {
    $out->write_tree($tree);
}

#!/usr/bin/perl -w

use strict;
use Bio::Tree::Draw::Cladogram;
use Bio::TreeIO;

my $dir = shift || '.';

opendir(DIR, $dir) || die $!;
for my $file ( readdir(DIR) ) {
    next unless $file =~ /([a-z]+)/i;
    my $stem = $1;
    my $treeio = Bio::TreeIO->new(-format => 'newick',
                                  -file   => "$dir/$file");

    if( my $t1 = $treeio->next_tree ) {
        my $obj1 = Bio::Tree::Draw::Cladogram->new(-bootstrap => 1,
                                                   -tree    => $t1,
                                                   -compact => 0);
        $obj1->print(-file => "$dir/$stem.eps");
    }
}

use Bio::AlignIO;
use Bio::Align::DNAStatistics;
use Bio::Tree::DistanceFactory;
use Bio::TreeIO;

my $alnio = Bio::AlignIO->new(-file => 'filename', -format=>'clustalw');
my $dfactory = Bio::Tree::DistanceFactory->new(-method => 'NJ');
my $stats = Bio::Align::DNAStatistics->new;
my $treeout = Bio::TreeIO->new(-format => 'newick');

while( my $aln = $alnio->next_aln ) {
  my $mat = $stats->distance(-method => 'Kimura',
                             -align  => $aln);
  my $tree = $dfactory->make_tree($mat);
  $treeout->write_tree($tree);
}

use Bio::AlignIO;
use Bio::Align::DNAStatistics;
use Bio::Tree::DistanceFactory;
use Bio::Matrix::IO;
use Bio::TreeIO;

my $alnio = Bio::AlignIO->new(-file => 'filename', -format=>'clustalw');
my $dfactory = Bio::Tree::DistanceFactory->new(-method => 'NJ');
my $stats = Bio::Align::DNAStatistics->new;
my $treeout = Bio::TreeIO->new(-format => 'newick');

while( my $aln = $alnio->next_aln ) {
  my $parser = Bio::Matrix::IO->new(-format => 'phylip',
                                    -file   => 'filename.dist');
  my $mat  = $parser->next_matrix;
  my $tree = $dfactory->make_tree($mat);
  $treeout->write_tree($tree);
}

use Bio::Align::Utilities qw(:all);
my $replicates = bootstrap_replicates($aln,$count);

use Bio::TreeIO;
use Bio::Tree::RandomFactory;

# initialize a TreeIO writer to output the trees as we create them
my $out = Bio::TreeIO->new(-format => 'newick',
                           -file   => ">randomtrees.tre");
my $listoftaxa = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' ];
my $factory = new Bio::Tree::RandomFactory(-taxa => $listoftaxa);

# generate 10 random trees
for( my $i = 0; $i < 10; $i++ ) {
     $out->write_tree($factory->next_tree);
}
# One can also just request a total number of taxa (8 here) and
# not provide labels for them
# In addition one can specify the total number of trees
# the object should return so we can call this in a while loop
$factory = new Bio::Tree::RandomFactory(-num_taxa => 8
                                        -max_count=> 10);
while( my $tree = $factory->next_tree) {
  $out->write_tree($tree);
}

Version	Note
Revision 0.1 2003-12-01 JES	First version
Revision 0.2 2004-11-05 BIO	Add SVG section and links
Revision 0.3 2005-07-11 JES	Explore Node objects more
Revision 0.4 [Torst] 05:49, 22 December 2005 (EST)	Wiki version
Revision 0.41 MAJ 2015-12-05	Port to bioperl.github.io

Format	Description	File extension
cluster	Algorithm::Cluster::treecluster() output
lintree	lintree output	lin,lintree
newick	Newick/New Hampshire/PHYLIP	dnd,newick,nh
nexml	NeXML
nexus	Nexus tree output from PAUP (‘‘read only’’)
nhx	Newick/New Hampshire eXtendend (NHX)	nhx
pag	Pagel
phyloxml	PhyloXML	xml
svggraph	converts a Tree object to an SVG output	svg
tabtree	format which displays a tree as an ASCII drawing

Author

Copyright

Revision History

Abstract

Introduction

Reading and Writing Trees

Example Code

Operations on Trees

Bio::Tree::TreeI methods

Bio::Tree::TreeFunctionsI

Operations on Nodes

Node state

Node connectivity methods

Node stats

Making Images of Trees

Constructing Trees

Bootstrap testing

Advanced Topics

References and More Reading