Free bio graphics feature software for linux

Bio::Graphics::FeatureFile is a set of Bio::Graphics features, stored in a file.

SYNOPSIS

use Bio::Graphics::FeatureFile;
my $data = Bio::Graphics::FeatureFile->new(-file => features.txt);


# create a new panel and render contents of the file onto it
my $panel = $data->new_panel;
my $tracks_rendered = $data->render($panel);

# or do it all in one step
my ($tracks_rendered,$panel) = $data->render;

# for more control, render tracks individually
my @feature_types = $data->types;
for my $type (@feature_types) {
my $features = $data->features($type);
my %options = $data->style($type);
$panel->add_track($features,%options); # assuming we have a Bio::Graphics::Panel
}

# get individual settings
my $est_fg_color = $data->setting(EST => fgcolor);

# or create the FeatureFile by hand

# add a type
$data->add_type(EST => {fgcolor=>blue,height=>12});

# add a feature
my $feature = Bio::Graphics::Feature->new(
# params
); # or some other SeqI
$data->add_feature($feature=>EST);

The Bio::Graphics::FeatureFile module reads and parses files that describe sequence features and their renderings. It accepts both GFF format and a more human-friendly file format described below. Once a FeatureFile object has been initialized, you can interrogate it for its consistuent features and their settings, or render the entire file onto a Bio::Graphics::Panel.

This moduel is a precursor of Jason Stajichs Bio::Annotation::Collection class, and fulfills a similar function of storing a collection of sequence features. However, it also stores rendering information about the features, and does not currently follow the CollectionI interface.

Bio::Graphics::Glyph::alignment is the "alignment" glyph.

SYNOPSIS

See L< Bio::Graphics::Panel > and L< Bio::Graphics::Glyph >.

This is identical to the "graded_segments" glyph, and is used for drawing features that consist of discontinuous segments. The color intensity of each segment is proportionate to the score.

Bio::Graphics::Panel is a Perl module to generate GD images of Bio::Seq objects.

SYNOPSIS

# This script parses a GenBank or EMBL file named on the command
# line and produces a PNG rendering of it. Call it like this:
# render.pl my_file.embl | display -

use strict;
use Bio::Graphics;
use Bio::SeqIO;

my $file = shift or die "provide a sequence file as the argument";
my $io = Bio::SeqIO->new(-file=>$file) or die "could not create Bio::SeqIO";
my $seq = $io->next_seq or die "could not find a sequence in the file";

my @features = $seq->all_SeqFeatures;

# sort features by their primary tags
my %sorted_features;
for my $f (@features) {
my $tag = $f->primary_tag;
push @{$sorted_features{$tag}},$f;
}

my $panel = Bio::Graphics::Panel->new(
-length => $seq->length,
-key_style => between,
-width => 800,
-pad_left => 10,
-pad_right => 10,
);
$panel->add_track( arrow => Bio::SeqFeature::Generic->new(-start=>1,
-end=>$seq->length),
-bump => 0,
-double=>1,
-tick => 2);
$panel->add_track(generic => Bio::SeqFeature::Generic->new(-start=>1,
-end=>$seq->length),
-glyph => generic,
-bgcolor => blue,
-label => 1,
);

# general case
my @colors = qw(cyan orange blue purple green chartreuse magenta yellow aqua);
my $idx = 0;
for my $tag (sort keys %sorted_features) {
my $features = $sorted_features{$tag};
$panel->add_track($features,
-glyph => generic,
-bgcolor => $colors[$idx++ % @colors],
-fgcolor => black,
-font2color => red,
-key => "${tag}s",
-bump => +1,
-height => 8,
-label => 1,
-description => 1,
);
}

print $panel->png;
$panel->finished;

exit 0;

The Bio::Graphics::Panel class provides drawing and formatting services for any object that implements the Bio::SeqFeatureI interface, including Ace::Sequence::Feature and Das::Segment::Feature objects. It can be used to draw sequence annotations, physical (contig) maps, or any other type of map in which a set of discrete ranges need to be laid out on the number line.

The module supports a drawing style in which each type of feature occupies a discrete "track" that spans the width of the display. Each track will have its own distinctive "glyph", a configurable graphical representation of the feature.
The module also supports a more flexible style in which several different feature types and their associated glyphs can occupy the same track. The choice of glyph is under run-time control.

Semantic zooming (for instance, changing the type of glyph depending on the density of features) is supported by a callback system for configuration variables. The module has built-in support for Bio::Das stylesheets, and stylesheet-driven configuration can be intermixed with semantic zooming, if desired.

You can add a key to the generated image using either of two key styles. One style places the key captions at the top of each track. The other style generates a graphical key at the bottom of the image.

Note that this module depends on GD. The optional SVG output depends on GD::SVG and SVG.

Bio::Graph::SimpleGraph is a Perl module that can create and manipulate undirected graphs.

SYNOPSIS

use Bio::Graph::SimpleGraph;

my $graph=new SimpleGraph;
# read pairs of nodes from STDIN
while () {
my($node1,$node2)=split;
$graph->add_edge($node1,$node2);
}
my @nodes=graph->nodes; # get list of nodes
my @edges=graph->edges; # get list of edges
foreach my $node (@nodes) {
my @neighbors=$node->neighbors; # get list of neighboring nodes
}

This is a simple, hopefully fast undirected graph package. The only reason this exists is that the standard CPAN Graph pacakge, Graph::Base, is seriously broken. The package implements a small and eclectic assortment of standard graph algorithms that we happened to need for our applications.

This module is a subclass of Class::AutoClass (available at CPAN). AutoClass auotgenerates simple accessor and mutator methods (aka get and set methods). It also automates class initialization.

Nodes can be any Perl values, including object references. Edges are pairs of nodes.

(Caveat: be careful with values that contain embedded instances of $; (the character Perl uses to separate components of multi-dimensional subscripts), because we use this in the text representation of edges.

The main data structures are:

An edge (x,y) is represented canonically as a two element list in
which the lexically smaller value is first. Eg, the node (b,a)
is represented as [a,b].

The graph contains

1) A hash mapping the text representation of a node to the node
itself. This is mostly relevant when the node is a reference.

2) A hash mapping the text representation of a node to a list of
the nodes neighbors.

3) A hash mapping the text representation of an edge to the edge itself.

SAgl is a portable small antialiased graphics library. It offers lines, circles, and bezier curves, as well as thick lines and fills.

It can be used on top of SDL or with X or any other graphics system.

Bio::Affymetrix::CDF is a Perl module to parse Affymetrix CDF files.

SYNOPSIS

use Bio::Affymetrix::CDF;

# Parse the CDF file

my $cdf=new Bio::Affymetrix::CDF({"probemode"=>0});

$cdf->parse_from_file("foo.cdf");

# Find some fun facts about this chip type

print $cdf->rows().",".$cdf->cols()."n";

print $cdf->version()."n";

# Print out all of the probeset names on this chip type

foreach my $i (keys %{$chp->probesets}) { print $chp->probesets->{$i}->name()."n"; }

The Affymetrix microarray system produces files in a variety of formats. If this means nothing to you, these modules are probably not for you :). This module parses CDF files. Use this module if you want to find out about the design of an Affymetrix GeneChip, or you need the object for another one of the modules in this package.

All of the Bio::Affymetrix modules parse a file entirely into memory. You therefore need enough memory to hold these objects. For some applications, parsing as a stream may be more appropriate- hopefully the source to these modules will give enough clues to make this an easy task. This module in particular takes a lot of memory if probe information is also stored (about 150Mb). Memory usage is not too onorous (about 15Mb) if probe level information is omitted. You can.control this by setting probemode=>1 or probemode=>0 in the constructor.

You can also use these modules to write CDF files (using the write_to_filehandle method). See COMPATIBILITY for some important caveats.

Bio::Das::Lite is a Perl extension for the DAS (HTTP+XML) Protocol.

SYNOPSIS

use Bio::Das::Lite;
my $bdl = Bio::Das::Lite->new_from_registry({category => Chromosome});
my $results = $bdl->features(22);

SUBROUTINES/METHODS

new : Constructor
my $das = Bio::Das::Lite->new(http://das.ensembl.org/das/ensembl1834);

my $das = Bio::Das::Lite->new({
timeout => 60,
dsn => http://user:pass@das.ensembl.org/das/ensembl1834,
http_proxy => http://user:pass@webcache.local.com:3128/,
});

Options can be: dsn (optional scalar or array ref, URLs of DAS services)
timeout (optional int, HTTP fetch timeout in seconds)
http_proxy (optional scalar, web cache or proxy if not set in %ENV)
caching (optional bool, primitive caching on/off)
callback (optional code ref, callback for processed XML blocks)
registry (optional array ref containing DAS registry service URLs
defaults to http://das.sanger.ac.uk/registry/services/das)
proxy_user (optional scalar, username for authenticating forward-proxy)
proxy_pass (optional scalar, password for authenticating forward-proxy)
user_agent (optional scalar, User-Agent HTTP request header value)

new_from_registry : Constructor
Similar to new above but supports capabilities and category
in the given hashref, using them to query the DAS registry and
configuring the DSNs accordingly.

my $das = Bio::Das::Lite->new_from_registry({
capabilities => [features],
category => [Protein Sequence],
});

Options are as above, plus
capability (optional arrayref of capabilities)
category (optional arrayref of categories)