TOP
tetris Programmez un Tetris en Java
360 pages PDF pour apprendre à votre rythme.
Développez des jeux vidéo en Java.
www.jdevmaker.com
Gimp 2.4
Documentation
Tutoriels
Ressources
Divers

Dernière mise à jour le 07 avr 2008
consultée 4861 fois
Apprendre  ›  Écrire un script-fu  ›  Basic Scheme 1

 

Scheme : Traduction Basic Scheme partie 1

 

Originale sur http://imagic.weizmann.ac.il/

 

Intention

Une des merveilleuses caractéristiques de GIMP est que toute sa fonctionnalité peut être accessible par script. La langage de script principal pour le GIMP qui y a été attaché est aujourd'hui le Scheme. Ce document essayera d'être une introduction brève à Scheme, apprenant juste les objets de première nécessité pour écrire des script-fu, sans entrer dans la théorie de langage de programmation qui est si typique d'autres références Scheme.

 

1. Expressions

Scheme est une variante de LISP et toutes les expressions sont entourées par des parenthèses. Par exemple une liste qui calculera la somme de 3 et 4 est écrite :

(+ 3 4)

Le signe + est la fonction d'addition et 3 et 4 sont les premiers et deuxièmes paramètres à cette fonction. Les expressions peuvent être emboîtées, donc l'expression (3+4) * (5/6) dans Scheme peut-être écrite

(* (+ 3 4) (/ 5 6))

L'espace blanc n'a aucune importance donc la susdite expression peut aussi être écrite :

(* (+ 3 4) (/ 5 6))

2. Fonctions

Hormis les quatre fonctions arithmétiques qui sont représenté à travers les symboles + - * /  il y a un bon nombre d'autres fonctions établies dans le langage. Tous ont la forme :

(fonction param1 param2 ...)

Des fonctions additionnelles peuvent être définies par l'utilisateur par le mot-clé define. Par exemple une fonction qui calcule la valeur carrée de son argument simple peut être déclarée comme ceci :

(define (square x) (* x x))

et cette fonction peut s'appeler par :

(square 5)

 

3. Variables et listes

Des variables peuvent être déclarées et placées par la commande set! (Ces variables seront globales mais ceci ne devrait pas tracasser le programmeur occasionnel de Gimp). Voici un couple d'assignations :

(set! grey_value 85) (set! angle (* (/ 30 180) 3.141)

Le LISP et ses variantes ont une utilisation lourde des listes. Le script-fu ne fait pas exception et il emploie par exemple une liste de trois éléments pour écrire une couleur en RVB. Par exemple la couleur orange serait écrite :

'(255 127 0)

Le signe ' est nécessaire pour dire à Scheme que c'est une liste littérale. Si le ' était omis scheme essayerait de chercher une fonction avec le nom 255 et lui enverraient les deux paramètres 127 et 0, ce qui n'est évidemment pas  ce que nous voulons.

Nous pouvons créer une variable appelée orange avec la susdite valeur et la définir ensuite comme couleur de fond.

(set! orange '(255 127 0))
(gimp-set-background-color orange)
			

3.1 car, cdr et ses amis (*)

Une liste dans Scheme est toujours composée d'une tête et une queue. La tête est la première entrée dans la liste et la queue est le reste des éléments. Cela signifie que la liste (255 127 63) signifie vraiment (255 (127 (63 ()))) mais Scheme permet la forme précédente comme un raccourci. La fonction car est utilisée pour retourner la tête de la liste et le cdr (prononcé d'habitude cudder) est utilisé pour obtenir la queue de la liste.

Ce qui suit est un essai des susdites fonctions qui peuvent en mode interactif être conduites dans la console de Script-fu :

=> (set! color '(255 127 63))
(255 127 63)
=> (car color)
255
=> (cdr color)
(127 63)
			

Pour obtenir le composant bleu d'une couleur il est nécessaire d'appliquer la fonction de cdr deux fois et ensuite la fonction car.

=> (car (cdr (cdr color)))
63
			

C'est très incommode a écrire. Donc ont a défini des abréviations sous la forme cadr, cddr, caddr, etc... que concatène les opérations décrites ci-dessus. L'expression précédente peut donc être plus commodément écrite :

=> (caddr color)
63
			

Pour l'auteur de Script-Fu une des utilisations les plus importantes de la fonction car est l' accès aux valeurs retournées des fonctions de GIMP. Toutes les fonctions de GIMP rendent une liste et même si la liste contient seulement un élément il peut être accessible par car. C'est par exemple le cas pour les fonctions importantes "gimp-new-image" et "gimp-new-layer" utilisées ci-dessous.

 

3.2 Variables locales (*)

Des programmeurs de scheme plus expérimentés utilisent surtout des variables locales au lieu des variables globales décrites ci-dessus. On le considère comme une meilleure pratique de programmation et cette construction doit vous être familière pour être capable de lire d'autres ScriptFu.

On déclare des variables locales par le mot-clé let comme dans l'exemple suivant :

(let* ((a 3)
	   (b 4))
	   ((* a b)))
			

Ici a et b ont une portée locale et conservent leurs valeurs seulement jusqu'à la fermeture de parenthèse correspondante à celle ouverte avant let*.

 

4. The GIMP PDB

Toute la fonctionnalité de GIMP est disponible par la base de données procédurale (PDB) (NdT : procédural data base en anglais). Chaque fonction de base de données procédurale a une configuration de fonction Scheme correspondante. Par exemple :

(gimp-image-new 100 150 RGB)
			

Produit une nouvelle image GIMP de type RGB et la taille 100x150.

Toutes les fonctions du PDB sont accessible par le navigateur DB qui est disponible du menu principal à Xtns - > DB le NAVIGATEUR .... (NdT : <toolbox> Exts > explorer la base de procédure)  par exemple l'entrée dans le Navigateur DB pour uni-img, que nous définirons dans l'exemple ci-dessous :

Pour le programmeur de Script-Fu ces informations montrent qu'uni-img peut être appelé avec trois paramètres de types INT32, la STRING et COLOR. On expliquera les différents types ci-dessous.

 

5. Enregistrement du script

Après qu'une fonction ait été écrite elle doit être enregistrée (NdT : au registre, il ne s'agit pas d'un enregistrement physique sur disque dur) avec le script-fu avant qu'il ne puisse être utilisé. C'est fait par la fonction scheme script-fu-register. L'enregistrement a les buts suivants :

Le dernier point ci-dessus signifie en réalité qu'un script est du point de vue du GIMP nullement différent d'une commande incorporée ou une commande de plug-in. Tant qu'une commande est enregistrée dans le PDB elle peut être appelée par n'importe quel script ou plug-in.

Les paramètres de script-fu-register peuvent être divisés dans deux groupes. On doit toujours donner le premier groupe de sept paramètres. Ceux-ci sont :

Après que l'on a renseigné ces sept paramètres, suit une liste de paramètres exigés par le scénario. On donne chaque paramètre comme un groupe de trois articles :

 

6. Un script commenté

Le script suivant uni.scm reçoit deux paramètres de l'utilisateur, la taille de l'image et une couleur, et produit une image uniforme de la taille demandée et la couleur demandée. Ca n'est pas très utile, mais il montre les éléments essentiels qui interviennent dans la production d'un script-fu.

; Définir la fonction du scénario et inscrire ses paramètres
; les paramètres seront les paramètres inscrits
; ci-dessous dans script-fu-register.

(define (uni-img size color)
  ; Create an img and a layer
  (set! img (car (gimp-image-new size size RGB)))
  (set! layer (car (gimp-layer-new img size size
                             RGB "layer 1" 100 NORMAL)))

; La chose suivante est faite pour tous les scénarios

 (gimp-image-undo-disable img)
 (gimp-image-add-layer img layer 0)

; Voici où la peinture commence. Nous avons maintenant une image
; et la couche et nous pouvons peindre dans la couche par les fonctions de PDB.

 (gimp-palette-set-background color)
 (gimp-edit-fill layer BG-IMAGE-FILL)

; La chose suivante est aussi faite pour tout le scénario

 (gimp-display-new img)
 (gimp-image-undo-enable img))

; Enregistrez finalement notre script-fu.

(script-fu-register "uni-img"
              "<Toolbox>/Xtns/Script-Fu/Tutorials/Uniform image"
              "Creates a uniform image"
              "Dov Grobgeld <dov@imagic.weizmann.ac.il>"
              "Dov Grobgeld"
              "2002-02-12"
              ""
              SF-VALUE "size" "100"
              SF-COLOR "color" '(255 127 0))
			

Pour tester le scénario sauvez-le dans $HOME/.gimp-1.2/scripts/uni.scm et choisissez ensuite Xtns - > le Scénario-Fu - > Rafraîchir.  (NdT : pour Gimp 2.0 windows, dans c:\program files\GIMP-2.0\share\gimp\2.0\scripts\uni.scm ; puis faites <toolbox> Exts > Script-fu > Rafraichir les scripts).

Le script image uniforme devrait maintenant apparaître dans le menu Xtns - > Script-Fu - > Tutorials - > Uniform image (NdT : <Toolbox>/Exts/Script-Fu/Tutorials/Uniform image). La sélection de ce scénario aboutit au menu contextuel suivant :

En acceptant les paramètres par défaut cela nous donne la nouvelle image suivante :

Il est aussi possible d'avoir accès à ce scénario par la console de Scénario-Fu en tapant la commande :

(uni-img 100 '(0 255 127))

6.1 Insersion d'un script dans le menu d'image

Le script uni-img a été placé sous Xtns/...(NdT : Exts/...) dans la fenêtre principale de GIMP. Cela est fait pour créer une nouvelle image independante des autres images. Il est aussi possible de créer un script qui travaille sur une image déjà existante. Si dans script-fu-register le deuxième argument est écrit :

<Image>/Script-Fu/...

alors le script sera disponible par le menu de GIMP qui est lancé par le clic droit sur une image. Un tel script doit aussi avoir comme premier et deuxième argument un SF-IMAGE et un SF-DRAWABLE.

Voici un script d'exemple qui copie la couche actuelle dans une nouvelle couche, ajoute un flou et l'inverse.

; Un scénario d'exemple qui ajoute un flou à l'image selon un rayon.
; il illustre comment accrocher un script dans le menu d'image et
; comment un module d'extension peut être appelé.

(define (script-fu-copy-blur img
                       drawable
                       blur-radius)
  ; Cree un nouveau calque
  (set! new-layer (car (gimp-layer-copy drawable 0)))

  ; attribue un nom
  (gimp-layer-set-name new-layer "Gauss-blurred")

  ; ajoute le calque à l'image
  (gimp-image-add-layer img new-layer 0)

  ; appel le plug-in de flou
  (plug-in-gauss-rle 1 img new-layer blur-radius 1 1)

  ; inverse le calque
  (gimp-invert new-layer)

  ; actualise l'image
  (gimp-displays-flush)
)

(script-fu-register "script-fu-copy-blur"
              "<Image>/Script-Fu/Tutorial/copy-blur"
              "Copy and blur a layer"
              "Dov Grobgeld"
              "Dov Grobgeld"
              "2002"
              "RGB*, GRAY*"
              SF-IMAGE "Image" 0
              SF-DRAWABLE "Layer to blur" 0
              SF-VALUE "Blur strength" "5")
			

7. Peindre des zones avec les sélections

Dans uni-img nous avons appelé la procédure "gimp-edit-fill" pour remplir l'image entière. En regardant les renseignements pour "gimp-edit-fill" dans le navigateur DB nous trouvons :

Ainsi, si nous avons une sélection active quand "gimp-edit-fill" est appelé seulement la sélection est peinte. Il y a des tas de façons de choisir une sélection comme peut voir en cherchant "select" dans le PDB. Nous utiliserons gimp-rect-select, dont l'entrée dans le PDB donne :

Une utilisation simple de cette fonction sélectionne un rectangle (x, y, largeur, hauteur) = (0,25,100,50), peint cette région en bleue et supprime la sélection :

(gimp-rect-select img 0 25 100 50 REPLACE 0 0)
(gimp-palette-set-background '(0 0 255))
(gimp-edit-fill layer BG-IMAGE-FILL)
(gimp-selection-none img)
			

8. Boucle

La seule boucle qui existe dans le Script-Fu est while

[Note : cette contrainte est dûe a l'interprète de Scheme actuel SIOD utilisée pour le Script-Fu. Une fois que l'interprète Scheme sera changé pour Guile, plus de types de boucle seront probablement disponibles.] la boucle while s'utilise comme suit :

(while (condition)
(statement1)
(statement2)
:
)
			

Voici un exemple qui dessine des lignes horizontales, de 16 pixels de haut, sur une image :

(set! y 0)
(while (< y size)
(gimp-rect-select img 0 y size 16 REPLACE 0 0)
(gimp-edit-fill layer-one BG-IMAGE-FILL)
(set! y (+ y 32)))
			

9. Sélections flottante

Lorsqu'on colle une image du presse-papiers, ou qu'on crée du texte dans un calque, le résultat n'est pas mis directement dans le calque. Au lieu de cela il est mis dans une couche provisoire spéciale connue comme une sélection flottante. La sélection flottante peut être manipulée de plusieurs façons et finalement elle est fusionnée dans le calque associé, par un processus connu pour l'ancrage.

 

9.1 Hello World - Ecrire du texte dans une image

En créant le texte par la commande de texte de GIMP, le texte est toujours mis dans une couche provisoire. Cette couche provisoire doit alors être ancrée. Voici un exemple de texte qui est collé dans le calque courant :

; Un script exemple qui écrit une chaine fixée dans l'image courante

(define (script-fu-hello-world img drawable)

; Début du groupe d'annulation. Tout, entre le début et la fin sera
; annulé si une commande d'annulation est invoquée.

  (gimp-undo-push-group-start img)

; Créer le texte. Voir la base de procédure pour les paramètres de texte de GIMP.

  (set! text-float (car (gimp-text-fontname
  img
  drawable
  10 10
  "Hello world"
  0
  1
  50
  0
  "-*-utopia-*-r-*-*-*-*-*-*-*-*-*-*")))

  ; ancrer la selection
  (gimp-floating-sel-anchor text-float)

  ; terminer le groupe d'annulation
  (gimp-undo-push-group-end img)

  ; actualisation de l'image
  (gimp-displays-flush))

(script-fu-register "script-fu-hello-world"
              "<Image>/Script-Fu/Tutorial/Hello World"
              "Write Hello World in the current image"
              "Dov Grobgeld <dov@imagic.weizmann.ac.il>"
              "Dov Grobgeld"
              "2002-02-12"
              "RGB*, GRAY*"
              SF-IMAGE "Input Image" 0
              SF-DRAWABLE "Input Drawable" 0)
			

Ce script montre une autre fonction que nous n'avons pas mentionnée auparavant. La possibilité de créer un groupe d'annulation. Toutes les commandes entre les commandes "gimp-undo-push-group-begin" et "gimp-undo-push-group-end" sont annulées si la commande d'annulation est demandée.

 

9.2 Copier une sélection

Pour copier une sélection, la commande "gimp-edit-copy" est utilisée. Elle place une copie du contenu de sélection en mémoire. Ce contenu peut alors être collé dans une couche, la même couche ou une autre et il est alors collé comme calque flottant.

Dans l'exemple suivant la sélection est copiée, collée dans le même calque, subit un déplacement offset, puis finalement ancrée. Essayez-le en dessinant une petite goutte au milieu de l'image, sélectionnez la goutte et appelez ensuite ce script.

; un exemple pour comment créer une selection flotante et l'ancrer.
(define (script-fu-sel-copy img
                          drawable)

  (gimp-undo-push-group-start img)
  (gimp-edit-copy drawable)
  (set! sel-float (car (gimp-edit-paste drawable FALSE)))
  (gimp-layer-set-offsets sel-float 100 50)

  ; ancre la selection
  (gimp-floating-sel-anchor sel-float)

  ; Termine l'hitorique d'annulation
  (gimp-undo-push-group-end img)

  ; actualise l'image
  (gimp-displays-flush))


(script-fu-register "script-fu-sel-copy"
              "<Image>/Script-Fu/Tutorial/Selection Copy"
              "Copy the selection into the same layer"
              "Dov Grobgeld"
              "Dov Grobgeld"
              "2002-02-12"
              "RGB*, GRAY*"
              SF-IMAGE "Image" 0
              SF-DRAWABLE "Layer" 0)
			

 

Valide XHTML 1.0 Strict
Valide CSS 2.0
Valide Accessibilité
Creative Commons License

Tous les documents et ressources sont sous un contrat Creative Commons.