Skript für Gimp

Hier werden alle anderen GUI-Toolkits sowie Spezial-Toolkits wie Spiele-Engines behandelt.
gahleitner
User
Beiträge: 28
Registriert: Montag 1. Mai 2017, 09:57

Skript für Gimp

Beitragvon gahleitner » Samstag 12. August 2017, 17:58

Hallo, zusammen!

Ich habe mir was für Gimp (großteils mit Hilfe des Prozedurenbrowsers) programmiert: Es soll ein Bild zerlegen (Farbe-zerlegen-HSV), dann die Ebene "Wert" unscharf maskieren und dann wieder zusammenfügen. Leider bekomme ich es nicht in Gang. Konnte auch im Internet diesbezüglich keine brauchbaren Info finden. Kann mir jemand helfen. Hier der Code:

  1. #!/usr/bin/env python
  2.  
  3. from gimpfu import *
  4.  
  5. def sharpen(img,layer):
  6.     img=gimp.Image() #3264mal2448
  7.     pdb.plug_in_decompose(0,img,layers,"HSV",3) #Zerlegen
  8.     img.set_active_layer(img,"Value")
  9.     pdb.plug_in_unsharp_mask(1,img,layer,2,9,0)
  10.     pdb.plug_in_compose(0,"Hue","Saturation","Value","HSV") # Zusammensetzen      
  11.    
  12. register(
  13.     "",#python_fu_test_hello_world",
  14.     "",#Hello world",
  15.     "",#Display a 'hello world' message",
  16.     "JFM",
  17.     "",#Open source (BSD 3-clause license)",
  18.     "2013",
  19.     "<Image>/Colors/Auto/Scharfmacher",
  20.     "*",
  21.     [],
  22.     [],
  23.     sharpen)
  24.    
  25. main()
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Samstag 12. August 2017, 20:55

Einzelne Prozeduren könntest Du einfacher Schritt für Schritt in der Python-Fu-Console testen.

Wenn ich da einen Test mache, erhalte ich bei plug_in_unsharp_mask eine Fehlermeldung wegen des ersten Parameters. Der wird zwar im Prozeduren-Browser so mit aufgeführt,

  1. INT32 The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }

doch das könnte sich auf Scheme-Scripts beziehen, da es sich um ein anderes Plugin handelt. Wenn ich den weglasse und die gewohnte Reihenfolge für Python-Plugins benutze, funktioniert das auch bei mir, liefert aber alles andere als eine Unschärfe, eher eine extreme Schärfe mit einer Reduzierung der Farben, in Abhängigkeit von den restlichen Parametern. Doch es funktioniert zumindest mit Konsole:

  1. >>> image = gimp.image_list()[0]
  2. >>> ebene = image.layers[0]
  3. >>> pdb.plug_in_unsharp_mask(image, ebene, 2, 9, 0)

Und wenn ich so wie in Deinem Beispiel gimp.Image() leer aufrufe, dann erhalte ich dieses Ergebnis:

  1. >>> img=gimp.Image()
  2. Traceback (most recent call last):
  3.   File "<input>", line 1, in <module>
  4. TypeError: Required argument 'width' (pos 1) not found
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Sonntag 13. August 2017, 06:37

Also, habe noch einmal gesucht, "plug_in_unsharp_mask" ist seit Gimp 1.2 oder früher unter folgenden Menüpunkt erreichbar und dort kannst Du die Einstellungen testen:

  1. <Image>/Filters/Enhance/Unsharp Mask...
  2.  
  3. # Quelle: "http://oldhome.schmorp.de/marc/pdb/plug_in_unsharp_mask.html"
  4.  
  5. # Menüpfad auf Deutsch:
  6. <Image>/Filter/Verbessern/Unscharf maskieren

Die Schreibweise erfolgte in bei github.com gefundenen Plugins ohne Angabe des ersten Parameters:

  1. pdb.plug_in_unsharp_mask(image, drawable, ...)

Ebenfalls im nachfolgenden Tutorial:

  1. workimg = pdb.gimp_image_duplicate(image)
  2. # ...
  3. # ...
  4. pdb.plug_in_unsharp_mask(workimg, drawable, 0.1, 0.5, 25)

http://www.photomappe.de/gimp/python-bildskalierung/

Nur einen Hinweis, warum im Prozeduren-Browser ein erster Parameter mit 0 oder 1 oder Konstanten erwähnt wird, habe ich nicht gefunden. Das könnte sich aber bei Python-Plugins halt anders verhalten als bei Scheme-Scripts und irgendwie damit zusammenhängen.
gahleitner
User
Beiträge: 28
Registriert: Montag 1. Mai 2017, 09:57

Re: Skript für Gimp

Beitragvon gahleitner » Sonntag 13. August 2017, 08:53

Hallo!
Vielen Dank. Es soll auch eine Schärfe erzeugen - mit den Einstellungen muss ich noch ein bisschen probieren.

Ein anderes Problem: Mit decompose:
  1. >>> pdb.plug_in_decompose(image,ebene,"HSV",2)
  2. Traceback (most recent call last):
  3.   File "<input>", line 1, in <module>
  4. RuntimeError: calling error

Mir sagt die Meldung nichts. Wie es aussieht, liegt es am letzten Parameter (layers-mode - es wird ein Integer verlangt). Woher weiß ich, welche Zahl ich da eingeben muss.
Das Plugin soll folgendes machen: Es soll das Bild über Farben-Komponenten-Zerlegen in Ebenen zerlegen. Es soll HSV und "in Ebenen zerlegen" ausgewählt sein -Ok. Ebene "Wert" mit vorgegebenen Werten unscharf maskieren. Dann die Ebenen zusammensetzen (mit Farben-Komponenten-zusammensetzen-HSV).
gahleitner
User
Beiträge: 28
Registriert: Montag 1. Mai 2017, 09:57

Re: Skript für Gimp

Beitragvon gahleitner » Sonntag 13. August 2017, 08:58

Hallo!
Bei compose gibt es auch ein Problem:
pdb.plug_in_compose("Hue","Saturation","Value","HSV")
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: wrong number of parameters

Hab es auch mit drawable_compose versucht - mit folgenden Fehlermeldungen:
>>> pdb.plug_in_drawable_compose(image,"Hue","Saturation","Value","HSV")
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: wrong number of parameters
>>> pdb.plug_in_drawable_compose(image,"Hue","Saturation","Value",None,"HSV")
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: wrong parameter type
>>> pdb.plug_in_drawable_compose(image,"Hue","Saturation","Value","None","HSV")
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: wrong parameter type

So wie es aussieht, werden 4Ebenen verlangt. Beim Zerlegen mit HSV sind es aber nur 3. Was kann ich da machen?
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Sonntag 13. August 2017, 09:30

gahleitner hat geschrieben:So wie es aussieht, werden 4Ebenen verlangt. Beim Zerlegen mit HSV sind es aber nur 3. Was kann ich da machen?

Meinst Du Farbkanäle oder Ebenen?
Ebenen kannst Du so viele erzeugen, wie Du möchtest.
Die Anzahl der Farbkanäle kann hingegen nur dem verwendeten Farbmodell oder Farbraum entsprechen.

Hier ist ein fertiges Script zum Testen.

https://gist.github.com/JacksonBates/59 ... 6657578854
gahleitner
User
Beiträge: 28
Registriert: Montag 1. Mai 2017, 09:57

Re: Skript für Gimp

Beitragvon gahleitner » Sonntag 13. August 2017, 12:17

Hallo!

Wenn man ein Bild zerlegt(egal ob mit RGB,LAB,HSV,...), entstehen immer drei Kanäle, werden aber im Ebenenregister angezeigt. Wenn ich diese wieder zusammenfüge, entsteht dann ein geschärftes Bild. Ich möchte ja nur Ebene "Wert" schärfen. Das mit unscharf maskieren funktioniert ja schon - ich möchte es aber nur auf einen "Kanal" anwenden.
Würde mich freuen, wenn du mir helfen würdest.

Gruss
Gerhard
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Sonntag 13. August 2017, 13:07

Da müsste ich mich ja auch erst einmal einarbeiten.

  1. >>> image = gimp.image_list()[0]
  2. >>> ebene = image.layers[0]
  3. >>> pdb.plug_in_decompose(1, image, ebene, RGB, 3)
  4. Traceback (most recent call last):
  5.   File "<input>", line 1, in <module>
  6. TypeError: wrong number of parameters


  1. >>> image = gimp.image_list()[0]
  2. >>> ebene = image.layers[0]
  3. >>> pdb.plug_in_decompose(image, ebene, RGB, 3)
  4. Traceback (most recent call last):
  5.   File "<input>", line 1, in <module>
  6. RuntimeError: calling error


So schon einmal nicht, doch wenn ich mir das nächste Listing ansehe, da wird es doch vorgemacht, wie man ein Image richtig mit "pdb.plug_in_decompose" zerlegen und wieder zusammenfügen kann.

  1. lab_images=pdb.plug_in_decompose(img, pseudolab_layer, "RGB", 0)
  2. l_work_layer=pdb.gimp_image_get_active_layer(lab_images[0])
  3. view_image=pdb.plug_in_compose(lab_images[0], l_work_layer, lab_images[1], lab_images[2], lab_images[3], "LAB")

https://github.com/sergeG/gimp-plug-ins ... ecolors.py
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Dienstag 15. August 2017, 12:33

Wenn Du weiter testen möchtest, so sei erwähnt, zuerst das im Fenster geöffnete Image und dessen Ebene auswählen, wobei die Zählung bei 0 beginnt beginnt. Beide Zeilen werden nur in der Konsole benötigt, in einem Plugin haben die nichts verloren. Die übliche Bezeichnung ist nicht ebene, sondern drawable für Auswahl und layer für Ebene, nur konnte ich anfänglich nichts mit der ersten Bezeichnung anfangen.

  1. image = gimp.image_list()[0]
  2. ebene = image.layers[0]

Dann hat gimp.Image() in Deinem Plugin nichts verloren, eigentlich nie, wenn Du einen Filter auf ein vorhandenes Image anwenden möchtest.
Wenn Du hingegen ein neues erzeugen möchtest, ohne ein bestehendes zu öffnen, musst Du zwingend die erforderlichen Werte übergeben.

  1. gimp.Image(width als int, height als int, Type als Konstante oder int)

Die Prozedur mit plug_in_decompose() und bisher gesehene Beispiele verstehe ich immer noch nicht richtig.
Bei "oldhome.schmorp.de/marc/pdb/plug_in_decompose.html" sieht es so aus:

  1. (new_image,new_image,new_image,new_image) = plug_in_decompose (run_mode,image,drawable,decompose_type)

bei "developer.gimp.org" finde ich die nicht und der Prozedurenbrowser übergibt es bei Klick so an die Konsole, die damit richtig liegen sollte, obwohl der Browser es anders beschreibt:

  1. new_image, new_image, new_image, new_image = pdb.plug_in_decompose(image, drawable, decompose_type, layers_mode)

Die Variablen "new_image" stehen somit wohl für einen Tupel [0] bis [3], falls ich mich nicht irren sollte, müsste man an einem funktionierenden Beispiel prüfen. In den gefundenen Beispielen sieht es ja auch danach aus. Irgendwann werde ich mich sicherlich noch damit auseinandersetzen, doch bislang gehe ich noch schrittweise vor. Manuell hatte ich es probiert, also über Menü Farben->Komponenten->zerlegen aufgerufen und ausgeführt und dann im Browser vom neuen Fenster aufgerufen:

  1. image = gimp.image_list()[0]
  2. ebene = image.layers[0]
  3. pdb.plug_in_unsharp_mask(image, ebene, 0.5, 5.0, 0)

Dann auf "später" verschoben. Bis dahin nur Beispiele, wie Du ein Image ebenfalls schärfen kannst.

Als farbiges Image:

  1. >>> # Diese Zeile nur in der Konsole verwenden
  2. >>> image = gimp.image_list()[0]
  3. >>> # Image duplizieren
  4. >>> geschaerftes_image = pdb.gimp_image_duplicate(image)
  5. >>> # Aktive Ebene
  6. >>> ebene = pdb.gimp_image_get_active_drawable(geschaerftes_image)
  7. >>> #Image schärfen
  8. >>> pdb.plug_in_unsharp_mask(geschaerftes_image , ebene, 0.5, 5.0, 0)
  9. >>> # anzeigen
  10. >>> pdb.gimp_display_new(geschaerftes_image)

Als Graustufen-Image:

  1. >>> # Diese Zeile nur in der Konsole verwenden
  2. >>> image = gimp.image_list()[0]
  3. >>> # Image duplizieren
  4. >>> geschaerftes_image = pdb.gimp_image_duplicate(image)
  5. >>> # Aktive Ebene
  6. >>> ebene = pdb.gimp_image_get_active_drawable(geschaerftes_image)
  7. >>> # Image in Graustufen
  8. >>> pdb.gimp_desaturate_full(ebene, DESATURATE_LIGHTNESS)
  9. >>> #Image schärfen
  10. >>> pdb.plug_in_unsharp_mask(geschaerftes_image , ebene, 0.5, 5.0, 0)
  11. >>> # anzeigen
  12. >>> pdb.gimp_display_new(geschaerftes_image)
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Dienstag 15. August 2017, 20:32

Nun dachte ich, ich wäre fertig aber unten mit den 4-mal delete, ich dachte es würde besser gehen. Bereinigt muss es werden, sonst ist nur ein Aufruf möglich und man muss für einen weiteren Aufruf Gimp erst neu starten.

Enthalten in temp_image bei Verwendung von "HSV":

  1. >>> temp_image = pdb.plug_in_decompose(geklontes_image, ebene_imageklon, "HSV", 0)
  2. >>> print "# Prüfen: {0}".format(type(temp_image))
  3. # Prüfen: <type 'tuple'>
  4. >>> print "# Ergebnis mit HSV: {0}".format(temp_image)
  5. # Ergebnis mit HSV: (<gimp.Image 'Farbton'>, <gimp.Image 'Sättigung'>, <gimp.Image 'Wert'>, None)

Enthalten in temp_image bei Verwendung von "RGB":

  1. >>> temp_image = pdb.plug_in_decompose(geklontes_image, ebene_imageklon, "RGB", 0)
  2. >>> print "# Prüfen: {0}".format(type(temp_image))
  3. # Prüfen: <type 'tuple'>
  4. >>> print "# Ergebnis mit RGB: {0}".format(temp_image)
  5. # Ergebnis mit RGB: (<gimp.Image 'Rot'>, <gimp.Image 'Grün'>, <gimp.Image 'Blau'>, None)

Abschließendes Aufräumen erster Versuch:

  1. >>> for temp in range(temp_image):
  2. ...     print temp
  3. ...
  4. Traceback (most recent call last):
  5.   File "<input>", line 1, in <module>
  6. TypeError: range() integer end argument expected, got tuple.

Abschließendes Aufräumen letzter Versuch. Keine Fehlermeldung beim ersten Aufruf, dafür beim zweiten um so mehr, weil nicht bereinigt. Nur mit del temp_image funktionierte es ebenfalls nicht.

  1. for temp in range(len(temp_image)):
  2.     pdb.gimp_image_delete(temp_image[temp])

So funktioniert es, habe es nun erst einmal so belassen, soweit es fertig ist. Ist ja dann nur noch in eine Funktion übernehmen und die Registrierung.

  1. # Die erste Zeile nur in der Konsole verwenden.
  2. image = gimp.image_list()[0]
  3.  
  4. # In die Gruppe der rückgängig-machbaren Prozeduren einreihen?
  5. pdb.gimp_image_undo_group_start(image)
  6. # Image duplizieren
  7. geklontes_image = pdb.gimp_image_duplicate(image)
  8. ebene_imageklon = geklontes_image.layers[0]
  9. # Image zerlegen und in Tupel speichern
  10. temp_image = pdb.plug_in_decompose(geklontes_image, ebene_imageklon, "HSV", 0)
  11. # Aktive Ebene
  12. arbeits_ebene = pdb.gimp_image_get_active_layer(temp_image[0])
  13. # Arbeits-Ebene schärfen
  14. pdb.plug_in_unsharp_mask(geklontes_image, arbeits_ebene, 0.5, 5.0, 0)
  15. # Image wieder vereinen, die Reihenfolge ist vorgegeben.
  16. neues_image = pdb.plug_in_compose(
  17.                      temp_image[0],
  18.                      arbeits_ebene,
  19.                      temp_image[1],
  20.                      temp_image[2],
  21.                      temp_image[3],
  22.                      "HSV")    
  23. # Ausgabe
  24. pdb.gimp_display_new(neues_image)                    
  25. # Einreihen Ende an dieser Stelle?
  26. pdb.gimp_image_undo_group_end(image)  
  27.  
  28. # Tupel zwinged aufräumen, ansonsten ist
  29. # nur ein Aufruf pro Gimp-Sitzung möglich.
  30. pdb.gimp_image_delete(temp_image[0])
  31. pdb.gimp_image_delete(temp_image[1])
  32. pdb.gimp_image_delete(temp_image[2])
  33. pdb.gimp_image_delete(temp_image[3])
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Dienstag 15. August 2017, 23:16

Der Fehler mit der For-Schleife lag einfach daran, dass die Python-Fu-Console das Ende der Schleife nicht erkannt hat und bei einem nachfolgenden Test-Kommentar den genauso weit einrückte, wie den Schleifenrumpf. Zum Glück nur die Konsole.

Dann ärgerte noch das None aus temp_image, weil delete nun auf eine nicht mehr existierende Image-ID angewendet wurde:

  1. (<gimp.Image 'Farbton'>, <gimp.Image 'Sättigung'>, <gimp.Image 'Wert'>, None)
  2. (<gimp.Image 'Rot'>, <gimp.Image 'Grün'>, <gimp.Image 'Blau'>, None)


Nun funktioniert das Plugin:

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from gimpfu import pdb, register, main, PF_IMAGE, PF_DRAWABLE
  5.  
  6. # Nur für Fehler bei der Registrierung.
  7. # Danach diese 3 Zeilen auskommentieren oder entfernen.
  8. import sys
  9. import os
  10. sys.stderr = open(os.path.normcase("C:/.../gimpfehler.txt"), "a")
  11.  
  12. def erhoehe_schaerfe(image, ebene):
  13.     # In die Gruppe der rückgängig-machbaren Prozeduren einreihen?
  14.     pdb.gimp_image_undo_group_start(image)
  15.  
  16.     # Image duplizieren
  17.     geklontes_image = pdb.gimp_image_duplicate(image)
  18.     ebene_imageklon = geklontes_image.layers[0]
  19.     # Image zerlegen und in Tupel speichern
  20.     temp_image = pdb.plug_in_decompose(geklontes_image, ebene_imageklon, "HSV", 0)
  21.     # Aktive Ebene
  22.     arbeits_ebene = pdb.gimp_image_get_active_layer(temp_image[0])
  23.     # Arbeits-Ebene schärfen
  24.     pdb.plug_in_unsharp_mask(geklontes_image, arbeits_ebene, 0.5, 5.0, 0)
  25.     # Image wieder vereinen, die Reihenfolge ist vorgegeben.
  26.     neues_image = pdb.plug_in_compose(
  27.                          temp_image[0],
  28.                          arbeits_ebene,
  29.                          temp_image[1],
  30.                          temp_image[2],
  31.                          temp_image[3],
  32.                          "HSV")
  33.     # Ausgabe
  34.     pdb.gimp_display_new(neues_image)
  35.  
  36.     # Einreihen Ende an dieser Stelle?
  37.     pdb.gimp_image_undo_group_end(image)
  38.  
  39.     # Tupel zwinged aufräumen, ansonsten ist nur ein Aufruf
  40.     # pro Gimp-Sitzung möglich.
  41.     for i in range(len(temp_image)):
  42.         if temp_image[i] is not None:
  43.             pdb.gimp_image_delete(temp_image[i])
  44.  
  45. register(
  46.     "erhoehe_schaerfe",
  47.     "Schärfe erhöhen",
  48.     "Schärfe von Images erhöhen",
  49.     "Mele Melewo",
  50.     "MIT-Lizenz",
  51.     "2017",
  52.     "Filter Schärfe",
  53.     "*",
  54.     [
  55.         (PF_IMAGE,    "image", "Input Image", None),
  56.         (PF_DRAWABLE, "ebene", "Input Ebene", None)
  57.     ],
  58.     [],
  59.     erhoehe_schaerfe,
  60.     menu="<Image>/Filters/Eigene")
  61.  
  62. main()
Melewo
User
Beiträge: 237
Registriert: Mittwoch 3. Mai 2017, 16:30

Re: Skript für Gimp

Beitragvon Melewo » Mittwoch 16. August 2017, 18:13

Habe noch einige Varianten durchgespielt, die beiden Zeilen "gimp_image_duplicate" und "layers" vom Duplikat sind eigentlich über, weil ohnehin ein neues Image erstellt wird.

Weiterhin ergibt "gimp_image_undo_group_..." in diesem Zusammenhang eher wenig Sinn. Mit "gimp_image_undo_group_..." erscheint ein Eintrag unter Menü Bearbeiten->Rückgängig, ohne nicht. Doch ein neu erstelltes Image in einem neuen Fenster wird ja ohnehin nicht mehr rückgängig gemacht. Wichtig wird undo_group erst, wenn mehrere Prozeduren für ein Image folgen, die dann der Reihe nach rückgängig gemacht werden könnten. Schaden tun sie aber halt auch nicht, womit es so aussehen könnte:

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from gimpfu import pdb, register, main, PF_IMAGE, PF_DRAWABLE
  5.  
  6. def erhoehe_schaerfe(image, ebene):
  7.     pdb.gimp_image_undo_group_start(image)
  8.  
  9.     temp_image = pdb.plug_in_decompose(image, ebene, "HSV", 0)
  10.     arbeits_ebene = pdb.gimp_image_get_active_layer(temp_image[0])
  11.     pdb.plug_in_unsharp_mask(image, arbeits_ebene, 0.5, 5.0, 0)
  12.     neues_image = pdb.plug_in_compose(
  13.                          temp_image[0],
  14.                          arbeits_ebene,
  15.                          temp_image[1],
  16.                          temp_image[2],
  17.                          temp_image[3],
  18.                          "HSV")
  19.  
  20.     pdb.gimp_image_undo_group_end(image)
  21.     pdb.gimp_display_new(neues_image)
  22.  
  23.     for i in range(len(temp_image)):
  24.         if temp_image[i] is not None:
  25.             pdb.gimp_image_delete(temp_image[i])
  26.  
  27. register(
  28.     "erhoehe_schaerfe",
  29.     "Schärfe erhöhen",
  30.     "Schärfe von Images erhöhen",
  31.     "Mele Melewo",
  32.     "MIT-Lizenz",
  33.     "2017",
  34.     "Filter Schärfe",
  35.     "*",
  36.     [
  37.         (PF_IMAGE,    "image", "Input Image", None),
  38.         (PF_DRAWABLE, "ebene", "Input Ebene", None)
  39.     ],
  40.     [],
  41.     erhoehe_schaerfe,
  42.     menu="<Image>/Filters/Eigene")
  43.  
  44. main()

Zurück zu „Sonstige (Pygame, PyOpenGL, ...)“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder