Si vous êtes intéressé par la création de scripts pour automatiser vos
traitements ou alors faire du traitement par lot sous Gimp, je vous propose
de voir les exemples de scripts que j'utilise :
http://www.photonature.fr/Gimp/script-fu.html
Vous y trouverez quelques explications et informations sur le langage des
scripts-fu ainsi que 5 scripts-fu dont 4 commentés et 1 survolé.
Je ne cherche pas à faire un tutoriel, certains en présentent d'excellents,
mais juste de montrer quelque chose qui marche pour moi et qui peut donner
des idées.
N'hésitez pas à faire des remarques ou à me demander des explications
complémentaires.
Bonne visite
--
Stephan Peccini
Nature : <URL:http://nature.tesenca.info>
Seurasaari : <URL:http://seurasaari.tesenca.info>
Bon en fait la récursivité terminale permet juste de boucler sans empiler.
C'est justement parce que je suis aller voir que j'en resterai au while :-)
En fait c'est tout con : il suffit que chaque appel récursif soit la dernière opération effectuée.
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça : pour r=a+b : r=b ; while (a>0) { a--;b++; } return r;
en scheme
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH -- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
Stéphan Peccini <stephan@tesenca.info> wrote:
Bon en fait la récursivité terminale permet juste de boucler sans
empiler.
C'est justement parce que je suis aller voir que j'en resterai au while :-)
En fait c'est tout con : il suffit que chaque appel récursif soit la
dernière opération effectuée.
En pratique cela revient à ce que chaque variable de la boucle soit
trimbalée dans les arguments, y compris le resultat. C'est finalement
plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les
incréments à un ou deux, en C tu ferais comme ça :
pour r=a+b :
r=b ; while (a>0) { a--;b++; }
return r;
en scheme
(letrec ((fun (lambda (r a) (if (> a 0)
(fun (+ r 1) (- a 1))
r))))
(fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que
la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1))
r))))
(fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
--
Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire
une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle.
Roland Barthes.
http://www.filh.org
Bon en fait la récursivité terminale permet juste de boucler sans empiler.
C'est justement parce que je suis aller voir que j'en resterai au while :-)
En fait c'est tout con : il suffit que chaque appel récursif soit la dernière opération effectuée.
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça : pour r=a+b : r=b ; while (a>0) { a--;b++; } return r;
en scheme
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH -- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
Stéphan Peccini
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant j'avance à petits pas avec mes quelques connaissances de programmation. Par contre les "set!" vont disparaître dans quelques temps.
A moins que je me laisse tenter par les scripts Python :-)
-- Stephan Peccini PhotoNature : <URL:http://www.photonature.fr>
En pratique cela revient à ce que chaque variable de la boucle soit
trimbalée dans les arguments, y compris le resultat. C'est finalement
plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les
incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli
m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent
pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je
ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant
j'avance à petits pas avec mes quelques connaissances de programmation.
Par contre les "set!" vont disparaître dans quelques temps.
A moins que je me laisse tenter par les scripts Python :-)
--
Stephan Peccini
PhotoNature : <URL:http://www.photonature.fr>
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant j'avance à petits pas avec mes quelques connaissances de programmation. Par contre les "set!" vont disparaître dans quelques temps.
A moins que je me laisse tenter par les scripts Python :-)
-- Stephan Peccini PhotoNature : <URL:http://www.photonature.fr>
filh
Stéphan Peccini wrote:
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant j'avance à petits pas avec mes quelques connaissances de programmation. Par contre les "set!" vont disparaître dans quelques temps.
Le pb de certains langages, scheme ou perl par exemple est qu'il existe effectivement un « style », mais ce n'est pas forcément une obligation.
Il vaut mieux faire un bon script perl avec des tests à la C qui rende service, que de passer 6 mois à apprendre un style parfois.
Mais bon... en tant qu'ex schemien, j'ai aussi du mal à résister.
FiLH
-- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
Stéphan Peccini <stephan@tesenca.info> wrote:
En pratique cela revient à ce que chaque variable de la boucle soit
trimbalée dans les arguments, y compris le resultat. C'est finalement
plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les
incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli
m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent
pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je
ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant
j'avance à petits pas avec mes quelques connaissances de programmation.
Par contre les "set!" vont disparaître dans quelques temps.
Le pb de certains langages, scheme ou perl par exemple est qu'il existe
effectivement un « style », mais ce n'est pas forcément une obligation.
Il vaut mieux faire un bon script perl avec des tests à la C qui rende
service, que de passer 6 mois à apprendre un style parfois.
Mais bon... en tant qu'ex schemien, j'ai aussi du mal à résister.
FiLH
--
Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire
une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle.
Roland Barthes.
http://www.filh.org
En pratique cela revient à ce que chaque variable de la boucle soit trimbalée dans les arguments, y compris le resultat. C'est finalement plus proche effectivement de la boucle que de la récursivité pure.
Un exemple classique, si tu veux faire une addition avec uniquement les incréments à un ou deux, en C tu ferais comme ça :
Merci pour les informations. Je trouve tout cela intéressant et j'ai failli m'acheter un livre sur le Scheme. Mais comme beaucoup de choses n'existent pas sous Gimp, je me suis dit que j'allais apprendre sur Scheme mais que je ne serais pas capable de le reproduire sous Gimp. Donc pour l'instant j'avance à petits pas avec mes quelques connaissances de programmation. Par contre les "set!" vont disparaître dans quelques temps.
Le pb de certains langages, scheme ou perl par exemple est qu'il existe effectivement un « style », mais ce n'est pas forcément une obligation.
Il vaut mieux faire un bon script perl avec des tests à la C qui rende service, que de passer 6 mois à apprendre un style parfois.
Mais bon... en tant qu'ex schemien, j'ai aussi du mal à résister.
FiLH
-- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
bruno louault
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
ca ressemble a du lisp non ?
(letrec ((fun (lambda (r a) (if (> a 0)
(fun (+ r 1) (- a 1))
r))))
(fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que
la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1))
r))))
(fun b a))
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
ca ressemble a du lisp non ?
filh
bruno louault wrote:
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
ca ressemble a du lisp non ?
C'est un dialecte lisp.
FiLH
-- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
bruno louault <louault_bruno@houanadou.efaire> wrote:
(letrec ((fun (lambda (r a) (if (> a 0)
(fun (+ r 1) (- a 1))
r))))
(fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que
la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1))
r))))
(fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
ca ressemble a du lisp non ?
C'est un dialecte lisp.
FiLH
--
Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire
une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle.
Roland Barthes.
http://www.filh.org
(letrec ((fun (lambda (r a) (if (> a 0) (fun (+ r 1) (- a 1)) r)))) (fun b a))
ce est quand même pas mal similaire comme structure; nettemment plus que la structure récursive classique
(letrec ((fun (lambda (r a) (if (> a 0) (+ 1 (fun r (- a 1)) r)))) (fun b a))
:) Bon prochaine leçon les fermetures...
FiLH
ca ressemble a du lisp non ?
C'est un dialecte lisp.
FiLH
-- Le fondement du constat bourgeois, c'est le bon sens, c'est-à-dire une vérité qui s'arrête sur l'ordre arbitraire de celui qui la parle. Roland Barthes. http://www.filh.org
