Ein kurzes Tutorial zum GIMP-Erweiterungsskript (Python-Fu). Hier sind einige grundlegende Möglichkeiten, um mit GIMP aus Python zu arbeiten. Der Schwierigkeitsgrad ist niedrig, da es sich um ein vertrauteres Tutorial als das Lernen handelt.
GIMP ist ein Open Source-Zeichenwerkzeug. Kategorisch handelt es sich um ein Malwerkzeug, das Bilder pixelweise bearbeitet. Es hat viele Funktionen, aber Sie können es kostenlos nutzen. Es funktioniert seit mehreren Jahren nativ unter Mac OS X (ohne X11). Das Zeichenwerkzeug ist standardmäßig nicht im Mac enthalten, daher ist es eine der guten Apps.
In diesem Tutorial wird GIMP 2.8 vorausgesetzt. Wenn die Version nahe an 2.8 liegt, können Sie sie ohne Änderungen ausführen.
GIMP wird mit einer Erweiterungsbibliothek geliefert, mit der Sie GIMP programmgesteuert bedienen können. Die Bibliothek für diese Erweiterung ist in Python eingeschlossen und heißt Python-Fu.
Mit Python-Fu können Python-Skripte GIMP Funktionen hinzufügen und GIMP-Vorgänge automatisieren. Dies ist praktisch, wenn Sie eine große Menge an Routineverarbeitung oder iterativer Verarbeitung ausführen möchten, indem Sie die Parameter nach und nach ändern. Wenn Sie beispielsweise dem Hintergrund eines Bildes konzentrierte Linien hinzufügen möchten, ist es einfacher, Dutzende von Linien manuell programmgesteuert zu zeichnen.
Alles ist in Ordnung, also habe ich Zeichenwerkzeuge verwendet und es reicht aus, um Python zu schreiben.
Es tut mir leid, wenn irgendwo ein Fehler vorliegt.
Laden Sie die Binärdatei für Ihr Betriebssystem von [hier] herunter und installieren Sie sie (https://www.gimp.org/downloads/).
Unter Mac OS X wird beim ersten Start der App eine Sicherheitsüberprüfung durchgeführt. Sie können die Prüfung umgehen, indem Sie sie mit Strg-Klick starten. Dies geschieht jedoch auf eigenes Risiko. Außerdem dauert der erste Start aufgrund der Initialisierungsverarbeitung einige Zeit.
Dieses Mal werde ich Ihnen zeigen, wie Sie ein Python-Fu-Skript über die Python-Fu-Konsole ausführen.
Wählen Sie im GIMP-Menü Filter >> Python-Fu >> Konsole aus, um die Python-Fu-Konsole mit einer Python-Eingabeaufforderung zu öffnen.
Die GIMP-Bibliothek wurde bereits mit dieser Eingabeaufforderung geladen. Es sind keine zusätzlichen Arbeiten erforderlich, um GIMP-Funktionen von Python zu verwenden. Es ist möglich, GIMP zu betreiben, indem plötzlich eine Funktion in der Bibliothek aufgerufen wird.
Wir haben ein Beispielskript vorbereitet, mit dem Sie die Funktionen von Python-Fu kennenlernen können.
Versuchen Sie, den gesamten folgenden Code zu kopieren und in die Python-Fu-Konsole einzufügen. Wenn Sie mit der Eingabe von main () unten fertig sind, sollte ein neues Fenster mit dem Bild geöffnet werden. Bitte versuchen Sie es zuerst.
# Python-Fu Beispielskript
#GIMP Python-Kopieren und in die Fu-Konsole einfügen und ausführen
#Erstellung von Bilddaten
##Erstellen Sie Bilddaten mit der angegebenen Größe
### width :Bilddatenbreite(px)
### height :Höhe der Bilddaten(px)
def create_image(width, height):
#Bilddaten generieren
return gimp.Image(width, height, RGB)
#Ebene hinzufügen
##Erstellen Sie eine neue Ebene mit dem angegebenen Namen und fügen Sie sie in die Bilddaten ein
### image :Bilddaten zum Hinzufügen einer Ebene
### name :Name (Zeichenkette) der neu erstellten Ebene
def add_layer(image, name):
#Parameter, die zum Erstellen einer Ebene erforderlich sind
width = image.width
height = image.height
type = RGB_IMAGE
opacity = 100
mode = NORMAL_MODE
#
#Erstellen Sie eine Ebene basierend auf den Parametern
layer = gimp.Layer(image, name, width, height, type, opacity, mode)
#
#Füllen Sie die Ebene mit der Hintergrundfarbe (entsprechend dem Standardverhalten von GIMP).
layer.fill(1)
#
#Fügen Sie eine Ebene an der 0. Position der Bilddaten ein
position = 0
image.add_layer(layer, position)
#
return layer
#Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie
##Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie, die die im Array gespeicherten Koordinatenzeichenfolgen im Zeichenbereich verbindet
### drawable :Zeichenbereich (Ebene usw.)
### lines :Ein Array, das die Koordinatenzeichenfolgen der gezeichneten Linien enthält
def draw_pencil_lines(drawable, lines):
#Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie
pdb.gimp_pencil(drawable, len(lines), lines)
#Zeichnen Sie mit dem Bleistiftwerkzeug ein Rechteck
##Zeichnen Sie ein Rechteck im Zeichenbereich basierend auf den Koordinaten oben links und unten rechts
### drawable :Zeichenbereich (Ebene usw.)
### x1 :X-Koordinate oben links
### y1 :Oben links Y-Koordinate
### x2 :Unten rechts X-Koordinate
### y2 :Unten rechts Y-Koordinate
def draw_rect(drawable, x1, y1, x2, y2):
lines = [x1, y1, x2, y1, x2, y2, x1, y2, x1, y1]
draw_pencil_lines(drawable, lines)
#Zeichnen Sie eine Linie mit einer Airbrush
##Zeichnen Sie mit einem Airbrush eine Linie, die die im Array gespeicherten Koordinatenzeichenfolgen im Zeichenbereich verbindet
### drawable :Zeichenbereich (Ebene usw.)
### pressure :Stiftdruck(0-100)
### lines :Ein Array, das die Koordinatenzeichenfolgen der gezeichneten Linien enthält
def draw_airbrush_lines(drawable, pressure, lines):
#Zeichnen Sie eine Linie mit einer Airbrush
pdb.gimp_airbrush(drawable, pressure, len(lines), lines)
#Zeichne eine Schnur
##Zeichnet eine Zeichenfolge im angegebenen Zeichenbereich
### drawable :Zeichenbereich (Ebene usw.)
### x :X-Koordinate der Position zum Zeichnen der Zeichenfolge
### y :Y-Koordinate der Position zum Zeichnen der Zeichenfolge
### size :Schriftgröße
### str :Zeichenkette zum Zeichnen
def draw_text(drawable, x, y, size, str):
image = drawable.image
border = -1
antialias = True
size_type = PIXELS
fontname = '*'
floating_sel = pdb.gimp_text_fontname(image, drawable, x, y, str, border,
antialias, size, size_type, fontname)
pdb.gimp_floating_sel_anchor(floating_sel)
#Ändern Sie die Zeichnungsfarbe
##Ändern Sie die Vordergrundfarbe der Palette, um die Zeichnungsfarbe festzulegen
### r :Rotes Element(0-255)
### g :Grünes Element(0-255)
### b :Blaues Element(0-255)
### a :Transparenz(0-1.0)
def set_color(r, g, b, a):
color = (r, g, b, a)
pdb.gimp_context_set_foreground(color)
#Ändern Sie die Dicke der gezeichneten Linie
##Ändern Sie die Größe des Pinsels, um die Linienstärke einzustellen
### width :Dicke der Linie
def set_line_width(width):
pdb.gimp_context_set_brush_size(width)
#Bildschirm
##Erstellen Sie ein neues Fenster und zeigen Sie die Bilddaten an
### image :Bilddaten angezeigt werden
def display_image(image):
gimp.Display(image)
def main():
image = create_image(640, 400)
layer = add_layer(image, "Hintergrund")
draw_rect(layer, 390, 210, 490, 310)
draw_text(layer, 200, 180, 20, "Hallo")
lines = [110,90, 120,180, 130,110, 140,150]
draw_airbrush_lines(layer, 75, lines)
set_color(255,0,0,1.0) # Red
set_line_width(1)
draw_rect(layer, 420, 240, 520, 340)
display_image(image)
main()
Wenn alles gut geht, sollte ein neues Fenster mit dem Bild erstellt worden sein.
Hast du das in 5 Minuten bekommen? Es geht nur um die Installation und das Kopieren von Software. Ich denke, es gab keinen schwierigen Teil, über den man stolpern könnte.
Als nächstes werde ich den Inhalt der Verarbeitung des gerade ausgeführten Skripts erläutern.
Im obigen Skript werden zunächst die Hilfsfunktionen definiert, die zum Erstellen und Verarbeiten von Bilddaten erforderlich sind. Funktionen zum Sichern von Bilddaten im Programm, Funktionen zum Erstellen von Ebenen, Funktionen zum Zeichnen von Figuren, Funktionen zum Schreiben von Zeichenketten, Funktionen zum Anzeigen von erstellten Bildern usw.
Wenn diese Hilfsfunktionen abgeschlossen sind, werden die Hilfsfunktionen aufgerufen, um in der main () - Funktion das Bild tatsächlich zu erstellen und anzuzeigen.
Im Folgenden möchte ich die Implementierung von Hilfsfunktionen entsprechend der Programmstruktur genauer betrachten.
Wenn Sie ein Bild mit GIMP erstellen, erstellen Sie zuerst die Bilddaten.
Bilddaten sind ein Container für Ebenen. Bilder wie Figuren werden nicht direkt in den Bilddaten gespeichert, sondern in den darin enthaltenen Ebenen. Wenn Sie die Bilddaten speichern, werden sie zu einer Bilddatei.
Zum Erstellen von Bilddaten sind Informationen wie Breite, Höhe und Bildtyp erforderlich. Die Breite und Höhe werden in Pixel angegeben. Der Bildtyp kann RGB, GREY, INDEXED usw. sein.
Bilddaten werden mit der Funktion gimp.Image () von Python-Fu erstellt. Der folgende Teil am Anfang des Skripts ist eine Funktion, die Bilddaten erstellt.
#Erstellung von Bilddaten
##Erstellen Sie Bilddaten mit der angegebenen Größe
### width :Bilddatenbreite(px)
### height :Höhe der Bilddaten(px)
def create_image(width, height):
#Bilddaten generieren
return gimp.Image(width, height, RGB)
Rufen Sie die Funktion create_image wie folgt auf:
image = create_image(640, 400)
Auf diese Weise werden Bilddaten mit einer Breite von 640 Pixel, einer Höhe von 400 Pixel und einer RGB-Farbe erstellt.
Fügen Sie als Nächstes den Bilddaten eine Ebene hinzu. Das Bild wird auf einer Ebene gezeichnet, sodass Sie mindestens eine Ebene benötigen.
Die Python-Fu-Funktion zum Erstellen von Ebenen lautet gimp.Layer (). Übergeben Sie die Bilddaten, den Ebenennamen, die Ebenenbreite, die Höhe, den Bildtyp, die Deckkraft und den Modus an die Argumente von gimp.Layer ().
Füllen Sie die Ebene nach dem Erstellen mit der Hintergrundfarbe. Dies entspricht dem Verhalten beim Erstellen von Ebenen über die GIMP-App-GUI. Wenn Sie eine Ebene mit GIMP hinzufügen, verhält es sich standardmäßig wie das Füllen mit der Hintergrundfarbe.
Verwenden Sie als Nächstes die Funktion gimp.Image.add_layer (), um die Ebene den Bilddaten zuzuordnen. Die Argumentposition ist ein Parameter, der die Position von oben angibt, um die Ebene hinzuzufügen.
Die Implementierung der Funktion zum Hinzufügen einer Ebene ist wie folgt.
#Ebene hinzufügen
##Erstellen Sie eine neue Ebene mit dem angegebenen Namen und fügen Sie sie in die Bilddaten ein
### image :Bilddaten zum Hinzufügen einer Ebene
### name :Name (Zeichenkette) der neu erstellten Ebene
def add_layer(image, name):
#Parameter, die zum Erstellen einer Ebene erforderlich sind
width = image.width
height = image.height
type = RGB_IMAGE
opacity = 100
mode = NORMAL_MODE
#
#Erstellen Sie eine Ebene basierend auf den Parametern
layer = gimp.Layer(image, name, width, height, type, opacity, mode)
#
#Füllen Sie die Ebene mit der Hintergrundfarbe (entsprechend dem Standardverhalten von GIMP).
layer.fill(1)
#
#Fügen Sie eine Ebene an der 0. Position der Bilddaten ein
position = 0
image.add_layer(layer, position)
#
return layer
In Qiitas Markdown scheinen leere Zeilen in leere Zeilen umgewandelt zu werden und der Einzug endet. Daher habe ich als Problemumgehung ein Kommentarzeichen (#) hinzugefügt.
Die Funktion add_layer () wird in der Funktion main () wie folgt aufgerufen.
layer = add_layer(image, "Hintergrund")
Wenn dies erledigt ist, wird eine Ebene mit dem Namen "Hintergrund" erstellt und den Bilddaten hinzugefügt.
Nachdem Sie die Ebene erstellt haben, können Sie mit dem Zeichnen beginnen. Als Grundlage für die Bildverarbeitung werden wir zunächst eine Methode zum Zeichnen einer Linie vorbereiten.
Verwenden Sie bei der Arbeit mit Python-Fu Werkzeuge wie Stifte und Pinsel in GIMP, genau wie beim Zeichnen mit der GIMP-App. Hier definieren wir eine Funktion zum Zeichnen einer Linie mit dem Bleistiftwerkzeug.
Mit dem Stiftwerkzeug können Sie mit der von Python-Fu bereitgestellten Funktion pdb.gimp_pencil () eine Linie zeichnen. Das Argument der Funktion pdb.gimp_pencil () ist ein Array, in dem der Zeichenbereich wie eine Ebene, die Anzahl der Koordinaten, die die Linie durchläuft, und die Koordinaten, die die Linie durchläuft, gespeichert werden.
Es scheint, dass der Grund, warum die Anzahl der Koordinaten als Argument übergeben wird, darin besteht, dass dieses gimp_pencil () ein Wrapper für die C-Funktion ist. Es gibt keine Möglichkeit, die Anzahl der Elemente in einem Array in C herauszufinden. Daher müssen Sie die Funktion explizit angeben.
#Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie
##Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie, die die im Array gespeicherten Koordinatenzeichenfolgen im Zeichenbereich verbindet
### drawable :Zeichenbereich (Ebene usw.)
### lines :Ein Array, das die Koordinatenzeichenfolgen der gezeichneten Linien enthält
def draw_pencil_lines(drawable, lines):
#Zeichnen Sie mit dem Bleistiftwerkzeug eine Linie
pdb.gimp_pencil(drawable, len(lines), lines)
Die Funktion draw_pencil_lines () wird von der folgenden Funktion draw_rect () aufgerufen.
Bereiten Sie als Nächstes ein Rechteck vor, dh eine Funktion, die ein Rechteck zeichnet. Verwenden Sie zum Zeichnen eines Rechtecks die zuvor erstellte Funktion draw_pencil_lines () anstelle der Python-Fu-Funktion.
Im folgenden Code wird der Funktion draw_pencil_lines (), die eine Linie zeichnet, ein Array übergeben, das die vier Seiten des Rechtecks nachzeichnet, um ein Rechteck zu zeichnen.
#Zeichnen Sie mit dem Bleistiftwerkzeug ein Rechteck
##Zeichnen Sie ein Rechteck im Zeichenbereich basierend auf den Koordinaten oben links und unten rechts
### drawable :Zeichenbereich (Ebene usw.)
### x1 :X-Koordinate oben links
### y1 :Oben links Y-Koordinate
### x2 :Unten rechts X-Koordinate
### y2 :Unten rechts Y-Koordinate
def draw_rect(drawable, x1, y1, x2, y2):
lines = [x1, y1, x2, y1, x2, y2, x1, y2, x1, y1]
draw_pencil_lines(drawable, lines)
Die Funktion draw_rect () wird wie folgt aufgerufen:
draw_rect(layer, 390, 210, 490, 310)
Dadurch wird ein Rechteck mit der Standardfarbe und der Standardlinienbreite gezeichnet. Ich werde später erklären, wie man die Farbe und Linienbreite beim Zeichnen ändert.
Wir bieten auch eine Funktion zum Zeichnen einer Linie mit einem Airbrush anstelle des Bleistiftwerkzeugs. Die Airbrush ist in der Funktion pdb.gimp_airbrush () verfügbar. Die Argumente von pdb.gimp_airbrush () sind fast dieselben wie die von pdb.gimp_pencil (), jedoch mit einem zusätzlichen Parameter zur Angabe des Stiftdrucks.
#Zeichnen Sie eine Linie mit einer Airbrush
##Zeichnen Sie mit einem Airbrush eine Linie, die die im Array gespeicherten Koordinatenzeichenfolgen im Zeichenbereich verbindet
### drawable :Zeichenbereich (Ebene usw.)
### pressure :Stiftdruck(0-100)
### lines :Ein Array, das die Koordinatenzeichenfolgen der gezeichneten Linien enthält
def draw_airbrush_lines(drawable, pressure, lines):
#Zeichnen Sie eine Linie mit einer Airbrush
pdb.gimp_airbrush(drawable, pressure, len(lines), lines)
Die Funktion draw_airbrush_lines () wird in der Funktion main () wie folgt aufgerufen. Zunächst wird der Pfad der Linie, die Sie zeichnen möchten, in einem Array zusammengefasst, und die Funktion wird mit diesem als Argument aufgerufen. Der Stiftdruck wird mit 75 angegeben.
lines = [110,90, 120,180, 130,110, 140,150]
draw_airbrush_lines(layer, 75, lines)
Wenn Sie eine Textnachricht in das Bild einfügen möchten, verwenden Sie die Funktion pdb.gimp_text_fontname (). Geben Sie zusätzlich zu der Zeichenfolge, die Sie zeichnen möchten, Parameter wie die Schriftgröße und die Durchführung der Anti-Aliasing-Verarbeitung an. Die Funktion draw_text () ist eine Funktion, die pdb.gimp_text_fontname () umschließt, sodass eine Zeichenfolge gezeichnet werden kann, indem nur die minimal erforderlichen Informationen angegeben werden.
#Zeichne eine Schnur
##Zeichnet eine Zeichenfolge im angegebenen Zeichenbereich
### drawable :Zeichenbereich (Ebene usw.)
### x :X-Koordinate der Position zum Zeichnen der Zeichenfolge
### y :Y-Koordinate der Position zum Zeichnen der Zeichenfolge
### size :Schriftgröße
### str :Zeichenkette zum Zeichnen
def draw_text(drawable, x, y, size, str):
image = drawable.image
border = -1
antialias = True
size_type = PIXELS
fontname = '*'
floating_sel = pdb.gimp_text_fontname(image, drawable, x, y, str, border,
antialias, size, size_type, fontname)
pdb.gimp_floating_sel_anchor(floating_sel)
Die Funktion draw_text () wird folgendermaßen aufgerufen. Der Zeichenbereich, die X-Koordinate der Position, an der das Zeichen geschrieben wird, die Y-Koordinate, die Schriftgröße und die zu zeichnende Zeichenfolge werden als Argumente übergeben und ausgeführt.
draw_text(layer, 200, 180, 20, "Hallo")
Die Farbe, die beim Zeichnen einer Figur oder Zeichenfolge verwendet wird, ist die Farbe, die in der Vordergrundfarbe in der GIMP-Farbpalette festgelegt wurde. Die Funktion zum Festlegen der Vordergrundfarbe der Farbpalette lautet pdb.gimp_context_set_foreground (), und die Farbdaten werden durch ein Tape von R, G, B, A dargestellt.
Hier haben wir der Klarheit halber einen Alias namens set_color angegeben, und jedes Element von RGBA wird separat als Argument übergeben.
#Ändern Sie die Zeichnungsfarbe
##Ändern Sie die Vordergrundfarbe der Palette, um die Zeichnungsfarbe festzulegen
### r :Rotes Element(0-255)
### g :Grünes Element(0-255)
### b :Blaues Element(0-255)
### a :Transparenz(0-1.0)
def set_color(r, g, b, a):
color = (r, g, b, a)
pdb.gimp_context_set_foreground(color)
In der Funktion main () wird mit dieser Funktion die rote Farbe eingestellt.
set_color(255,0,0,1.0) # Red
Die Funktion, die die Dicke des Stiftwerkzeugs und des Druckluftpinsels angibt, ist die Funktion pdb.gimp_context_set_bursh_size (). Im folgenden Code haben wir der Übersichtlichkeit halber den Alias set_line_width () angegeben.
#Ändern Sie die Dicke der gezeichneten Linie
##Ändern Sie die Größe des Pinsels, um die Linienstärke einzustellen
### width :Dicke der Linie
def set_line_width(width):
pdb.gimp_context_set_brush_size(width)
Wenn Sie eine Linie mit einer Breite von 1 Pixel zeichnen möchten, geben Sie 1 für das folgende Argument an.
set_line_width(1)
Nach Abschluss der Bildverarbeitung werden die Bilddaten auf dem Desktop angezeigt. Wenn Sie Bilddaten als Argument der Funktion gimp.Display () angeben und ausführen, wird ein neues Fenster erstellt und das Bild angezeigt.
Nach wie vor haben wir ihm auch hier einen leicht verständlichen Alias gegeben.
#Bildschirm
##Erstellen Sie ein neues Fenster und zeigen Sie die Bilddaten an
### image :Bilddaten angezeigt werden
def display_image(image):
gimp.Display(image)
Die Funktion display_image () wird folgendermaßen aufgerufen.
display_image(image)
Unten ist die main () Funktion. Die bisher definierten Funktionsaufrufe sind an einer Stelle zusammengefasst.
In Python ist die main () - Funktion nicht als Einstiegspunkt für das Programm definiert, daher nennen wir sie einfach main gemäß der üblichen Konvention.
def main():
image = create_image(640, 400)
layer = add_layer(image, "Hintergrund")
draw_rect(layer, 390, 210, 490, 310)
draw_text(layer, 200, 180, 20, "Hallo")
lines = [110,90, 120,180, 130,110, 140,150]
draw_airbrush_lines(layer, 75, lines)
set_color(255,0,0,1.0) # Red
set_line_width(1)
draw_rect(layer, 420, 240, 520, 340)
display_image(image)
main()
Dies ist das Ende der Erklärung des Programms. Der Hauptunterschied zu allgemeinen Bildverarbeitungsbibliotheken besteht darin, dass sie die App-Mechanismen von GIMP wie Pinsel und Paletten verwenden. Wenn Sie Zeichenwerkzeuge verwendet haben, ist das meiner Meinung nach nicht schwierig.
Ändern Sie zunächst das obige Programm, um die Farbe und die Linienbreite zu ändern, die Form der Figur zu ändern, den Stiftdruck des Airbrush-Werkzeugs zu ändern und zu sehen, wie sich die Bewegung ändert.
Lesen Sie danach die API-Referenz usw. und erstellen Sie viel interessanteren Code. Möglicherweise finden Sie auch Python help () und dir () hilfreich.
Ich habe es diesmal nicht erklärt, aber Sie können das von Ihnen erstellte Skript auch als Plug-In in GIMP integrieren. Wenn Sie sich daran gewöhnt haben, Skripte zu schreiben, probieren Sie es bitte aus.
http://developer.gimp.org/api/2.0/
https://www.gimp.org/docs/python/
http://gimpbook.com/scripting/
--Procedure Browser (PDF-Referenz)
Weitere Informationen zu Python-Objekten finden Sie in der integrierten Hilfe () und dir () in Python. Das Verwendungsbeispiel wird unten vorgestellt.
Mit der Funktion help () können Sie Hilfe für Python-Objekte abrufen.
>>> help(gimp)
Help on module gimp:
NAME
gimp - This module provides interfaces to allow you to write gimp plugins
FILE
/Users/.../Applications/GIMP/GIMP.app/Contents/Resources/lib/gimp/2.0/python/gimp.so
CLASSES
__builtin__.object
Display
Image
Item
Drawable
Channel
Layer
GroupLayer
Vectors
Parasite
PixelFetcher
PixelRgn
Tile
exceptions.RuntimeError(exceptions.StandardError)
error
VectorsStroke(__builtin__.object)
VectorsBezierStroke
...
Mit der Funktion dir () können Sie die Mitglieder eines Python-Objekts anzeigen.
>>> for i in dir(gimp.Layer):
... print i
...
ID
__class__
__cmp__
__delattr__
__doc__
__format__
__getattribute__
__hash__
__init__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
add_alpha
add_mask
apply_mask
attach_new_parasite
bpp
children
copy
create_mask
edit_mask
fill
...
Bisher haben wir die Schritte für den Einstieg in Python-Fu, die Skriptschnittstelle für GIMP-Erweiterungen, behandelt. Ich hoffe, Sie finden es nützlich.
__ Ende __
Recommended Posts