Free gimp feature software for linux

Gimp::Feature is a Perl module that can check for specific features to be present before registering the script.

SYNOPSIS

use Gimp::Feature;
or
use Gimp::Feature qw(feature1 feature2 ...);

This module can be used to check for specific features to be present. This can be used to deny running the script when neccessary features are not present. While some features can be checked for at any time, the Gimp::Fu module offers a nicer way to check for them.

gtk

checks for the presence of the gtk interface module.

gtk-1.1, gtk-1.2

checks for the presence of gtk-1.1 (1.2) or higher.

perl-5.005

checks for perl version 5.005 or higher.

pdl

checks for the presence of a suitable version of PDL (>=1.9906).

gnome

checks for the presence of the Gnome-Perl module.

gtkxmhtl

checks for the presence of the Gtk::XmHTML module.

unix

checks wether the script runs on a unix-like operating system. At the moment, this is every system except windows, macos, os2 and vms.

persistency

checks wether the Gimp::Data module (Gimp::Data) can handle complex persistent data structures, i.e. perl references in addition to plain strings.

The following features can only be checked after Gimp-main> has been called (usually found in the form exit main). See Gimp::Fu on how to check for these.
gimp-1.1, gimp-1.2

checks for the presense of gimp in at least version 1.1 (1.2).

FUNCTIONS

present(feature)

Checks for the presense of the single feature given as the argument. Returns true if the feature is present, false otherwise.

need(feature,[function-name])

Require a specific feature. If the required feature is not present the program will exit gracefully, logging an appropriate message. You can optionally supply a function name to further specify the place where this feature was missing.

This is the function used when importing symbols from the module.

missing(feature-description,[function-name])

Indicates that a generic feature (described by the first argument) is missing. A function name can further be specified. This function will log the given message and exit gracefully.

describe(feature)

Returns a string describing the given feature in more detail, or undef if there is no description for this feature.

list()

Returns a list of features that can be checked for. This list might not be complete.

Gimp::Fu is a "easy to use" framework for Gimp scripts.

SYNOPSIS

use Gimp;
use Gimp::Fu;

(this module uses Gtk, so make sure its correctly installed)

Currently, there are only three functions in this module. This fully suffices to provide a professional interface and the ability to run this script from within the Gimp and standalone from the commandline.

In general, a Gimp::Fu script looks like this:

#!/path/to/your/perl

use Gimp;
use Gimp::Fu;

register , sub {
your code;
}

exit main;

(This distribution comes with example scripts. One is examples/example-fu.pl, which is small Gimp::Fu-script you can take as starting point for your experiments)

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.

Gimp::Data is a Perl module to set and get state data.

SYNOPSIS

use Gimp::Data;

$Gimp::Data{value1} = "Hello";
print $Gimp::Data{value1},", World!!n";

With this module, you can access plugin-specific (or global) data in Gimp, i.e. you can store and retrieve values that are stored in the main Gimp application.

An example would be to save parameter values in Gimp, so that on subsequent invocations of your plug-in, the user does not have to set all parameter values again (Gimp::Fu does this already).

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::Compat is a Perl module with compatibility functions for older versions of Gimp.

SYNOPSIS

< loaded automatically on demand >

Older versions of Gimp (version 1.0 at the time of this writing) lack some very important or useful functions.

This module is providing the most needed replacement functions. If you happen to miss a function then please create a replacement function and send it to me ;)
These functions are 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.

FUNCTIONS

gimp_text_fontname, gimp_get_extents_fontname

These are emulated in 1.0.

gimp_paintbrush

The last two arguments only available in 1.1 are simply dropped.

GIMP Animation Package is a collection of Plug-Ins to extend the GIMP with capabilities to edit and create Animations as sequences of single frames.

Please note that gimp-gap 2.2.1 requires gimp 2.2 and glib 2.8 or higher. It is recommended to use gtk+ 2.8.

Additional Installation Notes:

This GIMP-GAP release includes sourcecode tarballs of external libraries :

- ffmpeg
- libmpeg3

Those libs are built automatically. Configuration options for those libs can be set by editing the
files:

extern_libs/configure_options_ffmpeg.txt
extern_libs/configure_options_libmpeg3.txt

Those configure_option files are read by the master .configure script

Installation:

./autogen.sh # includes the ./configure call
make
make install

GIMP is an acronym for GNU Image Manipulation Program. It is a freely distributed program for such tasks as photo retouching, image composition and image authoring.

GIMP circle brushes provides circle brushes for use as "rubber stamps" in the GIMP.

GIMP circle brushes can be used with one click instead of creating outline circles by making a circle, filling with black, shrinking, and filling with white.

The following pixel sizes are provided: 6, 12, 15, 20, 24, 30, 40, 50, 60, 80, 100, 140, 200, 300, 400, 500, and 600.

Circle brushes are my third brush collection for use in the GIMP.

It was brush week for me.

Making circles is a bit of a pain with the GIMP. I know the Make a circular selection,
fill it black, shrink it, fill it white thingy -- but come on already... if I can rubber stamp a
premade circle brush where I need it instead, wouldnt that be kinda nice?

These were fairly easy, in theory. I had to add a bit of extra feathering to the above technique to get nice circles in all the sizes. Also several 45-degree rotations which smoothed out a lot of upper-end noise.

I also tried exporing from Inkscape, but the paths I converted to bitmaps did not work out as well as I had hoped and wound up sticking with the GIMP to create all
of them.

Sizes I made are:

6,12,15,20,24,30,40,50,60,80,100,140,200,300,400,500 and 600.

Use them for anything youd like. If you redistribute them, please include this file.

I post these, and perhaps make updates, at gimphelp.org. All the items will also be included (in png format) at wpclipart.com, the Public Domain clipart site.

Installation:

Stick them in the GIMP brushes folder and either "refresh brushes" or restart the GIMP. I put them in the system-wide folder, on my Slackware machine this folder is located at: /usr/share/gimp/2.0/brushes

You should also have a local brushes folder at: ~/.gimp-2.x/brushes