image.getRaster().getDataBuffer() returns array of negative values

Question

This answer suggests that it's over 10 times faster to loop pixel array instead of using BufferedImage.getRGB. Such difference is too important to by ignored in my computer vision program. For that reason, O rewritten my IntegralImage method to calculate integral image using the pixel array:

/* Generate an integral image. Every pixel on such image contains sum of colors or all the
     pixels before and itself.
  */
  public static double[][][] integralImage(BufferedImage image) {
    //Cache width and height in variables
    int w = image.getWidth();
    int h = image.getHeight();
    //Create the 2D array as large as the image is
    //Notice that I use [Y, X] coordinates to comply with the formula
    double integral_image[][][] = new double[h][w][3];

    //Variables for the image pixel array looping
    final int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
    //final byte[] pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
    //If the image has alpha, there will be 4 elements per pixel
    final boolean hasAlpha = image.getAlphaRaster() != null;
    final int pixel_size = hasAlpha?4:3;
    //If there's alpha it's the first of 4 values, so we skip it
    final int pixel_offset = hasAlpha?1:0;
    //Coordinates, will be iterated too
    //It's faster than calculating them using % and multiplication
    int x=0;
    int y=0;

    int pixel = 0;
    //Tmp storage for color
    int[] color = new int[3];
    //Loop through pixel array
    for(int i=0, l=pixels.length; i<l; i+=pixel_size) {
      //Prepare all the colors in advance
      color[2] = ((int) pixels[pixel + pixel_offset] & 0xff); // blue;
      color[1] = ((int) pixels[pixel + pixel_offset + 1] & 0xff); // green;
      color[0] = ((int) pixels[pixel + pixel_offset + 2] & 0xff); // red;
      //For every color, calculate the integrals
      for(int j=0; j<3; j++) {
        //Calculate the integral image field
        double A = (x > 0 && y > 0) ? integral_image[y-1][x-1][j] : 0;
        double B = (x > 0) ? integral_image[y][x-1][j] : 0;
        double C = (y > 0) ? integral_image[y-1][x][j] : 0;
        integral_image[y][x][j] = - A + B + C + color[j];
      }
      //Iterate coordinates
      x++;
      if(x>=w) {
        x=0;
        y++;        
      }
    }
    //Return the array
    return integral_image;
  }

The problem is that if I use this debug output in the for loop:

  if(x==0) {
    System.out.println("rgb["+pixels[pixel+pixel_offset+2]+", "+pixels[pixel+pixel_offset+1]+", "+pixels[pixel+pixel_offset]+"]");
    System.out.println("rgb["+color[0]+", "+color[1]+", "+color[2]+"]");
  }

This is what I get:

rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
rgb[-16777216, -16777216, -16777216]
rgb[0, 0, 0]
...

So how should I properly retrieve pixel array for BufferedImage images?

Answer 1

A bug in the code above, that is easily missed, is that the for loop doesn't loop as you'd expect. The for loop updates i, while the loop body uses pixel for its array indexing. Thus, you will only ever see the values of pixel 1, 2 and 3.

---

Apart from that:

The "problem" with the negative pixel values, is most likely that the code assumes a BufferedImage that stores its pixels in "pixel interleaved" form, however, they are stored "pixel packed". That is, all samples (R, G, B and A) for one pixel is stored in a single sample, an int. This will be the case for all BufferedImage.TYPE_INT_* types (while the BufferedImage.TYPE_nBYTE_* types are stored interleaved).

It's completely normal to have negative values in the raster, this will happen for any pixel that is less than 50% transparent (more than or equal to 50% opaque), because of how the 4 samples are packed into the int, and because int is a signed type in Java.

In this case, use:

int[] color = new int[3];

for (int i = 0; i < pixels.length; i++) {
    // Assuming TYPE_INT_RGB, TYPE_INT_ARGB or TYPE_INT_ARGB_PRE
    // For TYPE_INT_BGR, you need to reverse the colors.

    // You seem to ignore alpha, is that correct?
    color[0] = ((pixels[i] >> 16) & 0xff); // red;
    color[1] = ((pixels[i] >>  8) & 0xff); // green;
    color[2] = ( pixels[i]        & 0xff); // blue;

    // The rest of the computations...
}

Another possibility, is that you have created a custom type image (BufferedImage.TYPE_CUSTOM) that really uses a 32 bit unsigned int per sample. This is possible, however, int is still a signed entity in Java, so you need to mask off the sign bit. To complicate this a little, in Java -1 & 0xFFFFFFFF == -1 because any computation on an int will still be an int, unless you explicitly say otherwise (doing the same on a byte or short value would have "scaled up" to int). To get a positive value, you need to use a long value like this: -1 & 0xFFFFFFFFL (which is 4294967295).

In this case, use:

long[] color = new long[3];

for(int i = 0; i < pixels.length / pixel_size; i += pixel_size) {
    // Somehow assuming BGR order in input, and RGB output (color)
    // Still ignoring alpha
    color[0] = (pixels[i + pixel_offset + 2] & 0xFFFFFFFFL); // red;
    color[1] = (pixels[i + pixel_offset + 1] & 0xFFFFFFFFL); // green;
    color[2] = (pixels[i + pixel_offset    ] & 0xFFFFFFFFL); // blue;

    // The rest of the computations...
}

I don't know what type of image you have, so I can't say for sure which one is the problem, but it's one of those. :-)

PS: BufferedImage.getAlphaRaster() is a possibly an expensive and also inaccurate way to tell if the image has alpha. It's better to just use image.getColorModel().hasAlpha(). See also hasAlpha vs getAlphaRaster.