[scpubgit/stemmatology.git] / analysis / lib / Text / Tradition / StemmaUtil.pm

package Text::Tradition::StemmaUtil;

use strict;
use warnings;
use Exporter 'import';
use vars qw/ @EXPORT_OK /;
use Bio::Phylo::IO;
use Encode qw( decode_utf8 );
use File::chdir;
use File::Temp;
use File::Which;
use Graph;
use IPC::Run qw/ run binary /;
use Text::Tradition::Error;
use Text::Tradition::Stemma;
@EXPORT_OK = qw/ character_input phylip_pars parse_newick newick_to_svg /;

=head1 NAME

Text::Tradition::StemmaUtil - standalone utilities for distance tree calculations

=head1 DESCRIPTION

This package contains a set of utilities for running phylogenetic analysis on
text collations.

=head1 SUBROUTINES

=head2 character_input( $tradition, $opts )

Returns a character matrix string suitable for Phylip programs, which 
corresponds to the given alignment table.  See Text::Tradition::Collation 
for a description of the alignment table format. Options include:

=over

=item * exclude_layer - Exclude layered witnesses from the character input, 
using only the 'main' text of the witnesses in the tradition.

=item * collapse - A reference to an array of relationship names that should
be treated as equivalent for the purposes of generating the character matrix.

=back

=cut

sub character_input {
    my ( $tradition, $opts ) = @_;
    my $table = $tradition->collation->alignment_table;
    if( $opts->{exclude_layer} ) {
    	# Filter out all alignment table rows that do not correspond
    	# to a named witness - these are the layered witnesses.
    	my $newtable = { alignment => [], length => $table->{length} };
    	foreach my $row ( @{$table->{alignment}} ) {
    		if( $tradition->has_witness( $row->{witness} ) ) {
    			push( @{$newtable->{alignment}}, $row );
    		}
    	}
    	$table = $newtable;
    }
    my $character_matrix = _make_character_matrix( $table, $opts );
    my $input = '';
    my $rows = scalar @{$character_matrix};
    my $columns = scalar @{$character_matrix->[0]} - 1;
    $input .= "\t$rows\t$columns\n";
    foreach my $row ( @{$character_matrix} ) {
        $input .= join( '', @$row ) . "\n";
    }
    return $input;
}

sub _make_character_matrix {
    my( $table, $opts ) = @_;
    # Push the names of the witnesses to initialize the rows of the matrix.
    my @matrix = map { [ _normalize_witname( $_->{'witness'} ) ] } 
    				@{$table->{'alignment'}};
    foreach my $token_index ( 0 .. $table->{'length'} - 1) {
        my @pos_tokens = map { $_->{'tokens'}->[$token_index] }
        						@{$table->{'alignment'}};
        my @pos_readings = map { $_ ? $_->{'t'} : $_ } @pos_tokens;
        my @chars = _convert_characters( \@pos_readings, $opts );
        foreach my $idx ( 0 .. $#matrix ) {
            push( @{$matrix[$idx]}, $chars[$idx] );
        }
    }
    return \@matrix;
} 

# Helper function to make the witness name something legal for pars

sub _normalize_witname {
    my( $witname ) = @_;
    $witname =~ s/\s+/ /g;
    $witname =~ s/[\[\]\(\)\:;,]//g;
    $witname = substr( $witname, 0, 10 );
    return sprintf( "%-10s", $witname );
}

sub _convert_characters {
    my( $row, $opts ) = @_;
    # This is a simple algorithm that treats every reading as different.
    # Eventually we will want to be able to specify how relationships
    # affect the character matrix.
    my %unique = ( '__UNDEF__' => 'X',
                   '#LACUNA#'  => '?',
                 );
    my %equivalent;
    my %count;
    my $ctr = 0;
    foreach my $rdg ( @$row ) {
    	next unless $rdg;
    	next if $rdg->is_lacuna;
		next if exists $unique{$rdg->text};
		if( ref( $opts->{'collapse'} ) eq 'ARRAY' ) {
			my @exclude_types = @{$opts->{'collapse'}};
			my @set = $rdg->related_readings( sub { my $rel = shift;
				$rel->colocated && grep { $rel->type eq $_ } @exclude_types } );
			push( @set, $rdg );
			my $char = chr( 65 + $ctr++ );
			map { $unique{$_->text} = $char } @set;
			$count{$rdg->text} += scalar @set;
		} else {
			$unique{$rdg->text} = chr( 65 + $ctr++ );
			$count{$rdg->text}++;			
		}
    }
    # Try to keep variants under 8 by lacunizing any singletons.
    if( scalar( keys %unique ) > 8 ) {
		foreach my $word ( keys %count ) {
			if( $count{$word} == 1 ) {
				$unique{$word} = '?';
			}
		}
    }
    my %u = reverse %unique;
    if( scalar( keys %u ) > 8 ) {
        warn "Have more than 8 variants on this location; phylip will break";
    }
    my @chars = map { $_ ? $unique{$_->text} : $unique{'__UNDEF__' } } @$row;
    return @chars;
}

=head2 phylip_pars( $character_matrix )

Runs Phylip Pars on the given character matrix.  Returns results in Newick format.

=cut

sub phylip_pars {
	my( $charmatrix ) = @_;
    # Set up a temporary directory for all the default Phylip files.
    my $phylip_dir = File::Temp->newdir();
    # $phylip_dir->unlink_on_destroy(0);
    # We need an infile, and we need a command input file.
    open( MATRIX, ">$phylip_dir/infile" ) or die "Could not write $phylip_dir/infile";
    print MATRIX $charmatrix;
    close MATRIX;

    open( CMD, ">$phylip_dir/cmdfile" ) or die "Could not write $phylip_dir/cmdfile";
    ## TODO any configuration parameters we want to set here
#   U                 Search for best tree?  Yes
#   S                        Search option?  More thorough search
#   V              Number of trees to save?  100
#   J     Randomize input order of species?  No. Use input order
#   O                        Outgroup root?  No, use as outgroup species 1
#   T              Use Threshold parsimony?  No, use ordinary parsimony
#   W                       Sites weighted?  No
#   M           Analyze multiple data sets?  No
#   I            Input species interleaved?  Yes
#   0   Terminal type (IBM PC, ANSI, none)?  ANSI
#   1    Print out the data at start of run  No
#   2  Print indications of progress of run  Yes
#   3                        Print out tree  Yes
#   4          Print out steps in each site  No
#   5  Print character at all nodes of tree  No
#   6       Write out trees onto tree file?  Yes
    print CMD "Y\n";
    close CMD;

    # And then we run the program.
    my $program = File::Which::which( 'pars' );
    unless( $program && -x $program ) {
		throw( "Phylip pars not found in path" );
    }

    {
        # We need to run it in our temporary directory where we have created
        # all the expected files.
        local $CWD = $phylip_dir;
        my @cmd = ( $program );
        run \@cmd, '<', 'cmdfile', '>', '/dev/null';
    }
    # Now our output should be in 'outfile' and our tree in 'outtree',
    # both in the temp directory.

    my @outtree;
    if( -f "$phylip_dir/outtree" ) {
        open( TREE, "$phylip_dir/outtree" ) or die "Could not open outtree for read";
        @outtree = <TREE>;
        close TREE;
    }
    return join( '', @outtree ) if @outtree;

	# If we got this far, we are about to throw an error.
    my @error;
    if( -f "$phylip_dir/outfile" ) {
        open( OUTPUT, "$phylip_dir/outfile" ) or die "Could not open output for read";
        @error = <OUTPUT>;
        close OUTPUT;
    } else {
        push( @error, "Neither outtree nor output file was produced!" );
    }
    throw( join( '', @error ) );
}

=head2 parse_newick( $newick_string )

Parses the given Newick tree(s) into one or more Stemma objects with
undirected graphs.

=cut

sub parse_newick {
    my $newick = shift;
    my @stemmata;
    # Parse the result into a tree
    my $forest = Bio::Phylo::IO->parse( 
        -format => 'newick',
        -string => $newick,
        );
    # Turn the tree into a graph, starting with the root node
    foreach my $tree ( @{$forest->get_entities} ) {
        my $stemma = Text::Tradition::Stemma->new(
        	graph => _graph_from_bio( $tree ) );
        push( @stemmata, $stemma );
    }
    return \@stemmata;
}

sub _graph_from_bio {
    my $tree = shift;
    my $graph = Graph->new( 'undirected' => 1 );
    # Give all the intermediate anonymous nodes a name.
    my $i = 0;
    my $classes = {};
    foreach my $n ( @{$tree->get_terminals} ) {
    	# The terminal nodes are our named witnesses.
		$classes->{$n->get_name} = 'extant';
	}
	foreach my $n ( @{$tree->get_internals} ) {
    	unless( defined $n->get_name && $n->get_name ne '' ) {
    		# Get an integer, make sure it's a unique name
    		while( exists $classes->{$i} ) {
    			$i++;
    		}
    		$n->set_name( $i++ );
    	}
    	$classes->{$n->get_name} = 'hypothetical';
    }
    _add_tree_children( $graph, $classes, undef, [ $tree->get_root ]);
    return $graph;
}

sub _add_tree_children {
    my( $graph, $classes, $parent, $tree_children ) = @_;
    foreach my $c ( @$tree_children ) {
        my $child = $c->get_name;
        $graph->add_vertex( $child );
        $graph->set_vertex_attribute( $child, 'class', $classes->{$child} );
        $graph->add_path( $parent, $child ) if defined $parent;
        _add_tree_children( $graph, $classes, $child, $c->get_children() );
    }
}

=head2 newick_to_svg( $newick_string )

Uses the FigTree utility (if installed) to transform the given Newick tree(s)
into a graph visualization.

=cut

sub newick_to_svg {
	my $newick = shift;
    my $program = File::Which::which( 'figtree' );
    unless( -x $program ) {
		throw( "FigTree commandline utility not found in path" );
    }
    my $svg;
    my $nfile = File::Temp->new();
    print $nfile $newick;
    close $nfile;
	my @cmd = ( $program, '-graphic', 'SVG', $nfile );
    run( \@cmd, ">", binary(), \$svg );
    return decode_utf8( $svg );
}

sub throw {
	Text::Tradition::Error->throw( 
		'ident' => 'StemmaUtil error',
		'message' => $_[0],
		);
}

1;

=head1 LICENSE

This package is free software and is provided "as is" without express
or implied warranty.  You can redistribute it and/or modify it under
the same terms as Perl itself.

=head1 AUTHOR

Tara L Andrews E<lt>aurum@cpan.orgE<gt>
Commit	Line	Data
68454b71	1	package Text::Tradition::StemmaUtil;
	2
	3	use strict;
	4	use warnings;
	5	use Exporter 'import';
	6	use vars qw/ @EXPORT_OK /;
b02332ca	7	use Bio::Phylo::IO;
27e2a8fe	8	use Encode qw( decode_utf8 );
b02332ca	9	use File::chdir;
	10	use File::Temp;
	11	use File::Which;
	12	use Graph;
b02332ca	13	use IPC::Run qw/ run binary /;
edac47cc	14	use Text::Tradition::Error;
ea45d2a6	15	use Text::Tradition::Stemma;
9457207b	16	@EXPORT_OK = qw/ character_input phylip_pars parse_newick newick_to_svg /;
68454b71	17
027d819c	18	=head1 NAME
	19
	20	Text::Tradition::StemmaUtil - standalone utilities for distance tree calculations
	21
	22	=head1 DESCRIPTION
	23
	24	This package contains a set of utilities for running phylogenetic analysis on
	25	text collations.
	26
	27	=head1 SUBROUTINES
	28
ea45d2a6	29	=head2 character_input( $tradition, $opts )
9457207b	30
	31	Returns a character matrix string suitable for Phylip programs, which
	32	corresponds to the given alignment table. See Text::Tradition::Collation
ea45d2a6	33	for a description of the alignment table format. Options include:
	34
	35	=over
	36
	37	=item * exclude_layer - Exclude layered witnesses from the character input,
	38	using only the 'main' text of the witnesses in the tradition.
	39
	40	=item * collapse - A reference to an array of relationship names that should
	41	be treated as equivalent for the purposes of generating the character matrix.
	42
	43	=back
9457207b	44
027d819c	45	=cut
027d819c	46
9457207b	47	sub character_input {
ea45d2a6	48	my ( $tradition, $opts ) = @_;
	49	my $table = $tradition->collation->alignment_table;
	50	if( $opts->{exclude_layer} ) {
	51	# Filter out all alignment table rows that do not correspond
	52	# to a named witness - these are the layered witnesses.
b39e7cb5	53	my $newtable = { alignment => [], length => $table->{length} };
b39e7cb5	54	foreach my $row ( @{$table->{alignment}} ) {
ea45d2a6	55	if( $tradition->has_witness( $row->{witness} ) ) {
	56	push( @{$newtable->{alignment}}, $row );
	57	}
	58	}
	59	$table = $newtable;
	60	}
	61	my $character_matrix = _make_character_matrix( $table, $opts );
9457207b	62	my $input = '';
	63	my $rows = scalar @{$character_matrix};
	64	my $columns = scalar @{$character_matrix->[0]} - 1;
	65	$input .= "\t$rows\t$columns\n";
	66	foreach my $row ( @{$character_matrix} ) {
	67	$input .= join( '', @$row ) . "\n";
	68	}
	69	return $input;
	70	}
	71
027d819c	72	sub _make_character_matrix {
ea45d2a6	73	my( $table, $opts ) = @_;
68454b71	74	# Push the names of the witnesses to initialize the rows of the matrix.
	75	my @matrix = map { [ _normalize_witname( $_->{'witness'} ) ] }
	76	@{$table->{'alignment'}};
	77	foreach my $token_index ( 0 .. $table->{'length'} - 1) {
ea45d2a6	78	my @pos_tokens = map { $_->{'tokens'}->[$token_index] }
68454b71	79	@{$table->{'alignment'}};
ea45d2a6	80	my @pos_readings = map { $_ ? $_->{'t'} : $_ } @pos_tokens;
ea45d2a6	81	my @chars = _convert_characters( \@pos_readings, $opts );
68454b71	82	foreach my $idx ( 0 .. $#matrix ) {
	83	push( @{$matrix[$idx]}, $chars[$idx] );
	84	}
	85	}
	86	return \@matrix;
	87	}
	88
	89	# Helper function to make the witness name something legal for pars
	90
	91	sub _normalize_witname {
	92	my( $witname ) = @_;
	93	$witname =~ s/\s+/ /g;
	94	$witname =~ s/[\[\]\(\)\:;,]//g;
	95	$witname = substr( $witname, 0, 10 );
	96	return sprintf( "%-10s", $witname );
	97	}
	98
027d819c	99	sub _convert_characters {
ea45d2a6	100	my( $row, $opts ) = @_;
68454b71	101	# This is a simple algorithm that treats every reading as different.
	102	# Eventually we will want to be able to specify how relationships
	103	# affect the character matrix.
	104	my %unique = ( '__UNDEF__' => 'X',
	105	'#LACUNA#' => '?',
	106	);
ea45d2a6	107	my %equivalent;
68454b71	108	my %count;
68454b71	109	my $ctr = 0;
ea45d2a6	110	foreach my $rdg ( @$row ) {
	111	next unless $rdg;
	112	next if $rdg->is_lacuna;
	113	next if exists $unique{$rdg->text};
	114	if( ref( $opts->{'collapse'} ) eq 'ARRAY' ) {
	115	my @exclude_types = @{$opts->{'collapse'}};
	116	my @set = $rdg->related_readings( sub { my $rel = shift;
	117	$rel->colocated && grep { $rel->type eq $_ } @exclude_types } );
	118	push( @set, $rdg );
	119	my $char = chr( 65 + $ctr++ );
	120	map { $unique{$_->text} = $char } @set;
	121	$count{$rdg->text} += scalar @set;
	122	} else {
	123	$unique{$rdg->text} = chr( 65 + $ctr++ );
	124	$count{$rdg->text}++;
	125	}
68454b71	126	}
	127	# Try to keep variants under 8 by lacunizing any singletons.
	128	if( scalar( keys %unique ) > 8 ) {
	129	foreach my $word ( keys %count ) {
	130	if( $count{$word} == 1 ) {
	131	$unique{$word} = '?';
	132	}
	133	}
	134	}
	135	my %u = reverse %unique;
	136	if( scalar( keys %u ) > 8 ) {
	137	warn "Have more than 8 variants on this location; phylip will break";
	138	}
ea45d2a6	139	my @chars = map { $_ ? $unique{$_->text} : $unique{'__UNDEF__' } } @$row;
68454b71	140	return @chars;
	141	}
	142
027d819c	143	=head2 phylip_pars( $character_matrix )
	144
	145	Runs Phylip Pars on the given character matrix. Returns results in Newick format.
	146
	147	=cut
	148
b02332ca	149	sub phylip_pars {
	150	my( $charmatrix ) = @_;
	151	# Set up a temporary directory for all the default Phylip files.
	152	my $phylip_dir = File::Temp->newdir();
	153	# $phylip_dir->unlink_on_destroy(0);
	154	# We need an infile, and we need a command input file.
	155	open( MATRIX, ">$phylip_dir/infile" ) or die "Could not write $phylip_dir/infile";
	156	print MATRIX $charmatrix;
	157	close MATRIX;
	158
	159	open( CMD, ">$phylip_dir/cmdfile" ) or die "Could not write $phylip_dir/cmdfile";
	160	## TODO any configuration parameters we want to set here
	161	# U Search for best tree? Yes
	162	# S Search option? More thorough search
	163	# V Number of trees to save? 100
	164	# J Randomize input order of species? No. Use input order
	165	# O Outgroup root? No, use as outgroup species 1
	166	# T Use Threshold parsimony? No, use ordinary parsimony
	167	# W Sites weighted? No
	168	# M Analyze multiple data sets? No
	169	# I Input species interleaved? Yes
	170	# 0 Terminal type (IBM PC, ANSI, none)? ANSI
	171	# 1 Print out the data at start of run No
	172	# 2 Print indications of progress of run Yes
	173	# 3 Print out tree Yes
	174	# 4 Print out steps in each site No
	175	# 5 Print character at all nodes of tree No
	176	# 6 Write out trees onto tree file? Yes
	177	print CMD "Y\n";
	178	close CMD;
	179
	180	# And then we run the program.
	181	my $program = File::Which::which( 'pars' );
b39e7cb5	182	unless( $program && -x $program ) {
edac47cc	183	throw( "Phylip pars not found in path" );
b02332ca	184	}
	185
	186	{
	187	# We need to run it in our temporary directory where we have created
	188	# all the expected files.
	189	local $CWD = $phylip_dir;
	190	my @cmd = ( $program );
	191	run \@cmd, '<', 'cmdfile', '>', '/dev/null';
	192	}
	193	# Now our output should be in 'outfile' and our tree in 'outtree',
	194	# both in the temp directory.
	195
	196	my @outtree;
	197	if( -f "$phylip_dir/outtree" ) {
	198	open( TREE, "$phylip_dir/outtree" ) or die "Could not open outtree for read";
	199	@outtree = <TREE>;
	200	close TREE;
	201	}
edac47cc	202	return join( '', @outtree ) if @outtree;
b02332ca	203
69403daa	204	# If we got this far, we are about to throw an error.
b02332ca	205	my @error;
	206	if( -f "$phylip_dir/outfile" ) {
	207	open( OUTPUT, "$phylip_dir/outfile" ) or die "Could not open output for read";
	208	@error = <OUTPUT>;
	209	close OUTPUT;
	210	} else {
	211	push( @error, "Neither outtree nor output file was produced!" );
	212	}
edac47cc	213	throw( join( '', @error ) );
b02332ca	214	}
b02332ca	215
027d819c	216	=head2 parse_newick( $newick_string )
027d819c	217
ea45d2a6	218	Parses the given Newick tree(s) into one or more Stemma objects with
ea45d2a6	219	undirected graphs.
027d819c	220
	221	=cut
	222
b02332ca	223	sub parse_newick {
b02332ca	224	my $newick = shift;
ea45d2a6	225	my @stemmata;
b02332ca	226	# Parse the result into a tree
	227	my $forest = Bio::Phylo::IO->parse(
	228	-format => 'newick',
	229	-string => $newick,
	230	);
	231	# Turn the tree into a graph, starting with the root node
	232	foreach my $tree ( @{$forest->get_entities} ) {
ea45d2a6	233	my $stemma = Text::Tradition::Stemma->new(
98f22390	234	graph => _graph_from_bio( $tree ) );
ea45d2a6	235	push( @stemmata, $stemma );
	236	}
	237	return \@stemmata;
	238	}
	239
	240	sub _graph_from_bio {
	241	my $tree = shift;
	242	my $graph = Graph->new( 'undirected' => 1 );
	243	# Give all the intermediate anonymous nodes a name.
	244	my $i = 0;
	245	my $classes = {};
	246	foreach my $n ( @{$tree->get_terminals} ) {
	247	# The terminal nodes are our named witnesses.
	248	$classes->{$n->get_name} = 'extant';
	249	}
	250	foreach my $n ( @{$tree->get_internals} ) {
	251	unless( defined $n->get_name && $n->get_name ne '' ) {
	252	# Get an integer, make sure it's a unique name
	253	while( exists $classes->{$i} ) {
	254	$i++;
	255	}
	256	$n->set_name( $i++ );
	257	}
	258	$classes->{$n->get_name} = 'hypothetical';
	259	}
	260	_add_tree_children( $graph, $classes, undef, [ $tree->get_root ]);
	261	return $graph;
	262	}
	263
	264	sub _add_tree_children {
	265	my( $graph, $classes, $parent, $tree_children ) = @_;
	266	foreach my $c ( @$tree_children ) {
	267	my $child = $c->get_name;
	268	$graph->add_vertex( $child );
	269	$graph->set_vertex_attribute( $child, 'class', $classes->{$child} );
	270	$graph->add_path( $parent, $child ) if defined $parent;
	271	_add_tree_children( $graph, $classes, $child, $c->get_children() );
b02332ca	272	}
b02332ca	273	}
b02332ca	274
027d819c	275	=head2 newick_to_svg( $newick_string )
	276
	277	Uses the FigTree utility (if installed) to transform the given Newick tree(s)
	278	into a graph visualization.
	279
	280	=cut
	281
27e2a8fe	282	sub newick_to_svg {
	283	my $newick = shift;
	284	my $program = File::Which::which( 'figtree' );
	285	unless( -x $program ) {
edac47cc	286	throw( "FigTree commandline utility not found in path" );
27e2a8fe	287	}
	288	my $svg;
	289	my $nfile = File::Temp->new();
	290	print $nfile $newick;
	291	close $nfile;
	292	my @cmd = ( $program, '-graphic', 'SVG', $nfile );
	293	run( \@cmd, ">", binary(), \$svg );
	294	return decode_utf8( $svg );
	295	}
	296
edac47cc	297	sub throw {
	298	Text::Tradition::Error->throw(
	299	'ident' => 'StemmaUtil error',
	300	'message' => $_[0],
	301	);
	302	}
	303
027d819c	304	1;
	305
	306	=head1 LICENSE
	307
	308	This package is free software and is provided "as is" without express
	309	or implied warranty. You can redistribute it and/or modify it under
	310	the same terms as Perl itself.
	311
	312	=head1 AUTHOR
	313
	314	Tara L Andrews E<lt>aurum@cpan.orgE<gt>