web-dev-qa-db-fra.com

Comment obtenir les valeurs RVB d'un bitmap sur un appareil Android?

Je veux obtenir des valeurs RVB de bitmap dans Android mais je ne peux pas le faire jusqu'à présent. Mon objectif est d'obtenir des valeurs RVB pour chaque pixel de bitmap. Existe-t-il une fonction spécifique pour Android ou autre chose ?? Je me demande également si j'ai besoin de la fonction colorMatrix ()? C'est très important pour mon projet. Merci

androidimageimage-processingrgb
29
barzos

Cela peut être légèrement en retard, mais pour dissiper la confusion avec l'utilisation de & 0xff:

In Java ints are 32 bits, so the (A) RGB values ​​for each pixel are packed in 4 bytes. En d'autres termes, un pixel avec les valeurs R (123), G (93) , B(49) = FF7B 5D31 dans le modèle ARGB_8888. Où Alpha = FF, R = 7B, G = 5D, B = 31. Mais cela est stocké sous la forme d'un entier sous la forme -8692431.

Donc, pour extraire la valeur verte de -8692431, nous devons décaler le 5D de 8 bits vers la droite, comme vous le savez. Cela donne 00FF 7B5D. Donc, si nous devions simplement prendre cette valeur, nous nous retrouverions avec 16743261 comme valeur verte. Par conséquent, nous binaire et cette valeur avec le masque de 0xFF (qui est équivalent à 0000 00FF) et se traduira par 00FF 7B5D étant "masqué" à 0000 005D. Nous avons donc extrait notre valeur verte de 5D (ou 93 décimales).

Nous pouvons utiliser le même masque de 0xFF pour chaque extraction car les valeurs ont toutes été décalées pour exposer les deux octets souhaités comme les moins significatifs. D'où le code précédemment suggéré de:

int p = pixel[index];

int R = (p >> 16) & 0xff;
int G = (p >> 8) & 0xff;
int B = p & 0xff;

Si cela est plus clair, vous pouvez effectuer l'opération équivalente de:

int R = (p & 0xff0000) >> 16;
int G = (p & 0x00ff00) >> 8;
int B = (p & 0x0000ff) >> 0;

Par souci de concision, les 0 supplémentaires peuvent être supprimés et ils peuvent être écrits sous la forme

int R = (p & 0xff0000) >> 16;
int G = (p & 0xff00) >> 8;
int B = p & 0xff;

Notez cependant que d'autres modèles de couleurs peuvent être utilisés, tels que RGB_555 qui stocke chaque pixel sur seulement 2 octets, avec une précision variable pour les canaux RVB. Vous devez donc vérifier le modèle que votre bitmap utilise avant d'effectuer l'extraction, car les couleurs peuvent être stockées différemment.

25
QuackSaysHe

Bitmap.getPixel(x, y) renvoie un int avec les valeurs de couleur et la valeur alpha incorporées.

int colour = bitmap.getPixel(x, y);

int red = Color.red(colour);
int blue = Color.blue(colour);
int green = Color.green(colour);
int alpha = Color.alpha(colour);
25
Cobbles

C'est ainsi que j'essaie d'obtenir cette valeur. Utilisez bitmap.getPixel () pour obtenir le bitmap correspondant dans un tableau d'entiers. En utilisant l'opération de rotation au niveau du bit, nous obtiendrons des valeurs RVB.

             int[] pix = new int[picw * pich];
             bitmap.getPixels(pix, 0, picw, 0, 0, picw, pich);

             int R, G, B,Y;

             for (int y = 0; y < pich; y++){
             for (int x = 0; x < picw; x++)
                 {
                 int index = y * picw + x;
                 int R = (pix[index] >> 16) & 0xff;     //bitwise shifting
                 int G = (pix[index] >> 8) & 0xff;
                 int B = pix[index] & 0xff;

                 //R,G.B - Red, Green, Blue
                  //to restore the values after RGB modification, use 
 //next statement
                 pix[index] = 0xff000000 | (R << 16) | (G << 8) | B;
                 }}
18
yogsma

Un pour la déclaration moins: D

imagen.getPixels(pix, 0, picw, 0, 0, picw, pich);

    for (i = 0; i < pix.length; i++) {
        r = (pix[i]) >> 16 & 0xff;
        g = (pix[i]) >> 8 & 0xff;
        b = (pix[i]) & 0xff;
    }
7
Wolf

Traitement arbitraire des couleurs bitmap

Vous pouvez lire ici les différentes méthodes Couleur qui extrairont les composants de la couleur d'un pixel int.

Vous souhaiterez peut-être appliquer un filtre au bitmap et renvoyer un tableau d'octets. Sinon, vous pouvez réduire cet exemple à la boucle for et parcourir les pixels générant votre tableau d'octets.

private byte[] rgbValuesFromBitmap(Bitmap bitmap)
{
    ColorMatrix colorMatrix = new ColorMatrix();
    ColorFilter colorFilter = new ColorMatrixColorFilter(
            colorMatrix);
    Bitmap argbBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(),
            Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(argbBitmap);

    Paint paint = new Paint();

    Paint.setColorFilter(colorFilter);
    canvas.drawBitmap(bitmap, 0, 0, Paint);

    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    int componentsPerPixel = 3;
    int totalPixels = width * height;
    int totalBytes = totalPixels * componentsPerPixel;

    byte[] rgbValues = new byte[totalBytes];
    @ColorInt int[] argbPixels = new int[totalPixels];
    argbBitmap.getPixels(argbPixels, 0, width, 0, 0, width, height);
    for (int i = 0; i < totalPixels; i++) {
        @ColorInt int argbPixel = argbPixels[i];
        int red = Color.red(argbPixel);
        int green = Color.green(argbPixel);
        int blue = Color.blue(argbPixel);
        rgbValues[i * componentsPerPixel + 0] = (byte) red;
        rgbValues[i * componentsPerPixel + 1] = (byte) green;
        rgbValues[i * componentsPerPixel + 2] = (byte) blue;
    }

    return rgbValues;
}
4
Cameron Lowell Palmer