 |
Programmez un Tetris en Java 360 pages PDF pour apprendre à votre rythme. Développez des jeux vidéo en Java. www.jdevmaker.com |
Ce document est sous un contrat Creative Commons.
Ce script permet d'obtenir d'une image couleur, une image en teinte de gris.
Nous avons besoin de déterminer une valeur unique qui représentera le pixel en niveau de gris.
Nous ne pourrions nous contentez de faire la moyenne entre les trois primaires. Mais le résultat obtenue ne serait pas tout à fait ce que l'œil perçoit de la brillance de l'image couleur.
La biologie nous apprend que pour des quantités égales de couleur l'oeil est le plus sensible au vert, puis au rouge, et enfin au bleu. Dans une proportion que nous connaissons. Cela donne un facteur à appliquer à une primaire.
0.59 * vert
0.3 * rouge
0.11 * bleu
Le vert semble plus lumineux que le rouge et beaucoup plus lumineux que le bleu (a quantité de couleur égale).
Ainsi la formule 0.3R + 0.59G + 0.11B nous donne une brillance plus proche de ce que l'œil perçoit..
Analysons le script ligne par ligne.
-- niveaux de gris
Cette ligne est un commentaire. Tout ce qui suit les double caractères -- est considéré comme tel, et donc n'intervient pas dans le script.
for y=0, height-1 do
Cette instruction est le point de départ (indissociable de end) de ce que l'on appel une boucle. Lorsque l'instruction end est rencontrée, le script reprend au point de départ de la boucle.
Vous devez donc considérer l'instruction dans son ensemble :
|
y est une variable. y=0 signifie que la valeur de y est 0 et c'est la valeur de départ de la boucle.
Nous trouvons ensuite une , afin de séparer le paramètre y=0 du suivant.
height-1 est un autre paramètre de la boucle. height est une variable qui retourne la hauteur du calque sur lequel le filtre travail. Admettons que la hauteur soit 400 px, alors height=400, height-1=399. C'est la valeur de fin de boucle.
Do fait partie de l'instruction, il vient après les paramètres du for.
Processus : La boucle commence avec y=0 puis le script continue, et les instructions situé après s'exécute. Jusqu'à ce que l'instruction end soit rencontré, alors elle fait repartir le script à l'instruction for, mais en incrémentant ensuite y de 1. Maintenant y=1 et ça recommence, les instructions situées après s'exécutent. Jusqu'à ce que l'instruction end soit rencontré, alors elle fait repartir le script à l'instruction for, mais en incrémentant ensuite y de 1. Maintenant y=2 et ça continue ... jusqu'à ce que y=399. C'est la dernière fois que la boucle se fait.
for x=0, width-1 do
C'est la même chose. Mais cette fois la variable de la boucle est x. width contient la largeur du calque.
Cependant on vois bien que cette seconde boucle est contenu dans la première.
|
Admettons que la largeur soit 400 px, alors width=400, width-1=399.
Pour y=0, le script se poursuivra et tombera sur cette seconde boucle imbriqué, qui s'exécutera 400 fois avant de finir. Le script continue et rencontre le end de la première boucle. y=1, le script se poursuivra et tombera sur cette seconde boucle imbriqué, qui s'exécutera 400 fois (x=0, x=1, x=2 ... x=399) avant de finir. Le script continue et rencontre le end de la première boucle. y=2...
Nous voyons que cette méthode de boucles imbriquées, permet d'obtenir toute les coordonnées de l'image. C'est une formule qui sera nécessairement très courante. Pour chaque ligne (horizontal) (y), toutes les colonnes (vertical) (x). Comme toutes les lignes de l'image seront examinées, toutes les colonnes de toutes les lignes, le seront aussi.
Dans tous le script, x et y représenteront les coordonnées de tous les pixels de l'image.
|
La zone du programme à l'intérieur de la seconde boucle est l'endroit où nous disposons des coordonnées x et y du point actuel. Nous y trouvons donc naturellement les instructions permettant d'agir sur eux.
r,g,b = get_rgb(x,y)
Nous avons besoin de connaître les composantes des trois primaires du pixel. get_rgb nous le permet. Les instructions get_* font souvent des renvoies multiples de valeur. Ainsi get_rgb(x,y) renvoie trois valeurs, le rouge, le vert et le bleu. Nous aurons donc besoin de trois variables pour stocker ces valeurs. Cela s'écrit sous la forme :
r,g,b = get_rgb(x,y)
r sera égal à la composante rouge, v sera égal à la composante verte, b sera égal à la composante bleu.
set_value(x,y,(0.3*r)+(0.59*g)+(0.11*b))
Nous devons maintenant bâtir notre formule qui convertie ces trois composantes primaires en une valeur unique représentant un niveau de gris.
Y = 0.3Rouge + 0.59Vert + 0.11Bleu = (0.3*r)+(0.59*g)+(0.11*b)
Nous avons ensuite besoin d'une instruction afin de définir le pixel avec ce paramètre, c'est ce que nous permet set_value. Cela s'écrit sous la forme :
set_value (x,y,v)
v représente la valeur du pixel que nous venons de calculer soit :
set_value (x,y,(0.3*r)+(0.59*g)+(0.11*b))
Progress (y/height)
Cette instruction agit sur la barre de preogression dans Gimp.
0 corespond à 0% et 1 à 100%.
y est comprise entre 0 et height. height est donc le plafond de y.
y/height permet donc d'obtenir une valeur situé entre 0 et 1.
Cette instruction sera déclenché une fois pour chaque valeurs de y.
