Free graphics interface software for linux

General Graphics User Interface is an effort to produce a common graphical user interface for any command-line program.

It uses a wizard-like input front end to collect the information needed. It then calls the desired program automatically with all the necessary options.

The user is able to point&click on various options and select them in a convenient way. In order to create a new user-interface, a user doesnt need to know a programming language, since there is a graphical editor for new GGUI "scripts".

Graphics::Simple is a simple , device-independent graphics API for Perl.

SYNOPSIS

use Graphics::Simple;

line 100,100,200,200;
circle 50,50,25;
stop(); clear(); # Wait for a button press, clear the page

Ever had a Commodore C-64 or Vic-20 or some other of the machines of that era? Where doing graphics was as simple as

line 20,20,50,30;

and you didnt have to go through things like XOpenDisplay etc.

This module tries to bring back the spirit of that era in a modern environment: this module presents a simple, unified API to several different graphics devices - currently X (using Gtk and Gnome) and PostScript.

The interface is primarily made easy-to-use, starting from the idea that the above line command must work. Therefore, it exports most of the primitives by default (you can turn this off).

However, everything is not sacrificed in the name of simplicity: believing in "simple things simple, complicated things possible", this module also allows multiple windows (all the primitives also work as methods of window objects) as well as raw access to the underlying devices - although the device-independence is then lost. In future plans are some sort of interactions with the devices with which it is possible as well as the addition of more devices.

The use command currently accepts the forms

use Graphics::Simple;
use Graphics::Simple qw/line circle/;
use Graphics::Simple 300,400; # portrait paper
use Graphics::Simple 300,400, qw/line circle/;

i.e. the optional size of the default window first and then normal Exporter arguments.

Graphics::Simple has several different back-ends, currently GnomeCanvas, TkCanvas, PostScript and (not fully working yet) Fig. Other backends are expected.
To start Graphics::Simple with a given backend, you should set the environment variable GSIMPL to the value, e.g. by running your script with the command

GSIMPL=PostScript perl gt1.pl

or by setting the environment variable permanently in your shell, by

GSIMPL=PostScript
export GSIMPL

or

setenv GSIMPL PostScript

VTKGraphics is a Perl interface to VTKGraphics library.

SYNOPSIS

use Graphics::VTK; use Graphics::VTK::Graphics;

Graphics::VTK::Graphics is an interface to the Graphics libaray of the C++ visualization toolkit VTK.

Graphics::VTK::AppendFilter

Inherits from DataSetToUnstructuredGridFilter

Functions Supported for this class by the PerlVTK module: (To find more about their use check the VTK documentation at http://www.kitware.com.)

void AddInput (vtkDataSet *in);
const char *GetClassName ();
vtkDataSet *GetInput (int idx);
vtkDataSet *GetInput ();
vtkDataSetCollection *GetInputList ();
vtkAppendFilter *New ();
void RemoveInput (vtkDataSet *in);

vtkAppendFilter Unsupported Funcs:
Functions which are not supported supported for this class by the PerlVTK module.

void PrintSelf (ostream &os, vtkIndent indent);
I/O Streams not Supported yet.

PDL::Graphics::TriD is a PDL 3D interface.

SYNOPSIS

use PDL::Graphics::TriD;

# After each graph, let the user rotate is and # wait for him to press q, then make new graph line3d($coords); # $coords = (3,n,...) line3d($coords,$colors); # $colors = (3,n,...) line3d([$x,$y,$z]); imagrgb([$r,$g,$b]); lattice3d([$x,$y,$z]); # 2-d piddles points3d([$x,$y,$z]);
hold3d(); # the following graphs are on top of each other and the previous line3d([$x,$y,$z]); line3d([$x,$y,$z+1]); $pic = grabpic3d(); # Returns the picture in a (3,$x,$y) float piddle (0..1).
release3d(); # the next graph will again wipe out things.

WARNING

These modules are still in a somewhat unfocused state: dont use them yet if you dont know how to make them work if they happen to do something strange.

This module implements a generic 3D plotting interface for PDL. Points, lines and surfaces (among other objects) are supported.

With OpenGL, it is easy to manipulate the resulting 3D objects with the mouse in real time - this helps data visualization a lot.

The Graphics Muse Tools are a collection of plug-ins and scripts for use with GIMP. The package now includes a set of C plugins (GFXArrows, GFXCards, GFXTrans, GFXLayers, GFXMerge, and GFXShapes) and a set of Perl scripts (GFXDodge, GFXGallery, GFXLayerSave, and GFXLayerOffsets).

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.

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.

PDL::Graphics::PGPLOT::Window is a OO interface to PGPLOT windows.

SYNOPSIS

perldl> use PDL::Graphics::PGPLOT::Window
perldl> $win = PDL::Graphics::PGPLOT::Window->new(Device => /xs);
perldl> $a = pdl [1..100]
perldl> $b = sqrt($a)
perldl> $win->line($b)
perldl> $win->hold()
perldl> $c = sin($a/10)*2 + 4
perldl> $win->line($c)

In the following documentation the commands are not shown in their OO versions. This is for historical reasons and should not cause too much trouble.

This package offers a OO interface to the PGPLOT plotting package. This is intended to replace the traditional interface in PDL::Graphics::PGPLOT and contains interfaces to a large number of PGPLOT routines. Below the usage examples for each function tend to be given in the non-OO version for historical reasons. This will slowly be changed, but in the meantime refer to the section on OO-interface below to see how to convert the usage information below to OO usage (it is totally trivial).

PDL::Graphics::PGPLOT::Window is an interface to the PGPLOT graphical libraries.

The list of currently availably methods:

imag - Display an image (uses pgimag()/pggray() as appropriate)
ctab - Load an image colour table
ctab_info - Get information about currently loaded colour table
line - Plot vector as connected points
points - Plot vector as points
errb - Plot error bars
cont - Display image as contour map
bin - Plot vector as histogram (e.g. bin(hist($data)) )
hi2d - Plot image as 2d histogram (not very good IMHO...)
poly - Draw a polygon
vect - Display 2 images as a vector field
text - Write text in the plot area
label_axes - Print axis titles
legend - Create a legend with different texts, linestyles etc.
cursor - Interactively read cursor positions.
circle - Draw a circle
ellipse - Draw an ellipse.

Device manipulation commands:

new - Constructor for a new PGPLOT output device
close - Close a PGPLOT output device
focus - Set focus to the given device. This should normally be
done behind the scenes.
hold - Hold current plot window range - allows overlays etc.
release - Release back to autoscaling of new plot window for each
command
held - Returns true if the graphics is held on the current device.
env - Define a plot window, put on hold
panel - Move to a specified plot panel when several panels are defined.
erase - Erase the current window (or panel)

options - Get the options set for the present output device
id - The ID for the device
device - The device type
name - The window name

Notes: $transform for image/cont etc. is used in the same way as the TR() array in the underlying PGPLOT FORTRAN routine but is, fortunately, zero-offset. The transform() routine can be used to create this piddle.

For completeness: The transformation array connect the pixel index to a world coordinate such that:

X = tr[0] + tr[1]*i + tr[2]*j
Y = tr[3] + tr[4]*i + tr[5]*j