Free graph visualization software for linux

Genomorama: Genome Visualization is a multi-scale, multi-genome, multi-platform visualization and analysis program. It provides a powerful yet easy to use interface that leverages the visualization power of modern computers (via OpenGL) and the substantial bioinformatic infrastructure provided by the NCBI (via the NCBI C toolkit).
Genomorama is written in portable, highly optimized C++ and comes in three "flavors" that allow it to run natively on (most) modern operating systems: OS X (using Carbon), Microsoft Windows (using MFC), and Linux (using Motif). Executables and source code are freely provided for all flavors.
Main features:
- High performance has not been sacrificed on the altar of portability
- OpenGL graphics take advantage of the video-game optimized graphics cards available in most desktop and laptop computers.
- C++ allows transparent and complete utilization of system resources (like memory).
- Native windowing toolkits (Carbon, MFC and Motif) for every operating system facilitate responsiveness and ease of use.
- A stand-alone, self-contained executable frees Genomorama from dependence on third party applications.
- Source code for all platforms is freely available.
- An attractive, full featured user interface
- Genomorama presents a clean, uncluttered user interface.
- Multi-scale rendering displays relevant details while maintaining readability.
- Use a keyboard or a mouse to efficiently zoom, pan and explore genomes of arbitrary size.
- Attractive WYSIWYG Postscript and GIF output formats yield publication quality images.
- Novel features to aid genome analysis
- In addition to the standard searching options (like query by sequence and gene name), Genomorama offers "forward and reverse" DNA hybridization based searches.
- Provide a pair of PCR primers, and Genomorama will output the amplicons.
- Provide a hybridization probe and Genomorama will find binding sites.
- Provide a pair of Padlock probes and Genomorama will identify binding locations
- Provide a set of PCR primer criteria (length, melting temperature, base composition, etc.) and Genomorama will find PCR primers.
- Genomorama can display and search an arbitrary number of genomes (limited only by computer memory).
- Harness the power of the NCBI toolkit to directly access and search the NCBI Entrez database.
- Compute melting profile, in addition to traditional base composition plots (i.e. %G+C, %A+T, etc).
Enhancements:
- This release fixes the following bugs: parsing gbk files that contain single base annotations on the complement strand;
- missed exact matches at 3 end of target sequence;
- fragile parsing of annotation range;
- downloading of very large Genbank records (i.e. human chromosomes);
- and omitted intergenic space following single base annotations (i.e. SNPs).
- Custom color records are now saved to and read from GBK files.
- An OS X Intel-specific executable has been added.
- The information dialog box has been made resizable.

XMMS Root Visualization Plugin is a little XMMS plugin wich can draw a spectrum analyzer directly to the background (root window) of X.
Enhancements:
- changed code to get rid of gcc 4 compiler warnings
- added alpha channel to all colors
- rewrote configuration backend
- introduced strange configuration variables definition struct its not the best thing around, but better than former behaviour and needed for the configuration frontend
- introduced configuration frontend (far from being complete!) BASIC WORK BY Niv Altivanik up till now it is possible to change colors
- introduced Imlib2 rendering:
- real transparency support
- gradient support
- bevel support
- peaks can be drawn solely
- no more drawing bugs
- higher performance cost :-( (see end of file)
- since this release, the background of the root window has to be collected; this method is not tested well
- new default config for imlib rendering
- cleaned up some minor bugs

Graph::ModularDecomposition is a Perl module for modular decomposition of directed graphs.

SYNOPSIS

use Graph::ModularDecomposition qw(pairstring_to_graph tree_to_string);
my $g = new Graph::ModularDecomposition;

my $h = $g->pairstring_to_graph( ab,ac,bc );
print "yesn" if check_transitive( $h );
print "yesn" if $h->check_transitive; # same thing
my $m = $h->modular_decomposition_EGMS;
print tree_to_string( $m );

This module extends Graph::Directed by providing new methods related to modular decomposition.

The most important new method is modular_decomposition_EGMS(), which for a directed graph with n vertices finds the modular decomposition tree of the graph in O(n^2) time. Method tree_to_string() may be useful to represent the decomposition tree in a friendlier format; this needs to be explicitly imported.

If you need to decompose an undirected graph, represent it as a directed graph by adding two directed edges for each undirected edge.

The method classify() uses the modular decomposition tree to classify a directed graph as non-transitive, or for transitive digraphs, as series-parallel (linear or parallel modules only), decomposable (not series-parallel, but with at least one non-primitive module), indecomposable (primitive), decomposable but consisting of primitive or series modules only (only applies to graphs of at least 7 vertices), or unclassified (should never apply).

Graph is a Perl module with graph data structures and algorithms.

SYNOPSIS

use Graph;
my $g0 = Graph->new; # A directed graph.

use Graph::Directed;
my $g1 = Graph::Directed->new; # A directed graph.

use Graph::Undirected;
my $g2 = Graph::Undirected->new; # An undirected graph.

$g->add_edge(...);
$g->has_edge(...)
$g->delete_edge(...);

$g->add_vertex(...);
$g->has_vertex(...);
$g->delete_vertex(...);

$g->vertices(...)
$g->edges(...)

Q-Graph is a collection of Q scripts that provide a graph data structure and a full-featured graph editor (the latter requires Tcl/Tk).

Q-Graph library can be used to implement and test graph algorithms using the Q language.

Q is a functional programming language based on term rewriting. Thus, a Q program or "script" is simply a collection of equations which are used to evaluate expressions in a symbolic fashion.

The equations establish algebraic identities and are interpreted as rewriting rules in order to reduce expressions to "normal forms".

For instance, here is how you define a function sqr which squares its argument by multiplying it with itself:
sqr X = X*X;

Note that, as in Prolog, capitalized identifiers are used to indicate the variables in an equation, which are bound to the actual values when an equation is applied. Equations may also include a condition part, as in the following definition of the factorial function:

fact N = N*fact (N-1) if N>0;
= 1 otherwise;

Functions on structured arguments are defined by "pattern matching". E.g., the product of a list (denoted in Prolog-like syntax) can be computed with these two equations:

prod [] = 1;
prod [X|Xs] = X*prod Xs;

With this definition, the factorial can now also be defined as follows (the notation [1..N], as in Haskell, denotes an arithmetic sequence):

fact N = prod [1..N];

As you can see, the definitions are really just like mathematical equations. The syntax is superficially similar to other modern functional languages like Miranda and Haskell, except that Q is "free-format", i.e., it does not use layout to indicate syntactical structure (thus the semicolon is used to terminate an equation).

Due to its term rewriting heritage, Q goes well beyond most other functional languages in that it also allows you to perform computations with symbolic expressions. For instance, with the definition of the sqr function from above, you will find that sqr (X+1) evaluates to (X+1)*(X+1). This might first look like an arcane feature, but it is actually quite useful, because you can try your definitions with symbolic inputs, too.

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.