Les amateurs de traitement d'images et de photographies ressentent très vite le besoin d'automatiser des suites d'opérations graphiques. Le GIMP offre une grande variété d'outils mais ne permet pas l'enregistrement d'une séquence d'opérations pour bâtir ce qu'il est courant d'appeler une macro-instruction.
Il offre en revanche une solution puissante de programmation qui permet de construire des suites d'opérations comme des macro-instructions et bien plus. Toutefois, les premiers contacts avec cette technique sont rebutants.
La documentation du GIMP comporte bien une présentation de Script-Fu mais donne l'impression qu'il faut apprendre tout un langage de programmation avant de commencer à écrire son premier script. On trouve ça et là sur l'internet des "cours" pour se mettre au script-fu mais, selon l'expérience de l'auteur de cette page, il ne semblent pas faits pour permettre d'accéder rapidement à l'autonomie souhaitée. Au premier abord, tout cela s'avère un peu décourageant.
La présente page est délibérément orientée vers l'accès le plus rapide possible à la pratique autonome pour des traitements simples. L'investissement nécessaire pour y parvenir dépend évidemment de son acquis initial. Pour devenir capable en moins d'une heure de faire un script simple à l'aide des conseils (en français) qui suivent, il est préférable quand même d'avoir quelques notions élémentaires de programmation et de langue anglaise et il faut bien sûr disposer d'un ordinateur doté d'une version récente de GIMP (la gestion des scripts ayant changé à la version 2.4 de GIMP).
Le bref didacticiel qui suit résulte de l'expérience récente de l'auteur de cette page, qui n'est pas un expert des entrailles de GIMP ni un informaticien professionnel, mais juste un utilisateur lambda qui a eu un peu de mal à démarrer.
Les manipulations ont été testées sur Ubuntu 8.04, Hardy Heron, avec la version 2.4.5 de GIMP et sur Ubuntu 9.04, Jaunty Jackalope, avec la version 2.6.6 de GIMP.
Pour commencer, il faut savoir que faire une "macro-instruction" simple sous GIMP est assez facile. La communauté de GIMP appelle cela un script. Plus précisément, l'art de faire ces scripts et, par extension, les scripts eux-mêmes, sont désignés par l'expression script-fu. La légende hacker dit que c'est par imitation du terme chinois kung fu évoquant à l'origine l'habilité d'une personne dans un art particulier et qui s'est spécialisé en occident pour désigner les arts martiaux chinois.
Quoiqu'il en soit, un script-fu est un simple fichier texte contenant une suite d'instructions à exécuter, entouré de quelques informations nécessaires à leur exécution. Pour peu que ce fichier soit placé au bon endroit pour être visible par GIMP, une opération très facile et rapide l'ajoute aux menus de GIMP, à un endroit choisi par le rédacteur du script-fu. La rédaction de ce fichier texte peut se faire avec tout éditeur de texte (on emploiera ici gedit).
Les fichiers sont usuellement nommés avec l'extension scm, comme par exemple monscript.scm, et, pour en rédiger un, il faut, d'une part, respecter la structure spécifiée par le langage utilisé (le squelette de l'animal) et, d'autre part, décrire les instructions à exécuter (les muscles), c'est-à-dire les fonctions à mettre en œuvre.
Toute ligne du fichier texte constituant le script-fu peut contenir deux parties optionnelles : d'abord, le texte utile énonçant l'instruction à exécuter, et, ensuite, à partir d'un point-virgule, les commentaires (la bête a besoin d'un peu de graisse!), non considérés à l'exécution mais rendant le script-fu intelligible au lecteur humain.
Un script-fu simple peut être vu essentiellement comme une fonction principale qui reçoit des variables en entrée, se définit des variables internes pour son usage local, utilise toutes ces variables pour appliquer un procédé à une image (qui peut d'ailleurs être existante ou créée par le script), affiche le résultat et rend la main au GIMP. Pour que ce dernier connaisse le script, il faut cependant y inclure quelques informations descriptives ayant notamment pour effet "d'enregistrer" le script auprès du GIMP.
La structure d'un script-fu reflète ces actions. Elle est balisée par des parenthèses. Même un script simple en comporte une profusion et il faut être particulièrement attentif à leur gestion car elle constitue la principale source d'erreur!
La structure d'un script-fu est formée de deux blocs que l'on peut symboliquement représenter comme suit (noter les parenthèses) :
Chacun des deux blocs peut se subdiviser. Après la déclaration de la fonction principale, le premier bloc définit et initialise les variables locales puis les manipule selon l'algorithme voulu. Le second peut en fait effectuer l'enregistrement par l'appel à deux fonctions qui donnent au GIMP les informations de raccordement à sa base de données de fonctions et lui disent où placer l'appel au script-fu dans les menus (ces deux fonctions peuvent être regroupées dans la même). Le script-fu prend donc la forme suivante (noter la notion importante de domaine de validité des [éventuelles] variables locales).
Un script-fu a donc l'écriture suivante (commentaires en bleu et association de parenthèses mises en évidence par la couleur).
(define (MaFonction Input1 Input2 InputN) ; déclaration de la fonction et des variables en entrée
(let* ; l'instruction let* crée et initialise les variables locales
((variable1 valeur1) (variable2 valeur2) (variableL valeurL)) ; attention aux ( () () )
( Fonction1 ArgumentsDeLaFonction1 ) ; les fonctions qui utilisent les
( Fonction2 ArgumentsDeLaFonction2 ) ; variables locales doivent se trouver
( FonctionF ArgumentsDeLaFonctionF ) ; avant la ) associée à (let*
)
(gimp-displays-flush) ; met à jour l'affichage de l'image
)
(
(script-fu-register ArgumentsDeScript-fu-register) ; enregistrement du script-fu dans le GIMP
(script-fu-menu-register ArgumentsDeScript-fu-menu-register) ; inscription du script-fu dans les menus du GIMP
)
Pour aller plus loin, reste à savoir comment écrire les fonctions voulues et les arguments nécessaires.
Le cas considéré ici est le cas simple mais très courant où le but visé est d'appliquer à une image existante une succession d'opérations déjà disponibles. C'est ce qui est usuellement couvert par l'expression "macro-instruction" qui n'est pas utilisée dans le contexte du GIMP mais représente un sous-ensemble des possibilités du script-fu.
L'image et le calque de travail sont alors des variables d'entrée (dans le cas contraire, il
faudrait les créer comme variables locales), c'est facile à comprendre. Pour le débutant, le plus difficile
est de savoir comment s'appellent les fonctions disponibles dans GIMP et ce qu'elles demandent en entrée
pour fonctionner... La clef pour ouvrir ce verrou simplement existe : c'est le navigateur de procédures.
Dans GIMP 2.4, il se trouve dans le menu Exts de la boîte à outils. Dans GIMP 2.6, on le lance par le menu Aide :
Ceci ouvre une fenêtre qui donne accès à l'intégralité des fonctions disponibles,
qu'elles soient des procédures internes de GIMP, des extensions ou des scripts déjà existants. D'après l'image
suivante, au moment de sa capture, 1063 procédures étaient disponibles.
Pour chaque procédure sont donnés son nom, une description et l'ensemble des arguments
qu'elle accepte. C'est là que la connaissance de l'anglais est utile car, d'une part, même dans une installation
en français, ces renseignements sont formulés en anglais et, d'autre part, si l'on cherche une fonction
qui permet de réaliser un traitement spécifique, il faut donner le mot clef en anglais dans le
champ prévu à cet effet. Ainsi, pour trouver une fonction appliquant un effet de flou, il est possible
d'obtenir une liste de 4 résultats pertinents en entrant "blur" dans le formulaire de recherche :
Les arguments passés aux fonctions utilisées dans le script peuvent être soit des arguments d'entrée de la fonction principale, soit des valeurs fixées dans le script. Dans ce second cas, pour plus de lisibilité et moins de risques d'incohérences, il est recommandé de définir au début du script les variables locales qui contiennent les valeurs désirées.
La fonction script-fu-register admet deux groupes d'arguments écrits les uns à la suite des autres.
Le deuxième groupe d'arguments sert en fait à spécifier la sympathique boîte de dialogue grâce à laquelle l'utilisateur du script va donner des valeurs aux variables d'entrée du script-fu. Chaque triplet spécifie un champ d'entrée de donnée de la boîte de dialogue.
Pour une macro-instruction qui travaille sur une image existante, le script-fu admet nécessairement
en entrée l'image active et le calque actif de cette image. Dans ce cas, il y a donc obligatoirement, dans
le deuxième groupe d'arguments de script-fu-register, les deux triplets d'arguments suivants :
SF-IMAGE "Image active" 0
SF-DRAWABLE "Calque actif" 0
et, dans les deux cas, le 0 désigne le numéro de l'image ou du calque actif parmi tous les existants (comptés
à partir de 0). Comme on est sûr qu'il y en a au moins un, 0 marche à tous les coups.
Bien d'autres types de variables sont possibles. Par exemple, le petit script-fu suivant :
(define (script-fu-faineant image calque param1 param2 couleur police gradient option texture chaine logique valeur fichier)
(gimp-message "Je lis beaucoup mais ne fais rien"))
(script-fu-register
"script-fu-faineant"
"<Image>/Filters/Tests/Faineant..."
"Script sans action"
"Sellig Zed"
"Ce script est sous licence de logiciel libre Cecill-C - Voir http://www.cecill.info/"
"28 mars 2010"
""
SF-IMAGE "Image active" 0
SF-DRAWABLE "Calque actif" 0
SF-ADJUSTMENT "Curseur pour choisir une valeur" '(20 1 200 1 10 1 0) ; (defaut min max pas pas_rapide nb_decimales curseur(0)_ou_non(1)
SF-ADJUSTMENT "Boite cliquable pour fixer une valeur" '(300 1 500 1 10 1 1)
SF-COLOR "Choix de couleur" '(255 0 255)
SF-FONT "Police" ""
SF-GRADIENT "Gradient" "Greens"
SF-OPTION "Liste d'options" '("Option 1" "Option 2" "Option 3")
SF-PATTERN "Choix de texture" "recessed"
SF-STRING "Petit texte" "Bah, juste pour voir !"
SF-TOGGLE "Case cochable pour faire un choix" TRUE
SF-VALUE "Valeur explicite" "2010"
SF-FILENAME "Nom complet de fichier" "/")
engendre une boîte de dialogue demandant beaucoup de paramètres :
mais ne fait rien d'autre qu'afficher un message lorsque l'utilisateur appuie sur "Valider"
La fonction script-fu-menu-register admet un seul argument qui est le chemin définissant la place de l'étiquette de menu par son chemin, placé entre guillemets. Au lieu d'utiliser cette fonction, il est possible de mettre directement le chemin de l'étiquette (y compris l'étiquette) à la place de l'énoncé de l'étiquette dans les arguments de script-fu-register, comme dans l'exemple ci-dessus.
Il ne reste plus qu'à placer le script dans le dossier (caché) idoine ~/.gimp-2.6/scripts (adapter en fonction de la version disponible) et à choisir "Actualiser les scripts" dans le menu Script-fu du GIMP pour voir appparaître le nom spécifié pour le script dans le menu voulu.
Le script-fu dessin-au-trait.scm, téléchargeable en cliquant sur son nom et affiché ci-dessous, transforme une image en dessin par une méthode simple enchaînant une extraction de contour et un seuillage.
(define (script-fu-dessin-au-trait inImage inCalque inContour inSeuil) ; introduction de la fonction
(gimp-image-undo-group-start inImage) ; ouverture du groupe d'annulation
(plug-in-edge ; instruction extrayant les contours
1 ; appel non interactif
inImage ; image active
inCalque ; calque actif
inContour ; sensibilité pour la détection du contour
1 ; comportement de détection du bord (1=enrouler)
0 ; algorithme de détection du bord (0=Sobel)
)
(gimp-threshold ; instruction appliquant un seuillage (blanc entre seuils, noir ailleurs)
inCalque ; calque actif
0 ; seuil bas mis nul
inSeuil ; seuil haut choisi par utilisateur
)
(gimp-image-undo-group-end inImage) ; fermeture du groupe d'annulation
(gimp-displays-flush) ; rafraichissement de l'affichage
)
(script-fu-register
"script-fu-dessin-au-trait"
"<Image>/Filters/Tests/Dessin au trait..."
"Effectue un dessin avec un trait choisi plus ou moins gras"
"Sellig Zed"
"Ce script est sous licence de logiciel libre Cecill-C - Voir http://www.cecill.info/"
"30 mars 2010"
""
SF-IMAGE "Image active" 0
SF-DRAWABLE "Calque actif" 0
SF-ADJUSTMENT "Force du contour" '(2 1 10 1 5 1 1)
SF-ADJUSTMENT "Valeur de seuillage" '(180 0 255 1 10 0 1)
)
Au lancement, il affiche une boîte de dialogue permettant à l'utilisateur de changer les valeurs pour l'intensité de détection du contour et pour le seuil puis traite l'image. Dans l'historique d'annulation, le traitement apparaît comme une seule opération. Illustration :
| Image originale | Premier traitement | Deuxième traitement |
 |  |  |
| Capture de la boîte de dialogue : |  |  |
Vu de l'utilisateur, l'application d'un script-fu est perçue comme une seule opération de
traitement. Il est donc logique de lui permettre de l'annuler en une seule fois, par exemple en pressant une seule
fois la combinaison de touches "<Ctrl>z". Ceci s'obtient en encadrant la suite d'opérations programmée
par la paire d'instructions :
(gimp-image-undo-group-start inImage)
(gimp-image-undo-group-end inImage)
où inImage est éventuellement à remplacer par le nom donné à l'image active,
comme déjà illustré par l'exemple qui précède.
Avant le lancement du script-fu, l'utilisateur a effectué un certain nombre d'opérations
et de paramétrages qui ont mis le GIMP dans un certain état nommé le "contexte". Il est souhaitable que
le GIMP se retrouve dans le même état en sortie de script, afin de ne pas perturber l'utilisateur.
Il est donc recommandé de sauvegarder le contexte avant entamer les grandes manœuvres et de le
rétablir à l'issue. Ceci se fait en encadrant le groupe d'opérations par la paire d'instructions :
(gimp-context-push)
(gimp-context-pop)
Enfin, il est prudent, toutes opérations finies, de s'assurer que l'affichage
est bien mis à jour en rafraichissant l'image par la commande :
(gimp-displays-flush)
Le fichier script-fu-vide.scm rassemble les principaux éléments utiles à l'écriture d'un script-fu qui s'applique à une image déjà existante et devrait répondre à la plupart des besoins de macro-instructions simples.