Getting Pixel Array From Image in Java

1. Overview

In this tutorial, we’ll learn how to get an array of pixels that contain image information (RGB values) from a BufferedImage instance in Java.

2. What Is the BufferedImage Class?

The BufferedImage class is a subclass of Image that describes a graphical image with an accessible buffer of image data. A BufferedImage consists of a ColorModel and a Raster.

A ColorModel describes how colors can be represented using a combination of components as tuples of values. The ColorModel class in Java consists of methods that can return color values for a specific pixel. For example, getBlue(int pixel) returns the blue value for the given pixel.

Moreover, the Raster class contains the image data in an array of pixels. The Raster class is composed of a DataBuffer that stores the image values and a SampleModel that describes how the pixels are stored in the DataBuffer.

3. Using getRGB()

The first approach is to use the getRGB() instance method from the BufferedImage class.

The getRGB() method combines the RGB values for the specified pixel into one integer and returns the result. This integer contains the RGB values that can be accessed using the instance’s ColorModel. Moreover, to get the result for every pixel in an image, we must iterate over them and call the method for each pixel individually:

public int[][] get2DPixelArraySlow(BufferedImage sampleImage) {
    int width = sampleImage.getWidth();
    int height = sampleImage.getHeight();
    int[][] result = new int[height][width];

    for (int row = 0; row < height; row++) {
        for (int col = 0; col < width; col++) {
            result[row][col] = sampleImage.getRGB(col, row);
        }
    }

    return result;
}

In the above code snippet, the result array is a two-dimensional array that contains RGB values for every pixel in an image. This approach is more straightforward but also less efficient than the next approach.

4. Getting the Values Directly From the DataBuffer

In this method, we first get all the RGB values from the image separately and then manually combine them into one integer. After that, we fill the two-dimensional array containing pixel values just as we did in the first approach. This method is more complicated but considerably faster than the first approach:

public int[][] get2DPixelArrayFast(BufferedImage image) {
    byte[] pixelData = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
    int width = image.getWidth();
    int height = image.getHeight();
    boolean hasAlphaChannel = image.getAlphaRaster() != null;

    int[][] result = new int[height][width];
    if (hasAlphaChannel) {
        int numberOfValues = 4;
        for (int valueIndex = 0, row = 0, col = 0; valueIndex + numberOfValues - 1 < pixelData.length; valueIndex += numberOfValues) {
            
            int argb = 0;
            argb += (((int) pixelData[valueIndex] & 0xff) << 24); // alpha value
            argb += ((int) pixelData[valueIndex + 1] & 0xff); // blue value
            argb += (((int) pixelData[valueIndex + 2] & 0xff) << 8); // green value
            argb += (((int) pixelData[valueIndex + 3] & 0xff) << 16); // red value
            result[row][col] = argb;

            col++;
            if (col == width) {
                col = 0;
                row++;
            }
        }
    } else {
        int numberOfValues = 3;
        for (int valueIndex = 0, row = 0, col = 0; valueIndex + numberOfValues - 1 < pixelData.length; valueIndex += numberOfValues) {
            int argb = 0;
            argb += -16777216; // 255 alpha value (fully opaque)
            argb += ((int) pixelData[valueIndex] & 0xff); // blue value
            argb += (((int) pixelData[valueIndex + 1] & 0xff) << 8); // green value
            argb += (((int) pixelData[valueIndex + 2] & 0xff) << 16); // red value
            result[row][col] = argb;

            col++;
            if (col == width) {
                col = 0;
                row++;
            }
        }
    }

    return result;
}

In the above code snippet, we first get the separate RGB values for every pixel in the image and store them in a byte array named pixelData.

For example, assuming the image does not have an alpha channel (the alpha channel contains the picture’s transparency information), pixelData[0] contains the blue value for the first pixel in the image, while pixelData[1] and pixelData[2] contain the green and red values respectively. Likewise, pixelData[3] through pixelData[5] contain the RGB values for the second image pixel, and so on.

After getting the values, we must combine them into one integer for each pixel. But before that, we need to find out if the image has an alpha channel. If the image has an alpha channel, we’ll need to combine four values (red, green, blue, and transparency information) into one integer. If not, we’ll only need to combine the RGB values.

After combining all the values into one integer, we put the integer into its position in the two-dimensional array.

5. Summary

In this short article, we learned how to get a two-dimensional array that contains the combined RGB values for every pixel in an image in Java.