Alle Funktionen, die GIMP über die GUI (grafische Benutzerschnittstelle) dem Benutzer anbietet, können auch von Skripten (Makros) genutzt werden. Mit solchen Skripten kann man Vorgänge, z.B. bestimmte Effekte oder Filter, automatisieren (Script-Fu bzw. Skript-Fu). GIMP unterstützt mehrere Programmiersprachen, mit denen die GIMP-Befehle verwendet und GIMP-Skripts geschrieben werden können (Bindings). Seit Anfang an ist Scheme dabei. In dieser Sprache wird das klassische Skript-Fu geschrieben; damit wollen wir uns in diesem Tutorial beschäftigen. Es gibt aber auch die Möglichkeit, Skripts mit gimp-perl bzw. Python (Python-Fu) zu schreiben.

Scheme ist ein LISP-Dialekt. Scheme besitzt nicht viele von anderen Programmiersprachen gewohnte Features (z.B. keine Schleifen), dafür gibt es auch wenig Einschränkungen.

Jemand, der andere Programmiersprachen beherrscht, wird sich relativ schnell mit Scheme zurechtfinden, auch wenn es ein paar Eigenheiten aufweist. Aber auch für Neulinge ist es nicht so schwer zu lernen, wenn man z.B. vorhandene Skripts kopiert und nur die relevanten Stelle ändert.

GIMP besitzt auch eine Skript-Fu-Konsole (Xtns / Skript-Fu / Skript-Fu-Konsole). Diese kann dazu verwendet werden, um einzelne Befehle auszuführen, Skripts zu testen usw.

Wir starten die Skript-Fu-Konsole.

Folgenden Befehl geben wir in die Skript-Fu-Konsole ein:
(gimp-message “Hier spricht GIMP!”)
Eine Dialogbox sollte erscheinen.

Erklärung:
Jeder Befehl wird innerhalb von Klammern geschrieben. Der erste Ausdruck nach der öffnenden Klammer ist der Befehl, dann folgen die Parameter (hier nur 1 Parameter, und zwar der auszugebende Text) und dann die schließende Klammer.

Alle Befehle, die von GIMP zur Verfügung gestellt werden, können im Prozedurbrowser PDB angeschaut werden.

Wir starten mit Xtns / Prozedurbrowser den PDB. Bei “Suche:” geben wir “gimp-message” ein und erhalten rechts Informationen über diese Funktion. Es wird auch mitgeteilt, dass diese Funktion nur 1 Parameter vom Typ STRING (Zeichenfolge) hat, der in UTF-8-Kodierung angebeben werden muss.

Der Prozedurbrowser ist beim Programmieren von Skript-Fu von großer Bedeutung, da er eine vollständige Referenz von GIMP-Befehlen ist. Wenn man einen Vorgang aus einem Skript heraus ausführen will (z.B. eine Bild duplizieren), muss man im Skript-Fu danach suchen (“duplicate”), die Ergebnisse durchschauen und die passende Funktion, so man sie gefunden hat, verwenden.

Zur Syntax: Wie oben bereits erwähnt, werden Befehle von runden Klammern umgeben:
[code](Befehl Parameter1 Parameter2 …)[/code]

Das erste Wort muss nicht unbedingt ein Befehl, sondern kann auch ein Operator sein:
(+ 6 2) hat den Wert 8 (Operator +, die zwei Parameter sind 6 und 2)
(if (= var 0) (befehl1) (befehl2)) Wenn var=0, führe befehl1 aus, sonst befehl2 (Näheres zu if unten)

Alles, was in einer Zeile ab einem Strichpunkt steht, wird als Kommentar angesehen und nicht ausgeführt:
; Dies ist ein Kommentar

Man beachte den Befehl print (im Screenshot), der nicht im PDB angezeigt wird, weil er vom Scheme-Interpreter und nicht von GIMP zur Verfügung gestellt wird. Mit print kann der Inhalt von Ausdrücken in der Skript-Fu-Konsole angezeigt werden. Das ist zum Debuggen sehr nützlich.

Scheme kennt natürlich auch Variablen und Konstanten. Diese werden ohne Präfix (kein $, % usw) mit normalen Wörter bezeichnet. Die Zuweisung erfolgt mit define (Konstanten) bzw. let und set (Variablen).

Folgende Datentypen existieren:

• Prozeduren: Für die Definition von Unterprogrammen (Prozeduren) gibt es keinen eigenen Befehl, sondern sie werden wie jeder andere Datentyp behandelt. So wie einer Variable ein Wert zugewiesen wird, wird einer Prozedur der Codeblock zugewiesen, den sie beinhalten soll.
• Listen
• Ganze Zahlen (beliebig groß)
• Dezimalzahlen
• Zeichenketten (Strings)
• Boolean (wahr: #t bzw. falsch: #f)

Variablen können global mit set! gesetzt werden.
Beispiel auf der Skript-Fu-Konsole:
(set! s “GIMP! GIMP! GIMP!”)
(gimp-message s)

Für lokale Variablen, d.h. solche, die nur innerhalb eines bestimmten Codebereiches gültig sind, ist es etwas komplizierter:
[b](let [color=red]((name1 wert1) (name2 wert2))[/color] [color=blue](befehl1) (befehl2)[/color])[/b]

Der erste Parameter (rot) besteht aus beliebig vielen Zuweisungen der Form (Var.name Wert), der Codeblock (blau) besteht aus beliebig vielen Anweisungen, in denen die Variablen gültig sind. Beispiel aus der Praxis:

• [color=red](
  (fname (car f))
  (img (car (gimp-file-load 1 fname fname)))
  )[/color][color=blue]
  (gimp-image-undo-disable img)
  (gimp-image-scale img newx newy 0 0)
  (gimp-file-save 1 img (car (gimp-image-get-active-drawable img)) fname fname)
  (gimp-image-delete img)[/color]
  )[/code]

Hier wurde *let** statt let verwendet. Der Unterschied ist, dass bei *let** die Variablen in der angegebenen Reihenfolge definiert werden. Bei let könnte GIMP zuerst “img” und dann “fname” setzen, was nicht funktionieren würde.

Hier sehen wir auch, dass jeder “Wert” auch durch einen geklammerten Ausdruck ersetzt werden kann: fname wird der Wert von “(car f)” zugewiesen usw.

Konstanten und Funktionen werden mit define gesetzt:
[code](define c 300000000) ; Lichtgeschwindigkeit
(define (func)
(gimp-message “func wurde aufgerufen”)
)
(func) ; Funktion aufrufen[/code]

Listen bestehen in Scheme immer aus einem Kopf und einem Rest (nichts dazwischen). Auf den Kopf greift man mit car zu, auf den Rest mit cdr. Will man mehr als 2 Elemente auflisten, werden die Listen verschachtelt. Allerdings kann man der Einfachkeit halber mehr als 2 Listenelemente mit einem Befehl setzen:
(set! l ’(1 2 3 4 5))
Das einfache Anführungszeichen steht hier für “Liste”.

Die Liste sieht jetzt im Speicher so aus:
(1 (2 (3 (4 5))))

Mit car können wir den Listenkopf anschauen, mit cdr den Rest:
(car l) => 1
(cdr l) => (2 3 4 5)

GIMP-Funktionen liefern als Rückgabewert immer eine Liste. So können theoretisch mehrere Rückgabewerte auf einmal zurückgegeben werden; das wird aber (noch) von keiner GIMP-Funktion verwendet. Will man auf den eigentlich Rückgabewert zurückgreifen, muss man also car verwenden. Skript-Fu-Konsole
(print (car (gimp-version))) => “2.3.11”

Zum Iterieren von Listen verwendet man rekursive Funktionsaufrufe.

Eine Fallunterscheidung / if-Anweisung hat folgende Syntax:
[b](if [color=red]bedingung[/color] [color=blue]then-codeblock[/color] [color=brown]else-codeblock[/color])[/b]

Beispiel:
[b](if [color=red](> x 0)[/color]
[color=blue](print “x ist positiv”)[/color]
[color=brown](print “x ist nicht positiv”)[/color]
)[/b]

Nachdem wir jetzt die Grundlagen der Syntax beherrschen, können wir beginnen, Skripts zu schreiben. Wenn wir aber nicht immer die Skript-Fu-Konsole verwenden wollen und das Skript auch in GIMP-Menü erscheinen soll, muss eine bestimmte Vorgangsweise eingehalten werden.

Das Skript selbst wird als .scm-Datei in ~/.gimp-2.3 (bzw. -2.4) abgelegt. Hier laden wir die Datei “beispiel.scm” (rechts unter Downloads verfügbar) in das gimp-Skript-Verzeichnis.

Wenn wir das Skript dort abgelegt haben und den GIMP 2.4 (2.3) starten (oder, falls der GIMP bereits gestartet ist: Xtns / Skript-Fu / Skripte auffrischen), findet sich unter Xtns / Verschiedenes jetzt das “Beispielskript”. Hier noch einmal der Inhalt (ohne Einrückungen):

)[/color]

; Im GIMP und im Menü registrieren
[color=red](script-fu-register “script-fu-beispiel”
_"_Beispielskript"
“Illustriert den Aufbau eines GIMP-Skripts”
“Richard Hirner”
“2006, Richard Hirner”
“Sep 10, 2006”
""
SF-STRING “Erster Parameter” “Hallo!”)[/color]
[color=blue](script-fu-menu-register “script-fu-beispiel”
“/Xtns/Misc”)[/color]
[/code]

Ganz oben im Code wird die Funktion, die aufgerufen wird, wenn das Skript-Fu ausgeführt wird, definiert (braun).

Die Funktion heißt “script-fu-beispiel” und hat einen Parameter namens “parameter”. Die Funktion ruft nur gimp-message auf und zeigt somit eine Dialogbox mit dem Inhalt von “parameter” an.

In anderen Skripts gehört hier statt gimp-message der Code, der die Bildbearbeitung durchführt, eingesetzt.

script-fu-register registriert die Funktion “script-fu-beispiel” im GIMP (rot). Sie ist dann auch im PDB einsehbar (siehe Screenshot). Die Parameter:
1. Name der Funktion, die registriert wird
2. Wo im Menü die Funktion registriert werden soll (der Unterstrich signalisiert, dass der Eintrag im Menü extra gemacht wird, siehe unten)
3. Beschreibung
4. Autor
5. Copyright
6. Datum
7. Auf welche Bilder das Skript angewendet werden kann. Mögliche Werte: “*” für alle Bilder, “RGB” oder “GRAY” für RGB- bzw. Graustufenbilder (in allen 3 Fällen muss ein solches Bild offen sein, damit das Skript aufgerufen werden kann); ein leerer String "" bedeutet, dass das Skript ein neues Bild erzeugt bzw. ohne offenes Bild verwendet werden kann.
8. Liste mit Parametern des Skripts, alle in der Form:
SF-TYP “Beschreibung” “Standardwert”
SF-TYP kann dabei verschiedene Werte annehmen, siehe unten.

Im Menü wird das Skript mit der Funktion script-fu-menu-register registriert (blau).
Parameter:
1. Funktion, die registriert wird
2. Ort im Menü (hier “ / Xtns / Misc”)

Möglichkeiten für die Parameter (SF-TYP Beschreibung Standardwert):

SF-VALUE “Zahlenwert eingeben:” 5
SF-STRING “Zeichenkette eingeben:” “beliebiger Text”
SF-FONT “Schrift auswählen:” “Times”
SF-COLOR “Farbe:” ’(255 0 0)
SF-TOGGLE “Kopie erstellen?” TRUE
SF-FILENAME “Originaldatei:” “*.jpg”
SF-PATTERN “Hintergrundmuster:” “Craters”
SF-GRADIENT “Verlauf:” “CD”

SF-IMAGE “Ausgangsbild” 0
SF-DRAWABLE “Ausgangsebene”
(Gehört zusammen)

SF-ADJUSTMENT “Wert einstellen:” ’(22 2 100 1 1 0 1)
Die Liste beinhaltet:
Anfangswert, minimaler Wert, maximaler Wert, minimale Schrittweite, maximale Schrittweite, ⁰ Werte als Ganzahl oder ¹ Werte als Kommazahl, ⁰ Schieberegler oder ¹ Zählbox

Die Parameter werden in der Reihenfolge, wie sie bei script-fu-register angegeben werden, an die registrierte Funktion übergeben.

Führt man das Skript-Fu im GIMP aus, erscheint eine Dialogbox, in der man diese Parameter einstellen kann. Klickt man dann auf “OK”, wird die registrierte Funktion ausgeführt. Im Dialog erscheint dann, was das Skript gerade tut. Wenn die registrierte Funktion fertig ist, schließt sich der Dialog.

Viel Spaß beim Herumexperimentieren! Es empfiehlt sich auch, die bereits mitgelieferten Skript-Fus (im script-Verzeichnis) eingehend zu studieren.

Diese liegen unter Linux meist in [b]/usr/[color=gray]local/[/color]share/gimp/2.0/scripts/[/b], bei Windows einfach im scripts-Verzeichnis von GIMP.