Image Processing in Java: Colored Image to Negative Image Conversion

Image processing is a technique used to perform operations on an image to enhance it or extract useful information. One common task in image processing is converting a colored image to its negative. In this section, we will explore how to achieve this using Java.

What is a Negative Image?

A negative image is a total inversion of a positive image. In a negative image, each color's intensity value is subtracted from the maximum value, creating an inverted color effect. For a colored image, this means inverting the RGB values.

For an 8-bit image (where each color channel value ranges from 0 to 255):

The negative value of a color component can be calculated as 255−current color value.

Tools and Libraries Used

To perform image processing in Java, we will use the following tools:

Java Development Kit (JDK): Ensure you have JDK installed.
Java AWT (Abstract Window Toolkit): Provides core graphical user interface (GUI) classes.
javax.imageio.ImageIO: A Java I/O extension for reading and writing images in various formats.

Implementation

File Name: NegativeImage.java

 
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class NegativeImage {
    public static void main(String[] args) {
        try {
            // Load the image
            File input = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\java image.jpg");
            BufferedImage image = ImageIO.read(input);
            // Convert to negative
            BufferedImage negativeImage = convertToNegative(image);
            // Save the negative image
            File output = new File("negative_image.jpg");
            ImageIO.write(negativeImage, "jpg", output);
            System.out.println("Conversion to negative completed.");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
    private static BufferedImage convertToNegative(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        BufferedImage negative = new BufferedImage(width, height, image.getType());
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int p = image.getRGB(x, y);
                // Extract color components
                int a = (p >> 24) & 0xff;
                int r = (p >> 16) & 0xff;
                int g = (p >> 8) & 0xff;
                int b = p & 0xff;
                // Invert colors
                r = 255 - r;
                g = 255 - g;
                b = 255 - b;
                // Reassemble the color
                p = (a << 24) | (r << 16) | (g << 8) | b;
                negative.setRGB(x, y, p);
            }
        }
        return negative;
    }
}   

Input Image:

Image Processing in Java: Colored Image to Negative Image Conversion

Output:

 
Conversion to negative completed.

Output Image:

Explanation

Loading the Image: The ImageIO.read() method reads an image from the specified file.

Converting to Negative: The convertToNegative() method iterates over each pixel of the image, extracts the ARGB (Alpha, Red, Green, Blue) components, inverts the RGB values, and sets the new RGB value to the pixel in the resulting image.

Saving the Image: The ImageIO.write() method writes the negative image to a file.

Conclusion

Converting a colored image to its negative is a straightforward image processing task that can be accomplished with Java's built-in libraries. This basic understanding can serve as a foundation for more advanced image processing techniques. Happy coding!

Next TopicImplementing-our-own-hash-table-with-separate-chaining-in-java

← prev next →