Free vector graphics software for linux

Comic Vector Icons package contains 100 vectorial icons developed with "cartoony" look and simple shapes that give to your project a funny feeling.

EPS Icons can be rescaled to any size while retaining their original detail, for use in Logo design, Blogs, Web, Software or Print projects.

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.

Bit::Vector is an efficient bit vector, set of integers and "big int" math library.

CLASS METHODS

Version

$version = Bit::Vector->Version();

Word_Bits
$bits = Bit::Vector->Word_Bits(); # bits in a machine word

Long_Bits
$bits = Bit::Vector->Long_Bits(); # bits in an unsigned long

new
$vector = Bit::Vector->new($bits); # bit vector constructor

@veclist = Bit::Vector->new($bits,$count);

new_Hex
$vector = Bit::Vector->new_Hex($bits,$string);

new_Bin
$vector = Bit::Vector->new_Bin($bits,$string);

new_Dec
$vector = Bit::Vector->new_Dec($bits,$string);

new_Enum
$vector = Bit::Vector->new_Enum($bits,$string);

Concat_List
$vector = Bit::Vector->Concat_List(@vectors);
OBJECT METHODS
new
$vec2 = $vec1->new($bits); # alternative call of constructor

@veclist = $vec->new($bits,$count);

Shadow
$vec2 = $vec1->Shadow(); # new vector, same size but empty

Clone
$vec2 = $vec1->Clone(); # new vector, exact duplicate

Concat
$vector = $vec1->Concat($vec2);

Concat_List
$vector = $vec1->Concat_List($vec2,$vec3,...);

Size
$bits = $vector->Size();

Resize
$vector->Resize($bits);
$vector->Resize($vector->Size()+5);
$vector->Resize($vector->Size()-5);

Copy
$vec2->Copy($vec1);

Empty
$vector->Empty();

Fill
$vector->Fill();

Flip
$vector->Flip();

Primes
$vector->Primes(); # Sieve of Erathostenes

Reverse
$vec2->Reverse($vec1);

Interval_Empty
$vector->Interval_Empty($min,$max);

Interval_Fill
$vector->Interval_Fill($min,$max);

Interval_Flip
$vector->Interval_Flip($min,$max);

Interval_Reverse
$vector->Interval_Reverse($min,$max);

Interval_Scan_inc
if (($min,$max) = $vector->Interval_Scan_inc($start))

Interval_Scan_dec
if (($min,$max) = $vector->Interval_Scan_dec($start))

Interval_Copy
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length);

Interval_Substitute
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1);

is_empty
if ($vector->is_empty())

is_full
if ($vector->is_full())

equal
if ($vec1->equal($vec2))

Lexicompare (unsigned)
if ($vec1->Lexicompare($vec2) == 0)
if ($vec1->Lexicompare($vec2) != 0)
if ($vec1->Lexicompare($vec2) < 0)
if ($vec1->Lexicompare($vec2) Lexicompare($vec2) > 0)
if ($vec1->Lexicompare($vec2) >= 0)

Compare (signed)
if ($vec1->Compare($vec2) == 0)
if ($vec1->Compare($vec2) != 0)
if ($vec1->Compare($vec2) < 0)
if ($vec1->Compare($vec2) Compare($vec2) > 0)
if ($vec1->Compare($vec2) >= 0)

to_Hex
$string = $vector->to_Hex();

from_Hex
$vector->from_Hex($string);

to_Bin
$string = $vector->to_Bin();

from_Bin
$vector->from_Bin($string);

to_Dec
$string = $vector->to_Dec();

from_Dec
$vector->from_Dec($string);

to_Enum
$string = $vector->to_Enum(); # e.g. "2,3,5-7,11,13-19"

from_Enum
$vector->from_Enum($string);

Bit_Off
$vector->Bit_Off($index);

Bit_On
$vector->Bit_On($index);

bit_flip
$bit = $vector->bit_flip($index);

bit_test
contains
$bit = $vector->bit_test($index);
$bit = $vector->contains($index);
if ($vector->bit_test($index))
if ($vector->contains($index))

Bit_Copy
$vector->Bit_Copy($index,$bit);

LSB (least significant bit)
$vector->LSB($bit);

MSB (most significant bit)
$vector->MSB($bit);

lsb (least significant bit)
$bit = $vector->lsb();

msb (most significant bit)
$bit = $vector->msb();

rotate_left
$carry = $vector->rotate_left();

rotate_right
$carry = $vector->rotate_right();

shift_left
$carry = $vector->shift_left($carry);

shift_right
$carry = $vector->shift_right($carry);

Move_Left
$vector->Move_Left($bits); # shift left "$bits" positions

Move_Right
$vector->Move_Right($bits); # shift right "$bits" positions

Insert
$vector->Insert($offset,$bits);

Delete
$vector->Delete($offset,$bits);

increment
$carry = $vector->increment();

decrement
$carry = $vector->decrement();

inc
$overflow = $vec2->inc($vec1);

dec
$overflow = $vec2->dec($vec1);

add
$carry = $vec3->add($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->add($vec1,$vec2,$carry);

subtract
$carry = $vec3->subtract($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->subtract($vec1,$vec2,$carry);

Neg
Negate
$vec2->Neg($vec1);
$vec2->Negate($vec1);

Abs
Absolute
$vec2->Abs($vec1);
$vec2->Absolute($vec1);

Sign
if ($vector->Sign() == 0)
if ($vector->Sign() != 0)
if ($vector->Sign() < 0)
if ($vector->Sign() Sign() > 0)
if ($vector->Sign() >= 0)

Multiply
$vec3->Multiply($vec1,$vec2);

Divide
$quot->Divide($vec1,$vec2,$rest);

GCD (Greatest Common Divisor)
$vecgcd->GCD($veca,$vecb);
$vecgcd->GCD($vecx,$vecy,$veca,$vecb);

Power
$vec3->Power($vec1,$vec2);

Block_Store
$vector->Block_Store($buffer);

Block_Read
$buffer = $vector->Block_Read();

Word_Size
$size = $vector->Word_Size(); # number of words in "$vector"

Word_Store
$vector->Word_Store($offset,$word);

Word_Read
$word = $vector->Word_Read($offset);

Word_List_Store
$vector->Word_List_Store(@words);

Word_List_Read
@words = $vector->Word_List_Read();

Word_Insert
$vector->Word_Insert($offset,$count);

Word_Delete
$vector->Word_Delete($offset,$count);

Chunk_Store
$vector->Chunk_Store($chunksize,$offset,$chunk);

Chunk_Read
$chunk = $vector->Chunk_Read($chunksize,$offset);

Chunk_List_Store
$vector->Chunk_List_Store($chunksize,@chunks);

Chunk_List_Read
@chunks = $vector->Chunk_List_Read($chunksize);

Index_List_Remove
$vector->Index_List_Remove(@indices);

Index_List_Store
$vector->Index_List_Store(@indices);

Index_List_Read
@indices = $vector->Index_List_Read();

Or
Union
$vec3->Or($vec1,$vec2);
$set3->Union($set1,$set2);

And
Intersection
$vec3->And($vec1,$vec2);
$set3->Intersection($set1,$set2);

AndNot
Difference
$vec3->AndNot($vec1,$vec2);
$set3->Difference($set1,$set2);

Xor
ExclusiveOr
$vec3->Xor($vec1,$vec2);
$set3->ExclusiveOr($set1,$set2);

Not
Complement
$vec2->Not($vec1);
$set2->Complement($set1);

subset
if ($set1->subset($set2)) # true if $set1 is subset of $set2

Norm
$norm = $set->Norm();
$norm = $set->Norm2();
$norm = $set->Norm3();

Min
$min = $set->Min();

Max
$max = $set->Max();

Multiplication
$matrix3->Multiplication($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Product
$matrix3->Product($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Closure
$matrix->Closure($rows,$cols);

Transpose
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1);

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::Feature is a simple feature object for use with Bio::Graphics::Panel.

SYNOPSIS

use Bio::Graphics::Feature;

# create a simple feature with no internal structure
$f = Bio::Graphics::Feature->new(-start => 1000,
-stop => 2000,
-type => transcript,
-name => alpha-1 antitrypsin,
-desc => an enzyme inhibitor,
);

# create a feature composed of multiple segments, all of type "similarity"
$f = Bio::Graphics::Feature->new(-segments => [[1000,1100],[1500,1550],[1800,2000]],
-name => ABC-3,
-type => gapped_alignment,
-subtype => similarity);

# build up a gene exon by exon
$e1 = Bio::Graphics::Feature->new(-start=>1,-stop=>100,-type=>exon);
$e2 = Bio::Graphics::Feature->new(-start=>150,-stop=>200,-type=>exon);
$e3 = Bio::Graphics::Feature->new(-start=>300,-stop=>500,-type=>exon);
$f = Bio::Graphics::Feature->new(-segments=>[$e1,$e2,$e3],-type=>gene);

This is a simple Bio::SeqFeatureI-compliant object that is compatible with Bio::Graphics::Panel. With it you can create lightweight feature objects for drawing.

SVGGraph is a Perl extension for creating SVG Graphs / Diagrams / Charts / Plots.

SYNOPSIS

use SVGGraph;

my @a = (1, 2, 3, 4);
my @b = (3, 4, 3.5, 6.33);

print "Content-type: image/svg-xmlnn";
my $SVGGraph = new SVGGraph;
print SVGGraph->CreateGraph(
{title => Financial Results Q1 2002},
[@a, @b, Staplers, red]
);

This module converts sets of arrays with coordinates into graphs, much like GNUplot would. It creates the graphs in the SVG (Scalable Vector Graphics) format. It has two styles, verticalbars and spline. It is designed to be light-weight.

If your internet browser cannot display SVG, try downloading a plugin at adobe.com.

EXAMPLES

For examples see: http://pearlshed.nl/svggraph/1.png and http://pearlshed.nl/svggraph/2.png

Long code example:

#!/usr/bin/perl -w -I.

use strict;
use SVGGraph;

### Array with x-values
my @a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
### Arrays with y-values
my @b = (-5, 2, 1, 5, 8, 8, 9, 5, 4, 10, 2, 1, 5, 8, 8, 9, 5, 4, 10, 5);
my @c = (6, -4, 2, 1, 5, 8, 8, 9, 5, 4, 10, 2, 1, 5, 8, 8, 9, 5, 4, 10);
my @d = (1, 2, 3, 4, 9, 8, 7, 6, 5, 12, 30, 23, 12, 17, 13, 23, 12, 10, 20, 11);
my @e = (3, 1, 2, -3, -4, -9, -8, -7, 6, 5, 12, 30, 23, 12, 17, 13, 23, 12, 10, 20);

### Initialise
my $SVGGraph = new SVGGraph;
### Print the elusive content-type so the browser knows what mime type to expect
print "Content-type: image/svg-xmlnn";
### Print the graph
print $SVGGraph->CreateGraph( {
graphtype => verticalbars, ### verticalbars or spline
imageheight => 300, ### The total height of the whole svg image
barwidth => 8, ### Width of the bar or dot in pixels
horiunitdistance => 20, ### This is the distance in pixels between 1 x-unit
title => Financial Results Q1 2002,
titlestyle => font-size:24;fill:#FF0000;,
xlabel => Week,
xlabelstyle => font-size:16;fill:darkblue,
ylabel => Revenue (x1000 USD),
ylabelstyle => font-size:16;fill:brown,
legendoffset => 10, 10 ### In pixels from top left corner
},
[@a, @b, Bananas, #FF0000],
[@a, @c, Apples, #006699],
[@a, @d, Strawberries, #FF9933],
[@a, @e, Melons, green]
);

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.

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.)