Version imprimable
voilà l'algorithme que j'ai trouvé sur internet permettant d'augmenter la valeur du vert
h = getHeight();
w = getWidth();
for (x=0; x<w; x++)
for (y=0; y<h; y++) {
v = getPixel(x, y);
r = v>>16;
g = (v>>8)&255;
b = v&255;
g = g*2;
if (g>255) g = 255;
setPixel(x, y, (r<<16)+(g<<8)+b);
}
mais que veut dire le symbole: >> ?
et que veut dire les lignes suivantes :
r = v>>16;
g = (v>>8)&255;
b = v&255;
??
merci
Salut,
>> et << sont les opérateurs de décalage binaire en java.
Cf : http://gfx.developpez.com/tutoriel/java/binaire/
Ici, de ce que j'en comprends et suppose, v = getPixel(x, y); te renvoie 3 bytes accolés (soit 24 bits), et r, g et b sont de type byte.
Et donc en gros, lorsque que fais r = v>>16; tu vas lire la valeur de v décalée de 16 bits vers la droite. Donc à partir de son 17ième.
&255 c'est un masque binaire, pour un int (donc codé sur 32bits), 255 sous forme de bits c'est : 00000000 00000000 00000000 11111111
Donc quand tu fais un & (opérateur logique ET), tu ne gardes que les 8 derniers bits de ce sur quoi tu appliques ton masques. Car 0&1 = 0 et 0&0 = 0.
Salut,
Bon je ne suis pas un spécialiste du traitement d'image mais je peux essayer de t’apporter quelques éléments de réponses.
Tout d'abord il faut bien comprendre que chaque composante de couleur est codée sur 1 octet, soit 256 valeurs possible. Avec 3 composante (RGB) ça nous fait donc 256*256*256 couleur possibles.
Soit 3 octets
00000000 00000000 00000000
Où chaque octet représente une composante
En java, un int fait 4 octet (32bits), donc il est possible de représenter une couleur avec ( on aura même un octet de trop qui pourra nous servir comme canal alpha par exemple ).
Donc on peut représenter une couleur par
- 00000000 11111111 10101010 00000000 (xRGB)
En Java, les opérateurs << et >> sont des opérateurs de décalages de bits.
C'est à dire qu'ils vont effectuer un décaler de n bit vers la droite ou la gauche et complète avec des 0
ex : 10000000 >> 7 = 00000001
Donc l'opération r = v>>16 va en fait faire un décalage de 16 bits vers la droite.
Si on se le représente sous forme de bits,
- 00000000 11111111 10101010 00000000 >> 16 = 00000000 00000000 00000000 11111111
On ne récupère donc que la valeur de la composante de rouge.
Pour le vert c'est un peu plus compliqué.
g = (v>>8)&255
Ici on décale donc de 8 bits
- 00000000 11111111 10101010 00000000 >> 8 = 00000000 00000000 11111111 10101010
Ce qui n'est pas bon. On va donc effectuer ce qu'on appelle une opération de masquage avec l'opérateur binare &
11111111 & 10101010 = 10101010
Si on applique ça à notre composante de vert
- 00000000 00000000 11111111 10101010 & 00000000 00000000 00000000 11111111
on obtient
- 00000000 00000000 0000000 10101010
Ce qui représente bien notre vert.
Pour le bleu c'est donc la même chose, on applique le masque et il va nous rester
- 00000000 11111111 10101010 00000000 & 00000000 00000000 00000000 00000000 = 00000000 00000000 00000000 00000000
A partir de là on peut donc travailler sur nos 3 composantes indépendamment et il nous suffira donc de faire l'opération inverse pour reconstruire notre pixel.
setPixel(x, y, (r<<16)+(g<<8)+b);
r = v>>16; --> Garde les bits 16 à 31 décalés en position 0 à 15
g = (v>>8)&255; -> Gardes les bits 8 à 15 décalés en position 0 à 8
b = v&255; -> Garde les bits 0 à 8
En gros, tu part, en binaires de
Code:
2
3
4
5
6
7
merci pour vos réponses.
mais je penses pas avoir compris le principe:
en particulier à la fin pour : setPixel(x, y, (r<<16)+(g<<8)+b);
j'ai l'impression que l'on récupère chaque octet des composantes puis on les rassemble. et j'ai du mal à comprendre pourquoi l'image est verte au final.
mon but est de faire la même chose mais que pour la composante rouge.
en faisant :
r = v>>16;
g = (v>>8)&255;
b = v&255;
r = r*2;
if (r>255) r = 255;
setPixel(x, y, (r<<16)+(g<<8)+b);
j'obtienne ce que je souhaite. je vais continuer à relire vos réponse
L'algorithme récupère la valeur/couleur du pixel, mais c'est codé dans un INT au format sRGB, donc difficilement exploitable tel quel.
Donc la première chose que fait l'algorithme (comme cela vient d'être dit dans les réponses précédentes), c'est d'extraire la couleur de chaque canal (r, g, b).
Un fois que tu connais la valeur du pixel dans chaque canal, tu peux travailler dessus.
En fait ton algorithme est VRAIMENT basique, il se contente de multiplier par 2 la valeur du canal vert : g = g*2;
Puis il vérifie que cette valeur n'est pas trop grande (elle doit être entre 0 et 255) : if (g>255) g = 255;
Cette opération prend la couleur de chaque canal, recompose le tout pour encoder au format sRGB et affecte la valeur au pixel.Citation:
Envoyé par kryss01s
Et si tu souhaites modifier le rouge, ton dernier morceau de code fonctionne.