Ve druhé části článku o tvorbě pluginů určených pro grafický editor GIMP si nejdříve ukážeme, jakým způsobem se vytvoří a zaregistruje jednoduchý plugin naprogramovaný v Pythonu a následně budeme tento plugin postupně rozšiřovat o interaktivní dialogy pro výběr barvy, rozměrů obrázku apod. Na závěr si pro porovnání ukážeme dva pluginy naprogramované pro změnu v jazyce Scheme.
Obsah
1. Tvorba pluginů pro grafický editor GIMP (2.část)
2. Vytvoření skutečného pluginu pro GIMP
3. První demonstrační příklad: kostra pluginu naprogramovaného v Pythonu
4. Uložení pluginu do správného adresáře a nastavení příznaku execute
6. Druhý demonstrační příklad: úprava pluginu pro vykreslení pozadí zadanou barvou
7. Nastavení velikosti obrázku
8. Třetí demonstrační příklad: úprava pluginu tak, aby bylo možné zadat velikost obrázku
9. Čtvrtý demonstrační příklad: zobrazení základních ovládacích prvků
10. Pátý demonstrační příklad: zobrazení složitějších ovládacích prvků
11. Šestý demonstrační příklad: nový obrázek s RGB paletou (skript naprogramovaný ve Scheme)
12. Sedmý demonstrační příklad: vykreslení Lissajousových obrazců
13. Repositář s demonstračními příklady
1. Tvorba pluginů pro grafický editor GIMP (2.část)
V první části seriálu o vytváření pluginů (přídavných modulů) pro známý grafický editor GIMP jsme si řekli, že pluginy je možné programovat buď v jazyce Scheme (tato technologie se nazývá Script-fu) nebo v populárním programovacím jazyce Python (Python-fu). Taktéž jsme se seznámili s interaktivními konzolemi, do nichž lze zapisovat jednotlivé příkazy, které jsou ihned prováděny (konzole pro Scheme se chová poněkud odlišně, než konzole pro Python). Dnes si ukážeme skutečné pluginy, které budou volány z menu GIMPu a které budou v případě potřeby doplněny o dialog, v němž bude možné nastavit jednotlivé parametry pluginů.
Obrázek 1: Prozatím prázdná interaktivní konzole Pythonu po spuštění.
2. Vytvoření skutečného pluginu pro GIMP
Vytvoření skutečného pluginu se v několika ohledech odlišuje od pouhého zapisování skriptu do interaktivní konzole. Plugin je totiž nutné zaregistrovat takovým způsobem, aby GIMP věděl, ve kterém menu bude umístěna položka sloužící pro jeho spuštění. Taktéž je nutné specifikovat i další metadata o pluginu: jeho jméno, autora, licenci, datum vytvoření apod. Kromě toho nesmíme zapomenout na další důležitou věc – mnohé pluginy vyžadují zadání parametrů, což je samozřejmě podporováno, jak se ostatně budeme moci přesvědčit v dalších demonstračních příkladech. A nakonec – pokud je plugin naprogramován v Pythonu, je nutné zajistit, aby byl plugin spustitelný (viz následující kapitoly) a aby se na konci skriptu volala funkce main() (pluginy psané v jazyku Scheme se v tomto ohledu odlišují).
Obrázek 2: Procházení API GIMPu.
3. První demonstrační příklad: kostra pluginu naprogramovaného v Pythonu
Ukažme si, jak může vypadat kostra pluginu naprogramovaného v Pythonu. Celý plugin je rozdělen na čtyři části.
První část je jednoduchá – jedná se o importy. Důležité je importovat především knihovnu nazvanou gimpfu, která zpřístupní objekt gimp, ale i další objekty, například v předchozí části popsanou interní databázi objektů pdb:
from gimpfu import *
Dále plugin obsahuje minimálně jednu funkci, která je zavolána buď přímo po spuštění pluginu uživatelem (pokud se nezadávají parametry) nebo až ve chvíli, kdy uživatel v grafickém dialogu vyplní všechny parametry a klikne na tlačítko OK. Tato funkce může mít libovolné jméno, které ovšem musí korespondovat se jménem uvedeným v dalším bloku:
# funkce zavolana po spusteni pluginu uzivatelem
def create_new_image():
pass
Část třetí je velmi důležitá, neboť obsahuje jak metadata pluginu, tak i případnou specifikaci jeho parametrů (jejich typ, popis, mezní hodnoty apod.). Metadata se předávají v rámci registrace pluginu funkcí nazvanou jednoduše register(). Tato funkce očekává minimálně jedenáct parametrů plus případné další pojmenované parametry. Postupně se jedná o tyto parametry:
- Unikátní jméno pluginu
- Krátký popisek
- Dlouhý popisek (může se lišit od popisku krátkého)
- Autor
- Licence či další informace o autorovi
- Typicky datum vydání pluginu
- Popisek v menu (tento text uvidí uživatel)
- Specifikace, pro jaké typy obrázků je plugin určen popř. zda plugin funguje i když obrázek neexistuje ("" – žádný obrázek, "*" – všechny typy, "RGB" – jen RGB atd.)
- Seznam vstupních parametrů zadávaných uživatelem
- Seznam výstupních parametrů (typicky prázdné!)
- Funkce, která se má zavolat
- Další nepovinné pojmenované parametry, nejdůležitější je menu
Prakticky celá registrace pluginu vypadá následovně:
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image",
"Vytvor novy obrazek",
"Vytvor novy obrazek",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek",
"", # plugin se spusti jen pokud neexistuje obrazek
[], # zadne parametry
[],
create_new_image,
menu="<Image>/Filters/Test/")
Na poslední část nesmíme zapomenout – v Pythonu je nutné spustit funkci main():
main()
4. Uložení pluginu do správného adresáře a nastavení příznaku execute
Celý zdrojový kód našeho prvního skutečného pluginu vypadá následovně. Popis jednotlivých volaných funkcí je zřejmý z komentářů vložených do kódu:
#!/usr/bin/env python
from gimpfu import *
# funkce zavolana po spusteni pluginu uzivatelem
def create_new_image():
# vytvoreni noveho obrazku
image = gimp.Image(256, 256, RGB);
# vytvoreni nove hladiny
layer = gimp.Layer(image, "Hladina", 256, 256, RGB_IMAGE, 100, NORMAL_MODE)
layer.fill(BACKGROUND_FILL)
# pridani hladiny do zasobniku hladin v obrazku
image.add_layer(layer, 0)
# zobrazeni
gimp.Display(image)
# zajisteni, ze se okno s obrazkem skutecne prekresli
gimp.displays_flush()
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image",
"Vytvor novy obrazek",
"Vytvor novy obrazek",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek",
"", # plugin se spusti jen pokud neexistuje obrazek
[], # zadne parametry
[],
create_new_image,
menu="<Image>/Filters/Test/")
main()
Zdrojový kód pluginu, který jsme si připravili v rámci předchozího textu, je nutné nainstalovat. Ve skutečnosti se celá „instalace“ skládá z pouhých dvou kroků:
- Kopie zdrojového kódu pluginu do adresáře ~/.gimp-2.x/plug-ins, kde n je číslo verze GIMPu. Pro jistotu si zkontrolujte, zda se tento adresář skutečně používá – k tomu slouží konfigurační dialog zobrazený na screenshotu níže.
- Nastavení příznaku spouštění (+x). Na tento krok se i v tutoriálech často zapomíná, možná kvůli tomu, že autoři návodů používají operační systém Microsoft Windows. Ovšem pokud nebude skript s pluginem spustitelný, bude ho GIMP ignorovat! Proto je zapotřebí povolit jeho spuštění aktivním uživatelem, a to konkrétně příkazem chmod u+x cesta/jméno_skriptu.py, konkrétně chmod u+x ~/.gimp-2.8/plug-ins/new_image.py
Obrázek 3: Zobrazení adresářů, v nichž se hledají pluginy, ať již pluginy nativní (překládané) či pluginy naprogramované v Pythonu.
Po provedení těchto dvou kroků by se po restartu GIMPu měl plugin automaticky zaregistrovat a položka pro jeho spuštění Vytvor novy obrazek by se měla objevit v menu Filters → Test.
Obrázek 4: Výsledek spuštění prvního demonstračního příkladu.
5. Dialog pro výběr barvy
V prvním demonstračním příkladu jsme si neukázali všechny možnosti, které grafický editor GIMP tvůrcům pluginů nabízí. Týká se to především možnosti specifikovat parametry pluginu při jeho spuštění, přičemž se pro nastavování parametrů používá interaktivní dialog s mnoha typy ovládacích prvků. Z tohoto důvodu si dnešní druhý demonstrační příklad nepatrně upravíme a nabídneme uživatelům pluginu, aby si sami zvolili barvu pozadí obrázku. Použijeme přitom ovládací prvek pro výběr barvy, který po výběru zobrazí systémový dialog, na němž lze barvu specifikovat mnoha různými způsoby – výběrem z předpřipravené palety, smícháním barvových složek atd. Skript tedy bude upraven na dvou místech.
Nejdříve změníme vlastní funkci starající se o vytvoření nového obrázku, vložení hladiny do obrázku a vyplnění této hladiny specifikovanou barvou. Povšimněte si nového parametru color a způsobu jeho použití:
# funkce zavolana po spusteni pluginu uzivatelem
def create_new_image_background(<strong>color</strong>):
# vytvoreni noveho obrazku
image = gimp.Image(256, 256, RGB);
# vytvoreni nove hladiny
layer = gimp.Layer(image, "Hladina", 256, 256, RGB_IMAGE, 100, NORMAL_MODE)
# nastaveni barvy vykreslovani pozadi (druha barva ve vyberu)
<strong>gimp.set_background(color)</strong>
layer.fill(BACKGROUND_FILL)
# pridani hladiny do zasobniku hladin v obrazku
image.add_layer(layer, 0)
# zobrazeni
gimp.Display(image)
# zajisteni, ze se okno s obrazkem skutecne prekresli
gimp.displays_flush()
Druhá úprava se týká způsobu registrace pluginu, protože je nutné specifikovat, jaké parametry může uživatel změnit. Řekli jsme si, že uživateli nabídneme možnost výběru barvy a (prozatím) žádné další možnosti, takže seznam parametrů bude obsahovat jedinou položku s předvybranou barvou:
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image_background",
"Vytvor novy obrazek s barevnym pozadim",
"Vytvor novy obrazek s barevnym pozadim",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek s barevnym pozadim",
"", # plugin se spusti jen pokud neexistuje obrazek
[
(PF_COLOR, "color", "Barva pozadi obrazku", (0.5, 0.5, 0.5))
],
[],
create_new_image_background,
menu="<Image>/Filters/Test/")
Výsledek bude z hlediska uživatele vypadat takto:
Obrázek 5: Dialog zobrazený při spuštění pluginu.
Obrázek 6: Výběr barvy.
Obrázek 7: Nový obrázek s vyplněným pozadím na základě vybrané barvy.
6. Druhý demonstrační příklad: úprava pluginu pro vykreslení pozadí zadanou barvou
Úplný programový kód dnešního druhého demonstračního příkladu vypadá následovně:
#!/usr/bin/env python
from gimpfu import *
# funkce zavolana po spusteni pluginu uzivatelem
def create_new_image_background(color):
# vytvoreni noveho obrazku
image = gimp.Image(256, 256, RGB);
# vytvoreni nove hladiny
layer = gimp.Layer(image, "Hladina", 256, 256, RGB_IMAGE, 100, NORMAL_MODE)
# nastaveni barvy vykreslovani pozadi (druha barva ve vyberu)
gimp.set_background(color)
layer.fill(BACKGROUND_FILL)
# pridani hladiny do zasobniku hladin v obrazku
image.add_layer(layer, 0)
# zobrazeni
gimp.Display(image)
# zajisteni, ze se okno s obrazkem skutecne prekresli
gimp.displays_flush()
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image_background",
"Vytvor novy obrazek s barevnym pozadim",
"Vytvor novy obrazek s barevnym pozadim",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek s barevnym pozadim",
"", # plugin se spusti jen pokud neexistuje obrazek
[
(PF_COLOR, "color", "Barva pozadi obrazku", (0.5, 0.5, 0.5))
],
[],
create_new_image_background,
menu="<Image>/Filters/Test/")
main()
Obrázek 8: Výběr barvy.
Obrázek 9: Nový obrázek s vyplněným pozadím na základě vybrané barvy.
7. Nastavení velikosti obrázku
Zkusme si příklad rozšířit ještě o možnost specifikace velikosti obrázku, tj. počtu pixelů na horizontální a vertikální ose. V tomto případě použijeme ovládací prvek typu PF_SPINNER, kterému se zadá výchozí hodnota a v n-tici i minimální hodnota, hodnota maximální a přírůstek při použití šipek na spinneru (důsledek – ve skriptu už není nutné kontrolovat, jaké údaje uživatel zadal). Registrace pluginu a jeho metadata mohou vypadat následovně:
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image_background_and_size",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"", # plugin se spusti jen pokud neexistuje obrazek
[
(PF_COLOR, "color", "Barva pozadi obrazku", (0.5, 0.5, 0.5)),
(PF_SPINNER, "xsize", "Sirka", 100, (1, 1000, 10)),
(PF_SPINNER, "ysize", "Vyska", 100, (1, 1000, 10)),
],
[],
create_new_image_background_and_size,
menu="<Image>/Filters/Test/")
Vlastní skript se změní jen minimální – funkci předáme o dva parametry více, které interně použijeme (musíme je převést na celé číslo):
def create_new_image_background_and_size(color, xsize, ysize):
# vytvoreni noveho obrazku
image = gimp.Image(int(xsize), int(ysize), RGB);
# vytvoreni nove hladiny
layer = gimp.Layer(image, "Hladina", int(xsize), int(ysize), RGB_IMAGE, 100, NORMAL_MODE)
# nastaveni barvy vykreslovani pozadi (druha barva ve vyberu)
gimp.set_background(color)
layer.fill(BACKGROUND_FILL)
# pridani hladiny do zasobniku hladin v obrazku
image.add_layer(layer, 0)
# zobrazeni
gimp.Display(image)
# zajisteni, ze se okno s obrazkem skutecne prekresli
gimp.displays_flush()
Obrázek 10: Výběr barvy pozadí i velikosti obrázku.
8. Třetí demonstrační příklad: úprava pluginu tak, aby bylo možné zadat velikost obrázku
Úplný programový kód dnešního třetího demonstračního příkladu vypadá následovně:
#!/usr/bin/env python
from gimpfu import *
# funkce zavolana po spusteni pluginu uzivatelem
def create_new_image_background_and_size(color, xsize, ysize):
# vytvoreni noveho obrazku
image = gimp.Image(int(xsize), int(ysize), RGB);
# vytvoreni nove hladiny
layer = gimp.Layer(image, "Hladina", int(xsize), int(ysize), RGB_IMAGE, 100, NORMAL_MODE)
# nastaveni barvy vykreslovani pozadi (druha barva ve vyberu)
gimp.set_background(color)
layer.fill(BACKGROUND_FILL)
# pridani hladiny do zasobniku hladin v obrazku
image.add_layer(layer, 0)
# zobrazeni
gimp.Display(image)
# zajisteni, ze se okno s obrazkem skutecne prekresli
gimp.displays_flush()
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"create_new_image_background_and_size",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Vytvor novy obrazek s barevnym pozadim a nastavitelnou velikosti",
"", # plugin se spusti jen pokud neexistuje obrazek
[
(PF_COLOR, "color", "Barva pozadi obrazku", (0.5, 0.5, 0.5)),
(PF_SPINNER, "xsize", "Sirka", 100, (1, 1000, 10)),
(PF_SPINNER, "ysize", "Vyska", 100, (1, 1000, 10)),
],
[],
create_new_image_background_and_size,
menu="<Image>/Filters/Test/")
main()
9. Čtvrtý demonstrační příklad: zobrazení základních ovládacích prvků
Čtvrtý demonstrační příklad, jenž je použitelný (spustitelný) i bez nutnosti otevření či vytvoření nového obrázku, po svém vyvolání z menu zobrazí dialog, v němž se nachází všechny základní ovládací prvky, které je možné použít v grafickém editoru GIMP. Samotný skript ve skutečnosti nic neprovádí, protože zavolaná funkce basic_controls() je prázdná. Navíc se při jejím volání nepředávají všechny parametry: vzhledem ke způsobu volání této funkce je totiž nutné, aby akceptovala přesně takový počet parametrů, jaký odpovídá počtu ovládacích prvků zobrazených na dialogu (parametry si samozřejmě můžete v rámci cvičení spočítat a přidat). Po spuštění tohoto demonstračního příkladu a následném zobrazení dialogu si vyzkoušejte, jak se chovají jednotlivé ovládací prvky:
#!/usr/bin/env python
from gimpfu import *
# funkce zavolana po spusteni pluginu uzivatelem
def basic_controls():
pass
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"basic_controls",
"Zobrazeni zakladnich ovladacich prvku",
"Zobrazeni zakladnich ovladacich prvku",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Zobrazeni zakladnich ovladacich prvku",
"", # plugin se spusti jen pokud neexistuje obrazek
[
(PF_INT, "number", "Cele cislo", 42),
(PF_FLOAT, "angle", "Desetinne cislo", 0.5),
(PF_STRING, "string", "String", "bla bla"),
(PF_TEXT, "text", "Text", "The quick red fox jumped over the lazy dog"),
(PF_BOOL, "prepinac", "Prepinac", True),
(PF_TOGGLE, "prepinac2", "Prepinac2", 1),
(PF_OPTION, "vyber1", "List box", 2, ("foo", "bar", "baz")),
(PF_RADIO, "vyber2", "Prepinace", "jpg", (("png", "png"), ("jpg", "jpg"))),
(PF_SPINNER, "spinner", "Numericky vstup", 42, (1, 8000, 1)),
(PF_SLIDER, "slider", "Posuvnik", 100, (0, 100, 1)),
(PF_COLOR, "color", "Barva", (1.0, 1.0, 1.0)),
],
[],
basic_controls,
menu="<Image>/Filters/Test/")
main()
Obrázek 11: Základní ovládací prvky zobrazené čtvrtým příkladem.
10. Pátý demonstrační příklad: zobrazení složitějších ovládacích prvků
V pátém demonstračním příkladu jsou ukázány prakticky všechny složitější ovládací prvky, které je v případě potřeby možné použít v dialogu pro konfiguraci pluginu. Mezi tyto prvky patří zejména:
- Výběr barevné palety (zobrazí se v novém dialogu)
- Výběr štětce pro kreslení (opět se zobrazí v novém dialogu)
- Výběr vzorku pro vyplňování (nový dialog)
- Výběr gradientu (barevného přechodu)
- Výběr fontu
- Výběr obrázku (listbox)
- Výběr hladiny (listbox)
- Výběr kanálu (listbox)
- Výběr souboru (GTK dialog)
Obrázek 12: Ovládací prvky zobrazené pátým příkladem.
Ani tento skript ve skutečnosti nepracuje korektně, protože se do funkce more_controls() nepředávají všechny parametry. To však příliš nevadí (v případě potřeby lze daný počet parametrů předat a tiše je ignorovat):
#!/usr/bin/env python
from gimpfu import *
# funkce zavolana po spusteni pluginu uzivatelem
def more_controls():
pass
# Registrace skriptu do prosteedi grafickeho editoru GIMP
# a specifikace parametru nastavitelnych uzivatelem,
# ktere se posleze prenesou jako parametry skriptu.
register(
"more_controls",
"Zobrazeni dalsich ovladacich prvku",
"Zobrazeni dalsich ovladacich prvku",
"Pavel Tisnovsky",
"Open source",
"2017-02-11",
"Zobrazeni dalsich ovladacich prvku",
"*", # plugin se spusti jen pokud existuje obrazek
[
(PF_PALETTE, "palette", "Paleta", ""),
(PF_BRUSH, "brush", "Stetec", None),
(PF_PATTERN, "pattern", "Vzorek", None),
(PF_GRADIENT, "gradient", "Gradient", None),
(PF_FONT, "font", "Font", "Sans"),
(PF_IMAGE, "image", "Obrazek", None),
(PF_LAYER, "layer", "Hladina", None),
(PF_CHANNEL, "channel", "Kanal", None),
(PF_DRAWABLE, "drawable", "Drawable", None),
(PF_FILE, "imagefile", "Image file", ""),
(PF_DIRNAME, "dir", "Directory", "/tmp"),
],
[],
more_controls,
menu="<Image>/Filters/Test/")
main()
Obrázek 13: Samostatné dialogy pro všechny ovládací prvky zobrazené pátým příkladem.
11. Šestý demonstrační příklad: nový obrázek s RGB paletou (skript naprogramovaný ve Scheme)
Pro porovnání rozdílů mezi skripty napsanými v Pythonu na jedné straně a programovacím jazyku Scheme na straně druhé si ukážeme skript, který po svém spuštění vyzve uživatele k zadání rozměrů nového obrázku a posléze obrázek vytvoří a vykreslí do něj barvovou paletu (což jsme si vlastně ukázali minule, ovšem v Pythonu). Zdrojový kód příkladu, který naleznete pod tímto odstavcem, je nutné uložit do souboru s příponou .scm a následně ho zkopírovat nebo přesunout do adresáře ~/.gimp-2.x/scripts (za n je nutné dosadit číslo aktuálně nainstalované podverze grafického editoru GIMP, s velkou pravděpodobností bude n==8, ostatně viz předchozí kapitoly).
Obrázek 14: Zobrazení adresářů, v nichž se hledají pluginy naprogramované v jazyku Scheme.
Posléze je možné spustit grafický editor GIMP a po jeho spuštění zvolit z hlavního menu příkaz Script-Fu/Obnovit Skripty (Refresh Scripts). Po zvolení tohoto příkazu začne GIMP hledat a načítat skripty ze systémového adresáře i z adresáře uživatelského. Případné chyby ve skriptech se vypisují do konzole (pokud je GIMP z konzole/terminálu spuštěn) a posléze se zobrazí i v grafickém dialogu:
; Funkce, která vytvoří nový obrázek o zadané velikosti.
; V obrázku bude jedna hladina nazvaná "Hladina-1" a
; v této hladině bude vykreslena RGB paleta.
(define (script-fu-rgb-colors width height)
; definice lokálních proměnných platných uvnitř bloku
(let*
(
; vytvoření nového obrázku, jehož ID se uloží
; do proměnné nazvané "image"
(image (car (gimp-image-new width height RGB)))
; vytvoření nové hladiny, jejíž ID se uloží
; do proměnné nazvané "layer"
(layer (car (gimp-layer-new image width height RGB-IMAGE "Hladina-1" 100 NORMAL-MODE)))
; počitadla smyček
(x 0)
(y 0)
; pole s uloženými RGB hodnotami pixelu
(pixel (cons-array 3 'byte))
)
; zákaz ukládání operací do zásobníku
(gimp-image-undo-disable image)
; přidání hladiny do vytvořeného obrázku
(gimp-image-add-layer image layer 0)
; změna barvy popředí a pozadí
(gimp-palette-set-foreground '(255 255 255))
(gimp-context-set-background '(0 0 0))
; vyplnění hladiny konstantní barvou
(gimp-drawable-fill layer 1) ;0 FG, 1 BG
; vnější smyčka pro všechny řádky obrázku
(while (< y height)
; nastavit počitadlo vnitřní smyčky
(set! x 0)
; vnitřní smyčka pro všechny pixely ležící na řádku
(while (< x width)
(aset pixel 0 (* 256 (/ x width)))
(aset pixel 1 (* 256 (/ y height)))
(aset pixel 2 (* 256 (+ (/ x width) (/ y height))))
; vykreslení pixelu
(gimp-drawable-set-pixel layer x y 3 pixel)
; zvýšit hodnotu počitadla vnitřní smyčky
(set! x (+ x 1))
)
; zvýšit hodnotu počitadla vnější smyčky
(set! y (+ y 1))
) ; end of loop
; zobrazení právě vytvořeného obrázku
(gimp-display-new image)
; povolení ukládání operací do zásobníku
(gimp-image-undo-enable image)
)
)
; Registrace skriptu do prostředí grafického editoru GIMP
; a specifikace proměnných nastavitelných uživatelem,
; které se posléze přenesou jako parametry skriptu.
(script-fu-register "script-fu-rgb-colors"
"<Image>/Filters/Render/Pattern/RGB colors"
"Vytvori obrazek s RGB paletou."
"Pavel Tisnovsky"
"Pavel Tisnovsky"
"2017-02-12"
""
SF-ADJUSTMENT "Image width" '(256 16 8192 16 64 0 1)
SF-ADJUSTMENT "Image height" '(256 16 8192 16 64 0 1)
)
; finito
Obrázek 15: Skript ve chvíli, kdy generuje obrázek.
Maximální rozlišení obrázku je omezeno na 8192×8129 pixelů a krok v ovládacím prvku je nastaven na 16. Samozřejmě je však možné zapsat libovolnou hodnotu menší než 8193 z klávesnice.
Obrázek 16: Výsledek běhu skriptu.
Náš demonstrační skript se po své registraci GIMPem nachází v menu Filters/Render/Pattern pod názvem RGB colors. Po výběru skriptu z menu se otevře dialog s možností zadání rozměrů nového obrázku. Vhodné hodnoty jsou například 128×128 pixelů nebo 256×256 pixelů, neboť u větších obrázků trvá jejich vykreslení poměrně dlouho. Jakmile jsou rozměry obrázku zadány, skript vytvoří nový plnobarevný (truecolor) obrázek, v něm zaregistruje jedinou hladinu pojmenovanou „Hladina-1“ a do této hladiny vykreslí RGB paletu (obdélník s postupnou změnou barvových složek R, G a B). Vybarvení obrázku je provedeno tak, že se ve dvojici vnořených smyček se prochází všemi pixely obrázku (přesněji řečeno všemi pixely hladiny, protože hladiny mohou mít obecně jiné rozměry než samotný obrázek) a každý pixel je obarven na základě své x-ové a y-ové pozice v hladině. Povšimněte si, že před prováděním jakýchkoli složitějších operací je zakázáno ukládání těchto operací do zásobníku, ve kterém si GIMP pamatuje předchozí stavy obrázku. Důvod je jednoduchý – urychlení běhu skriptu, které může být v tomto případě dosti výrazné (ani tak vás ale skript neoslní velkou rychlostí).
Obrázek 17: Funkce tvořená skriptem (pluginem) se zobrazí ve vestavěném prohlížeči.
12. Sedmý demonstrační příklad: vykreslení Lissajousových obrazců
Kreslení na úrovni jednotlivých pixelů, které bylo popsáno v předchozích kapitolách, není v žádném případě typickou operací, kterou skripty určené pro grafický editor GIMP provádí. Mnohem častěji se můžeme setkat se skripty, které kreslí či modifikují obrázek s využitím nástrojů dostupných samotným uživatelům GIMPu, což je samozřejmě mnohem zajímavější a užitečnější, neboť tyto nástroje jsou plně konfigurovatelné, a to jak programově (přímo ze spuštěného skriptu), tak i z grafického uživatelského rozhraní GIMPu. Právě tuto možnost si ukážeme v dnešním sedmém a současně i posledním demonstračním příkladu, v němž je předvedeno, jakým způsobem je možné kreslit do již vytvořeného obrázku pomocí tužky (kreslicí nástroj pencil) popř. štětce (kreslicí nástroj brush) nebo rozprašovače (kreslicí nástroj airbrush).
Obrázek 18: Výsledek běhu sedmého demonstračního příkladu při kreslení tužkou (pencil).
Pro kreslení tužkou je možné použít funkci gimp-pencil, pro kresbu štětcem funkci gimp-paintbrush. Při volání těchto funkcí se předávají různé parametry, především hladina, do níž se má vykreslování provést, počet bodů tvořících vrcholy polyčáry a poté vektor (zde je myšlena stejně pojmenovaná datová struktura, nikoli geometrický vektor), v němž jsou uloženy x-ové a y-ové souřadnice vrcholů polyčáry. Navíc se při kreslení štětcem předávají další parametry: kreslicí metoda (zda se barva při kreslení na stejné místo slévá či nikoli), délka barevného přechodu (gradient) a míra zeslabení při kresbě tlustým štětcem. Pokud tyto parametry nepotřebujeme či nechceme zadávat, lze namísto funkce gimp-paintbrush volat funkci gimp-paintbrush-default.
Obrázek 19: Výsledek běhu sedmého demonstračního příkladu při malování štětcem (brush).
Sedmý demonstrační příklad po svém spuštění zobrazí formulář, do kterého je možné zadat základní parametry takzvaných Lissajousových obrazců (které jsou mj. využívané například při měření různých parametrů signálů pomocí osciloskopů). Jedná se o střed obrazce, poloměr obrazce v obou osách a také dvojici parametrů, které určují násobky základní frekvence. Tyto parametry ovlivňují tvar obrazce; pro souměrné tvary je například zajímavé použít dvojici malých nesoudělných celých čísel (2:3, 3:4, 3:5, 5:7 apod.). Při vykreslování obrazce je použit aktuálně nastavený nástroj tužka nebo štětec, přičemž přepínání mezi těmito dvěma nástroji se pro jednoduchost provádí zapoznámkováním jednoho z programových řádků v oblasti omezené znaky #######. Povšimněte si taktéž způsobu, jakým je do skriptu předán identifikátor aktuálního obrázku a hladiny:
; Funkce, která do existujícího obrázku vykreslí
; Lissajousův obrazec buď vybraným perem/tužkou nebo štětcem.
(define (script-fu-draw-lissajous selected-image selected-layer cx cy rx ry dx dy)
; definice lokálních proměnných
(let*
(
; vykreslovaná úsečka je představována vektorem
; (vektorem je zde myšlena datová struktura Scheme)
(segment (make-vector 4 ))
; počet prvků vektoru
(npoint 4)
(alfa 0)
(beta 0)
; 2xPi
(full-circle (* 3.1415927 2))
; počet vykreslených segmentů
(step (/ full-circle 200))
)
(gimp-undo-push-group-start selected-image)
; programová smyčka, v níž se vykreslí úsečkové segmenty
; ze kterých se skládá aproximace Lissajousovy křivky
(while (<= alfa full-circle)
(set! beta (+ alfa step))
; výpočet počáteční a koncové souřadnice úsečky
(vector-set! segment 0 (+ cx (* rx (cos (* alfa dx )) )))
(vector-set! segment 1 (+ cy (* ry (cos (* alfa dy )) )))
(vector-set! segment 2 (+ cx (* rx (cos (* beta dx )) )))
(vector-set! segment 3 (+ cy (* ry (cos (* beta dy )) )))
; na tomto místě je možné vybrat buď kreslení
; tužkou/perem (pencil) nebo štětcem (brush)
; #################################################š
;(gimp-pencil selected-layer npoint segment )
(gimp-paintbrush selected-layer 100 npoint segment 0 10)
; #################################################š
; přinutíme GIMP, aby obrázek vykreslil
(gimp-displays-flush)
(set! alfa beta)
)
; uložíme stav obrázku na zásobník
(gimp-undo-push-group-end selected-image)
)
; naposledy přinutíme GIMP, aby obrázek vykreslil
(gimp-displays-flush)
)
; Registrace skriptu do prostředí grafického editoru GIMP
; a specifikace proměnných nastavitelných uživatelem,
; které se posléze přenesou jako parametry skriptu.
(script-fu-register "script-fu-draw-lissajous"
"<Image>/Filters/Render/Lissajous"
"Vykresli Lissajousuv obrazec na zaklade zadanych parametru"
"Pavel Tisnovsky"
"Pavel Tisnovsky"
"2017-02-11"
"RGB* GRAY* INDEXED*"
SF-IMAGE "The Image" 0
SF-DRAWABLE "The Layer" 0
SF-ADJUSTMENT "X center" '(200 0 999 1 10 0 1)
SF-ADJUSTMENT "Y center" '(200 0 999 1 10 0 1)
SF-ADJUSTMENT "X radius" '(160 0 999 1 10 0 1)
SF-ADJUSTMENT "Y radius" '(160 0 999 1 10 0 1)
SF-ADJUSTMENT "Xd" '(2 0 10 1 10 0 1)
SF-ADJUSTMENT "Yd" '(3 0 10 1 10 0 1)
)
; finito
Obrázek 20: Skript se opět korektně zaregistroval v grafickém editoru GIMP a jeho popis je dostupný v prohlížeči procedur.
13. Repositář s demonstračními příklady
Všechny dnes popisované demonstrační příklady byly uloženy do Git repositáře
dostupného na adrese https://github.com/tisnik/presentations.
Příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti
klonovat celý repositář:
| Příklad | Odkaz |
|---|---|
| new_image.py | https://github.com/tisnik/presentations/blob/master/gimp/GIMP-Python/new_image.py |
| new_color_image.py | https://github.com/tisnik/presentations/blob/master/gimp/GIMP-Python/new_color_image.py |
| color_image_with_specified_size.py | https://github.com/tisnik/presentations/blob/master/gimp/GIMP-Python/color_image_with_specified_size.py |
| basic_controls.py | https://github.com/tisnik/presentations/blob/master/gimp/GIMP-Python/basic_controls.py |
| more_controls.py | https://github.com/tisnik/presentations/blob/master/gimp/GIMP-Python/more_controls.py |
| rgb-colors.scm | https://github.com/tisnik/presentations/blob/master/gimp/scheme/rgb-colors.scm |
| draw-lissajous.scm | https://github.com/tisnik/presentations/blob/master/gimp/scheme/draw-lissajous.scm |
14. Odkazy na Internetu
- GIMP Home Page
http://www.gimp.org/ - GIMP Python Documentation
https://www.gimp.org/docs/python/ - Writing GIMP Scripts and Plug-Ins
http://gimpbook.com/scripting/ - GIMP Scripts and Plug-ins (slajdy)
http://gimpbook.com/scripting/slides/index.html - Use Python to write plug-ins for GIMP
http://www.ibm.com/developerworks/library/os-autogimp/index.html - A Script-Fu Tutorial
http://www.linuxtopia.org/online_books/graphics_tools/gimp_user_manual/en/gimp-using-script-fu-tutorial.html - A Script-Fu Tutorial
http://docs.gimp.org/en/gimp-using-script-fu-tutorial.html - Digital Watercolor with Mypaint 0.9 and Gimp-painter (video)
https://vimeo.com/18157214 - Water in Nature - a MyPaint + GIMP tutorial
http://www.gimptalk.com/index.php?showtopic=37706 - MyPaint (Wikipedia)
https://en.wikipedia.org/wiki/MyPaint - David Revoy (mj. používá MyPaint, GIMP i Kritu)
http://davidrevoy.com/ - Tux Paint Home Page
http://www.tuxpaint.org/ - Tux Paint (Wikipedia)
https://en.wikipedia.org/wiki/Tux_Paint - MyPaint Home Page
http://mypaint.org/ - MyPaint – Documentation
https://github.com/mypaint/mypaint/wiki/Documentation - Gamut
https://cs.wikipedia.org/wiki/Gamut - MtPaint Home Page
http://mtpaint.sourceforge.net/ - The mtPaint Handbook
http://mtpaint.sourceforge.net/handbook/en_GB/chap_00.html - MtPaint na Free Software Directory
https://directory.fsf.org/wiki/MtPaint - XPaint (minimalisticky pojatá home page)
http://sf-xpaint.sourceforge.net/ - XPaint (Wikipedia)
https://en.wikipedia.org/wiki/XPaint - X Athena Widgets
https://en.wikipedia.org/wiki/X_Athena_Widgets - Pinta: Painting Made Simple
https://pinta-project.com/pintaproject/pinta/ - Pinta (software)
https://en.wikipedia.org/wiki/Pinta_%28software%29 - Krita Home Page
https://krita.org/en/ - Krita (Wikipedia)
https://en.wikipedia.org/wiki/Krita - Pinta – Image Editing Alternative to The GIMP
https://www.maketecheasier.com/pinta-image-editing-alternative-to-the-gimp/ - GNU Paint Homepage
https://www.gnu.org/software/gpaint/ - GNU Paint na FreeCode
http://freecode.com/projects/gpaint/ - KolourPaint - Paint Program
https://www.kde.org/applications/graphics/kolourpaint/ - The KolourPaint Handbook
https://docs.kde.org/stable5/en/kdegraphics/kolourpaint/index.html - KolourPaint (Wikipedia)
https://en.wikipedia.org/wiki/KolourPaint - KIconEdit - Icon Editor
https://www.kde.org/applications/graphics/kiconedit/ - Phatch (Wikipedia)
https://en.wikipedia.org/wiki/Phatch - GrafX2 Home Page
http://pulkomandy.tk/projects/GrafX2 - GrafX2 (Wikipedia)
https://en.wikipedia.org/wiki/GrafX2 - Resurgence of Pixel art
http://www.developmentguruji.com/blog/142/Resurgence-of-Pixel-Art.html - Citypixel
http://www.citypixel.com/index.htm
18. 2. 2017 at 09:31
typo v clanku
->
Kopie zdrojového kódu pluginu do adresáře ~/.gimp-2.x/plug-ins, kde n je číslo verze GIMPu.
->>
Kopie zdrojového kódu pluginu do adresáře ~/.gimp-2.x/plug-ins, kde x je číslo verze GIMPu.
18. 2. 2017 at 17:42
Mockrat dekuju, opravim to.