Free graphical software for linux

Dirsave is graphical utility for intellectually generated senteces urls from you links (example: pic01,pic02 or pic1,pic2).

After generate with 3 clicks you execute program and wget download this files.

Its no hard type:

http://nameserver/folder/pic1.jpg
http://nameserver/folder/pic2.jpg

or

http://nameserver/folder/docum01.xml
http://nameserver/folder/docum02.xml

Its yesterday day!

Dirsave program automatically generate links (and choise 1,2,3 or 01,02,03 or 001,002,003 numeration)!

Its easy and quick!

Linux graphical bootsplash allows you to use custom graphics during early system startup. It makes it possible to place a nice graphic behind or above the kernel boot messages.
Linux graphical bootsplash hooks into the fbcon layer and, if activated, searches the initial ramdisk for a JPEG picture to show.
On any output operations to the console, it takes care of painting a margin around your text and a background picture behind the text with a set of special cfb functions.
Main features:
- Nice graphics (JPEG)
- Antialiased text rendering (TrueType)
- Animations (MNG)
- Progress Bar
- Display of boot messages above or below a graphic. ("verbose" and "silent" modes)
- Fully themeable
Enhancements:
- The bootsplash patch was updated to apply cleanly against Linux kernel 2.6.21.

fid-graphics project is a simple toolkit for the Frigand Imperial Desktop.
It is probably the easiest toolkit to write a display engine for, but it does not support any widgets.
Enhancements:
- src/Desktop/Fid/Window.lhs (displayWaitRedisplay): New function.
- (requestRedisplay): Tidy up.
- src/Desktop/Fid/Main.lhs (data WinCapLine): New type.
- (data WindowType): Use it.
- (&&*, ||*, isnt, haveEnvVar, haveOpt): Deleted.
- (lookupFeature, lookupProtocol, lookupKeywords): New functions.
- (windowTypes): Use WindowCapLine.
- (forkProcess): Unused; deleted.
- (data FidOpt): Unused; deleted.
- (fidMain): Dont consider forking.
- Only call getOpt to sort out verbose options.
- src/Desktop/Fid/Control.lhs (PrimKey): New type.
- (instance Eq PrimKey, instance Ord PrimKey)
- (instance Show PrimKey, instance Arbitrary PrimKey): Instances for t.
- (data Key): Use it.
- (charKey, control, keyToChar): Do the right thing with PrimKey.
- (symbolKey): New function.
- (instance Arbitrary Key): Use instance Arbitrary PrimKey.
- (instance Arbitrary Char): New Instance.

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

Graphics::ColorUtils Perl module is an easy-to-use color space conversions and more.

SYNOPSIS

use Graphics::ColorUtils;

( $y, $i, $q ) = rgb2yiq( $r, $g, $b );
( $r, $g, $b ) = yiq2rgb( $y, $i, $q );
$hex_string = yiq2rgb( $y, $i, $q );

( $c, $m, $y ) = rgb2cmy( $r, $g, $b );
( $r, $g, $b ) = cmy2rgb( $c, $m, $y );
$hex_string = cmy2rgb( $c, $m, $y );

( $h, $l, $s ) = rgb2hls( $r, $g, $b );
( $r, $g, $b ) = hls2rgb( $h, $l, $s );
$hex_string = hls2rgb( $h, $l, $s );

( $h, $s, $v ) = rgb2hsv( $r, $g, $b );
( $r, $g, $b ) = hsv2rgb( $h, $s, $v );
$hex_string = hsv2rgb( $h, $s, $v );

# -----

use Graphics::ColorUtils qw( :gradients );

( $r, $g, $b ) = grad2rgb( $name, $f ); # where 0.0 colorAllocate( hsv2rgb( 270, 0.5, 0.3 ) );.)

Features:

Color Space Conversions
Color space conversions, in particular between the "intuitive" color spaces HSV (Hue/Saturation/Value) and HLS (Hue/Lightness/Saturation) to and from RGB (Red/Green/Blue).
Color Lookup
Color lookup by name for three standard sets of colors: WWW/CSS, SVG, and X11.
Color Gradients
Management of color gradients, which can be indexed by a floating point number in the range 0..1. (Mostly intended for false-color data visualization.)

PDL::Graphics::X is a PDL OO access to X windows.

SYNOPSIS

# example 1

use PDL;
use PDL::Graphics::X;

my $x_size = 255; my $y_size = 255;
my $win1 = PDL::Graphics::X->new({SIZE_X => $x_size, SIZE_Y => $y_size});
my $a = xvals(zeroes(byte,$x_size,$y_size));
$win1->imag($a);

# example 2

use PDL;
use PDL::Graphics::X;

my $win1 = PDL::Graphics::X->new({WIN_TITLE => "PDL", SIZE_X => 210, SIZE_Y => 210});
my $x = pdl(10, 100, 100, 10);
my $y = pdl(10, 10, 100, 100);
$win1->line($x, $y, {COLOR => [1,0,0], LINEWIDTH => 5});

This module interfaces PDL directly to X windows in a OO fashion. Each X object has an associated X window and handles opening, closing and drawing in the associated window. Hopefully it is reasonably intuitive to use. The vision is that this will serve as a base upon which other fully native PDL graphics modules could be built.

Common options such as LINEWIDTH are remembered from function call to function call, i.e. if you call $win1->line($x, $y, {COLOR => [1,0,0], LINEWIDTH => 5}) then the rectangle drawn by $win1->rect(10, 10, 190, 190) will also have a red border of width equal to 5.

FUNCTIONS

new

Constructor for a new X window object.

Usage: my $win1 = PDL::Graphics::X->new(); # open the window with the defaults
Usage: my $win1 = PDL::Graphics::X->new({WIN_TITLE => "PDL", SIZE_X => 210, SIZE_Y => 210});

Creates a new X object & its associated X window.

Options recognized :

SIZE_X - window x size in pixels (default = 400)
SIZE_Y - window y size in pixels (default = 300)
WIN_TITLE - A title for the window, if desired (default = "X")
BACK_COLOR - [r, g, b] the windows background color (default = [1.0, 1.0, 1.0], i.e. white)
imag

Display a PDL as a bitmap.

Usage: $win1->imag($my_img); # display an image with default size and scaling
Usage: $win1->imag($my_img, {AUTO_SCALE => 1.0}); # display an auto-scaled image

Displays a PDL as a bitmap. The PDL can be of size either (m,n) or (m,n,3). PDLs of size (m,n) are converted to indexed color based on the current color table (see ctab). PDLs of size (m,n,3) are displayed as true-color images with the last dimension specifying the color (RGB). Unless a re-scaling is specified, the minimum value displayed is 0.0 and the maximum is 255.0. If the PDL is larger then the window then the window will be re-scaled to accomodate the PDL;

Options recognized :

DEST_X - position of the left side of the bitmap in pixels (default = 0)
DEST_Y - position of the bottom of the bitmap in pixels (default = 0)
DEST_W - width of the bitmap to be displayed (default = width of the PDL)
DEST_H - height of the bitmap to be displayed (default = height of the PDL)
AUTO_SCALE - if set equal to 1, the PDL will be rescaled such that its
minimum value is 1 and its max is 255 (default = 0)
MIN - the minimum value to be displayed (default = 0.0)
MAX - the maximum value to be displayed (default = 255.0)
ctab

Set the color table

Usage: $win1->ctab(cat(lut_data(idl5))); # set the color table to idl5

Makes a local copy of a user supplied color table. The color table must be a 256 x 4 pdl of the form (l,r,g,b), as would be generated by the command $ct = cat(lut_data("xyz")). The l value is ignored. The r, g and b values should be in the range 0.0 - 1.0.

line

Draws a vector as connected points.

Usage: $win1->line($x, $y, {COLOR => [0,0,0], LINEWIDTH => 5}); # draw black line of width 5

Draw a poly-line between a set of points given by two PDLs of size (n). The first PDL gives the x position & the second piddle gives the y position of the individual points, n is the total number of points.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
rect

Draws a rectangle.

Usage: $win1->rect($x1, $y1, $x2, $y2);

Draws a rectangle with corners at ($x1, $y1) and ($x2, $y2).

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
circle

Draws a circle.

Usage: $win1->circle($x, $y, $r);

Draws a circle centered at ($x, $y) with radius $r.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
ellipse

Draws an oval.

Usage: $win1->ellipse($x, $y, $a, $b);

Draws a oval centered at ($x, $y) with x size $a and y size $b.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
erase

Erases the contents of the window.

Usage: $win1->erase();

Resets the contents of the window to the background color.

text

Draw text

Usage: $win1->text("hello", $x, $y, $angle);

Draws text starting at $x and $y with baseline angle given by $angle. If you know how to draw truly rotated text in X, please let me know. How fonts are currently dealt with is imperfect at best. So that the font size can easily be changed, a search is performed for a scalable font with specified font name. If such a font cannot be found then the text will be displayed with the default X font and no font scaling.

Options recognized

FONT_NAME - name of the font family (default = "courier")
CHARSIZE - desired font size in points
COLOR - [r, g, b] color of the font

cursor

Returns the location of next mouse click in the window

Usage : my($x,$y) = $win1->cursor();

Returns the x & y locations of the next mouse click in the window.

we_exist

Returns 0 if the window still exists, 1 if it does not

Usage : my $exists = $win1->we_exist();

Originally written to help debug some problems with associated with X windows being closed by the user with a mouse. Preserved on the off chance that it will be useful to a dependent module.

winsize

Returns the window size & maximum window size (in pixels) in x and y

Usage : my ($win_x, $win_y, $max_x, $max_y) = $win1->winsize();

Primarily intended for use by dependent modules that might want to know what the current and maximum window size is.

resize

resizes a window & returns the new size (which might not be what you requested)

Usage : my ($new_x, $new_y) = $win1->resize($size_x, $size_y);

Primarily intended for use by dependent modules that might want to resize a window without destroying it and creating another one.

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.

Gd is a graphics library. It allows your code to quickly draw images complete with lines, arcs, text, multiple colors, cut and paste from other images, and flood fills, and write out the result as a PNG or JPEG file. This is particularly useful in World Wide Web applications, where PNG and JPEG are two of the formats accepted for inline images by most browsers.

In gd 1.0, it stood for "gif draw." After the Unisys patent on the LZW compression used in GIF came to light and GIF support was dropped, it did not officially stand for anything, but lets just say "graphics draw" and leave it at that. (GIF support is back, thanks to the expiration of the patent, but gd can draw much more than GIFs.)

This is a quick install guide:

1. Type ./configure
2. Type make install