Forum Wiki Galerie Kontakt Wie man Fragen richtig stellt. Tutorial Forum
Zurück   GIMP-Forum 3.0 > Arbeiten mit Gimp > GIMP-Ressourcen > Plug-ins

Hinweise
Alt 10.05.2020, 14:32   #1
Tscheppo
Neuer Benutzer
 
Benutzerbild von Tscheppo
 
Registriert seit: 12.01.2019
Ort: Im Süden Deutschlands
Beiträge: 26
Standard Unterschied Python-Fu- und "echtes" Plugin

Noch vor einem Jahr war ich ein wirklicher "NEULING", was das Schreiben von GIMP-Plugins angeht. In der Zwischenzeit habe ich mich sehr intensiv mit der Programmierung von GIMP-Plugins mit Python, C und C++ beschäftigt. Im Internet gibt es zum Thema GIMP, Plugins und Python sehr viele Informationen. Diese sind so unterschiedlich und nicht immer richtig, sodass ein Anfänger leicht die Lust verliert und das Plugin-Programmieren lieber sein lässt. Damit diese nicht geschieht, möchte ich anderen Neulingen und Anfängern eine wenig helfen.

Zu Beginn meiner Plugin-Programmierung habe ich mich immer wieder gefragt, was den der Unterschied zwischen einem Python-Fu- und einem "echten" Python-Plugin ist. Diesen möchte ich im Folgenden erklären. Übrigens stammt der Begriff „Echtes Plugin“ nicht von mir, ich würde eher Python-Plugin sagen.

Ein "Python-Fu"-Plugin ohne GIMP-Funktionalität sieht grob wie folgt aus:
Code:
#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
Zweck:   Grundsätzlicher Aufbau eines Python-fu GIMP-Plugins.
Aufruf:  <Image>/Filters/Formen
Author:  Herbert Nemeczek
Version: 2020-05-10
"""

from gimpfu import *

##########################################################################################
# Plugin-Klasse.
def plugin_main(fImage, fDrawable, fX1, fY1):
  return
   
##########################################################################################
# Registrierung des Python-Fu Plugins.
register(
  "HN_Gimp_Plugin_PythonFu",
  "Kurzbeschreibung des Plugins.",
  "Ausführliche Beschreibung des Plugins.",
  "Herbert Nemeczek (Herbert.Nemeczek@t-online.de)",
  "(c) Herbert Nemeczek",
  "2020-05-10",
  "<Image>/Filters/Formen/HN: GIMP-Plugin (Python-Fu) ...",
  "RGB*, GRAY*, INDEXED*",
  [ (PF_INT,    "x1",    "X-Koordinate: x",    0),
    (PF_INT,     "y1",    "Y-Koordinate: y",    0)
  ],
  [],
  plugin_main
)
 
main()
Das „Python-Fu“-Plugin verwendet das Modul „gimpfu“, welches das Schreiben von Plugins stark vereinfacht. Anstatt sich selbst um die gesamte Benutzerinteraktion zu kümmern, wird das vom „gimpfu“-Modul erledigt. Es bietet eine einfache „register()“-Funktion, mit der das eigene Plugin registriert und bei Bedarf aufgerufen wird. „gimpfu“ behandelt auch das Anzeigen einer Benutzeroberfläche zum Bearbeiten der Plugin-Parameter, wenn das Plugin interaktiv aufgerufen wird. Außerdem wird sichergestellt, dass die Anzeigen nach Abschluss geleert werden.

Ein "echtes" Python-Plugin ohne GIMP-Funktionalität sieht grob so aus:
Code:
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Zweck:   Grundsätzlicher Aufbau eines "echten" Python GIMP-Plugins.
Aufruf:  <Image>/Filters/Formen
Author:  Herbert Nemeczek
Version: 2020-05-10
"""

import gimp, gimpplugin
pdb = gimp.pdb
from gimpenums import *
#
import gimpui
import pygtk, gtk

##########################################################################################
# Benutzeroberflächen-Klasse.
class winBenOberflaeche(gtk.Window):
  #=======================================================================================
  # Der Konstruktor, der das Fenster (window) erstellt.
  def __init__(self):
    #
    #-------------------------------------------------------------------------------------
    # Titel, Größe, Position des Fensters
    gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
    self.set_title('Beispiel für ein "echtes" Python GIMP-Plugin')
    self.winBreite = 500   ; self.winHoehe = 300  # Festlegung der Mindestgrößen
    self.set_default_size(self.winBreite, self.winHoehe)
    self.set_position(gtk.WIN_POS_NONE)           # Auch möglich: gtk.WIN_POS_CENTER)
    self.set_border_width(10)
    self.set_resizable(True)
    #
    #-------------------------------------------------------------------------------------
    # Behälter (Tabelle) für die Widget-Elemente definieren.
    self.layTab = gtk.Table(rows=7, columns=3, homogeneous=True)
    self.layTab.set_border_width(5)
    self.layTab.set_col_spacings(10)
    self.layTab.set_row_spacings(10)
    self.add(self.layTab)
    #
    #-------------------------------------------------------------------------------------
    # Schaltfläche/Taste hinzufügen.
    self.okTaste = gtk.Button("OK")
    self.okTaste.set_relief(gtk.RELIEF_NORMAL)
    self.okTaste.set_tooltip_text("Führt eine Tätigkeit aus und beendet das Plugin.")
    self.okTaste.connect("clicked", self.winEvtBeendenClicked)
    #self.horBox.pack_start(self.okTaste, True, True, 0)
    self.layTab.attach(self.okTaste, 1, 2, 6, 7, gtk.FILL | gtk.EXPAND, 0, 0, 0)
    #
    #-------------------------------------------------------------------------------------
    # Schließen der Benutzeroberfläche über den X-Knopf hinzufügen.
    self.connect("destroy", self.winEvtBeendenClicked)  
  #
  #=======================================================================================
  # Methode zum Anzeigen des Fensters und Verweilen in der Event-Warteschleife.
  def winAnzeigen(self):
    self.show_all()     # Im Konstruktor aufgebautes Fenster jetzt anzeigen
    gtk.main()         # Event-Warteschleife, nach dem Anzeigen des Hauptfensters
  #
  #=======================================================================================
  # Ereignis (event) als Reaktion des Tastendrucks auf "Beenden" oder "X".
  def winEvtBeendenClicked(self, widget, data=None):
    gtk.main_quit()         # Ende der Event-Warteschleife, die mit "gtk.main()" anfing.

##########################################################################################
# Plugin-Klasse.
class plugin_main(gimpplugin.plugin):
  #
  #=======================================================================================
  # Normalerweise definiert man die folgenden drei Methode im eigenen Plugin nicht neu, 
  # da diese bereits in der Oberklasse passend gesetzt sind. Aber, es geht.
  def start(self) :
    gimp.main(self.init, self.quit, self.query, self._run)
  def init(self):
    pass
  def quit(self):
    pass
  #
  #=======================================================================================
  # Methode "query(self)" wird aufgerufen, wenn das Plugin als neu/geändert erkannt wird.
  def query(self):
    pluginName = "HN_Gimp_Plugin_Python"
    gimp.install_procedure(
      pluginName,
      "Kurzbeschreibung des Plugins.",
      "Ausführliche Beschreibung des Plugins.",
      "Herbert Nemeczek (Herbert.Nemeczek@t-online.de)",
      "(c) Herbert Nemeczek",
      "2020-05-10", 
      "HN: GIMP-Plugin (Python) ...",
      "RGB*, GRAY*, INDEXED*",
      PLUGIN,
      [ ( # Run-Modus (32-bit Integer)
          PDB_INT32,        # Ein Plugin kann in folgenden Modies gestartet werden:
          "run_mode",       #   RUN_INTERACTIVE (0), RUN_NONINTERACTIVE (1)
          "Run mode"        #   und RUN_WITH_LAST_VALS (2)
        ),
        ( # Bild/Image (Image ID)
          PDB_IMAGE,        # Jedes geöffnete Bild hat zu jeder Zeit eine einzige
          "image",          # aktive Zeichenfläche, das "Drawable".
          "Input image"
        ),
        ( # Zeichenfläche/Drawable (Drawable ID)
          PDB_DRAWABLE,     # Ein "Drawable" ist ein GIMP-Konzept, das Ebenen (layers),
          "drawable",       # aber auch verschiedene andere Arten von Dingen wie Kanäle, 
          "Input drawable"  # Ebenenmasken und die Auswahlmaske enthält.
        )
      ], 
      []
    )
    gimp.menu_register(pluginName, "<Image>/Filters/Formen")
  #
  #======================================================================================
  # Die Methode "run(self)" realisiert das eigentliche Plugin.
  def HN_Gimp_Plugin_Python(self, fRunMode, fImage, fDrawable):
    if (fRunMode == RUN_NONINTERACTIVE):
      return

    benOberflaeche = winBenOberflaeche()
    # GTK: Oberfläche anzeigen und verweilen, bis "gtk_main_quit()" aufgerufen wird.
    benOberflaeche.winAnzeigen()
            
if (__name__ == '__main__'):
  plugin_main().start()
Das „echte“ Python-Plugin verwendet das Modul „gimpplugin“ für die Registrierung und den Aufruf des eigenen Plugins. In meinem Beispiel verwendet ich für den Aufbau der Benutzeroberfläche die Module „gimpui“, „pygtk“ und „gtk“ (PyGTK 2.0, siehe http://developer.gnome.org/pygtk/stable/). Auf den ersten Blick, entsteht der Eindruck, dass alles viel komplizierter ist. Dies ist wohl zunächst der Fall, aber der Programmierer hat viel mehr Freiheiten bei der Oberflächengestaltung.
Ich habe mich für die Verwendung dieser Variante entschieden.

Am besten Ihr ruft meine MagentaCLOUD-Webseite
https://www.magentacloud.de/share/362yyd13.n#$/Plug-Ins
auf und wählt den Ordner
Gimp-Plugin (Python, C, C++) -> Python
aus. Darin befinden sich die beiden oben beschriebenen Plugins. Bitte beachtet dabei, dass ich mit den Plugins lediglich die Unterschiede der beiden Plugin-Rahmen zeigen möchte. Eine "echte" Benutzeroberfläche und die GIMP-Funktionalität fehlt vollständig.

Ladet die beiden Plugins „HN-Gimp-Plugin-Python.py“ sowie„HN-Gimp-Plugin-PythonFu.py“ auf den eigenen Rechner herunter und kopiert sie in das private „plug-ins“-Verzeichnis (unter Windows „C:\Users\<Benutzername>\AppData\Roaming\GIMP\2.10 \plug-ins“).
Nach dem Start von GIMP und dem Erstellen eines neuen Bildes (Datei -> Neu), startest Ihr nacheinander beide Plugins über
Filter -> Formen.
Begutachtet den Inhalt und die Funktionalität der Plugins. Schaut besonders die Unterschiede im Code.
Wenn Ihr
Hilfe -> Plugin-Browser
in GIMP aufruft, danach im Suchfeld „HN“ eintippt und nacheinander die angezeigten Plugins auswählt, solltest Ihr vor allem die OBERSTE Zeile im rechten Fenster des Plugin-Browsers vergleichen.

Inzwischen habe ich ein eigenes Modul mit vielen Methoden geschrieben, die das Schreiben eines Python- und C++ -Plugins erheblich erleichtern. Wollte Ihr ein vollständig programmiertes "echtes" Python-Plugin begutachten, so empfehle ich mein "HN: Pfeil zeichen"-Plugin (http://www.gimpforum.de/showthread.php?t=24074).
Übrigens: Ich erstelle und teste meine Python-Plugins unter "Windows 10" mit Hilfe der freien Entwicklungsumgebung "Microsoft Visual Studio Community 2019, Version 16.5.4".

Solltest Ihr Fragen haben oder weitere Hilfe brauchen, stehe ich Euch gerne zur Verfügung.

Gruß Tscheppo

Geändert von Tscheppo (10.05.2020 um 14:45 Uhr)
Tscheppo ist offline   Mit Zitat antworten
 

Lesezeichen

Stichworte
plugins , python , python-fu , windows

Themen-Optionen
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist An.
Smileys sind An.
[IMG] Code ist An.
HTML-Code ist Aus.

Gehe zu

Ähnliche Themen
Thema Autor Forum Antworten Letzter Beitrag
Neuling braucht Hilfe Tscheppo Plug-ins 3 12.05.2020 15:31
Plugins in Python - und zwar richtig schumaml Plug-ins 26 11.05.2019 09:44
Mit Python ein Plugin bauen PeterPKHG Skripte 2 28.12.2017 18:18
[MeetTheGIMP] - Episode 129: Octave Sharpening Python Plugin Wilber GIMP 0 12.12.2009 19:00


Alle Zeitangaben in WEZ +2. Es ist jetzt 15:15 Uhr.


Powered by vBulletin® Version 3.8.2 (Deutsch)
Copyright ©2000 - 2020, Jelsoft Enterprises Ltd.