web-dev-qa-db-fra.com

Comprendre les valeurs de sortie BufferedImage.getRGB

J'obtiens une valeur entière pour le pixel dans une image en utilisant cette méthode:

int colour = img.getRGB(x, y);

Ensuite, j'imprime les valeurs et je vois que les pixels noirs correspondent à une valeur comme "-16777216", une sorte de bleu à quelque chose comme "-16755216", etc. Quelqu'un peut-il m'expliquer la logique derrière cette valeur?

javaimage-processingcolorsrgbbufferedimage
32
leonardo

getRGB(int x, int y) vous renvoie la valeur du pixel de couleur à l'emplacement (x, y).
Vous interprétez mal la valeur renvoyée.
Il est au format binaire. comme 11 ... 11010101 et qui vous est donné comme valeur int.
Si vous souhaitez obtenir des composants RVB (c'est-à-dire rouge, vert, bleu) de cette valeur, utilisez la classe Couleur. par exemple.

Color mycolor = new Color(img.getRGB(x, y));

Ensuite, vous pouvez obtenir la valeur Rouge, Vert ou Bleu en utilisant getRed(), getGreen(), getBlue(), getAlpha(). Ensuite, une valeur int sera retournée par ces méthodes dans un format familier ayant la valeur 0 < value < 255

int red = mycolor.getRed();

Si vous ne souhaitez pas utiliser la classe Color, vous devrez utiliser des opérations au niveau du bit pour obtenir sa valeur.

32
afzalex

La couleur RVB int contient les composants Rouge, Vert, Bleu de la couleur dans ses bits. Vous devez regarder sa représentation binaire ou hexadécimale et ne pas la regarder comme un nombre entier (ne pas regarder sa représentation décimale).

Un int a 32 bits, 3x8 = 24 est utilisé pour stocker les composants RVB (8 bits pour chacun) dans le format suivant:

               2          1          0
bitpos      32109876 54321098 76543210
------   --+--------+--------+--------+
bits     ..|RRRRRRRR|GGGGGGGG|BBBBBBBB|

Vous pouvez extraire ou définir les composants à l'aide de masques de bits:

int color = img.getRGB(x, y);

// Components will be in the range of 0..255:
int blue = color & 0xff;
int green = (color & 0xff00) >> 8;
int red = (color & 0xff0000) >> 16;

Si la couleur a également un composant alpha (transparence) ARGB, elle obtient les 8 derniers bits restants.

           3          2          1          0
bitpos    10987654 32109876 54321098 76543210
------   +--------+--------+--------+--------+
bits     |AAAAAAAA|RRRRRRRR|GGGGGGGG|BBBBBBBB|

Et la valeur:

int alpha = (color & 0xff000000) >>> 24; // Note the >>> shift
                                         // required due to sign bit

Une valeur alpha de 255 signifie qu'une couleur est complètement opaque et une valeur de 0 signifie que la couleur est complètement transparente.

Votre couleur:

Votre couleur est color = -16755216 qui a:

blue : 240         // Strong blue
green:  85         // A little green mixed in
red  :   0         // No red component at all
alpha: 255         // Completely opaque
47
icza

Voir implémentation de ColorModel.getRgb:

589  public int getRGB(int pixel) {
590        return (getAlpha(pixel) << 24)
591             | (getRed(pixel) << 16)
592             | (getGreen(pixel) << 8)
593             | (getBlue(pixel) << 0);
594   }
6
Jens

C'est expliqué dans la documentation :

Renvoie un pixel entier dans le modèle de couleur RVB par défaut (TYPE_INT_ARGB) [...]

Vous obtenez donc un canal alpha 8 bits, 8 bits rouge, 8 bits vert, 8 bits bleu.

Une manière simple (et lente) d'examiner la valeur consiste à utiliser new Java.awt.Color(colour, true); puis à appeler les getters.

Ou vous pouvez imprimer la valeur sous la forme d'une valeur hexadécimale 32 bits non signée: Integer.toString(colour, 16). Chacun des deux caractères de la sortie fera partie de l'ensemble ARGB.

5
Aaron Digulla

En fait, vous pouvez transformer l'int en chaîne binaire par Integer.toBinaryString (-16755216), qui est 11111111000000000101010111110000.it composé de 4 octets: alpha, rouge, vert, bleu. Les valeurs ne sont pas multipliées, ce qui signifie que toute transparence est stockée uniquement dans le composant alpha et non dans les composants de couleur. Les composants sont stockés comme suit (alpha << 24) | (rouge << 16) | (vert << 8) | bleu. Chaque composant se situe entre 0..255, 0 signifiant aucune contribution pour ce composant et 255 signifiant une contribution de 100%. Ainsi, le noir opaque serait 0xFF000000 (100% opaque mais aucune contribution du rouge, vert ou bleu), et le blanc opaque serait 0xFFFFFFFF.

3
ben