Discussion :

[kryss01s]

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

[Carhiboux]

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.

[Nico02]

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);

[tchize_]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
aaaaaaaa bbbbbbbb cccccccc dddddddd
 
 
r = 00000000 00000000 aaaaaaaa bbbbbbbb
g= 00000000 00000000 00000000 cccccccc
b= 00000000 00000000 00000000 dddddddd

[kryss01s]

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

[ToTo13]

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;

setPixel(x, y, (r<<16)+(g<<8)+b);

Cette opération prend la couleur de chaque canal, recompose le tout pour encoder au format sRGB et affecte la valeur au pixel.

Et si tu souhaites modifier le rouge, ton dernier morceau de code fonctionne.