Image Processing in Java - Contrast Enhancement

Digital image analysis and computer vision both heavily rely on image processing. In order to obtain the intended results, this calls for image alteration. Contrast enhancement is a fundamental method of image processing that highlights the things in the image so that they are more visible. In this section, we will delve more into contrast enhancement using Java.

Contrast Enhancement: what is meant by it?

Improving the perceptibility in light areas of an image is called contrast enhancement. An image with good contrast helps people to identify the concepts and things more quickly by making them stand out. It is particularly crucial in fields like medical imaging, where contrast can be used to highlight essential information.

Why Use Java for Image Processing?

Java's robust library, widespread community support, and platform neutrality make it an excellent option for image processing. Java has built-in classes for image processing in the Java Development Kit (JDK), and additional libraries like OpenCV and BoofCV can expand Java's visualization capabilities even further.

Coding for the Contrast Enhancement in Java

This is a step-by-step tutorial on using the Java AWT (Abstract Window Toolkit) package's BufferedImage class to implement contrast development in Java.

1. Setting Up the Project

Firstly, get ready by installing Java on your pc. Then, create a new Java project and start adding the below-mentioned imports.

 
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import java.awt.Color;   

2. Loading the Image

To use the ImageIO.read() method, load the desired image. Using this technique, the picture file is read into a BufferedImage object.

 
public class ContrastEnhancement {
    public static void main(String[] args) {
        try {
            File inputImage = new File("input_image.jpg");
            BufferedImage picture = ImageIO.read(inputImage);
            BufferedImage outcome = enhanceContrast(picture);
            File outputImage = new File("enhanced_image.jpg");
            ImageIO.write(outcome, "jpg", outputImage);
            System.out.println("Contrast enhancement completed.");
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }   

3. Implementing Contrast Enhancement

Numerous techniques can be employed to attain enhanced distinction. Here, for simplicity, we will be using the linear inverse stretching technique.

 
public static BufferedImage enhanceContrast(BufferedImage image) {
    int widthOfImage = image.getWidth();
    int heightOfImage = image.getHeight();
    BufferedImage outcome = new BufferedImage(widthOfImage, heightOfImage, BufferedImage.TYPE_INT_RGB);
    int min = 255, max = 0;    
    for (int y = 0; y < heightOfImage; y++) {
        for (int x = 0; x < widthOfImage; x++) {
            Color color = new Color(picture.getRGB(x, y));
            int grayscale = (color.getRed() + color.getGreen() + color.getBlue()) / 3;
            if (grayscale < min) min = grayscale;
            if (grayscale > max) max = grayscale;
        }
    }
    // Apply contrast stretching
    for (int y = 0; y < heightOfImage; y++) {
        for (int x = 0; x < widthOfImage; x++) {
            Color color = new Color(picture.getRGB(x, y));
            int red = stretchContrast(color.getRed(), min, max);
            int green = stretchContrast(color.getGreen(), min, max);
            int blue = stretchContrast(color.getBlue(), min, max);
            Color newColor = new Color(red, green, blue);
            outcome.setRGB(x, y, newColor.getRGB());
        }
    }
    return outcome;
}
public static int stretchContrast(int value, int min, int max) {
    return (value - min) * 255 / (max - min);
}   

4. Explanation of the Code

Finding Min and Max Values: The first loop looks for the lowest and most significant values of each pixel in the image. These values represent the image's brightest and darkest areas.

Contrast Stretching: By using the linear contrast expansion, the second loop shows pixel values from the initial range [min, max] to [0, 255]. It essentially spreads the pixel values by increasing the contrast so that the brightest pixels are white and the darkest pixels are black.

Creating a New Image: The source object stores the newly developed high-contrast image before being saved to a file.

5. Saving the Enhanced Image

In the main() method modified image is saved in ImageIO.write() method. The modified image in the same format as the input image.

It is the whole Java code for contrast enhancement:

File Name: ContrastEnhancement.java

 
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
public class ContrastEnhancement {
    public static void main(String[] args) {
        try {
            // Load the input image
            File inputImage = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\java image.png");
            if (!inputImage.exists()) {
                System.out.println("Input Image file not found!");
                return;
            }
            BufferedImage picture = ImageIO.read(inputImage);
            // Enhance the contrast of the image
            BufferedImage outcome = enhanceContrast(inputImage);
            // Save the enhanced image
            File outputImage = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\enhanced_image.png");
            if (!outputImage.getParentFile().exists()) {
                System.out.println("Output Image directory does not exist!");
                return;
            }
            ImageIO.write(outcome, "png", outputImage);
            System.out.println("Contrast enhancement completed. Image saved at: " + output.getAbsolutePath());
        } catch (Exception e) {
            e.printStackTrace(); // Print stack trace for debugging
        }
    }
    public static BufferedImage enhanceContrast(BufferedImage inputImage) {
        int imageWidth = inputImage.getWidth();
        int imageHeight = inputImage.getHeight();
        BufferedImage outcome = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
        int minimum = 255, maximum = 0;
        // Find min and max pixel values
        for (int y = 0; y < imageHeight; y++) {
            for (int x = 0; x < imageWidth; x++) {
                Color color = new Color(inputImage.getRGB(x, y));
                int grayscale = (color.getRed() + color.getGreen() + color.getBlue()) / 3;
                if (grayscale < minimum) minimum = grayscale;
                if (grayscale > maximum) maximum = grayscale;
            }
        }
        // Apply contrast stretching
        for (int y = 0; y < inputHeight; y++) {
            for (int x = 0; x < inputWidth; x++) {
                Color color = new Color(inputImage.getRGB(x, y));
                int red = clamp(stretchContrast(color.getRed(), minimum, maximum));
                int green = clamp(stretchContrast(color.getGreen(), minimum, maximum));
                int blue = clamp(stretchContrast(color.getBlue(), minimum, maximum));
                Color newColor = new Color(red, green, blue);
                outcome.setRGB(x, y, newColor.getRGB());
            }
        }
        return outcome;
    }
    // Clamping method to keep values within the 0-255 range
    public static int clamp(int value) {
        return Math.min(255, Math.max(0, value));
    }
    public static int stretchContrast(int value, int minimum, int maximum) {
        if (maximum == minimum) {
            return value; // Avoid division by zero if the image is a solid color
        }
        return (value - minimum) * 255 / (maximum - minimum);
    }
}   

Input Image:

Image Processing in Java - Contrast Enhancement

Output:

 
Contrast enhancement completed. Image saved at C:\Users\deeks\OneDrive\Pictures\Screenshots\enhanced_image.png

Output Image:

How to Use This Code?

Setup: Verify that your device has Java installed and set up.

Picture input: The path to the image you wish to improve should be substituted for "C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\java image.png". The image needs to give the complete path or be located in the same directory as the code.

Code: Install and launch the Java application.

The enhanced image "enhanced_image.jpg" is uploaded to the same directory. As a result, after reading the input image, the application uses linear contrast enlargement to increase the image's contrast before saving the improved version. This Java code offers a straightforward yet efficient method of enhancing visual contrast. To analyze images or find new ways to boost contrast, we can make more modifications to the code.

Conclusion

In photography, contrast augmentation is a potent tool that can boost image quality and increase object visibility. Java's libraries are strong and user-friendly, making it an excellent platform for differentiation strategies.

The above example shows how to use Java's built-in libraries to achieve a more contrast-rich image in a straightforward yet efficient manner. You can experiment with other settings for more functionality, including gamma correction and histogram equalization, or use third-party libraries like OpenCV for complex image processing jobs.

Next TopicVolatile-keyword-in-java

← prev next →