GIMP - Initiation au Script-Fu

Programmer en Scheme avec Gimp (Licence creative commons).

Gimp permet de réaliser des traitements sur des images en effectuant une succession d'opérations réalisées à l'aide des menus proposés en haut de la fenêtre principale du programme.
Dans certains cas, la série d’opérations à effectuer peut se révéler relativement longue, c’est pourquoi Gimp offre la possibilité de les regrouper au sein d’un script. L’exécution automatique de ce script permet ainsi de gagner du temps lorsque les mêmes opérations sont à reproduire souvent ou sur plusieurs images.

Le Script-Fu est un langage de programmation interprété basé sur le langage TinyScheme (langage dérivé du langage Scheme qui est lui même dérivé du langage Lisp - List Processing). Le langage Script-Fu fait partie du noyau de Gimp. Tout comme le langage Lisp, il dispose d’une syntaxe en forme de listes encadrées par des parenthèses.

Un script Gimp, également appelé Script-Fu, est un fichier texte (doté d’une extension .scm). Ce fichier peut être créé avec le Bloc-Notes de Windows.
Il est composé d’instructions dont le nombre varie selon la nature du traitement à effectuer. Chacune d’elles peut être testée séparément à l’aide de la console Script-Fu qui fait partie intégrante de Gimp. Cette possibilité permet d’identifier facilement les erreurs de syntaxes pouvant exister au sein d’un script.

L’exemple suivant, crée et affiche, dans la fenêtre principale de Gimp, une image blanche de taille 400x300. Cet exemple ne présente pas d'intérêt en tant que tel mais iIl est suffisamment simple et court pour permettre d'illustrer clairement l'essentiel des opérations importantes : 1-utiliser la console script-fu pour se documenter et tester des instructions; 2-écrire des scripts, placer ces scripts dans le bon répertoire puis les utiliser avec Gimp. Une fois cet exemple de base bien maitrisé, ainsi que la méthode de travail associée, il devient alors possible de se lancer dans l’écriture de scripts plus complexes.

Pour créer une nouvelle image, la méthode naturelle consiste tout simplement à utiliser le menu de la fenêtre pricnipale de Gimp.
1) Lancer Gimp

2) Créer une nouvelle image à l’aide du menu de la fenêtre principale de GIMP. Pour cela, faire «Fichier/Nouvelle image»

Dans la boîte de dialogue qui s’ouvre saisir les valeurs souhaitées pour la largeur et la hauteur de l’image (400x300 par exemple) puis cliquer le bouton «Valider»

L’image souhaitée est automatiquement créée, placée dans un calque et affichée dans la fenêtre principale de Gimp avec la couleur d’arrière plan en cours de la boîte à outils de Gimp

Pour réaliser cette opération, Gimp effectue la succession de tâches suivantes :
1) Création en mémoire (non visible à l’écran ) de l’image ;
2) Création en mémoire (non visible à l’écran ) du calque destiné à contenir l’image ;
3) Affichage de l'image dans le calque avec la couleur d’avant plan en cours ;
4) Remplissage de l’image avec la couleur d’arrière plan en cours.

1- Utiliser la Console Script-Fu

Il est possible de réaliser avec la console Script-Fu l’ensemble des tâches réalisées à l’aide des options de menu de Gimp. Cela s'effectue en écrivant des lignes de commande.

La Console Script-Fu est un outil de développement interactif intégré à Gimp. Il permet d'écrire et d'exécuter en mode ligne par ligne des instructions en langage TinyScheme.
La Console Script-Fu apparaît sous forme d'une fenêtre de travail accessible depuis l'option de menu «Filtres/Script-Fu/Console» de la fenêtre principale de Gimp sous Gimp 2.8 (remarque : faire «Exts/Script-Fu/Console Script-Fu» du menu de la Boîte à outils de Gimp sous Gimp 2.4 ou antérieur).

1) Ouvrir la Console Script-Fu en cliquant l'option de menu «Filtre/Script-Fu/Console».

2) Saisir une par une les instructions suivantes dans la zone de saisie de la console Script-Fu :

(gimp-image-new 400 300 RGB)
Cette instruction crée une nouvelle image de taille 400x300 en mémoire. La valeur 1 retournée par la console script-fu represente le numéro d’identification (id) de cette image en mémoire.

(gimp-layer-new 1 400 300 RGB-IMAGE "MonNomDeCalque" 100 NORMAL-MODE)
Cette instruction crée un calque de taille 400x300 en mémoire et lui attribue le nom «MonNomDeCalque ». Ce calque est nécessaire car l’image doit être associée à un calque. La valeur 2 retournée par la console script-fu represente le numéro d’identification de ce calque en mémoire.

(gimp-image-add-layer 1 2 0)
Cette instruction place l'image 1 dans le calque 2 en mémoire. La valeur #t retournée par la console script fu signifie "true" (vrai). Cela signifie que l'opération s'est déroulée avec succès.

(gimp-display-new 1)
Cette instruction affiche l'image dans le calque, dans la fenêtre principale de Gimp, avec la couleur d'avant plan en cours (noir dans notre exemple). La console script fu retourne l’id de l’image en mémoire, c’est à dire 1.

(gimp-drawable-fill 2 BG-IMAGE-FILL)
Cette instruction remplit l'image affichée avec la couleur d'arrière plan en cours (blanc dans notre exemple). La valeur #t retournée par la console script fu signifie signifie que l'opération s'est déroulée avec succès.

3) Examiner la documentation permettant d'approfondir toutes les instructions Script-Fu disponibles ainsi que leur syntaxe. Celle-ci est accesssible en cliquant le bouton «Parcourir..» de la Console Script-Fu.

Examiner la documentation associée à chaque instruction utilisée.

image gimp-image-new width height type
Cette instruction est une procédure interne de Gimp. Elle crée une nouvelle image en mémoire.

Paramètres :
width INT32 : Largeur de l'image (comprise entre 1 et 262144)
height INT32 : Hauteur de l'image (comprise entre 1 et 262144)
type INT32 : type de l'image (0 pour RGB, 1 pour nuances de gris et 3 pour indexée)

Valeur retournée :
image IMAGE : ID (identificateur) de la nouvelle image créée en mémoire

Information supplémentaire :
Crée une nouvelle image en mémoire (non affichée à l'écran) avec le type spécifié. Un calque devra être créé puis atribué à cette image pour que celle-ci puisse être affichée, sinon les appels suivants à «gimp-display-new» avec cette image comme argument échoueront. Les calques peuvent être créés en utilisant la commande «gimp-layer-new». Ils peuvent être attribués à une image en utilisant la commande «gimp-image-insert-layer» (ou «gimp-image-add-layer» qui devient une commande obsolète).

layer gimp-layer-new image width height type name opacity mode
Cette instruction est une procédure interne de Gimp. Elle crée un nouveau calque en mémoire.

Paramètres :
image IMAGE : l'identificateur (ID) de l'image à laquelle est ajouté le calque
width INT32 : Largeur du calque (comprise entre 1 et 262144)
height INT32 : Hauteur du calque (comprise entre 1 et 262144)
type INT32 : type du calque (0 pour RGB-IMAGE, 1 pour RGBA-IMAGE, 3 pour GRAYA-IMAGE , 4 pour INDEXED-IMAGE et 5 pour pour INDEXEDA-IMAGE )
name STRING : nom attribué au calque
opacity FLOAT : Transparence du calque (comprise entre 0 et 100)
mode INT32 : Mode de combinaison du calque { NORMAL-MODE (0), DISSOLVE-MODE (1…

Valeur retournée :
layer LAYER : ID (identificateur) du nouveau calque créé en mémoire

Informations supplémentaires :
Cette procédure crée un nouveau calque avec la largeur, la hauteur et le type spécifiés. Le nom, l'opacité et le mode du calque sont également fournis en paramètres. Le nouveau calque devra être ajouté à une image et cela n'est pas automatique. Ajouter le nouveau calque avec la commande gimp-image-insert-layer. D'autres attributs tels que les modes de masque du calque ainsi que les décalages éventuels doivent être fixés avec des appels de procédure explicites.

Etc…

2- Ecrire un script simple

Il est possible de regrouper dans un script l’ensemble des instructions décrites précédemment. Ce script peut ensuite être éxécuté automatiquement autant de fois que l’on souhaite.

Ecrire le script suivant avec le Bloc-Notes puis l’enregistrer dans le répertoire «C:/ Program Files/ GIMP2/ lib/ gimp/ 2.0/ share/ gimp/ 2.0/ scripts» avec le nom «ma-nouvelle-image.scm».
Remarque : pour permettre la prise en compte du script par GIMP, le nom du fichier doit obligatoirement être identique au nom attribué au script dans le texte du script.

(
define (script-fu-ma-nouvelle-image )
(gimp-image-new 400 300 RGB)
(gimp-layer-new 1 400 300 RGB-IMAGE "MonNomDeCalque" 100 NORMAL-MODE)
(gimp-image-add-layer 1 2 0)
(gimp-display-new 1)
(gimp-drawable-fill 2 BG-IMAGE-FILL)
)
(

script-fu-register
"script-fu-ma-nouvelle-image"
"<Image>/MesScripts/ma-nouvelle-image"
"--------------"
"Essai de script Gimp"
"Claude Turrier"
"2016"
"------------"
)

11-0

La première partie du script, placée entre une parenthèse ouvrante et une parenthèse fermante, contient une instruction «define» qui définit le nom du script (celui-ci correspond au nom du fichier .scm du script) puis l’ensemble des instructions à exécuter

La seconde partie du script, placée elle aussi entre parenthèses, permet d’enregistrer le script afin que Gimp puisse le prendre en compte.

(
script-fu-register
"script-fu-ma-nouvelle-image"
"<Image>/MesScripts/ma-nouvelle-image"
"-------------------------------"
"Essai de script Gimp"
"Claude Turrier"
"2016"
"-------------------------------"
)

script-fu-register : cette instruction est indispensable pour que Gimp enregistre le script.
"script-fu-ma-nouvelle-image" :cette instruction sert à enregistrer le nom du script dans Gimp
"<Image>/MesScripts/ma-nouvelle-image"
cette instruction sert à faire apparaître une option de menu « MesScripts/ma-nouvelle-image » dans la barre de menu de la fenêtre principale de Gimp. Cette information, précédée de la balise <image>, est indispensable pour que le nom du script puisse apparaitre dans le menu de la fenêtre principale de Gimp.

Puis viennent 5 lignes de commentaires dont la présence est obligatoire pour que le nom du script puisse également apparaitre dans le menu.
"-------------------------------"
"Essai de script Gimp"
"Claude Turrier"
"2016"
"-------------------------------"

Il suffit alors de cliquer l’option de menu «MesScripts/ma-nouvelle-mage» pour reproduire automatiquement la création d’une nouvelle image de taille 400x300 avec un fond blanc.

Améliorer le script

Le script précédent permet de créer une nouvelle image uniquement avec une taille fixe 400x300. Il serait donc utilie de le modifier afin de pouvoir créer des images de tailles variables. Cela peut se faire à l'aide d'une boîte de dialogue permettant de saisir les valeurs à prendre en compte pour la largeur et pour la hauteur de l'image à créer.

(
define (script-fu-ma-nouvelle-image maLargeur maHauteur)
(gimp-image-new maLargeur maHauteur RGB)
(gimp-layer-new 1 maLargeur maHauteur RGB-IMAGE "MonNomDeCalque" 100 NORMAL-MODE)
(gimp-image-add-layer 1 2 0)
(gimp-display-new 1)
(gimp-drawable-fill 2 BG-IMAGE-FILL)
)

(
script-fu-register
"script-fu-ma-nouvelle-image"
"<Image>/MesScripts/ma-nouvelle-image"
"-------------"
"Essai de script Gimp"
"Claude Turrier"
"2016"
"-----------"
SF-VALUE "maLargeur" "100"
SF-VALUE "maHauteur" "100"
)

Les modifications effectuées au sein du script sont les suivantes :
1) Insertion des paramètres maLargeur et maHauteur dans l'instruction «define» qui définit le nom du script
2) Insertion de ces paramètres dans les instructions gimp-image-new et gimp-layer-new qui les utilisent
3) Insertion, à la fin de la partie script-fu-register du script, des indications SF-VALUE "maLargeur" "100" et SF-VALUE "maHauteur" "100"

L'insertion, à la fin de la partie script-fu-register du script, des indications SF-VALUE "maLargeur" "100" et SF-VALUE "maHauteur" "100" permet :
1) l'enregistrement dans l'ordre les paramètres maLargeur maHauteur déclarés dans l'instruction «define»
2) la prise en compte de ces paramètres en tant que valeurs numériques
3) l'ouverture automatique, lors di lancement du script, d'une boîte de dialogue qui permet de saisir les valeurs de largeur et de hauteur d'image à utiliser par le script
4) l'initialisation de la boîte de dialogue avec la valeur 100 pour ces paramètres.

13-0

Le script modifié s'exécute alors automatiquement de la façon suivante :

Cliquer «MesScripts/ma-nouvelle-image» ;

12b

La boîte de dialogue permetttant de saisir les valeurs de maLargeur et maHauteur s'ouvre alors automatiquement. Elle est prérenseignée avec les valeurs 100 (celles indiquées avec le paramètre SF-VALUE pour la largeur et la hauteur ) ;

Saisir les valeurs souhaitées pour la taille de la nouvelle image (300 pour la largeur et 150 pour la hauteur par exemple) puis cliquer le bouton «Valider».

Le script crée une nouvelle image avec la taille souhaitée.

3- Ecrire un script de traitement par lot

Le script suivant ct-mult.scm effectue les tâches décrites ci-après.

Ce script permet de donner du piqué, de façon entièrement automatique, à un lot d'images trop pâles. Après installation du script dans l'environnement de Gimp, il suffit de cliquer le menu "MesScript > ct-mult" (dans la barre de menu de Gimp) pour démarrer l'exécution du script.

Pour chaque fichier image png se trouvant dans le répertoire "home/ubuntu/ess1" le script fait dans l'ordre :
{
1. fichier > ouvrir image.png
2. calque > dupliquer le calque
3. calque du dessus : mode multiplier
4. image > aplatir l'image
5. fichier > enregistrer image.png
}

Installation du script (dans l'environnement de Gimp) : sudo cp ct-mult.scm /usr/share/gimp/2.0/scripts
Suppression du script (de l'environnement de Gimp) : sudo rm /usr/share/gimp/2.0/scripts/ct-mult.scm

Remarques
1) Si les images se trouvent dans un autre répertoire que, "/home/ubuntu/ess1", il suffit d'indiquer ce répertoire dans l'instruction SF-DIRNAME "repertoire" "/home/ubuntu/ess1" si on veut que le chemin correspondant soit affiché par défaut dans la boîte de dialogue (de sélection de répertoire) associée au script. Sinon il suffira de choisir le répertoire souhaité depuis la boîte de dialogue.
2) Il faut penser à sauvegarder les images avant d'appliquer le script car celui-ci traite directement les images puis les enregistre dans le répertoire, à la place des images d'origine, sans conserver une copie des images d'origine.

(define (ct-mult folder-path)
(let* ((files (cadr (file-glob (string-append folder-path "/*.png") 1))))
(while (not (null? files))
(let* ((file (car files))
(image (car (gimp-file-load RUN-NONINTERACTIVE file file)))
(drawable (car (gimp-image-get-active-layer image))))

; Dupliquer le calque
(let* ((layer (car (gimp-layer-copy drawable TRUE))))
(gimp-image-add-layer image layer 0)
(gimp-image-set-active-layer image layer))

; Appliquer le mode "Multiplier" au calque
(gimp-layer-set-mode (car (gimp-image-get-active-layer image)) MULTIPLY-MODE)

; Aplatir l'image
(gimp-image-flatten image)
; Enregistrer l'image
(let* ((filename (car (gimp-image-get-filename image))))
(gimp-file-save RUN-NONINTERACTIVE image (car (gimp-image-get-active-drawable image)) filename filename)))

(set! files (cdr files)))
))

(script-fu-register "ct-mult"
"/MesScripts/ct-mult"
"--------------------------------"
"Traitement par lot- Multiplie"
"Claude Turrier"
"2023"
"--------------------"
SF-DIRNAME "repertoire" "/home/ubuntu/ess1"; folder-path
)