In this theory part of the Image Processing Project we will learn about pixels. We will learn how to store pixel value in a variable. How to get pixel values of an image and how to set pixel value of an image in Java programming language.

The smallest unit of an image is called a Pixel, and it is generally made up of 4 components namely:

- Alpha
- Red
- Green
- Blue

Alpha determines the transparency while Red, Green and Blue determines the color of the pixel. We generally denote these four components as A for Alpha, R for Red, G for Green and B for Blue.

Each of these four components (ARGB) take a value between 0 to 255 both inclusive, where 0 means the component is missing and 255 means the component is fully present.

Since, 2^{8} = 256. So, 8 bits can represent any value in the range 0 to 255. This means we will need only 8 bits to store the value of any of the four component. And since a pixel has 4 components so, the total number of bits required to store the value of all the four components ARGB is equal to 4x8 = 32 bits or 4 bytes.

The image shown below represent a single pixel value consisting of 32 bits. Alpha take the leftmost 8 bits while Blue takes the rightmost 8 bits of the pixel. The first bit is at the rightmost side and is numbered or indexed 0 and the last bit is at the leftmost side and is numbered or indexed 31.

The bit position of the 4 components is summarized in the table below

ALPHA | RED | GREEN | BLUE | |

BIT POSITION | 31 - 24 | 23 - 16 | 15 - 8 | 7 - 0 |

Each of these bit position will take any of the two bit values or binary values i.e., 0 or 1.

Therefore, if all the 8 bits of ALPHA is set to 0 i.e., 0000 0000. Then converting this value into decimal, we will get (0000 0000)_{2} = 0_{10}

Similarly, if all the 8 bits of ALPHA is set to 1 i.e., 1111 1111. Then converting this value into decimal, we will get (1111 1111)_{2} = 255_{10}

We can also represent the bit values in hexadeimal form. So, (0000 0000)_{2} in binary is equal to (00)_{16}in hexadecimal. Similarly, (1111 1111)_{2} in binary is equal to (FF)_{16} in hexadecimal.

2D images have a width and a height generally denoted in pixels. In the following image we get the detail like Type, Dimensions and Size of the Image File.

Dimensions of an image file is generally represented in **width x height** format. In the above picture we can see the dimensions as 963x640. That is the width of the image is 963 pixels and the height of the image is 640 pixels.

For a 2D image we will have pixels arranged in rows and columns. Origin (starting pixel) of the image is at the coordinate (0,0).

The image show below has dimensions 3x3.

So, we can denote a pixel (x,y) as P_{x,y}(A,R,G,B)

Where, (x,y) is the co-ordinate of the pixel and A, R, G and B denote the Alpha, Red, Green and Blue value of the pixel respectively.

Example: P_{0,0}(255,100,150,200) represents a pixel at co-ordinate (0,0) having A = 255, R = 100, G = 150 and B = 200.

To proceed further it is assumed that you have completed the previous project How to read and write image file in Java

`import java.io.File;`

`import java.io.IOException;`

`import java.awt.image.BufferedImage;`

`import javax.imageio.ImageIO;`

`public class GetSetPixels{`

`public static void main(String args[])throws IOException{`

`BufferedImage img = null;`

`File f = null;`

`//read image`

`try{`

`f = new File("D:\\Image\\Sample.jpg");`

`img = ImageIO.read(f);`

`}catch(IOException e){`

`System.out.println(e);`

`}`

// some code goes here...

}//main() ends here`}//class ends here`

In the above code we have imported the required classes. Then inside the **main()** function we are reading the **Sample.jpg** image file.

The File object f holds the image file path "**D:\\Image\\Sample.jpg**". The Sample.jpg image is of dimensions **1x1**, i.e., it is a single pixel image.

`f = new File("D:\\Image\\Sample.jpg");`

Then we are reading the image and storing it in variable **img**.

`img = ImageIO.read(f);`

To get the image dimensions we use the **getWidth()** and **getHeight()** functions. We will create two integer variables width and height for this purpose.

`int width = img.getWidth();`

int height = img.getHeight();

Since, the Sample.jpg is a single pixel image so, variable width and height each will hold value 1.

Note! We will not be using the width and height variable value in this project. But this concept will be used in the later projects.

To get the pixel value we use the **getRGB(x,y)** function. This function takes as parameter the co-ordinate of the pixel and it returns an integer value which can be positive and negative. So, to store the pixel value we will create an integer variable.

`int p = img.getRGB(x,y);`

As, Sample.jpg is a single pixel image so, to read that pixel we will replace (x,y) with (0,0) which is the co-ordinate of that pixel.

So, the above code will be written as:

`int p = img.getRGB(0,0);`

So, we have the pixel value stored in the integer variable p it's time for us to get each of the four component (ARGB) values. And since we know that ARGB value is an integer in the range 0 to 255 so, we will create 4 integer variables a, r, g and b for this purpose.

We, have seen that the ALPHA bits occupy 8 bits from index 24 to index 31. So, to get the ALPHA bits we have to first right shift the 32 bits of the pixels by 24 position and then bitwise ADD it with 0xFF.

When we perform the right shift operation we bring the bits to the rightmost 8 bit position. And when we bitwise ADD it with 0xFF we are left with the value of the component we are interested in.

So, to get the required Alpha value we will write:

`int a = (p>>24) & 0xff;`

Note! 0xFF is the hexadecimal representation of the decimal value 255.

Similarly, the RED bits occupy 8 bits from index 16 to index 23. So to get the RED bits we have to first right shift the 32 bits of the pixels by 16 position and then bitwise ADD it with 0xFF. For this we will write:

`int r = (p>>16) & 0xff;`

Likewise, the GREEN bits occupy 8 bits from index 8 to index 15. So, to get the GREEN bits we have to right shift the 32 bits of the pixels by 8 positionand then bitwise ADD it with 0xFF.

`int g = (p>>8) & 0xff;`

And, to get the BLUE bits which occupy 8 bits from index 0 to index 7 we DON'T have to right shift the pixel bits. This is because the BLUE bits already occupy the rightmost 8 bits. So, we will simply bitwise ADD the pixel value with 0xFF.

`int b = p & 0xff;`

Now, our code will look something like the following.

`import java.io.File;`

`import java.io.IOException;`

`import java.awt.image.BufferedImage;`

`import javax.imageio.ImageIO;`

`public class GetSetPixels{`

`public static void main(String args[])throws IOException{`

`BufferedImage img = null;`

`File f = null;`

`//read image`

`try{`

`f = new File("D:\\Image\\Sample.jpg");`

`img = ImageIO.read(f);`

`}catch(IOException e){`

`System.out.println(e);`

`}`

//get image width and height

int width = img.getWidth();

int height = img.getHeight();

/**

* Since, Sample.jpg is a single pixel image so, we will

* not be using the width and height variable in this

* project.

*/

//get pixel value

int p = img.getRGB(0,0);

//get alpha

int a = (p>>24) & 0xff;

//get red

int r = (p>>16) & 0xff;

//get green

int g = (p>>8) & 0xff;

//get blue

int a = p & 0xff;

//some code goes here...

}//main() ends here`}//class ends here`

To keep the project simple, lets set the value of Alpha, Red, Green and Blue to 255, 100, 150 and 200 respectively. For this we will write.

`a = 255;`

r = 100;

g = 150;

b = 200;

To set the pixel value with the new ARGB value we will first set p to 0.

`p = 0;`

Note! p is an integer variable and holds the value of the pixel.

We, know that 8 bits of the ALPHA component occupy the bit position from index 24 to index 31. So, we will left shift the alpha value by 24 position and bitwise OR it with the p value.

`p = p | (a<<24);`

Similarly, 8 bits of the RED component occupy the bit position from index 16 to index 23. So, we will left shift the red value by 16 position and bitwise OR it with the p value.

`p = p | (r<<16);`

Likewise, 8 bits of the GREEN component occupy the bit position from index 8 to index 15. So, we will left shift the green value by 8 position and bitwise OR it with the p value.

`p = p | (g<<8);`

And for BLUE component we DON'T have to left shift. We, will simply bitwise OR it with p.

`p = p | b;`

We, can write the above lines of code in a single line as:

`p = (a<<24) | (r<<16) | (g<<8) | b;`

To set this pixel value to the image at co-ordinate (x,y) we use the **setRGB(x,y,p)** function. And Sample.jpg image is a single pixel image so, we will replace (x,y) with (0,0).

For this we will write:

`img.setRGB(0, 0, p);`

`import java.io.File;`

`import java.io.IOException;`

`import java.awt.image.BufferedImage;`

`import javax.imageio.ImageIO;`

`public class GetSetPixels{`

`public static void main(String args[])throws IOException{`

`BufferedImage img = null;`

`File f = null;`

`//read image`

`try{`

`f = new File("D:\\Image\\Sample.jpg");`

`img = ImageIO.read(f);`

`}catch(IOException e){`

`System.out.println(e);`

`}`

//get image width and height

int width = img.getWidth();

int height = img.getHeight();

/**

* Since, Sample.jpg is a single pixel image so, we will

* not be using the width and height variable in this

* project.

*/

//get pixel value

int p = img.getRGB(0,0);

//get alpha

int a = (p>>24) & 0xff;

//get red

int r = (p>>16) & 0xff;

//get green

int g = (p>>8) & 0xff;

//get blue

int a = p & 0xff;

/**

* to keep the project simple we will set the ARGB

* value to 255, 100, 150 and 200 respectively.

*/

a = 255;

r = 100;

g = 150;

b = 200;

//set the pixel value

p = (a<<24) | (r<<16) | (g<<8) | b;

img.setRGB(0, 0, p);

//write image

try{

f = new File("D:\\Image\\Output.jpg");

ImageIO.write(img, "jpg", f);

}catch(IOException e){

System.out.println(e);

}

}//main() ends here`}//class ends here`

Recently Updated

- Product of Sums reduction using Karnaugh Map Boolean Algebra
- Sum of Products reduction using Karnaugh Map Boolean Algebra
- Karnaugh Map Boolean Algebra
- Sum of Products and Product of Sums Boolean Algebra
- Minterm and Maxterm Boolean Algebra
- Basic laws and properties of Boolean Algebra Boolean Algebra
- Propositional Logic Syllogism Boolean Algebra
- Propositional Logic Equivalence Laws Boolean Algebra
- Propositional Logic Important Terms Boolean Algebra
- Propositional Logic Truth Table Boolean Algebra