Free graph layout software for linux

mfGraph is a graph rendering library for interactive applications. Written in C++ and Python, mfGraph parses GraphViz DOT and XDOT files and provides rendering and hit-testing facilities. Supports Microsoft Windows natively, GNU/Linux through wxPython.
Main features:
- An object model for manipulating graphs and their attributes
- As a serialization format, the GraphViz DOT language is used
- The DOT tool can be used to calculate the layout, then mfGraph is used to build a list of primitive drawing commands by interpreting the XDOT attributes
- For each platform, all that is needed are basic drawing functions (text, lines, ellipses, Bezier curves, and the like) to do the actual rendering
- Zooming and hit-testing are supported
Enhancements:
- Added Visual Studio 2005 project files (".vcproj", ".sln")
- Minor code fixes to resolve compiler errors and warnings in Visual Studio 2005

XmGraph is a package containing two widgets: XmGraph and XmArc. XmGraph is the container, and XmArc widgets are displayed on it. The widgets provide the application developer with the ability to display any group of widgets as a graph, with each widget representing a node.
We here at SESD have been using the graph widget for about a year and a half in our testing tools for Softbench. We have found several bugs in the graph widget. Some have been fixed through code changes, others we haveworked around. Here are our work arounds:
Arcs with a slope of -1 and a width of 0 are not drawn. The work around is to put a blank label on each arc.Backgound pixmaps on the graph widget do not get refreshed when
an arc is moved. This is unfortunate since you cant distinguish selected arcs from unselected arcs on a black and white display. We dont use a background pixmap on the graph widget. In cxxdev,CLL added a callback to make the selected arc wider.
The automatic scroll bars do not come and go properly. We force the scroll bars to always be present. The X server gives a bad value error if you try to create a window that is larger than ~16K pixels in either direction. This has only been a problem for us since switching to HP-UX 8.0. Under 7.0 we could make windows that were about 32K pixels and if we made our graph bigger than that the nodes would wrap around. We have changed our layout algorithm to automatically wrap our graphs to fit in the new 16K pixel limit. Our layout algorithm is separate fromthe graph widget.
The graph widget can core dump the 8.0 X server when drawing long zero width lines that are nearly vertical or nearly horizontal. Make sure you have the X server patches from this past November.
All of our code chages have been given to Thuan either directly (today) or through CLL.
Enhancements:
- I added one more fix to Arc.c. The "if" statement allows a background pixmap to be used with the graph widget. I fixed this so the graphic front end to softstatic will be usable on a monochrome display. To see the error that this corrects run:
-
- ./sort -xrm "*XmGraph.backgroundPixmap:25_foreground" 17
-
- Then move some of the nodes around. With this patch the old arcs are correctly erased.

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.

ibargraph provides a tool which shows the throughput on an ISDN line as a bar graph.

This program shows the current throughput on an ISDN line as LED bar graph with LCDProc. Currently, this feature is only supported via the HD44780 extended display driver connect with the LCDTime wiring.

graph-tool project is a program to help with statistical analysis of graphs.
Main features:
- support for directed and undirected graphs
- support for arbitrary vertex or edge properties
- generic filtering of edges and vertices
- several statistical measurements:
- degree (or scalar property) histogram
- vertex-vertex degree (or scalar property) correlation
- average nearest neighbours degree (or scalar property)
- vertex-edge-vertex correlation
- clustering coefficients
- assortativity coefficient
- average distance
- component statistics
- generation of random graphs with arbitrary degree distribution and degree correlation
- graph history measurement based on filtering
- support for graphml and dot file formats
The core algorithms are written in C++, making use of the Boost Graph Library, and template metaprogramming techniques, with performace in mind. The command line interface and other outlying code are written in python.

SVG::Graph is a Perl module to visualize your data in Scalable Vector Graphics (SVG) format.

SYNOPSIS

use SVG::Graph;
use SVG::Graph::Data;
use SVG::Graph::Data::Datum;

#create a new SVG document to plot in...
my $graph = SVG::Graph->new(width=>600,height=>600,margin=>30);

#and create a frame to hold the data/glyphs
my $frame = $graph->add_frame;

#lets plot y = x^2
my @data = map {SVG::Graph::Data::Datum->new(x=>$_,y=>$_^2)}
(1,2,3,4,5);
my $data = SVG::Graph::Data->new(data => @data);

#put the xy data into the frame
$frame->add_data($data);

#add some glyphs to apply to the data in the frame
$frame->add_glyph(axis, #add an axis glyph
x_absolute_ticks => 1, #with ticks every one
#unit on the x axis
y_absolute_ticks => 1, #and ticks every one
#unit on the y axis

stroke => black, #draw the axis black
stroke-width => 2, #and 2px thick
);

$frame->add_glyph(scatter, #add a scatterplot glyph
stroke => red, #the dots will be outlined
#in red,
fill => red, #filled red,
fill-opacity => 0.5, #and 50% opaque
);

#print the graphic
print $graph->draw;

SVG::Graph is a suite of perl modules for plotting data. SVG::Graph currently supports plots of one-, two- and three-dimensional data, as well as N-ary rooted trees. Data may be represented as:

Glyph Name Dimensionality supported
1d 2d 3d tree
--------------------------------------------------------
Axis x
Bar Graph x
Bubble Plot x
Heatmap Graph x
Line Graph x
Pie Graph x
Scatter Plot x
Spline Graph x
Tree x

SVG::Graph 0.01 is a pre-alpha release. Keep in mind that many of the glyphs are not very robust.