Traitement par lot sous Gimp 2.6

21 04 2010

J’ai déjà décortiqué un script pour The Gimp. Il s’agit d’un script tout ce qu’il y a de plus classique : un script qui travaille sur une image ouverte.

Cette fois, je m’attaque à un script de traitement par lot. Sous ce nom barbare se cache la possibilité de faire traiter par The Gimp un répertoire complet sans devoir ouvrir chaque fichier l’un après l’autre.

À qui s’adresse ce billet ?

Avec le traitement par lot, il est possible d’automatiser des tâches que vous effectuez pour chacune de vos photos comme :

  • correction automatique,
  • application d’un logo,
  • ajout d’une bordure,
  • redimensionnement,
  • etc.

Moyennant une légère modification, le script présenté dans ce billet s’adaptera facilement à vos besoins.

Mais avant de vous lancer à cœur perdu dans son étude, posez-vous la question de savoir si le traitement que vous voulez automatiser n’est pas suffisamment simple pour être traité par une autre solution.

Pour commencer vous pouvez jeter un œil sur :

Si ces solutions ne vous satisfont pas ou si vous avez déjà développé votre propre script et ne voulez pas vous en séparer, n’hésitez pas à poursuivre la lecture de ce billet😉

Principe

Le script est découpé en trois parties :

  • fonction traiter-image : j’ai séparé le traitement d’un fichier en 2, traiter-image est chargée de traiter une seule image ouverte passée en paramètre, cela facilitera l’adaptation de scripts initialement prévus pour ne traiter qu’une seule image,
  • fonction traiter-fichier : elle est chargée de traiter un seul fichier, c’est-à-dire d’ouvrir le fichier, de récupérer l’image, de la faire traiter par traiter-image, d’enregistrer les modifications et de fermer le fichier,
  • parcours de chaque fichier : cette fonction va générer les noms de fichiers pour ensuite les traiter un à un par la fonction traiter-fichier.

Pour adapter le script à vos besoins, il faudra juste modifier la fonction traiter-image.

Le script

Voici le script au complet.  Les explications et le détail suivent.

Pour rappel, il s’agit de code TinyScheme pour The Gimp.

; Définition des extensions autorisées
(define TRAITEMENTPARLOT-EXTENSIONS
  '("JPG" "jpg" "jpeg" "tif" "xcf" "png")
)

; Fonction de traitement par lot
(define (script-fu-traitementparlot nom-repertoire extension)
  ; Fonction chargée de traiter une image
  (define (traiter-image image)
    ; Démarre un niveau de undo
    (gimp-image-undo-group-start image)

    ; Réduit l'image à 500 pixels de large
    (let* ((old-largeur (car (gimp-image-width  image)))
           (old-hauteur (car (gimp-image-height image)))
           (new-largeur 500)
           (new-hauteur (/ (* old-hauteur new-largeur) old-largeur))
          )
      (gimp-image-scale image new-largeur new-hauteur)
    )

    ; Termine le niveau de undo
    (gimp-image-undo-group-end image)
  )

  ; Fonction chargée de traiter un fichier
  (define (traiter-fichier nom-fichier)
    ; Ouverture du fichier
    (let* ((image  (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier)))
           (calque (car (gimp-image-get-active-drawable image)))
          )
      ; Traitement de l’image
      (traiter-image image)

      ; Enregistrement du fichier
      (gimp-file-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier)

      ; Fermeture du fichier
      (gimp-image-delete image)
    )
  )

  (let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
         (pattern   (string-append nom-repertoire "/*." extension))
         (fichiers  (cadr (file-glob pattern 0)))
        )
    ; Application de la fonction traiter-fichier à chaque fichier
    (map traiter-fichier fichiers)
  )
)

(script-fu-register "script-fu-traitementparlot"
  "/Script-Fu/Traitement par lot"
  "Exemple de traitement par lot"
  "Frédéric Bisson "
  "Frédéric Bisson"
  "2010-04-20"
  ""
  SF-DIRNAME "Répertoire à traiter" ""
  SF-OPTION "Extension" TRAITEMENTPARLOT-EXTENSIONS
)

Explications du code

Définition des extensions autorisées

Le script nécessite de connaître les extensions de fichiers à traiter. Elles sont définies en tout de début de script sous la constante TRAITEMENTPARLOT-EXTENSIONS. Attention : sous Linux, les extensions sont sensibles à la casse, d’où le JPG et jpg. S’il vous manque une extension, libre à vous de l’ajouter !

(define TRAITEMENTPARLOT-EXTENSIONS
  '("JPG" "jpg" "jpeg" "tif" "xcf" "png")
)

Squelette de la fonction

La fonction principale est la fonction script-fu-traitementparlot qui prend en paramètre un nom de répertoire ainsi que l’index de l’extension sélectionnée parmi celles autorisées (voir ci-dessus).

Script-fu-traitementparlot définit 2 sous-fonctions présentées dans “Principe”.

Pour adapter ce script à vos besoins, il faudra insérer du code entre gimp-image-undo-group-start et gimp-image-undo-group-end.

(define (script-fu-traitementparlot nom-repertoire extension)
  (define (traiter-image image)
    (gimp-image-undo-group-start image)
    ; Traitement de l’image…
    (gimp-image-undo-group-end image)
  )

  (define (traiter-fichier nom-fichier)
    ; …
  )

  (let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
         (pattern   (string-append nom-repertoire "/*." extension))
         (fichiers  (cadr (file-glob pattern 0)))
        )
    (map traiter-fichier fichiers)
  )
)

Traitement d’un fichier

La fonction traiter-fichier prend comme seul paramètre le chemin complet vers un fichier. La fonction gimp-file-load va ouvrir le fichier sans afficher la moindre fenêtre (RUN-NONINTERACTIVE). Si vous voyez 2 fois le paramètre nom-fichier, rassurez-vous, vous n’avez pas bu, c’est juste nécessaire pour que The Gimp puisse ouvrir des fichiers à travers le réseau (ce qui n’est pas notre cas).

On récupére ensuite un calque de cette image uniquement pour satisfaire une exigence de gimp-file-save bien qu’il ne s’en serve pas…

Une fois ces informations récupérées, on peut lancer le traitement à proprement parler.

La fonction gimp-file-save va permettre de sauvegarder l’image.

Attention : le comportement retenu est celui d’écraser le fichier original, à vous de dupliquer le répertoire sur lequel travailler pour ne pas perdre vos originaux !

On ferme finalement l’image avec la fonction gimp-image-delete. Oui, tout est normal, cette fonction ne va pas supprimer votre fichier mais seulement les informations contenues en mémoire par The Gimp, ce qui revient à fermer le fichier.

(define (traiter-fichier nom-fichier)
  (let* ((image  (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier)))
         (calque (car (gimp-image-get-active-drawable image)))
        )
    (traiter-image image)
    (gimp-file-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier)
    (gimp-image-delete image)
  )
)

Parcours de répertoire

Le parcours de répertoire est un peu plus sioux que le reste.

Tout d’abord on récupère l’extension. The Gimp nous fournit l’index de l’extension dans la liste des extensions autorisées. La fonction list-ref permet de récupérer un élément dans une liste. En PHP on écrirait “$extension=TRAITEMENTPARLOT_EXTENSIONS[$extension]”, mais on est en TinyScheme…

Il nous faut ensuite un pattern (ex. : /home/user/Images/*.JPG) qui permettra de récupérer les fichiers. Il s’obtient en concaténant le nom de répertoire et l’extension.

Pour obtenir la liste des fichiers, The Gimp dispose d’un plug-in standard appelé file-glob qui travaille sur le pattern précédemment présenté.

La fonction map permet alors d’exécuter la fonction traiter-fichier avec chacun des fichiers trouvés par file-glob. C’est un équivalent de boucle for qui parcourrait la liste des fichiers.

(let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
       (pattern   (string-append nom-repertoire "/*." extension))
       (fichiers  (cadr (file-glob pattern 0)))
      )
  (map traiter-fichier fichiers)
)

Déclaration de la fonction

La déclaration mérite quelques mots. Tout d’abord, on ne spécifie aucun type de fichier puisqu’elle n’est pas destinée à être exécutée sur une image préalablement ouverte (chaîne vide après la date).

Ensuite on utilise le type de paramètre SF-DIRNAME pour demander à The Gimp d’afficher un widget permettant de sélectionner un répertoire. Il retournera une chaîne avec le chemin complet.

Enfin, le paramètre SF-OPTION permet d’obtenir une combo-box avec la liste des extensions autorisées. Il retournera l’index de l’extension sélectionnée (0 pour la première, 1 pour la deuxième etc.)

(script-fu-register "script-fu-traitementparlot"
  "/Script-Fu/Traitement par lot"
  "Exemple de traitement par lot"
  "Frédéric Bisson "
  "Frédéric Bisson"
  "2010-04-20"
  ""
  SF-DIRNAME "Répertoire à traiter" ""
  SF-OPTION "Extension" TRAITEMENTPARLOT-EXTENSIONS
)

Utilisation

Le script est utilisable tel quel mais ne présente pas un intérêt particulier. Il redimensionne chaque image proportionnellement pour qu’elles aient une largeur de 500 pixels.

Une fois installé, une nouvelle entrée vient prendre place dans le menu Script-Fu :

Menu

Menu

En sélectionnant cette entrée dans le menu, la fenêtre de paramètres apparaît avec la possibilité de sélectionner un dossier existant ainsi qu’une extension :

Fenêtre de paramètres

Fenêtre de paramètres

Quand on clique sur le bouton “Valider”, la fenêtre est utilisée pour afficher le traitement en cours :

Traitement en cours

Traitement en cours


Actions

Information

33 responses

21 04 2010
Simon

Merci merci ! C’est parfait pour mettre un « watermark » et c’est clairement une fonction à la photoshop comme il me fallait !

22 04 2010
Uliamar

Et bien justement je ne comprend pas…
Si je veut rajouter un dégradé/cadre à environ 130 images comment je fait.
Il me semble que ce programme ne fait que redimmensionner ?

22 04 2010
zigazou

Bonjour,

« Il me semble que ce programme ne fait que redimmensionner ? »
Oui… dans sa version actuelle. Comme expliqué dans la section “À qui s’adresse ce billet ?”, le script nécessite d’être adapté pour répondre à votre besoin.

« Si je veut rajouter un dégradé/cadre à environ 130 images comment je fait »
Il faudra juste écrire les quelques lignes réalisant cette opération pour disposer d’un script l’appliquant à vos 130 images.

23 04 2010
Uliamar

Et en ce cas ou trouver les infos pour créé un tel script ?

23 04 2010
zigazou

Bonjour,

Vous pourrez trouver de la documentation sur l’écriture de scripts sur le site de The Gimp :
http://docs.gimp.org/2.6/fr/gimp-concepts-script-fu.html
http://docs.gimp.org/2.6/fr/gimp-using-script-fu-tutorial.html

J’ai également rédigé un billet qui décortique un script-fu de base :
https://zigazou.wordpress.com/2009/05/19/decortiquons-un-script-fu-pour-gimp/

Une fois les bases acquises, vous pourrez trouver la liste des fonctions disponibles en allant dans le menu Filtres → Script-Fu → Console et en cliquant sur le bouton Parcourir…

26 04 2010
hibikitokay

bonsoir
tous d’abord merci pour toute ton aides

mon problème c’est que je n’arrive pas a trouver cette nouvelle fonction dans gimp

je l’ai nommer Traitementparlot.scm
je l’ai mis dans .gimp-2.6/scripts et aussi dans /usr/share/gimp/2.0/scripts
par contre je n’ai pas d’onglet script-fu dans la fenètre principal de gimp

donc j’ai un peut modifier la seconde ligne car je suppose que c’est la ou je devrais la voir mais rien

(script-fu-register « script-fu-traitementparlot »
« /Filtres/Traitement par lot »
« Exemple de traitement par lot »
« Frédéric Bisson  »
« Frédéric Bisson »
« 2010-04-20 »
«  »
SF-DIRNAME « Répertoire à traiter » «  »
SF-OPTION « Extension » TRAITEMENTPARLOT-EXTENSIONS
)

autre chose je voudrais centrer mon image horizontalement sur mon canevas

et encore merci

27 04 2010
zigazou

“je l’ai mis dans .gimp-2.6/scripts et aussi dans /usr/share/gimp/2.0/scripts”
Il est normalement déconseillé de placer ses scripts dans les répertoires de base des applications. Ils ne devraient être installés que dans votre répertoire personnel (~/.gimp-2.6/scripts). Pour connaître la liste des répertoires dans lesquels Gimp recherche les scripts, il faut aller dans Édition → Préférences, et sélectionner l’entrée Dossier → Scripts. Le script ne devrait d’ailleurs se trouver qu’à un seul endroit.

“donc j’ai un peut modifier la seconde ligne car je suppose que c’est la ou je devrais la voir mais rien”
La définition de l’entrée de menu devrait commencer par l’un des éléments suivants entre inférieur et supérieur : Toolbox, Image, Layers, Channels, Vectors, Colormap, Load, Save, Brushes, Gradients, Palettes, Patterns, Buffers.

Exemples (remplacer les – par inférieur et supérieur) :
-Image-/Script-fu/Traitement par lot → crée un sous-menu Traitement par lot dans un menu Script-fu dans la barre de menu de la fenêtre principale.

-Image-/Filters/Enhance/Traitement par lot → crée un sous-menu Traitement par lot dans le menu Filtres/Amélioration dans la barre de menu de la fenêtre principale. Si tu veux utiliser des sous-menus existants, il faut indiquer leur nom en anglais (les menus fonctionnent en anglais et sont traduits en français pour l’affichage).

Il ne faut bien sûr pas oublier d’actualiser les scripts en allant dans Filtres → Script-fu → Actualiser les scripts.

“autre chose je voudrais centrer mon image horizontalement sur mon canevas”
Plus être précis sur les termes, tu veux centrer ton calque dans ton image (du point de vue interne à Gimp).

Si la variable image est définie, le code suivant devrait faire l’affaire :
(let* ((layer (car (gimp-image-get-active-layer image)))
(layerwidth (car (gimp-drawable-width layer)))
(layerheight (car (gimp-drawable-height layer)))
(imagewidth (car (gimp-image-width image)))
(imageheight (car (gimp-image-height image)))
(offsetx (/ (- imagewidth layerwidth) 2))
(offsety (/ (- imageheight layerheight) 2))
)

(gimp-layer-set-offsets layer offsetx offsety)
)

Beaucoup de lignes pour pas grand chose, mais cela tient des noms de fonctions de Gimp qui, si elles sont explicites, n’en sont pas moins looooongues. En plus, la plupart des fonctions de Gimp retournent une liste même pour une seule valeur (d’où le car).

27 04 2010
hibikitokay

Merci pour ta réponse rapide bien après avoir écrit j’avais fait la rectif de moi même en ce qui concerne «  », maintenant c’est bon. juste un problème que je tente de rectifier mais c’est pas simple.
Quand je le lance j’ai ça comme message

Message Traitement par lot
Erreur lors de l’exécution de script-fu-traitementparlot :
Error: Procedure execution of gimp-file-save failed on invalid input arguments: La procédure « gimp-file-save » a été appelée avec un ID erroné pour le paramètre « drawable ». Très probablement un greffon est en train d’essayer de travailler sur un calque qui n’existe plus.

je te met la totalité du script car je pense que le problème vient de plus haut

; Définition des extensions autorisées
(define TRAITEMENTPARLOT-EXTENSIONS
‘(« JPG » « jpg » « jpeg » « tif » « xcf » « png »)
)

; Fonction de traitement par lot
(define (script-fu-traitementparlot nom-repertoire extension)
; Fonction chargée de traiter une image
(define (traiter-image image)
; Démarre un niveau de undo
(gimp-image-undo-group-start image)

; Réduit l’image à 500 pixels de haut
(let* ((old-hauteur (car (gimp-image-height image)))
(old-largeur (car (gimp-image-width image)))
(new-hauteur 500)
(new-largeur (/ (* old-largeur new-hauteur) old-hauteur))
)
(gimp-image-scale image new-largeur new-hauteur)
)

; Retaille le canevas à 450 pixels de large
(let* ((old-largeur (car (gimp-image-width image)))
(old-hauteur (car (gimp-image-height image)))
(new-largeur 510)
(new-hauteur (/ (* old-hauteur new-largeur) old-largeur))
(new-offsetx (/ (- new-largeur old-largeur) 2))
(new-offsety (/ (- new-hauteur old-hauteur) 2))
)
(gimp-image-resize image new-largeur new-hauteur new-offsetx new-offsety)
)

; Centrage
(let* ((layer (car (gimp-image-get-active-layer image)))
(layerwidth (car (gimp-drawable-width layer)))
(layerheight (car (gimp-drawable-height layer)))
(imagewidth (car (gimp-image-width image)))
(imageheight (car (gimp-image-height image)))
(offsetx (/ (- imagewidth layerwidth) 2))
(offsety (/ (- imageheight layerheight) 2))
)
(gimp-layer-set-offsets layer offsetx offsety)
)

; Aplatit l’image
(gimp-image-flatten image)

; Sélectionne toute l’image
(gimp-selection-all image)

; Réduit la sélection de 1 pixel
(gimp-selection-shrink image 1)

; Inverse la sélection
(gimp-selection-invert image)

; Remplit la sélection de noir (couleur d’avant-plan)
(let* ((drawable (car (gimp-image-active-drawable image))))
(gimp-edit-bucket-fill drawable 0 0 100 0 0 0 0)
)

; Déselectionne tout
(gimp-selection-none image)

; Termine le niveau de undo
(gimp-image-undo-group-end image)
)

; Fonction chargée de traiter un fichier
(define (traiter-fichier nom-fichier)
; Ouverture du fichier
(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier)))
(calque (car (gimp-image-get-active-drawable image)))
)
; Traitement de l’image
(traiter-image image)

; Enregistrement du fichier
(gimp-file-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier)

; Fermeture du fichier
(gimp-image-delete image)
)
)

(let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
(pattern (string-append nom-repertoire « /*. » extension))
(fichiers (cadr (file-glob pattern 0)))
)
; Application de la fonction traiter-fichier à chaque fichier
(map traiter-fichier fichiers)
)
)

(script-fu-register « script-fu-traitementparlot »
« /Script-fu/Traitement par lot »
« Exemple de traitement par lot »
« Frédéric Bisson  »
« Frédéric Bisson »
« 2010-04-20 »
«  »
SF-DIRNAME « Répertoire à traiter » «  »
SF-OPTION « Extension » TRAITEMENTPARLOT-EXTENSIONS
)

27 04 2010
zigazou

Tu peux essayer ce bout de code :

(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier))))
; Traitement de l’image
(traiter-image image)

; Enregistrement du fichier
(gimp-file-save RUN-NONINTERACTIVE image (car (gimp-image-get-active-drawable image)) nom-fichier nom-fichier)

; Fermeture du fichier
(gimp-image-delete image)
)

J’ai replacé la récupération du drawable directement dans l’appel à gimp-file-save car il est fort probable que tes actions influent sur le drawable actif.

28 07 2010
Xavier

Bonjour,

Tout d’abord un grand merci pour vos tutoriels.
Ils m’ont grandement aidé dans la création d’un script, et j’ai enfin pu réaliser ce que je souhaitais.

Malheureusement je n’arrive pas à passer au traitement de masse.
J’ai fidèlement reproduit votre exemple mais rien n’y fait : le fenêtre se referme aussitôt après avoir cliqué sur « Valider ». J’ai à peine le temps de lire ‘file-glob’, et ça se referme.

Pour info je suis sous Gimp 2.6.2 et Windows XP.

J’ai creusé un peu et j’ai le sentiment que le programme ne trouve aucun fichier à traiter, il ignore purement et simplement les images situées dans mon répertoire.
En creusant un peu plus, je pense que le problème se situe au niveau du séparateur : « / » pour Gimp et « \ » pour windows, ce qui expliquerait le retour d’une liste vide par la fonction ‘file-glob’.

Le problème c’est que je ne vois pas comment m’en sortir…
Avez-vous une idée ?

28 07 2010
zigazou

Bonjour,

J’ai effectivement développé ce script sous Linux ce qui expliquerait qu’il ait du mal à fonctionner sous Windows.

Quelques pistes pour essayer d’y remédier :
Changer la ligne
(pattern (string-append nom-repertoire « /*. » extension))
en
(pattern (string-append nom-repertoire « \*. » extension))
ou en
(pattern (string-append nom-repertoire « \\*. » extension))

Et par la même occasion, en profiter pour changer la ligne :
(« JPG » « jpg » « jpeg » « tif » « xcf » « png »)
en
(« jpg » « jpeg » « tif » « xcf » « png »)
ou en
(« JPG » « JPEG » « TIF » « XCF » « PNG »)

(Windows ne fait pas de distinction à l’ouverture de fichier entre les minuscules et les majuscules tandis que Linux oui, si on laisse la ligne telle qu’elle, les fichiers JPG pourraient être traités deux fois)

29 07 2010
Xavier

Génial !!!

Un grand merci pour votre réponse rapide et aussi et surtout pour la solution à mon problème.

Il faut bien mettre :
(pattern (string-append nom-repertoire « \\*. » extension))

Je commençais à désespérer en me perdant dans les diverses documentations Scheme. La solution était finalement simple mais hors de ma portée.

Je prend note pour la liste des extensions.

Encore merci. Continuez à faire vos tutos, ils sont d’une aide précieuse…

16 08 2010
Jean-François Asselin

Bonjour,

Merci beacoup pour ce code, cela m’a beaucoup aidé
(Surtout une fois les modifications faites pour qu’il fonctionne sur windows)

J’utilise ce script pour convertir les images png & jpg d’un dossiers principal contenant entre 1 et 3 niveaux de dossiers d’images (Il y a des images à chaque niveaux). Chacunes de ces images doit être converties en grayscale et enregistrée au format .tif

j’ai réussi à faire à ce que le script convertisse l’imae en grayscale et l’enregistre au format .tif
…cependant j’ai plusieurs problèmes :

1) Le script crash si l’image est déjà au format grayscale originallement.
2) Bien que l’image soit bel et bien enregistrée au format « .tif », elle ne possède pas la bonne extention (Elle conserve l’extension d’origine)
3) Je ne parvient pas à faire fonctionner le script sur plusieurs niveau de dossiers (des dossier contenant d’autres dossiers)
4) Je ne parvient pas à faire rouler le script sur plusieur extentions à la fois

Désolé pour toutes ces questions mais j’ai vraiment besoin d’aide.😦

voici mon code :

**********************************************************************
**********************************************************************

; Définition des extensions autorisées
(define TRAITEMENTPARLOT-EXTENSIONS
‘(« JPG » « JPEG » « TIF » « XCF » « PNG »)
)

; Fonction de traitement par lot
(define (script-fu-traitementparlot nom-repertoire extension)
; Fonction chargée de traiter une image
(define (traiter-image image)
; Démarre un niveau de undo
(gimp-image-undo-group-start image)

; Réduit l’image à 500 pixels de large
(gimp-image-convert-grayscale image)

; Termine le niveau de undo
(gimp-image-undo-group-end image)
)

; Fonction chargée de traiter un fichier
(define (traiter-fichier nom-fichier)
; Ouverture du fichier
(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier)))
(calque (car (gimp-image-get-active-drawable image)))
)
; Traitement de l’image
(traiter-image image)

; Enregistrement du fichier
(file-tiff-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier 1)

; Fermeture du fichier
(gimp-image-delete image)
)
)

(let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
(pattern (string-append nom-repertoire « \\*. » extension))
(fichiers (cadr (file-glob pattern 0)))
)
; Application de la fonction traiter-fichier à chaque fichier
(map traiter-fichier fichiers)
)
)

(script-fu-register
« script-fu-traitementparlot » ;func name
« :D »
« Exemple de traitement par lot »
« Frédéric Bisson  »
« Frédéric Bisson »
« 2010-04-20 »
«  »
SF-DIRNAME « Répertoire à traiter » «  »
SF-OPTION « Extension » TRAITEMENTPARLOT-EXTENSIONS
)

(script-fu-menu-register « script-fu-traitementparlot » «  »)

**********************************************************************
**********************************************************************

Bonne journée.

16 08 2010
zigazou

“1) Le script crash si l’image est déjà au format grayscale originallement.”

La fonction gimp-image-convert-grayscale que tu utilises requiert une image RGB, RGBA ou en couleurs indexées. Lui fournir une image en niveau de gris ne lui convient pas.

Il faut que tu testes d’abord le type d’image :

(if (not (= (car (gimp-image-base-type image)) GRAY))
(gimp-image-convert-grayscale image)
)

“2) Bien que l’image soit bel et bien enregistrée au format « .tif », elle ne possède pas la bonne extention (Elle conserve l’extension d’origine)”

Il faut que tu transformes la ligne :
(file-tiff-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier 1)

en

(file-tiff-save RUN-NONINTERACTIVE image calque (remplace-extension nom-fichier « tiff ») (remplace-extension nom-fichier « tiff ») 1)

après avoir défini la fonction remplace-extension :

(define (remplace-extension nom-fichier nouvelle-extension)
(let* ((longueur-1 (- (string-length nom-fichier) 1)))
(cond
((= longueur-1 0) (string-append « sansnom. » nouvelle-extension))
((char=? (string-ref nom-fichier longueur-1) #\.) (string-append nom-fichier nouvelle-extension))
(else (remplace-extension (substring nom-fichier 0 longueur-1) nouvelle-extension))
)
)
)

Il y a peut-être une autre façon de faire ça mieux, mais ça fonctionne, c’est le principal😉

“3) Je ne parvient pas à faire fonctionner le script sur plusieurs niveau de dossiers (des dossier contenant d’autres dossiers)”

Je n’ai pas de code à te proposer pour ça (j’étudie encore le problème).

“4) Je ne parvient pas à faire rouler le script sur plusieur extentions à la fois”

Si tu remplaces

(pattern (string-append nom-repertoire « \\*. » extension))

par

(pattern (string-append nom-repertoire « \\*.* »))

ça devrait passer.

17 08 2010
Jean-François Asselin

Thanks a lot sir.

Unfortunately I already had these issues near corrected by the time I read your reply, but since your experience of scheme & script-fu is what it is, I’m defenetively going to play with your bits of codes to learn from them.

I just figured out a pretty simple (still complex a little but pretty clean) way of coding the « recursive children folders » option.

I’m working on that now and il keep you updated of my progress.

Have a marvelous day sir…

…ho merde…

Je vien juste de me rappeller qu’on est sur une page en français.

…Je suis sincèrement désolé, en gros ça disait « merci beaucoup pour ton code, je travail sur la fonction « dossiers enfants récurants », je t’en donnerai des nouvelles.

Merci encore pour ton aide

17 08 2010
Jean-François Asselin

Est-ce que vous avez une idée de comment ajouter le contenu d’une variable à une liste de la bonne façon ?

…voici une version un peu plus détaillée de mon problème :

http://www.gimptalk.com/forum/viewtopic.php?f=2&t=50197&p=369605#p369605

Merci & bonne journée

4 10 2010
bellamy

Bonjour et merci pour ce script très détaillé.

Avant tou une petite précision, avec mon Gimp 2.6.10, j’ai changé la ligne 52 :
« /Script-Fu/Traitement par lot »
en
« /Script-Fu/Traitement par lot »
pour que le script apparaisse.

Ensuite ,ce que je cheche surtout, c’est de convertir mes images xcf en png, et je me disais que ça doit être possible avec ce script, mais je ne connais rien au scheme…

J’avais trouvé ce script-ci :save-layers-as-img.scm (http://www.gimp-attitude.org/ressources-scripts-savelayers.php) mais il n’a plus l’air d’actualité. (une erreur apparait : Error: car: argument 1 must be: pair )

Je ne trouve donc aucune solution. Tout aide est la benvenue.

ps: J’ai aussi posté sur GimpAttitude (http://www.gimp-attitude.org/forum2/viewtopic.php?f=40&t=6951&p=46603#p46603)

4 10 2010
zigazou

Bonjour,

Je n’ai pas bien vu la différence entre “/Script-Fu/Traitement par lot” et “/Script-Fu/Traitement par lot”…

Sinon, as-tu jeté un œil sur mon article “Traitement par lot sous Gimp 2.6” ?
https://zigazou.wordpress.com/2010/04/21/traitement-par-lot-sous-gimp-2-6/

5 10 2010
bellamy

Ha! Désolé, c’est donc à la ligne 52:

« /Script-Fu/Traitement par lot »

qui devient

« /Script-Fu/Traitement par lot ».
puisque les script-fu sont maintenant dans le menu de la fenre image.

quand à l’article, oui, bien sûr, c’est de celui-là dont je parle.

5 10 2010
bellamy

ha! ha! il y a un soucis sur ce blog, je vais essayer avec des espace ou plutôt comme ça: il faut rajouter Image entre avant /Script-Fu/Traitement par lot, mais quand je l’écris et que j’envois le message, il disparait. ça correspond à une balise ?

8 10 2010
zigazou

Il y a toute une mise en forme faite automatiquement par WordPress sur les commentaires et les billets😉

13 11 2010
Shadoward

Bonjour á tous,

Aprés de nombreuses heures (plutôt jour ), j’ai enfin réussis, avec l’aide de nombreux sites et scripts, à faire un script de traitemant par lot sous windows xp et gimp 2.6. Mon script permet de sélectionner un dossier où doit être fait le traitement par lot et applique les filtres plug-in-lens-distortion, gimp-brightness-contrast, plug-in-unsharp-mask, puis sauve les images dans un autre dossier de votre choix.

> ; -*- Script Batch Processing*-
; Version 0.9 November 13, 2010
; By Patrice Ponchant
;
; GIMP – The GNU Image Manipulation Program
; Copyright (C) 1995 Spencer Kimball and Peter Mattis
;
; This program is free software; you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 2 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program; if not, write to the Free Software
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

;—————————————————————————————————————————————————————–
;; Définitions des filtres utiliser pour le traitement des images

(define (script-fu-foto-auv image drawable edge-adjust rescale brightness contrast)
(plug-in-lens-distortion RUN-NONINTERACTIVE image drawable 0 0 0 edge-adjust rescale 0) ;; Corrects lens distortion.
(gimp-brightness-contrast drawable brightness contrast) ;; Modify brightness/contrast in the specified drawable.
(plug-in-unsharp-mask RUN-NONINTERACTIVE image drawable 5 0.5 0) ;; Sharpening filter
)

;—————————————————————————————————————————————————————–
;; Fonction de traitement par lot des images

(define (script-fu-batch-fotos-auv image
drawable
dirname-in
edge-adjust
rescale ;; Liste des variables SF-*
brightness
contrast
dirname-out
)
(let* ((filelist (cadr (file-glob (string-append dirname-in « \\*.jpg ») 1)))) ;; Sélection du dossier à traiter avec SF-DIRNAME
(while (not (null? filelist)) ;; et listage des images (.jpg) dans le dossier sélectionné
(let* ((filename-in (car filelist)) ;; Définition de la variable filename-in
(image (car (gimp-file-load RUN-NONINTERACTIVE filename-in filename-in))) ;; Définition de la variable image
(drawable (car (gimp-image-get-active-layer image))) ;; Définition de la variable drawable
(filename-out (string-append dirname-out « \\ » filename-in)) ;; Définition de la variable filename-out
)
(script-fu-foto-auv image drawable edge-adjust rescale brightness contrast) ;; Traitement de l’image
(file-jpeg-save RUN-NONINTERACTIVE image drawable filename-out filename-out 1 0 1 0 «  » 0 1 0 0) ;; Sauvegarde de l’image
(gimp-image-delete image) ;; Fermeture de l’image
)
(set! filelist (cdr filelist))
)
)
)

;—————————————————————————————————————————————————————–
;; Registre du script

(script-fu-register « script-fu-batch-fotos-auv » ; nom du script
« /Batch/2 – Batch Processing » ;; Position du script dans le menu
« Batch Processing » ;; Commentaires
« Patrice Ponchant » ;; Auteur
« Patrice Ponchant » ;; Copyright
« 13/11/2010 » ;; Date
«  » ;; Types d’images supportés par le script
SF-IMAGE « Image » 0 ;; Image dans lequel le calque est ajouté
SF-DRAWABLE « Drawable » 0 ;; Calque actif de l’image
SF-DIRNAME « Pasta RAW » «  » ;; Demande à The Gimp d’afficher un widget permettant de sélectionner un répertoire
SF-ADJUSTMENT « Distorção de lente (Bordas) » ‘(0 -100 100 .1 1 3 0) ;; Variable edge-adjust
SF-ADJUSTMENT « Distorção de lente (Zoom) » ‘(0 -100 100 .1 1 3 0) ;; Variable rescale
SF-ADJUSTMENT « Ajustar Brilho » ‘(0 -127 127 1 10 0 0) ;; Variable brightness
SF-ADJUSTMENT « Ajustar Contraste » ‘(0 -127 127 1 10 0 0) ;; Variable contrast
SF-DIRNAME « Pasta PROC » «  » ;; Demande à The Gimp d’afficher un widget permettant de sélectionner un répertoire
) ; fin du register
[\code]

14 11 2010
zigazou

Bravo et merci de partager !🙂

14 11 2010
Shadoward

Petite modification :

(filename-out (string-append dirname-out « \\ » (car (gimp-image-get-name image)))) ;; Définition de la variable filename-out

14 11 2010
Shadoward

Autre modification : Il est inutile de définir les variable image et drawable dans (define (script-fu-batch-fotos-auv et vous pouvez tirer SF-IMAGE « Image » 0 et SF-DRAWABLE « Drawable » 0. Si vous avez d’autre correction à apporter n’hésitez pas.

Nouveau script comme correction:

> ; -*- Script Batch Processing*-
; Version 0.9 November 13, 2010
; By Patrice Ponchant
;
; GIMP – The GNU Image Manipulation Program
; Copyright (C) 1995 Spencer Kimball and Peter Mattis
;
; This program is free software; you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation; either version 2 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program; if not, write to the Free Software
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

;—————————————————————————————————————————————————————–
;; Définitions des filtres utiliser pour le traitement des images

(define (script-fu-foto-auv image drawable edge-adjust rescale brightness contrast)
(plug-in-lens-distortion RUN-NONINTERACTIVE image drawable 0 0 0 edge-adjust rescale 0) ;; Corrects lens distortion.
(gimp-brightness-contrast drawable brightness contrast) ;; Modify brightness/contrast in the specified drawable.
(plug-in-unsharp-mask RUN-NONINTERACTIVE image drawable 5 0.5 0) ;; Sharpening filter
)

;—————————————————————————————————————————————————————–
;; Fonction de traitement par lot des images

(define (script-fu-batch-fotos-auv dirname-in
edge-adjust
rescale ;; Liste des variables SF-*
brightness
contrast
dirname-out
)
(let* ((filelist (cadr (file-glob (string-append dirname-in « \\*.jpg ») 1)))) ;; Sélection du dossier à traiter avec SF-DIRNAME
(while (not (null? filelist)) ;; et listage des images (.jpg) dans le dossier sélectionné
(let* ((filename-in (car filelist)) ;; Définition de la variable filename-in
(image (car (gimp-file-load RUN-NONINTERACTIVE filename-in filename-in))) ;; Définition de la variable image
(drawable (car (gimp-image-get-active-layer image))) ;; Définition de la variable drawable
(filename-out (string-append dirname-out « \\ » (car (gimp-image-get-name image)))) ;; Définition de la variable filename-out
)
(script-fu-foto-auv image drawable edge-adjust rescale brightness contrast) ;; Traitement de l’image
(file-jpeg-save RUN-NONINTERACTIVE image drawable filename-out filename-out 1 0 1 0 «  » 0 1 0 0) ;; Sauvegarde de l’image
(gimp-image-delete image) ;; Fermeture de l’image
)
(set! filelist (cdr filelist))
)
)
)

;—————————————————————————————————————————————————————–
;; Registre du script

(script-fu-register « script-fu-batch-fotos-auv » ; nom du script
« /Batch/2 – Batch Processing » ;; Position du script dans le menu
« Batch Processing » ;; Commentaires
« Patrice Ponchant » ;; Auteur
« Patrice Ponchant » ;; Copyright
« 13/11/2010 » ;; Date
«  » ;; Types d’images supportés par le script
SF-DIRNAME « Pasta RAW » «  » ;; Demande à The Gimp d’afficher un widget permettant de sélectionner un répertoire
SF-ADJUSTMENT « Distorção de lente (Bordas) » ‘(0 -100 100 .1 1 3 0) ;; Variable edge-adjust
SF-ADJUSTMENT « Distorção de lente (Zoom) » ‘(0 -100 100 .1 1 3 0) ;; Variable rescale
SF-ADJUSTMENT « Ajustar Brilho » ‘(0 -127 127 1 10 0 0) ;; Variable brightness
SF-ADJUSTMENT « Ajustar Contraste » ‘(0 -127 127 1 10 0 0) ;; Variable contrast
SF-DIRNAME « Pasta PROC » «  » ;; Demande à The Gimp d’afficher un widget permettant de sélectionner un répertoire
) ; fin du register

14 11 2010
17 11 2010
Mric

Bonjour,
je crois que j’ai compris le principe, par contre (après avoir adapté à mes besoins le traitement de l’image et adapté les ligne de codes pour windows comme suggéré) l’erreur eval undound variable: //.* apparait…
Avez vous une explication?
Merci beaucoup en tous cas!

18 11 2010
zigazou

Bonjour,

vous avez probablement oublié une double quote  » quelque part ou mal placé la chaîne //.*

Sans voir votre code, je ne pourrais guère en dire plus.

18 11 2010
Mric

je copie le code
merci

; Définition des extensions autorisees
(define TRAITEMENTPARLOT-EXTENSIONS
‘(« JPG » « JPEG » « TIF » « XCF » « PNG »)

)

; Fonction de traitement par lot
(define (script-fu-traitementparlot nom-repertoire extension)
; Fonction chargée de traiter une image
(define (traiter-image image)
; Démarre un niveau de undo
;begin undo group
(gimp-image-undo-group-start image)
(gimp-undo-push-group-start image)

;constants
(let* (
(highlights-opacity 100)
(shadows-opacity 100)
(lower-yellow-saturation-opacity 40)
(lower-green-saturation-opacity 40)
(lower-red-saturation-opacity 40)
(lower-yellow-saturation-visibility 0)
(lower-green-saturation-visibility 0)
(lower-red-saturation-visibility 0)
(blur-radius 25)
)

;create and process auto-stretch-layer)
(define auto-stretch-layer (car (gimp-layer-copy drawable 1)))
(gimp-layer-set-name auto-stretch-layer « auto stretch »)
(gimp-image-add-layer image auto-stretch-layer -1)
(gimp-levels-stretch auto-stretch-layer)
(gimp-layer-set-mode auto-stretch-layer 0)
(gimp-layer-set-opacity auto-stretch-layer 100)
(gimp-layer-set-visible auto-stretch-layer 1)

;create and process lower-red-saturation-layer
(define lower-red-saturation-layer (car (gimp-layer-copy auto-stretch-layer 1)))
(gimp-drawable-set-name lower-red-saturation-layer « lower red saturation »)
(gimp-image-add-layer image lower-red-saturation-layer -1)
(gimp-hue-saturation lower-red-saturation-layer 1 0 0 -100)
(gimp-layer-set-mode lower-red-saturation-layer 0)
(gimp-layer-set-opacity lower-red-saturation-layer lower-red-saturation-opacity)
(gimp-layer-set-visible lower-red-saturation-layer lower-red-saturation-visibility)

;create and process lower-green-saturation-layer
(define lower-green-saturation-layer (car (gimp-layer-copy auto-stretch-layer 1)))
(gimp-drawable-set-name lower-green-saturation-layer « lower green saturation »)
(gimp-image-add-layer image lower-green-saturation-layer -1)
(gimp-hue-saturation lower-green-saturation-layer 3 0 0 -100)
(gimp-layer-set-mode lower-green-saturation-layer 0)
(gimp-layer-set-opacity lower-green-saturation-layer lower-green-saturation-opacity)
(gimp-layer-set-visible lower-green-saturation-layer lower-green-saturation-visibility)

;create and process lower-yellow-saturation-layer
(define lower-yellow-saturation-layer (car (gimp-layer-copy auto-stretch-layer 1)))
(gimp-drawable-set-name lower-yellow-saturation-layer « lower yellow saturation »)
(gimp-image-add-layer image lower-yellow-saturation-layer -1)
(gimp-hue-saturation lower-yellow-saturation-layer 2 0 0 -100)
(gimp-layer-set-mode lower-yellow-saturation-layer 0)
(gimp-layer-set-opacity lower-yellow-saturation-layer lower-yellow-saturation-opacity)
(gimp-layer-set-visible lower-yellow-saturation-layer lower-yellow-saturation-visibility)

;create and process highlights-layer
(define highlights-layer (car (gimp-layer-copy auto-stretch-layer 1)))
(gimp-drawable-set-name highlights-layer « highlights »)
(gimp-image-add-layer image highlights-layer -1)
(gimp-layer-set-mode highlights-layer 5)
(gimp-layer-set-opacity highlights-layer highlights-opacity)
(gimp-layer-set-visible highlights-layer 1)

;process highlights-layer
(gimp-desaturate highlights-layer)
(gimp-invert highlights-layer)
(plug-in-gauss-iir2 1 image highlights-layer blur-radius blur-radius)

;create shadows-layer
(define shadows-layer (car (gimp-layer-copy highlights-layer 1)))
(gimp-drawable-set-name shadows-layer « shadows »)
(gimp-image-add-layer image shadows-layer -1)
(gimp-layer-set-mode shadows-layer 5)
(gimp-layer-set-opacity shadows-layer shadows-opacity)
(gimp-layer-set-visible shadows-layer 1)

;colortoalpha white for highlights-layer
(plug-in-colortoalpha 1 image highlights-layer ‘(255 255 255))

;colortoalpha black for shadows-layer
(plug-in-colortoalpha 1 image shadows-layer ‘(0 0 0))

)

;update image window
(gimp-displays-flush)
(gimp-undo-push-group-end image)

;end undo group
(gimp-image-undo-group-end image)

)

; Fonction chargée de traiter un fichier
(define (traiter-fichier nom-fichier)
; Ouverture du fichier
(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE nom-fichier nom-fichier)))
(calque (car (gimp-image-get-active-drawable image)))
)
; Traitement de l’image
(traiter-image image)

; Enregistrement du fichier
(gimp-file-save RUN-NONINTERACTIVE image calque nom-fichier nom-fichier)

; Fermeture du fichier
(gimp-image-delete image)
)
)

(let* ((extension (list-ref TRAITEMENTPARLOT-EXTENSIONS extension))
(pattern (string-append nom-repertoire « \\*. » extension))

(fichiers (cadr (file-glob pattern 0)))
)

; Application de la fonction traiter-fichier à chaque fichier
(map traiter-fichier fichiers)
)
)

(script-fu-register « script-fu-traitementparlot »
« /Script-Fu/Traitement par lot »
« Exemple de traitement par lot »
« Frédéric Bisson  »
« Frédéric Bisson »
« 2010-04-20 »
«  »
SF-DIRNAME « Repertoire a traiter » «  »
SF-OPTION « Extension » TRAITEMENTPARLOT-EXTENSIONS
)

18 11 2010
zigazou

Attention quand vous recopiez le code : wordpress.com a tendance à remplacer les double quotes anglaises par des guillemets français qui sont interprêtés comme des caractères différents. Je pense que ça vient de là.

18 11 2010
Mric

j’ai remplacé les guillement, je n’ai plus de message d’erreur, mais une fois le dossier et le type de fichier choisi, rien ne se passe…

21 03 2011
Willy

Bonjour
Merci pour ce tutoriel !
Je l’ai adapté à mon besoin qui est de remplacer le noir d’environ 500 images par de l’alpha.
Pour ça j’utilise le plug-in plug-in-colortoalpha

voici le code (très simple) au cas ou :
;remplace le noir par de l’alpha
(plug-in-colortoalpha RUN-NONINTERACTIVE image (car (gimp-image-get-active-drawable image)) ‘(0 0 0))

20 08 2011
Le Gnou

Bonjour,

Un big grand merci pour le script…cela m’a permis d’aider quelqu’un souhaitant traiter des images en lots (« bandeau » flou en haut & en bas).

Forcément, je me suis fait avoir…la personne étant sous Windows, le script ne donnait rien (alors qu’il fonctionnait dans mon PC sous Linux…)…

Je confirme, les deux différences :
1° récupération des noms de fichiers :
Sous GNU/Linux :
(pattern (string-append nom-repertoire « /*. » extension))
Sous Windows :
(pattern (string-append nom-repertoire « \\*. » extension))

2° Les extensions :
Sous GNU/Linux :
Sensible à la casse, donc il faut prévoir les extensions en majuscules & en minuscules
Sous Windows :
J’ai testé le script en laissant les extensions en minuscules (dans le script), et cela fonctionne même si une image a son extension en majuscule…

Encore un grand merci…ce genre de script décuple les possibilités de Gimp…

Cela permet aussi de montrer que Gimp regorge de possibilités (l’utilisant depuis la version 1.2, j’en découvre encore🙂.

Accessoirement, cela m’a également permis de me remettre au script…j’avais « lâché » depuis le changement de l’interpréteur (« Ubound Variable », quand on n’a pas Internet…grr).

Merci encore, et @+.

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s




%d blogueurs aiment cette page :