Un court tutoriel sur le script d'extension GIMP (Python-Fu). Voici quelques méthodes de base pour travailler avec GIMP à partir de Python. Le niveau de difficulté est faible car il s'agit d'un didacticiel plus familier que l'apprentissage.
GIMP est un outil de dessin open source. De manière catégorique, il s'agit d'un outil de peinture qui manipule les images pixel par pixel. Il a de nombreuses fonctionnalités, mais vous pouvez l'utiliser gratuitement. Il fonctionne nativement sur Mac OS X depuis plusieurs années (sans avoir besoin de X11). L'outil de dessin n'est pas inclus dans le Mac par défaut, c'est donc l'une des bonnes applications à inclure.
Ce tutoriel suppose GIMP 2.8. Si la version est proche de la 2.8, vous pouvez l'exécuter sans aucune modification.
GIMP est livré avec une bibliothèque d'extension, qui vous permet d'exploiter GIMP par programmation. La bibliothèque de cette extension est encapsulée en Python et s'appelle Python-Fu.
Python-Fu permet aux scripts Python d'ajouter des fonctionnalités à GIMP et d'automatiser les opérations GIMP. Ceci est pratique lorsque vous souhaitez exécuter une grande quantité de traitement de routine ou de traitement itératif en modifiant les paramètres petit à petit. Par exemple, si vous souhaitez ajouter des lignes concentrées à l'arrière-plan d'une image, il est plus facile de dessiner manuellement des dizaines de lignes par programmation.
Tout va bien, j'ai donc utilisé des outils de dessin, et c'est suffisant pour écrire du Python.
Je suis désolé s'il y a une erreur quelque part.
Téléchargez et installez le binaire de votre système d'exploitation depuis ici.
Pour Mac OS X, une vérification de sécurité sera appliquée la première fois que vous lancerez l'application. Vous pouvez contourner la vérification en la démarrant avec Ctrl-clic, mais faites-le à vos risques et périls. De plus, le premier démarrage prend un peu de temps en raison du processus d'initialisation.
Cette fois, je vais vous montrer comment exécuter un script Python-Fu depuis la console Python-Fu.
Dans le menu GIMP, sélectionnez Filtre >> Python-Fu >> Console pour ouvrir la console Python-Fu et vous demander Python.
La bibliothèque GIMP a déjà été chargée avec cette invite. Aucun travail supplémentaire n'est requis pour utiliser les fonctionnalités GIMP de Python. Il est possible de faire fonctionner GIMP en appelant soudainement une fonction dans la bibliothèque.
Nous avons préparé un exemple de script pour vous donner une idée des fonctionnalités de Python-Fu.
Essayez de copier tout le code ci-dessous et de le coller dans la console Python-Fu. Lorsque vous avez terminé de taper vers main () en bas, une nouvelle fenêtre devrait s'ouvrir avec l'image. Veuillez l'essayer d'abord.
# Python-Exemple de script Fu
#GIMP Python-Copiez et collez sur la console Fu et exécutez
#Création de données d'image
##Créer des données d'image avec la taille spécifiée
### width :Largeur des données d'image(px)
### height :Hauteur des données d'image(px)
def create_image(width, height):
#Générer des données d'image
return gimp.Image(width, height, RGB)
#Ajouter une couche
##Créez un nouveau calque avec le nom spécifié et insérez-le dans les données d'image
### image :Données d'image pour ajouter un calque
### name :Nom (chaîne de caractères) du calque nouvellement créé
def add_layer(image, name):
#Paramètres requis pour créer un calque
width = image.width
height = image.height
type = RGB_IMAGE
opacity = 100
mode = NORMAL_MODE
#
#Créer une couche basée sur les paramètres
layer = gimp.Layer(image, name, width, height, type, opacity, mode)
#
#Remplissez le calque avec la couleur d'arrière-plan (correspondant au comportement par défaut de GIMP)
layer.fill(1)
#
#Insérer un calque à la 0ème position des données d'image
position = 0
image.add_layer(layer, position)
#
return layer
#Tracez une ligne avec l'outil crayon
##Tracez une ligne reliant les chaînes de coordonnées stockées dans le tableau dans la zone de dessin avec l'outil crayon
### drawable :Zone de dessin (calque, etc.)
### lines :Un tableau contenant les chaînes de coordonnées des lignes dessinées
def draw_pencil_lines(drawable, lines):
#Tracez une ligne avec l'outil crayon
pdb.gimp_pencil(drawable, len(lines), lines)
#Dessinez un rectangle avec l'outil crayon
##Dessinez un rectangle dans la zone de dessin en fonction des coordonnées supérieure gauche et inférieure droite
### drawable :Zone de dessin (calque, etc.)
### x1 :Coordonnée X supérieure gauche
### y1 :Coordonnée Y supérieure gauche
### x2 :Coordonnée X inférieure droite
### y2 :Coordonnée Y inférieure droite
def draw_rect(drawable, x1, y1, x2, y2):
lines = [x1, y1, x2, y1, x2, y2, x1, y2, x1, y1]
draw_pencil_lines(drawable, lines)
#Tracez une ligne avec un aérographe
##Tracez une ligne reliant les chaînes de coordonnées stockées dans le tableau dans la zone de dessin avec un aérographe
### drawable :Zone de dessin (calque, etc.)
### pressure :Pression du stylo(0-100)
### lines :Un tableau contenant les chaînes de coordonnées des lignes dessinées
def draw_airbrush_lines(drawable, pressure, lines):
#Tracez une ligne avec un aérographe
pdb.gimp_airbrush(drawable, pressure, len(lines), lines)
#Dessinez une chaîne
##Dessine une chaîne de caractères dans la zone de dessin spécifiée
### drawable :Zone de dessin (calque, etc.)
### x :Coordonnée X de la position pour dessiner la chaîne de caractères
### y :Coordonnée Y de la position pour dessiner la chaîne de caractères
### size :taille de police
### str :Chaîne de caractères à dessiner
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)
#Changer la couleur du dessin
##Changer la couleur de premier plan de la palette pour définir la couleur du dessin
### r :Élément rouge(0-255)
### g :Élément vert(0-255)
### b :Élément bleu(0-255)
### a :Transparence(0-1.0)
def set_color(r, g, b, a):
color = (r, g, b, a)
pdb.gimp_context_set_foreground(color)
#Changer l'épaisseur de la ligne dessinée
##Redimensionner le pinceau pour définir l'épaisseur du trait
### width :Épaisseur de ligne
def set_line_width(width):
pdb.gimp_context_set_brush_size(width)
#Affichage de l'image
##Créer une nouvelle fenêtre et afficher les données d'image
### image :Données d'image à afficher
def display_image(image):
gimp.Display(image)
def main():
image = create_image(640, 400)
layer = add_layer(image, "Contexte")
draw_rect(layer, 390, 210, 490, 310)
draw_text(layer, 200, 180, 20, "Bonjour")
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()
Si tout s'est bien passé, une nouvelle fenêtre aurait dû être créée avec l'image.
Avez-vous obtenu cela en 5 minutes? C'est juste l'installation et la copie de logiciels, donc je pense qu'il n'y avait pas une partie difficile qui pourrait trébucher.
Ensuite, j'expliquerai le contenu du traitement du script que je viens d'exécuter.
Dans le script ci-dessus, tout d'abord, les fonctions auxiliaires nécessaires pour créer et traiter les données d'image sont définies. Fonctions de sécurisation des données d'image dans le programme, fonctions de création de calques, fonctions nécessaires pour dessiner des figures, fonctions d'écriture de chaînes de caractères, fonctions d'affichage d'images créées, etc.
Lorsque ces fonctions auxiliaires sont terminées, les fonctions auxiliaires sont appelées dans l'ordre dans la fonction main () pour créer et afficher réellement l'image.
Ci-dessous, je voudrais examiner de plus près la mise en œuvre des fonctions auxiliaires en fonction de la structure du programme.
Lors de la création d'une image avec GIMP, créez d'abord les données d'image.
Les données d'image sont un conteneur pour les couches. Les images telles que les figures ne sont pas stockées directement dans les données d'image, mais dans les couches qu'elles contiennent. Lorsque vous enregistrez les données d'image, elles deviennent un fichier image.
Des informations de réglage telles que la largeur, la hauteur et le type d'image sont nécessaires pour créer des données d'image. La largeur et la hauteur sont spécifiées en pixels. Le type d'image peut être RVB, GRIS, INDEXÉ, etc.
Les données d'image sont créées avec la fonction gimp.Image () de Python-Fu. La partie suivante au début du script est une fonction qui crée des données d'image.
#Création de données d'image
##Créer des données d'image avec la taille spécifiée
### width :Largeur des données d'image(px)
### height :Hauteur des données d'image(px)
def create_image(width, height):
#Générer des données d'image
return gimp.Image(width, height, RGB)
Appelez la fonction create_image comme suit:
image = create_image(640, 400)
Cela crée des données d'image avec une largeur de 640 pixels, une hauteur de 400 pixels et une couleur RVB.
Ensuite, ajoutez un calque aux données d'image. L'image sera dessinée sur un calque, vous avez donc besoin d'au moins un calque.
La fonction Python-Fu pour créer des couches est gimp.Layer (). Transmettez les données d'image, le nom du calque, la largeur du calque, la hauteur, le type d'image, l'opacité et le mode aux arguments de gimp.Layer ().
Après avoir créé le calque, remplissez-le avec la couleur d'arrière-plan. Cela correspond au comportement lors de la création de couches à partir de l'interface graphique de l'application GIMP. Lorsque vous ajoutez un calque avec GIMP, il se comporte comme un remplissage avec la couleur d'arrière-plan par défaut.
Ensuite, utilisez la fonction gimp.Image.add_layer () pour associer le calque aux données d'image. L'argument position est un paramètre qui spécifie la position à partir du haut pour ajouter la couche.
La mise en œuvre de la fonction pour ajouter une couche est la suivante.
#Ajouter une couche
##Créez un nouveau calque avec le nom spécifié et insérez-le dans les données d'image
### image :Données d'image pour ajouter un calque
### name :Nom (chaîne de caractères) du calque nouvellement créé
def add_layer(image, name):
#Paramètres requis pour créer un calque
width = image.width
height = image.height
type = RGB_IMAGE
opacity = 100
mode = NORMAL_MODE
#
#Créer une couche basée sur les paramètres
layer = gimp.Layer(image, name, width, height, type, opacity, mode)
#
#Remplissez le calque avec la couleur d'arrière-plan (correspondant au comportement par défaut de GIMP)
layer.fill(1)
#
#Insérer un calque à la 0ème position des données d'image
position = 0
image.add_layer(layer, position)
#
return layer
Dans le Markdown de Qiita, il semble que les lignes vides soient converties en lignes vierges et l'indentation se termine, j'ai donc ajouté un caractère de commentaire (#) comme solution de contournement.
La fonction add_layer () est appelée dans la fonction main () comme suit.
layer = add_layer(image, "Contexte")
Lorsque cela est fait, un calque nommé "Arrière-plan" est créé et ajouté aux données d'image.
Maintenant que vous avez créé le calque, vous êtes prêt à commencer à dessiner. Comme base du traitement d'image, préparez tout d'abord une méthode de dessin de ligne.
Lorsque vous travaillez avec Python-Fu, utilisez des outils tels que des stylos et des pinceaux dans GIMP, comme vous le feriez pour dessiner avec l'application GIMP. Ici, nous définissons une fonction pour dessiner une ligne à l'aide de l'outil crayon.
Vous pouvez utiliser la fonction pdb.gimp_pencil () fournie par Python-Fu pour dessiner une ligne avec l'outil crayon. L'argument de la fonction pdb.gimp_pencil () est un tableau qui stocke la zone de dessin telle qu'un calque, le nombre de coordonnées que traverse la ligne et les coordonnées que traverse la ligne.
Il semble que la raison pour laquelle le nombre de coordonnées est passé en argument est que ce gimp_pencil () est un wrapper pour la fonction C. Il n'y a aucun moyen de connaître le nombre d'éléments dans un tableau en C, vous devez donc indiquer explicitement la fonction.
#Tracez une ligne avec l'outil crayon
##Tracez une ligne reliant les chaînes de coordonnées stockées dans le tableau dans la zone de dessin avec l'outil crayon
### drawable :Zone de dessin (calque, etc.)
### lines :Un tableau contenant les chaînes de coordonnées des lignes dessinées
def draw_pencil_lines(drawable, lines):
#Tracez une ligne avec l'outil crayon
pdb.gimp_pencil(drawable, len(lines), lines)
La fonction draw_pencil_lines () est appelée par la fonction draw_rect () suivante.
Ensuite, préparez un rectangle, c'est-à-dire une fonction qui dessine un rectangle. Pour dessiner un rectangle, utilisez la fonction draw_pencil_lines () créée précédemment au lieu de la fonction Python-Fu.
Dans le code ci-dessous, la fonction draw_pencil_lines () qui dessine une ligne reçoit un tableau qui trace les quatre côtés du rectangle pour dessiner un rectangle.
#Dessinez un rectangle avec l'outil crayon
##Dessinez un rectangle dans la zone de dessin en fonction des coordonnées supérieure gauche et inférieure droite
### drawable :Zone de dessin (calque, etc.)
### x1 :Coordonnée X supérieure gauche
### y1 :Coordonnée Y supérieure gauche
### x2 :Coordonnée X inférieure droite
### y2 :Coordonnée Y inférieure droite
def draw_rect(drawable, x1, y1, x2, y2):
lines = [x1, y1, x2, y1, x2, y2, x1, y2, x1, y1]
draw_pencil_lines(drawable, lines)
La fonction draw_rect () est appelée comme suit:
draw_rect(layer, 390, 210, 490, 310)
Cela dessinera un rectangle avec la couleur par défaut et la largeur de ligne par défaut. J'expliquerai plus tard comment changer la couleur et la largeur de ligne lors du dessin.
Nous fournissons également une fonction pour dessiner une ligne à l'aide d'un aérographe au lieu de l'outil crayon. L'aérographe est disponible dans la fonction pdb.gimp_airbrush (). Les arguments de pdb.gimp_airbrush () sont presque les mêmes que pdb.gimp_pencil (), mais avec l'ajout d'un paramètre pour spécifier la pression du stylet.
#Tracez une ligne avec un aérographe
##Tracez une ligne reliant les chaînes de coordonnées stockées dans le tableau dans la zone de dessin avec un aérographe
### drawable :Zone de dessin (calque, etc.)
### pressure :Pression du stylo(0-100)
### lines :Un tableau contenant les chaînes de coordonnées des lignes dessinées
def draw_airbrush_lines(drawable, pressure, lines):
#Tracez une ligne avec un aérographe
pdb.gimp_airbrush(drawable, pressure, len(lines), lines)
La fonction draw_airbrush_lines () est appelée dans la fonction main () comme suit. Tout d'abord, le chemin de la ligne que vous souhaitez dessiner est mis ensemble dans un tableau et la fonction est appelée avec cela comme argument. La pression du stylet est spécifiée à 75.
lines = [110,90, 120,180, 130,110, 140,150]
draw_airbrush_lines(layer, 75, lines)
Si vous souhaitez mettre un message texte dans l'image, utilisez la fonction pdb.gimp_text_fontname (). En plus de la chaîne de caractères que vous souhaitez dessiner, spécifiez des paramètres tels que la taille de la police et s'il faut effectuer un traitement anti-crénelage. La fonction draw_text () est une fonction qui encapsule pdb.gimp_text_fontname () afin qu'une chaîne de caractères puisse être dessinée en ne donnant que les informations minimales nécessaires.
#Dessinez une chaîne
##Dessine une chaîne de caractères dans la zone de dessin spécifiée
### drawable :Zone de dessin (calque, etc.)
### x :Coordonnée X de la position pour dessiner la chaîne de caractères
### y :Coordonnée Y de la position pour dessiner la chaîne de caractères
### size :taille de police
### str :Chaîne de caractères à dessiner
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)
La façon d'appeler la fonction draw_text () est la suivante. La zone de dessin, la coordonnée X de la position où le caractère est écrit, la coordonnée Y, la taille de la police et la chaîne de caractères à dessiner sont passées en arguments et exécutées.
draw_text(layer, 200, 180, 20, "Bonjour")
La couleur utilisée pour dessiner une figure ou une chaîne de caractères est celle définie dans la couleur de premier plan dans la palette de couleurs GIMP. La fonction qui définit la couleur de premier plan de la palette de couleurs est pdb.gimp_context_set_foreground (), et les données de couleur sont représentées par un taple de R, V, B, A.
Ici, par souci de clarté, nous avons donné un alias appelé set_color, et chaque élément de RGBA est passé comme argument séparément.
#Changer la couleur du dessin
##Changer la couleur de premier plan de la palette pour définir la couleur du dessin
### r :Élément rouge(0-255)
### g :Élément vert(0-255)
### b :Élément bleu(0-255)
### a :Transparence(0-1.0)
def set_color(r, g, b, a):
color = (r, g, b, a)
pdb.gimp_context_set_foreground(color)
Dans la fonction main (), cette fonction est utilisée pour définir la couleur rouge.
set_color(255,0,0,1.0) # Red
La fonction qui spécifie l'épaisseur de l'outil crayon et de l'aérographe est la fonction pdb.gimp_context_set_bursh_size (). Dans le code ci-dessous, nous avons donné l'alias set_line_width () pour plus de clarté.
#Changer l'épaisseur de la ligne dessinée
##Redimensionner le pinceau pour définir l'épaisseur du trait
### width :Épaisseur de ligne
def set_line_width(width):
pdb.gimp_context_set_brush_size(width)
Si vous souhaitez dessiner une ligne d'une largeur de 1 pixel, spécifiez 1 pour l'argument comme celui-ci.
set_line_width(1)
Une fois le traitement d'image terminé, les données d'image s'affichent sur le bureau. Si vous spécifiez des données d'image comme argument de la fonction gimp.Display () et que vous l'exécutez, une nouvelle fenêtre sera créée et l'image sera affichée.
Comme précédemment, nous lui avons également donné un alias facile à comprendre.
#Affichage de l'image
##Créer une nouvelle fenêtre et afficher les données d'image
### image :Données d'image à afficher
def display_image(image):
gimp.Display(image)
La manière d'appeler la fonction display_image () est la suivante.
display_image(image)
Voici la fonction main (). Les appels de fonction qui ont été définis jusqu'à présent sont résumés en un seul endroit.
En Python, la fonction main () n'est pas définie comme le point d'entrée du programme, nous la nommons donc simplement main selon une convention commune.
def main():
image = create_image(640, 400)
layer = add_layer(image, "Contexte")
draw_rect(layer, 390, 210, 490, 310)
draw_text(layer, 200, 180, 20, "Bonjour")
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()
C'est la fin de l'explication du programme. La principale différence avec les bibliothèques de traitement d'images générales est qu'elles utilisent les mécanismes d'application de GIMP tels que les pinceaux et les palettes. Si vous avez utilisé des outils de dessin, je pense qu'il n'y a rien de difficile à ce sujet.
Tout d'abord, modifiez le programme ci-dessus pour changer la couleur et la largeur de la ligne, changez la forme de la figure, changez la pression du stylet de l'outil Air Brush et voyez comment le mouvement change.
Après cela, veuillez consulter la référence API, etc. et créer beaucoup de code plus intéressant. Vous pouvez également trouver utile Python help () et dir ().
Je ne l'ai pas expliqué cette fois, mais vous pouvez également incorporer le script que vous avez créé dans GIMP en tant que plug-in. Si vous vous habituez à écrire des scripts dans une certaine mesure, essayez-le.
http://developer.gimp.org/api/2.0/
https://www.gimp.org/docs/python/
http://gimpbook.com/scripting/
Navigateur de procédures (référence pdb)
Barre de menus >> Aide >> Commencez par sélectionner Navigateur de procédures
Vous pouvez en savoir plus sur les objets Python en utilisant l'aide intégrée () et dir () en Python. L'exemple d'utilisation est présenté ci-dessous.
Vous pouvez utiliser la fonction help () pour obtenir de l'aide sur les objets Python.
>>> 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
...
Vous pouvez utiliser la fonction dir () pour voir les membres d'un objet Python.
>>> 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
...
Jusqu'à présent, nous avons couvert les étapes pour démarrer avec Python-Fu, l'interface de script pour les extensions GIMP. J'espère que tu trouves cela utile.
__ Fin __
Recommended Posts