Comprendre BufferedImage.getRGB valeurs de sortie
Je reçois 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?
5 réponses
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é en tant que valeur int.
Si vous voulez obtenir des composants RVB (C'est-à-dire rouge, vert, bleu) de cette valeur, utilisez la classe de couleur. par exemple
Color mycolor = new Color(img.getRGB(x, y));
Ensuite, vous pouvez obtenir une valeur rouge, verte ou bleue en utilisant getRed(), getGreen(), getBlue(), getAlpha().
Ensuite, une valeur int sera renvoyée par ces méthodes dans un format familier ayant la valeur 0 < value < 225
int red = mycolor.getRed();
Si vous ne voulez pas utiliser la classe Color, vous devrez utiliser des opérations au niveau du BIT pour obtenir sa valeur.
La couleur RVB int contient les composants rouge, vert et 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 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 bitmasks:
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 une composante alpha (transparence) ARGB, il 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 transparent.
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
C'est expliqué dans les docs:
Renvoie un pixel entier dans le modèle de couleur RVB par défaut (TYPE_INT_ARGB) [...]
Donc vous obtenez 8 bits canal alpha, 8 bits Rouge, 8 bits Vert, 8 bits bleu.
Un moyen simple (et lent) d'examiner la valeur consiste à utiliser new java.awt.Color(colour, true); puis à appeler les getters.
Ou vous pouvez imprimer la valeur en tant que valeur hexadécimale 32 bits non signée: Integer.toString(colour, 16). Chaque deux caractères de la sortie seront une partie de L'ensemble ARGB.
Voir mise en œuvre 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 }
En fait, vous pouvez transformer l'int en chaîne binaire par Entier.toBinaryString(-16755216), qui est 11111111000000000101010111110000.it composé de 4 octets: alpha, rouge, vert, bleu. Les valeurs ne sont pas multiples, 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