Image Processing in Java- Colored Image to Sepia Image Conversion

It is that part of Computer Science that deals with image manipulation and analysis in the digital domain. Image processing, due to the increasing use of multimedia, has become an integral part of tasks like image enhancement, text extraction, artistic effects, etc.

In this section, we will discuss how to transform images with colors into their sepia-toned versions using Java-thus going from images to vintage. It gives a melancholy bright blue color reminiscent of a painting.

Definition of a Sepia Tone

Nowadays, sepia toning is mainly carried out with the computer so as to achieve an ancient image. The sepia effect is the red tint replacing the original colors of the painting.

Conversion of an image into a sepia image is done by supposedly altering the value of the red, green, and blue components in the RGB of every pixel. The resulting image is brightly monochromatic in color, primarily of blue tones, usually to bring about an old-style vintage appearance.

Why Do We Use Java in Image Processing?

Image processing in Java is very popular as it is platform-independent, straightforward to code, and swells with a lot of support for image processing. Java contains a wide range of classes through which images can be easily manipulated; for instance, the BufferedImage class under the java.awt.image package is one such famous way widely used for image manipulation.

Some of the advantages of using Java for image processing include:

Cross-platform compatibility: "write once, run anywhere," meaning programs that do graphics processing can run with many other operating systems.

Good support for the API: Java provided many libraries for image management, including javax.imageio, java.awt.image, and java.awt.Color. Hence, it will be straightforward to do image manipulation into complex image processing.

Communities and Documentation: The Java community is very dynamic, and there is an enormous amount of documentation available, making it possible for the programmer to seek help from several sources.

Step-by-Step Implementation of Sepia Conversion in Java

Now, let us get into the details of the process of turning color images into sepia tones using Java. Do the following steps to load the image, apply the sepia filter, and then save the image that will have resulted from this process.

1. Importing required libraries

Before starting the conversion process, import the necessary Java libraries:

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

BufferedImage: Represents an image in an accessible image data buffer.

File: Operations on files, including reading from and writing to disk.

ImageIO: This class provides methods for reading and writing images.

2. Loading the image

 
public static void main(String[] args) {
    try {
        // Load the image
        File input = new File("path_to_colored_image.jpg");
        BufferedImage image = ImageIO.read(input);        
        // Convert to sepia
        BufferedImage sepiaImage = convertToSepia(image);        
        // Save the sepia image
        File output = new File("path_to_save_sepia_image.jpg");
        ImageIO.write(sepiaImage, "jpg", output);        
        System.out.println("Image converted to sepia successfully.");
    } catch (IOException e) {
        System.out.println("Error: " + e.getMessage());
    }
}   

3. Applying the Sepia Filter

The Sepia filter works by changing the RGB values of each pixel. The following method, convertToSepia(), iterates more on each pixel in the image, using the sepia conversion formulas, and sets new RGB values accordingly.

 
public static BufferedImage convertToSepia(BufferedImage img) {
    int width = img.getWidth();
    int height = img.getHeight();
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int p = img.getRGB(x, y);            
            // Get the original colors
            int alpha = (p >> 24) & 0xff;
            int red = (p >> 16) & 0xff;
            int green = (p >> 8) & 0xff;
            int blue = p & 0xff;       
            // Apply the sepia formula
            int newRed = (int)(0.393 * red + 0.769 * green + 0.189 * blue);
            int newGreen = (int)(0.349 * red + 0.686 * green + 0.168 * blue);
            int newBlue = (int)(0.272 * red + 0.534 * green + 0.131 * blue);         
            // Cap the values to 255 if necessary
            newRed = Math.min(255, newRed);
            newGreen = Math.min(255, newGreen);
            newBlue = Math.min(255, newBlue);
            // Set the new pixel value
            int newPixel = (alpha << 24) | (newRed << 16) | (newGreen << 8) | newBlue;
            img.setRGB(x, y, newPixel);
        }
    }
    return img;
}   

Red Statistics: The new red value is calculated by adding the percentage to the original red, green, and blue values. This formula produces a weighted average, which turns the color red-brown.

Green count: The new value of green is slightly lower than the red, contributing to the overall vibrant tone.

Blue Count: The new blue value is the smallest, giving the sepia effect its characteristic blue color.

4. Saving the modified image

Once processed, the new sepia-toned image can be saved to disk using the ImageIO.write() method. This method takes the BufferedImage, format (for example, "jpg"), and output file as parameters.

 
File output = new File("path_to_save_sepia_image.jpg");
ImageIO.write(sepiaImage, "jpg", output);   

5. Handling exceptions

In any file processing, there are chances of path falls like unknown files or unsupported file formats. These exceptions are handled by the try-catch block in the main() method so the program will run smoothly and produce helpful error messages.

 
catch (IOException e) {
    System.out.println("Error: " + e.getMessage());
}   

Here is the full code in Java that converts a colored image to a sepia image:

File Name: SepiaConverter.java

 
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import java.io.IOException;
public class SepiaConverter {
    public static void main(String[] args) {
        try {
            // Load the image
            File input = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\java image.png");
            BufferedImage image = ImageIO.read(input);
            // Convert to sepia
            BufferedImage sepiaImage = convertToSepia(image);
            // Save the sepia image
            File output = new File("C:\\Users\\deeks\\OneDrive\\Pictures\\Screenshots\\sepia_image.png");
            ImageIO.write(sepiaImage, "png", output);
            System.out.println("The image converted to sepia successfully.");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
    public static BufferedImage convertToSepia(BufferedImage img) {
        int width = img.getWidth();
       int height = img.getHeight();
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int p = img.getRGB(x, y);
                // Get the original colors
                int alpha = (p >> 24) & 0xff;
                int red = (p >> 16) & 0xff;
                int green = (p >> 8) & 0xff;
                int blue = p & 0xff;
                // Apply the sepia formula
                int newRed = (int)(0.393 * red + 0.769 * green + 0.189 * blue);
                int newGreen = (int)(0.349 * red + 0.686 * green + 0.168 * blue);
                int newBlue = (int)(0.272 * red + 0.534 * green + 0.131 * blue);
                // Cap the values to 255 if necessary
                newRed = Math.min(255, newRed);
                newGreen = Math.min(255, newGreen);
                newBlue = Math.min(255, newBlue);
                // Set the new pixel value
                int newPixel = (alpha << 24) | (newRed << 16) | (newGreen << 8) | newBlue;
                img.setRGB(x, y, newPixel);
            }
        }
        return img;
    }
}   

Input Image:

Image Processing in Java- Colored Image to Sepia Image Conversion

Output:

 
C:\Users\deeks\OneDrive\Desktop\java>javac SepiaConverter.java
C:\Users\deeks\OneDrive\Desktop\java>java SepiaConverter
The image converted to sepia successfully.

Output Image:

Enhancing the sepia effect

While a sepia filter can make the result very primitive in appearance, it is further enhanced if the intensity of the sepia tones is changed. It may be implemented using weighting factors within the sepia formula or with some other image processing techniques like contrast enhancement or noise reduction.

For example, one can enhance the resolution of the shapes to increase the sepia effect, especially in red and green elements. Conversely, you can narrow down these dimensions to create subtle effects.

Expanding image processing capabilities

Sepia filters are just one of many image processing techniques you can use in Java. Other common image-processing tasks include:

Edge detection: Highlighting edges using algorithms such as the Sobel operator.
Color filtering: Separation or enhancement of specific colors in an image.

Together with its extensive API and tremendous community support, Java has become a perfect fit for developing sophisticated graphics applications. You have at your disposal a language that provides everything necessary to do anything from the implementation of an image editing tool and computer vision applications to just applying artistic effects.

Conclusion

Conversion of color images to sepia images in Java is relatively simple and does really unleash the power of image processing in this versatile programming language. By calculating the RGB values per pixel using the formula an easily changed so, you can have a classic sepia effect that adds warmth and nostalgia to your processing.

Next TopicImage-processing-in-java-watermarking-an-image

← prev next →