Skript-Fu-Einstieg: Skript
Aus GIMPForum
| << Das "Rezept" | ^ Inhaltsverzeichnis ^ | Benutzereingaben >> |
Das Skript
Da wir nun etwa wissen, was, wie, wo und wann geklickt wird, können wir mit dem Skript beginnen. Das einzige was jetzt noch anders wird als zuvor ist, dass du nun in erster Linie mit einem Editor arbeiten wirst und nicht mehr mit der Skript-Fu-Konsole.
Anmerkung: Um ein Skript zu schreiben benötigst du einen ganz gewöhnlichen Text-Editor, der auf jedem modernen Betriebssystem drauf sein sollte.
Wichtig! Speichern nicht vergessen. Das Skript speicherst du in deinem Skript-Ordner. Wo dieser ist kannst du rausfinden indem du in GIMP unter Bearbeiten/Einstellungen/Ordner/Skripte nachschaust.
In diesem Ordner speicherst du nun dein Skript mit der Endung .scm ab.
Falls du es noch nicht getan hast, starte deinen Editor!
Der Anfang eines Skript-Fu-Skripts ist nicht wirklich schwierig (es sollte dir eigentlich nichts mehr wirklich schwer fallen, wenn du die ersten vier Kapitel begriffen hast, nur etwas gewöhnungsbedürftig ist ein Teil evtl.). Zuallererst erzeugst du eine Funktion mit allen Parametern, die du später vom Benutzer einlesen willst. Wir wollen die Textfarbe, die Textgröße, die Schriftart und den Text.
(define (text-effekt sfText sfTextgroesse sfFarbe sfFont)
Anmerkung: Genau wie bei Variablen können auch den Parametern frei wählbare Namen zugewiesen werden, wobei dieselben Regeln gelten wie bei den Variablen (Groß- Kleinschreibung beachten, keine Umlaute).
Nun haben wir schon einmal die Grundlage geschaffen. Das gesamte Skript schreiben wir nämlich zwischen die schließende define-Klammer und die Parameter. Der nächste Schritt heißt Variablen deklarieren.
(let* (
Bei der Variablendeklaration sollte man sich überlegen, welche Informationen man speichern möchte.
1. Da die Bildgröße später verändert wird, wird eine Variable für die Bildgröße erstellt. Damit das Skript auch ab GIMP Version 2.6 funktionieren soll, weisen wir ihr einen beliebigen Anfangswert hinzu.
(varBreite 0) (varHoehe 0)
2. Da wir mit Farben arbeiten, kann es sicher nicht schaden die Vorder- bzw. Hintergrundfarbe als Variable zu deklarieren.
(varVGFarbe '(255 255 255)) (varHGFarbe '(0 0 0))
Wieso diese Werte? Da ich als Hintergrundfarbe sowieso schwarz will, ist es unsinnig, zuerst eine Variable mit irgendwelchen sinnlosen Werten zu deklarieren um ihr gleich daraufhin die richtigen Werte zuzuweisen.
Als Vordergrundfarbe steht da weiß, da die Farbe erst ganz am Schluss mit einer zusätzlichen Färbungsebene eingefügt wird.
3. Um die dritte Variable erklären zu können muss noch ein wenig Theorie eingebracht werden:
Jeder Ebene und jedem Bild teilt GIMP eine ID zu, sobald sie/es erstellt wird. Diese ID ist pro GIMP-Session einzigartig und wird benötigt um Bilder/Ebenen voneinander zu unterscheiden. Dies ist nun so ein Fall, indem wir eine Variable zwingend brauchen um das Skript automatisch ausführen zu können.
Hier wurde also die Variable "varBild" erstellt um die Bild-ID zu speichern.
(varBild
(car
(gimp-image-new
1
1
RGB
)
)
)
Verwirrend? Keine Sorge, Erläuterung folgt: Damit du bei der Erklärung auch draus kommst, öffnest du am besten den Prozeduren-Browser von GIMP (Toolbox/Extras/Prozeduren-Browser). (Ab GIMP 2.6 unter (Bildfenster/Hilfe/Prozeduren-Browser)). Nun tippst du mal in der Suche den Text "gimp-image-new" ein. Dies ist nun eine GIMP-eigene Funktion. Ihr Name ist eigentlich selbsterklärend; diese Funktion erstellt ein neues Bild. Im rechten Teil des Browsers siehst du eine Beschreibung der Funktion, die benötigten Parameter, den Rückgabewert und noch weitere (programmier-technisch unwichtige) Informationen. Einige der Infos bedürfen aber einer weiteren Erklärung:
width INT32 The width of the Image (1 <= width <= 262144)
width: Name des Parameters (engl. = Breite)
INT32: Dies ist nun einer dieser Datentypen, die im ersten Kapitel erklärt wurden. INT32 ist eine Ganzzahl (also keine Kommastellen). Die 32 wird wohl die physikalische Speichergrenze in Bit sein (in 32 Bit kann ein Wert zwischen 0 und 4.294.967.296 bzw. -2.147.483.647 und 2.147.483.648 gespeichert werden). Das ist allerdings nicht wirklich wichtig, da GIMP selbst eine Zahl in einem viel kleineren Wertebereich verlangt. Es ist also nicht schlimm, wenn du das jetzt nicht verstanden hast.
Rest: Der Rest ist einfach eine Beschreibung und in diesem Fall wird noch die Beschränkung angezeigt (das Bild muss breiter oder gleich 1 Pixel und weniger breit oder gleich 262.144 Pixel sein)
Bei height haben wir nochmals dasselbe in grün einfach mit der Höhe.
Beim dritten Wert, den wir benötigen sind type und INT32 wieder Name des Wertes und Datentyp. Der Unterschied hier ist allerdings, dass du anstatt einer Zahl auch RGB, GRAY oder INDEXED schreiben kannst.
Als Rückgabewert hat diese Funktion den Typ Image. Wie du der Beschreibung entnehmen kannst, wird die ID des erstellten Bildes zurückgegeben. Du kannst ruhig mal die Funktion in die Skript-Fu-Konsole eintippen (anstatt width, height und type einfach gültige Werte verwenden) und schauen was passiert. Wenn du keine Schreibfehler machst und die Klammern gesetzt hast, dann wirst du wohl irgend eine Zahl erhalten. Keine Sorge, dass du kein Bild siehst, ist ganz normal. Diese Funktion erstellt nur ein Bild, zeigt es aber noch nicht an. Falls du das nicht glaubst, kannst du auch gerne über Toolbox/Datei/Dialoge/Bilder den Bilddialog öffnen und wirst mindestens einen Eintrag mit dem Namen Unbenannt-ID sehen. (Ab GIMP 2.6 unter (Bildfenster/Fenster/Andockbare Dialoge/Bilder))
Zurück zu unserem Skript.
(varBild
(car
(gimp-image-new
1 ;width INT32, Breite
1 ;height INT32, Höhe
RGB ;type INT32, Bildmodus
)
)
)
Bei der Variablendeklaration wurde hier der Head des Rückgabewerts (bei GIMP-Funktionen immer eine Liste) mit car genommen und in die Variable gespeichert.
Formatierung: Wenn du noch nie etwas mit Programmieren am Hut hattest, wirst du dich vielleicht Fragen, was all die Einrückungen des Textes sollen.. Der Grund dafür ist, dass durch eine schöne Formatierung der Code leserlicher ist. Der Computer könnte auch einfach alles auf einer Zeile einlesen, dem ist die Darstellung mehr oder weniger egal. Eine schöne Formatierung ist nur für den Menschen gedacht. Klammerpaare untereinander haben beispielsweise den Vorteil, dass du immer sofort siehst, wo eine Klammer wieder geschlossen wird und aufgelistete Parameter bei einer Funktion dienen der Übersicht. Wie du das anstellst ist aber dir überlassen.
4. Die nächste Variable ist der Hintergrund, da im "Rezept" steht, dass wir einen Hintergrund (schwarz) benötigen.
(varHintergrund
(car
(gimp-layer-new
varBild ;image IMAGE, ID des Bildes in welchem die Ebene erstellt wird
1 ;width INT32, Breite
1 ;height INT32, Höhe
RGBA-IMAGE ;type INT32, Ebenentyp, das A steht für Alpha
"Hintergrund" ;name STRING, String ist eine (Zeichen-)Kette für z.B. Namen; Strings müssen in Gänsefüßchen angegeben werden
100 ;opacity FLOAT, Float sind Fließkommazahlen (also Zahlen mit Kommastellen sind erlaubt); wird hier für Opazität ("Undurchsichtigkeit") verwendet
NORMAL-MODE ;mode INT32, Ebenenmodus (Überlagern, Normal, etc.) auch hier kann der Ausdruck anstatt der Zahl benutzt werden
)
)
)
Diese Variable ist ähnlich wie die Variable "varBild". Bei der Funktion gimp-layer-new wird eine neue Ebene erstellt (nur erstellt, noch nicht angezeigt).
5. Zum Schluss müssen noch eine Farb- und eine Texteben erstellt werden.
(varTextlayer 0) (varFarblayer 0)
Damit wären alle Variablen deklariert und die Variablendeklaration kann geschlossen werden.
Falls du bis hierhin mitgeschrieben hast, solltest du noch überprüfen, dass auch alle Klammern korrekt geschlossen sind und da stehen wo sie hin gehören.
Hier ist mal der Code, wie er bis jetzt aussehen sollte:
(define (text-effekt sfText sfTextgroesse sfFarbe sfFont)
(let* (;---------------------------------------Variablendeklaration
(varBreite 0)
(varHoehe 0)
(varVGFarbe '(255 255 255))
(varHGFarbe '(0 0 0))
(varBild
(car
(gimp-image-new
1
1
RGB
)
)
)
(varHintergrund
(car
(gimp-layer-new
varBild
1
1
RGBA-IMAGE
"Hintergrund"
100
NORMAL-MODE
)
)
)
(varTextlayer 0)
(varFarblayer 0)
);---------------------------------------Variablendeklaration Ende
Achtung bei der Reihenfolge! Wenn du Skripts schreibst, ist es wichtig, dass du auf die Reihenfolge von Funktionen/Variablen achtest. Du kannst keine Ebene in einem Bild erstellen, wenn es noch gar kein Bild gibt. Das Bild muss also zuerst erstellt werden und erst dann die Ebene.
Und weiter geht's.
Als ersten weiteren Schritt werden die Vorder- und Hintergrundfarbe in GIMP festgelegt (bis jetzt haben wir ja nur Variablen mit den gewünschten Werten). Versuch die Prozedur ohne Hilfe zu finden. Du musst nicht den ganzen Namen einer Funktion kennen um sie zu finden. Hier willst du ja die Hintergrundfarbesetzen. Welchen Begriff musst du nun wohl eingeben um die richtige Funktion zu finden (nicht vergessen, alle Prozeduren sind englisch)?
Lösung: gimp-context-set-background
Der einzige Parameter dieser Funktion ist background COLOR. Der Typ COLOR erfordert immer eine Liste von drei Elementen (Rot Grün Blau). Da in unserem Beispiel eine Variable "varHGFarbe" deklariert und ihr auch gleich einen Wert zugewiesen (0 0 0 für schwarz) wurde, kann einfach der Namen der Variable als Parameter der Funktion angeben.
(gimp-context-set-background varHGFarbe)
Die Vordergrundfarbe wird genau gleich festgelegt.
(gimp-context-set-foreground varVGFarbe)
Als nächstes fügen wir die Hintergrundebene, die wir in der Variablendeklaration erstellt haben, dem Bild hinzu (hinzufügen im Sinne von sichtbar machen, bei der Erstellung der Ebene wird ja bereits angegeben, zu welchem Bild sie gehört). Die Funktion lautet "gimp-image-add-layer". Als Parameter werden zuerst die Bild-ID (varBild), dann die Ebene welche eingefügt werden soll (varHintergrund) und zum Schluss die Position auf dem Ebenenstapel (0) verlangt.
(gimp-image-add-layer varBild varHintergrund 0 )
Der nächste Schritt sieht auf den ersten Blick evtl. etwas komplizierter aus, ist er aber nicht.
(set! varTextlayer
(car
(gimp-text-fontname
varBild ;image IMAGE, Bild-ID
-1 ;drawable DRAWABLE, ID der betreffenden Ebene(Zeichnungsfläche); -1 erstellt eine neue
15 ;x FLOAT, horizontale Position der Ebene
15 ;y FLOAT, vertikale Position der Ebene
sfText ;text STRING, der Text, wird vom Benutzer eingegeben
0 ;border INT32, die Dicke des Rahmens
TRUE ;antialias INT32, Kantenglättung, hier gibt es nur TRUE(wahr) oder FLASE(falsch)
sfTextgroesse ;size FLOAT, Schriftgrösse (Pixel oder Points), wird bei mir auch vom Benutzer eingegeben
PIXELS ;size-type INT32, Grössentyp, PIXELS(0) oder POINTS(1)
sfFont ;fontname STRING, Schriftartenname, wird hier auch vom Benutzer bestimmt
)
)
)
Drawable: Zwischen Drawable und Layer gibt es fast keinen Unterschied(Layer = Ebene; Drawable = Zeichenfläche). Falls du mal eine Funktion für Ebenen suchst und nichts findest, kannst du auch mal nach Drawable suchen, evtl. wirst du dann fündig.
Erinnerst du dich noch an die set!-Funktion aus dem Kapitel der Variablen? Damit können wir einer Variable einen neuen Wert zuweisen. Du weisst vielleicht auch noch, dass der Variable "varTextlayer" erst ein sinnfreier Anfangswert zugewiesen wurde. Wir nehmen wieder das erste (und einzige) Element, das die Funktion "gimp-text-fontname" zurückgibt. Das ist in diesem Fall wieder eine Ebenen-ID.
Danach kommt der Gaussscher Weichzeichner.
(plug-in-gauss RUN-NONINTERACTIVE ;RUN-INTERACTIVE oder RUN-NONINTERACTIVE, RUN-INTERACTIVE öffnet das Gaussscher-Filter-Fenster varBild ;image IMAGE, Bild-ID VarTextlayer ;drawable DRAWABLE, Ebenen-ID 10 ;horizontal FLOAT, horizontaler "Verschwimmwert" 10 ;vertical FLOAT, vertikaler "Verschwimmwert" 1 ;method INT32, IIR(0) oder RLE(1), bei diesem Filter muss die Zahl angegeben werden )
Dann kommt der nächste Filter: Verpixeln.
(plug-in-pixelize2 RUN-NONINTERACTIVE ;RUN-INTERACTIVE oder RUN-NONINTERACTIVE, RUN-INTERACTIVE öffnet das Verpixeln-Filter-Fenster varBild ;image IMAGE, Bild-ID varTextlayer ;drawable DRAWABLE, Ebenen-ID 10 ;pixel-width INT32, horizontaler Verpixel-Wert )
Als nächstes wird die Höhe und die Breite der Textebene in je eine Variable gespeichert.
(set! varBreite
(car
(gimp-drawable-width varTextlayer)
)
)
und
(set! varHoehe
(car
(gimp-drawable-height varTextlayer)
)
)
Die folgenden paar Zeilen Code werden nicht mehr großartig erklärt. Wenn du verstanden hast, wie die Funktionen aufgebaut sind, wieso, dass es bei der Zuweisung einer Variable immer ein (car) hat etc. dann wirst du kein Problem haben, das zu kapieren.
Größe der Textebene verändern.
(gimp-layer-resize varTextlayer ;drawable DRAWABLE, ID der Textebene (+ varBreite 15) ;width INT32, Anstatt einem einzelnen Wert steht hier einfach eine Rechnung. (+ varHoehe 15) ;width INT32, ditto... 0 ;offx INT32, Verschiebung der Ebene auf der X-Achse (horizontal) 0 ;offy INT32, Verschiebung der Ebene auf der Y-Achse (vertikal) )
Bild auf Ebene skalieren.
(gimp-image-resize-to-layers varBild)
Aktive Ebene wählen.
(gimp-image-set-active-layer varBild ;image IMAGE, Bild-ID varTextlayer ;drawable DRAWABLE, Ebenen-ID )
Hintergrundebene (1px*1px) auf Bildgrösse strecken.
(gimp-layer-resize-to-image-size varHintergrund)
Hintergrundebene mit Hintergrundfarbe (schwarz) füllen.
(gimp-drawable-fill varHintergrund ;drawable DRAWABLE, Ebenen-ID BACKGROUND-FILL ;Füll-Art )
Vereinen der beiden Ebenen und zuweisen der neuen ID.
(set! varTextlayer
(car
(gimp-image-merge-down
varBild ;image IMAGE, Bild-ID
varTextlayer ;drawable DRAWABLE, Ebenen-ID
EXPAND-AS-NECESSARY ;merge-type INT32, Erweitern der Ebene (0), auf Bild beschneiden (1), auf untereste Ebene beschneiden (2)
)
)
)
Schärfen-Filter verwenden.
(plug-in-sharpen RUN-NONINTERACTIVE ;RUN-INTERACTIVE oder RUN-NONINTERACTIVE, RUN-INTERACTIVE öffnet das Schräfen-Filter-Fenster varBild ;image IMAGE, Bild-ID varTextlayer ;drawable DRAWABLE, Ebenen-ID 70 ;percent INT32, Wert der für den Filter benutzt wird )
Nun fehlt nur noch die Farbe. Die Färbung wird über eine neue Ebene erzeugt, welche mit der gewünschten Farbe gefüllt und auf den Ebenenmodus Überlagern gesetzt wird. Natürlich gibt es hier aber ganz unterschiedliche Methoden um das selbe Ergebnis zu erzielen.
(set! varFarblayer
(car
(gimp-layer-new
varBild ;image IMAGE, Bild-ID
1 ;width INT32, Breite des Bildes, hier unwichtig, da die Ebene später sowieso skaliert wird
1 ;height INT32, dasselbe wie oben
RGB-IMAGE ;type INT32, Ebenentyp (RGB-, GRAY-, INDEXED-IMAGE; ein A hinter dem Typ fügt einen Alphakanal hinzu)
"Farbe" ;string STRING, Name der Ebene
100 ;opacity FLOAT, Undurchsichtigkeit
OVERLAY-MODE ;mode INT32, Ebenen-Modus
)
)
)
Nun wird die Farbe, welche vom Benutzer gewählt werden kann als Vordergrundfarbe gesetzt.
(gimp-context-set-foreground sfFarbe)
Bevor die Ebene nun gefüllt wird, muss sie erst einmal ins Bild eingefügt werden.
(gimp-image-add-layer varBild ;image IMAGE, Bild-ID varFarblayer ;layer LAYER, Ebenen-ID -1 ;position INT32, Position der Ebene, -1 setzt sie zuoberst oder über die aktive Ebene (weiss ich nicht genau) )
Dann wird die Ebene auf die Bildgröße gestreckt.
(gimp-layer-resize-to-image-size varFarblayer)
Als nächstes bekommt die Ebene Farbe.
(gimp-drawable-fill varFarblayer ;drawable DRAWABLE, Ebenen-ID FOREGROUND-FILL ;fill-type INT32, Füllmethode wählen(Vorder- oder Hintergrundfarbe, Muster etc.) )
Zum Schluss werden die beiden Ebenen noch vereint...
(gimp-image-merge-down varBild ;Langsam weisst du was das bedeutet, oder? varFarblayer ;Ditto EXPAND-AS-NECESSARY )
...und dann das Bild angezeigt.
(gimp-display-new varBild)
Nicht vergessen: Ganz am Anfang wurde ein define und ein let* geöffnet, diese beiden Funktionen müssen noch geschlossen werden.
Und jetzt... kommt noch ein kleiner aber wichtiger Teil hinzu.
| << Das "Rezept" | ^ Inhaltsverzeichnis ^ | Benutzereingaben >> |
