Free image handling software for linux

Image Magazine provides a content type which acts both as a folder and as an image.
You populate it with 2 to 4 images, and optionnaly select a layout.
Options include width, background color, padding and margin, and layout mode.
ImageMag then merges the images into a layout while keeping the aspect ratios.
You can then use and call your ImageMag as a standard ploneImage, this mean you can :
.use instance/image_thumbnail, instance/image_large, and so on suffixes to call its different sizes
.call it directly from kupu to illustrate your articles (see readme.txt)
Works with:
- Plone 2.5.2
- Plone 2.5.1
- Plone 2.5

GFL::Image is an OO interface to P-e Gougelets Graphic File Library.

SYNOPSIS

use GFL::Image;

my $im = GFL::Image-> new;

$im -> load("test.png");
$im -> set( output => "jpeg",
undolevel => 5
);
$im -> resize (320, 200);
$im -> filter( maximum => 3,
mediancross => 7
);
$im -> undo;
$im -> save("test.jpg");

undef ($im);

This module provides an Object Oriented interface to Pierre-E. Gougelets Graphic File Library.

GFL provides a comprehensive set of image processing tools and can access more than 300 image formats.

GFL is free for non-commercial use, you can grab the latest version at http://www.xnview.org. People wanting to use it in a commercial application must ask authorization to the author.

Image Assistant is a Firefox extension that launches an image in an external viewer, when user selects the context menu item provided, which is titled "Open Image..." and is located under View Image right-click menu item.

This allows for zooming, printing, and other rich functionality not available in the browser.

GD::Image::AnimatedGif is a Perl extension for creating animated gifs with GD.

SYNOPSIS

use GD::Image::AnimatedGif;

# setup the image
my $image = GD::Image->new(42,21);
my $white = $image->colorAllocate(255,255,255);
$image->transparent($white);

# setup some font goodies
my $fontcolor = $image->colorAllocate(0,0,0);
my $font = GD::Font->Small();

# setup some settings into variables
my $loop = 0;
my $speed = 42; # 1/100 of a sec
my $x_font = 10; # from right (x or y ??)
my $y_font = 2; # from top (x or $y ??)

print "Content-type: image/gifnn";
print $image->animated_gif($loop,$font,$fontcolor,$speed,$x_font,$y_font,[qw(text per frame)],&optional_frame_handler);
or
print $image->animated_gif_easy(0,0,@array,&optional_frame_handler);
So you can have this be your entire script, actual animation creation is on one line:
#!/usr/bin/perl

use strict;
use warnings;
use GD::Image::AnimatedGif;

print "Content-type: image/gifnn";
print GD::Image->new(50,20)->animated_gif_easy(0,[qw(10 9 8 7 6 5 4 3 2 1 0 Liftoff!)]);

Image::Imlib2 is a Perl interface to the Imlib2 image library.

SYNOPSIS

use Image::Imlib2;

# create a new image
my $image = Image::Imlib2->new(200, 200);

# or load an image
$image = Image::Imlib2->load("foo.png");

# Enable the alpha channel support
$image->has_alpha(1);

# set a colour (rgba, so this is transparent orange)
$image->set_color(255, 127, 0, 127);

# draw a rectangle
$image->draw_rectangle(50, 50, 50, 50);

# draw a filled rectangle
$image->fill_rectangle(150, 50, 50, 50);

# draw a line
$image->draw_line(0, 0, 200, 50);

# set quality before saving
$image->set_quality(50);

# save out
$image->save(out.png);

# create a polygon
my $poly = Image::Imlib2::Polygon->new();

# add some points
$poly->add_point(0, 0);
$poly->add_point(100, 0);
$poly->add_point(100, 100);
$poly->add_point(0, 100);

# fill the polygon
$poly->fill();

# draw it closed on image
$image->draw_polygon($poly, 1);

# create a color range
my $cr = Image::Imlib2::ColorRange->new();

# add a color
my ($distance, $red, $green, $blue, $alpha) = (15, 200, 100, 50, 20);
$cr->add_color($distance, $red, $green, $blue, $alpha);

# draw it
my($x, $y, $width, $height, $angle) = (20, 30, 200, 200, 1);
$image->fill_color_range_rectangle($cr, $x, $y,
$width, $height, $angle);

Image::Imlib2 is a Perl port of Imlib2, a graphics library that does image file loading and saving as well as manipulation, arbitrary polygon support, etc. It does ALL of these operations FAST. It allows you to create colour images using a large number of graphics primitives, and output the images in a range of formats.

Image::Imlib2::Polygon and Image::Imlib2::ColorRange are described following Image::Imlib2 but may be referenced before their description.

Note that this is an early version of my attempt at a Perl interface to Imlib2. Currently, the API is just to test things out. Not everything is supported, but a great deal of functionality already exists. If you think the API can be tweaked to be a bit more intuitive, drop me a line!
Note that a development version of Imlib2 must be installed before installing this module.

Image::ParseGIF can parse a GIF image into its compenent parts.

SYNOPSIS

use Image::ParseGIF;

$gif = new Image::ParseGIF ("image.gif") or die "failed to parse: $@n";

# write out a deanimated version, showing only the first frame
$gif->deanimate(0);

# same again, manually printing each part
print $gif->header;
print $gif->part(0);
print $gif->trailer;
# or, without passing scalars around:
$gif->print_header;
$gif->print_part(0);
$gif->print_trailer;


# send an animated gif frame by frame
# - makes for a progress bar which really means something
$gif = new Image::ParseGIF ("progress.gif") or die "failed to parse: $@n";

$gif->print_header;

$gif->print_percent(0.00); # starting...
do_some_work_stage1();

$gif->print_percent(0.10); # 10% complete
do_some_work_stage2();

$gif->print_percent(0.25); # 25% complete
do_some_work_stage3();

$gif->print_percent(0.70); # 70% complete
do_some_work_stage4();

$gif->print_percent(1.00); # done!

$gif->print_trailer;

This module parses a Graphics Interchange Format (GIF) image into its component parts. A GIF is essentially made up of one or more images - multiple images typically are used for animated gifs.

Image::BMP is a bitmap parser/viewer.
SYNOPSIS
use Image::BMP;
# Example one:
my $img = new Image::BMP(
file => some.bmp,
debug => 1,
);
$img->view_ascii;
# Example two:
my $img2 = new Image::BMP;
$img2->open_file(another.bmp);
my $color = $img2->xy(100,100); # Get pixel at 100,100
my ($r,$g,$b) = $img2->xy_rgb(100,200);
Image::BMP objects can parse and even ascii view bitmaps of the .BMP format. It can read most of the common forms of this format.
It can be used to:
Just get image info, dont read the whole image:
my $img = new Image::BMP(file => some.bmp);
print "Resolution: $img->{Width} x $img->{Height}n";
View images
(See C< SYNOPSIS > example one)
Read images and poke at pixels
(See C< SYNOPSIS > example two)
Parse through all pixel data
(See C< ADD_PIXEL > below)
It does not currently write bmap data, simply because I didnt have a use for that yet. Convince me and Ill add it.
Version restrictions:
4-bit RLE compression
- I havent seen an image like this yet, it wouldnt be hard to add.
bitfields compression
- I dont even know what that is..
RLE delta compression
- This isnt tested yet - I havent seen an image that uses this portion of RLE compression, so it currently does what I think is right and then prints a message asking you to send me the image/results.

create Image is an amarok script that can create an image of the current playlist and save the files to an iso image.

The iso image is found in the respective home folders.