Free gimp software for linux

GIMP# is an API wrapper around GIMP, written in C#. However, its not just a wrapper. GIMP# project also adds a thin layer which adds C# specific features, like iterating through a collection. An example of this is an iteration through the guides of an image. In C# this looks like:

foreach (Guide guide in image.Guides)
{
// Do something
}

In C this would have been:

gint32 guide_ID = 0:
while ((guide_ID = gimp_image_find_next_guide(image_ID, guide_ID)) != 0)
{
// Do something
}

GIMP# also offers a base plug-in class which does the difficult stuff for you. Implementing a new plug-in is just a matter of overriding a few virtual methods. See the samples directory for examples of how to do this.

Gimp# fills the niche between scripting languages (easy to write, slow) and C (harder to write, fast). If you need a quick and dirty plug-in where speed doesnt matter that much, write it in any of the scripting languages that come with GIMP (Scheme, Perl, etc.). Scripting languages are very well fitted for calling existing functionality, shortening manual tasks.

You probably dont want pixel manipulation in Scheme. In C, on the other hand, it takes a lot more time to create a plug-in for several reasons: building the GUI is time consuming. Secondly, pixel handling is not completely trivial. You have to know how to traverse through the tiles of an image, etc. Typically the actual algorithm is only a very small (5 - 20 %) part of the total code. Gimp# is not as fast as C, but much faster than a scripting language. Building a decent GUI is much easier than in C.

JGimp is a framework to write 100% Java-based plug-ins and extensions for the GIMP and Film GIMP.
Main features:
- lug-ins for the GIMP can be written in Java and use Javas existing set of widgets for the plug-ins user interface. One of the included sample plug-ins (see figure to the right) displays a plug-in dialog box using Swing widgets, complete with a real-time preview
- Java applications can use the GIMP as an image manipulation "engine," essentially embedding the GIMPs capabilities in the Java application. Possible uses of this capability include:
- Creating new graphics applications in Java using the GIMP to perform the underlying image manipulation
- Server-client architectures where JGimp is used to wrap a server around the GIMPs capabilities. Client applications, such as applets or web-based applications can access the server across the network
Two sample plug-ins illustrate how to use this architecture to write plug-ins, ImageDividerPlugIn and DesaturatePlugIn. These plug-ins demonstrate all the aspects necessary to write a Java-based plug-in: how it is installed in the GIMP, how to make PDB calls, and how to read and write pixels from images in the GIMP.

Gimp::Lib is an interface to libgimp (as opposed to Gimp::Net).

SYNOPSIS

use Gimp; # internal use only

This is the package that interfaces to The Gimp via the libgimp interface, i.e. the normal interface to use with the Gimp. You dont normally use this module directly, look at the documentation for the package "Gimp".

gimphp is a PHP Class library to write Gimp scripts directly in PHP.

To realize the Cultural Association Milug cards it was created a web-application that is based on PHP to use Gimp as a graphic engine. It work with gimuse server to produce cards.

Gimp::PDL is a Perl module to overwrite Tile/Region functions to work with piddles. This module is obsolete, please remove any references to it.

SYNOPSIS
use Gimp;
use Gimp::PDL;
use PDL;

This module overwrites some methods of Gimp::Tile and Gimp::PixelRgn. The new functions return and accept piddles. The last argument (height) of gimp_pixel_rgn_set_rect is calculated from the piddle. There is no other way to access the raw pixeldata in Gimp.

Some exmaples:

$region = $drawable->get->pixel_rgn (0,0, 100,100, 1,0);
$pixel = $region->get_pixel (5,7); # fetches the pixel from (5|7)
print $pixel; # outputs something like
# [255, 127, 0], i.e. in
# RGB format ;)
$region->set_pixel ($pixel * 0.5, 5, 7);# darken the pixel
$rect = $region->get_rect (3,3,70,20); # get a horizontal stripe
$rect = $rect->hclip(255/5)*5; # clip and multiply by 5
$region->set_rect($rect); # and draw it!
undef $region; # and update it!

Gimp::Net is a communication module for the gimp-perl server.

For Gimp::Net (and thus commandline and remote scripts) to work, you first have to install the "Perl-Server" extension somewhere where Gimp can find it (e.g in your .gimp/plug-ins/ directory). Usually this is done automatically while installing the Gimp extension. If you have a menu entry < Xtns/Perl-Server > then it is probably installed.

The Perl-Server can either be started from the < Xtns > menu in Gimp, or automatically when a perl script cant find a running Perl-Server.

When started from within The Gimp, the Perl-Server will create a unix domain socket to which local clients can connect. If an authorization password is given to the Perl-Server (by defining the environment variable GIMP_HOST before starting The Gimp), it will also listen on a tcp port (default 10009).

Since the password is transmitted in cleartext, using the Perl-Server over tcp effectively lowers the security of your network to the level of telnet. Even worse: the current Gimp::Net-protocol can be used for denial of service attacks, i.e. crashing the Perl-Server. There also *might* be buffer-overflows (although I do care a lot for these).

Gimp::Util is a Perl module to some handy routines for Gimp-Perl users.

SYNOPSIS

use Gimp;
use Gimp::Util;

Gimp-Perl is nice, but when you have to write everytime 10 lines just to get some simple functions done, it very quickly becomes tedious :-/

This module tries to define some functions that aim to automate frequently used tasks, i.e. its a sort of catch-all-bag for (possibly) useful macro functions. If you want to add a function just mail the author of the Gimp-Perl extension (see below).

In Gimp-Perl (but not in Gimp as seen by the enduser) it is possible to have layers that are NOT attached to an image. This is, IMHO a bad idea, you end up with them and the user cannot see them or delete them. So we always attach our created layers to an image here, too avoid memory leaks and debugging times.

These functions try to preserve the current settings like colors, but not all do.

These functions can also be handled in exactly the same way as PDB-Functions, i.e. the (hypothetical) function gimp_image_xyzzy can be called as $image->xyzzy, if the module is available.

The need to explicitly use Gimp::Util will go away in the future.

FUNCTIONS

get_state (), set_state state

get_state returns a scalar representing most of gimps global state (at the moment foreground colour, background colour, active gradient, pattern and brush). The state can later be restored by a call to set_state. This is ideal for library functions such as the ones used here, at least when it includes more state in the future.

layer_create image,name,color,pos

create a colored layer, insert into image and return layer

text_draw image,layer,text,font,size,fgcolor

Create a colored text, draw over a background, add to img, ret img.

image_create_text text,font,size,fgcolor,bgcolor

Create an image, add colored text layer on a background layer, return img.

layer_add_layer_as_mask image,layer,layermask

Take a layer and add it as a mask to another layer, return mask.

gimp_text_wh $text,$fontname

returns the width and height of the "$text" of the given font (XLFD format)

gimp_image_layertype $alpha

returns the corresponding layer type for an image, alpha controls wether the layer type is with alpha or not. Example: imagetype: RGB -> RGB_IMAGE (or RGBA_IMAGE).

gimp_layer2imagetype $layertype

returns the corresponding layer type for an image, alpha controls wether the layer type is with alpha or not. Example: imagetype: RGB -> RGB_IMAGE (or RGBA_IMAGE).

gimp_image_add_new_layer $image,$index,$fill_type,$alpha

creates a new layer and adds it at position $index (default 0) to the image, after filling it with gimp_drawable_fill $fill_type (default BG_IMAGE_FILL). If $alpha is non-zero (default 1), the new layer has alpha.

gimp_image_set_visible $image,@layers, gimp_image_set_invisible $image,@layers

mark the given layers visible (invisible) and all others invisible (visible).

gimp_layer_get_position $layer

return the position the layer has in the image layer stack.

gimp_layer_set_position $layer,$new_index

moves the layer to a new position in the layer stack.

Gimp::Config is a Perl module with config options found during configure time.

The Gimp::Config module creates a tied hash %Gimp::Config which contains all the definitions the configure script and perl deduced from the system configuration at configure time. You can access these values just like you access any other values, i.e. $Gimp::Config{KEY}. Some important keys are:

IN_GIMP => true when gimp-perl was part of the Gimp distribution.
GIMP => the path of the gimp executable
prefix => the installation prefix
libdir => the gimp systemwide libdir
bindir => paths where gimp binaries are installed
gimpplugindir => the gimp plug-in directory (without the /plug-ins-suffix)