Image Processing in Java-Comparison of Two Images

It has many libraries and tools for image processing, such as BufferedImage, Graphics2D, and java.awt package, which is indefinitely ready to help in image editing with functions like editing, editing, and comparing images. These libraries enable any developer to manipulate graphics in their Java applications efficiently.

Comparing Two Images in Java

In order to compare two images, we should undergo a few steps. The steps include loading the images, analysing pixel data, finally checking whether they are the same or different. Below are the steps on how the process of comparing two images in Java works in detail.

Step 1: Load the Images

Firstly, we should load the images into the memory using the BufferedImage class. The BufferedImage, as well as the ImageIO class has to be imported. This ImageIO class accepts the pictures in PNG, JPEG, and BMP formats.

 
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
public class ImageComparison {
    public static void main(String[] args) {
        try {
            BufferedImage img1 = ImageIO.read(new File("image1.jpg"));
            BufferedImage img2 = ImageIO.read(new File("image2.jpg"));

            // Continue with image comparison
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}   

Step 2: Checking Image Dimensions

It should be checked before comparing pixel data for resolution to be the same for both images. Otherwise, the images cannot be considered perfect.

 
if (img1.getWidth() == img2.getWidth() && img1.getHeight() == img2.getHeight()) {
    // Proceed with pixel-by-pixel comparison
} else {
    System.out.println("Images have different dimensions.");
}   

Step 3: Comparing Pixel Data

Comparing images is completed by looping through every pixel in both images and comparing their RGB values. If the pixel is different, it means that the images are different.

 
boolean areIdentical = true;
for (int y = 0; y < img1.getHeight(); y++) {
    for (int x = 0; x < img1.getWidth(); x++) {
        int pixel1 = img1.getRGB(x, y);
        int pixel2 = img2.getRGB(x, y);
        if (pixel1 != pixel2) {
            areIdentical = false;
            break;
        }
    }
    if (!areIdentical) break;
}
if (areIdentical) {
    System.out.println("The images are identical.");
} else {
    System.out.println("The images are different.");
}   

Step 4: Highlighting Differences

Sometimes, it might be worthwhile to emphasize the differences between these two pictures. It can be done with another image that marks the pixels in contrasting colors.

 
BufferedImage diffImage = new BufferedImage(img1.getWidth(), img1.getHeight(), BufferedImage.TYPE_INT_RGB);
for (int y = 0; y < img1.getHeight(); y++) {
    for (int x = 0; x < img1.getWidth(); x++) {
        int pixel1 = img1.getRGB(x, y);
        int pixel2 = img2.getRGB(x, y);
        if (pixel1 != pixel2) {
            diffImage.setRGB(x, y, 0xFF0000); // Mark difference with red color
        } else {
            diffImage.setRGB(x, y, pixel1); // Copy original pixel
        }
    }
}
try {
    ImageIO.write(diffImage, "png", new File("diff.png"));
    System.out.println("Difference image created: diff.png");
} catch (Exception e) {
    e.printStackTrace();
}   

The following is the combination of Java code using the technique of comparing two images and generating a DIFF image with all differences highlighted in red:

File Name: ImageComparison.java

 
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
public class ImageComparison {
    public static void main(String[] args) {
        try {
            // Load the images
            BufferedImage img1 = ImageIO.read(new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\green_image.png"));
            BufferedImage img2 = ImageIO.read(new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\red_image.png"));
            // Check if images have the same dimensions
            if (img1.getWidth() != img2.getWidth() || img1.getHeight() != img2.getHeight()) {
                System.out.println("Images have different dimensions and cannot be compared.");
                return;
            }
            // Initialize a flag to check if images are identical
            boolean areIdentical = true;
            // Create a new image to store differences
            BufferedImage diffImage = new BufferedImage(img1.getWidth(), img1.getHeight(), BufferedImage.TYPE_INT_RGB);
            // Compare images pixel by pixel
            for (int y = 0; y < img1.getHeight(); y++) {
                for (int x = 0; x < img1.getWidth(); x++) {
                    int pixel1 = img1.getRGB(x, y);
                    int pixel2 = img2.getRGB(x, y);
                    if (pixel1 != pixel2) {
                        areIdentical = false;
                        diffImage.setRGB(x, y, 0xFF0000); // Mark difference with red color
                    } else {
                        diffImage.setRGB(x, y, pixel1); // Copy original pixel
                    }
                }
            }
            if (areIdentical) {
                System.out.println("The images are identical.");
            } else {
                System.out.println("The images are different.");
            }
            // Save the difference image
            File outputfile = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\diff.png");
            ImageIO.write(diffImage, "png", outputfile);
            System.out.println("Difference image saved as diff.png");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}  

Input Images:

Image 1:

Image Processing in Java-Comparison of Two Images

Image 2:

Output:

 
C:\Users\deeks\OneDrive\Desktop\java>javac ImageComparison.java
C:\Users\deeks\OneDrive\Desktop\java>java ImageComparison
The images are different.
Difference image saved as diff.png

Output Image:

How the Code Works?

Load images: Images loading with ImageIO.read() methods by loading BufferedImage objects for each image.

Dimension Check: Checks that the two dimensions of the image match and can be compared pixel by pixel. In the case where the dimensions differ, the execution of the program will be exited.

Pixel Comparison: A nested loop is used to iterate over each pixel in the images. The RGB values of corresponding pixels are compared.

Highlighting Differences: If the pixels differ, the corresponding pixel in the diffImage is set to red (0xFF0000). If they are the same, the original pixel value is copied.

Output: The Output will be displayed according to the pictures.

Conclusion

Java itself is a powerhouse of graphics libraries, so it's an attractive option to compare graphics. The processes discussed in this section allows us to compare two images, pixel by pixel. Two different images could be compared, and a contrast created, thereby highlighting the difference.

Moreover, this solution can be easily extended toward more complex tasks of image processing, such as feature detection, image filtering, and much more advanced comparison methods, taking into account the rotation, magnification, and control of noises in such images.

Next TopicImage-processing-in-java-creating-a-random-pixel-image

← prev next →