Implement basic operations of image processing using Java

With the development of digital technology, image processing technology has received more and more attention. In image processing, the Java language is popular because of its simplicity, ease of learning, and cross-platform characteristics. This article will introduce the basic operations of image processing in Java.

1. Reading and displaying images

In Java, images can be read and loaded using the javax.imageio.ImageIO class. ImageIO provides the static method read(), which can read images stored in files, URLs, or input streams and convert them into Java BufferedImage objects.

The following is a sample code for reading and displaying an image:

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

public class ImageIOExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 显示图像
    ImageViewer viewer = new ImageViewer(image);
    viewer.show();
  }

}

Among them, ImageViewer is a custom image viewer class that can display BufferedImage objects in the window. I won’t go into details here, readers can implement it by themselves.

2. Image scaling

Image scaling is one of the most basic operations in image processing. Java provides the AffineTransform class to implement image scaling. When scaling, you need to specify the scaling factor, which is the scaling ratio in the horizontal and vertical directions.

The following is a sample code for image scaling:

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

public class ImageScalingExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 缩放图像
    int width = image.getWidth() / 2;
    int height = image.getHeight() / 2;
    BufferedImage scaledImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2d = scaledImage.createGraphics();
    AffineTransform transform = AffineTransform.getScaleInstance(0.5, 0.5);
    g2d.drawRenderedImage(image, transform);
    g2d.dispose();
    // 显示图像
    ImageViewer viewer = new ImageViewer(scaledImage);
    viewer.show();
  }

}

In the above code, create a BufferedImage object and specify its width and height, and then draw the scaled image through the drawRenderedImage() method of the Graphics2D object image. The getScaleInstance() method of the AffineTransform class returns an AffineTransform object that implements the specified horizontal and vertical scaling factors.

3. Image rotation

The AffineTransform class can also be used to rotate images in Java. When rotating, you need to specify the rotation angle and rotation center point.

The following is a sample code for image rotation:

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

public class ImageRotationExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 旋转图像
    int width = image.getWidth();
    int height = image.getHeight();
    BufferedImage rotatedImage = new BufferedImage(height, width, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2d = rotatedImage.createGraphics();
    AffineTransform transform = new AffineTransform();
    transform.translate(height / 2, width / 2);
    transform.rotate(Math.toRadians(90));
    transform.translate(-width / 2, -height / 2);
    g2d.drawRenderedImage(image, transform);
    g2d.dispose();
    // 显示图像
    ImageViewer viewer = new ImageViewer(rotatedImage);
    viewer.show();
  }

}

In the above code, create a BufferedImage object and specify its width and height, and then draw the rotated image through the drawRenderedImage() method of the Graphics2D object image. The translate() and rotate() methods of the AffineTransform class implement rotation operations. The translate() method is used to translate the center point of the image, and the rotate() method is used to rotate the image.

4. Image grayscale

Image grayscale is the operation of converting a color image into a grayscale image. In Java, the image can be grayscaled by the following formula:

gray = 0.299 red 0.587 green 0.114 * blue

The following is a sample code for grayscale image:

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

public class ImageGrayscaleExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 灰度化图像
    int width = image.getWidth();
    int height = image.getHeight();
    BufferedImage grayscaleImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
    Graphics2D g2d = grayscaleImage.createGraphics();
    g2d.drawImage(image, 0, 0, null);
    g2d.dispose();
    // 显示图像
    ImageViewer viewer = new ImageViewer(grayscaleImage);
    viewer.show();
  }

}

In the above code, create a BufferedImage object and specify its type as TYPE_BYTE_GRAY, and then convert the color image into a grayscale image through the drawImage() method of the Graphics2D object.

5. Image binarization

Image binarization is the operation of converting grayscale images into black and white images. In Java, the image can be binarized through the following formula:

if (gray > threshold) {
binary = 255;
} else {
binary = 0;
}

The following is a sample code for image binarization:

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

public class ImageBinarizationExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 灰度化图像
    int width = image.getWidth();
    int height = image.getHeight();
    BufferedImage grayscaleImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
    Graphics2D g2d = grayscaleImage.createGraphics();
    g2d.drawImage(image, 0, 0, null);
    g2d.dispose();
    // 二值化图像
    int threshold = 128;
    BufferedImage binaryImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        int gray = grayscaleImage.getRGB(x, y) & 0xFF;
        int binary = 0;
        if (gray > threshold) {
          binary = 255;
        }
        binaryImage.setRGB(x, y, binary);
      }
    }
    // 显示图像
    ImageViewer viewer = new ImageViewer(binaryImage);
    viewer.show();
  }

}

In the above code, the color image is first converted into a grayscale image, and then the grayscale image is converted into a black and white image by setting a threshold . In the loop, you can use the getRGB() method to get the grayscale value of each pixel, and use the setRGB() method to set the pixels of the binary image to 0 or 255.

6. Image filtering

Image filtering is achieved by convolving the image. In Java, the Kernel class is used to create a convolution kernel, and the ConvolveOp class is used to apply the convolution kernel to the image.

The following is a sample code for image filtering:

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

public class ImageFilteringExample {

  public static void main(String[] args) throws IOException {
    // 读取图像
    File file = new File("image.jpg");
    BufferedImage image = ImageIO.read(file);
    // 定义卷积核
    float[] kernelData = {-1, -1, -1, -1, 9, -1, -1, -1, -1};
    Kernel kernel = new Kernel(3, 3, kernelData);
    // 滤波图像
    int width = image.getWidth();
    int height = image.getHeight();
    BufferedImage filteredImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2d = filteredImage.createGraphics();
    ConvolveOp op = new ConvolveOp(kernel);
    op.filter(image, filteredImage);
    g2d.drawImage(filteredImage, 0, 0, null);
    g2d.dispose();
    // 显示图像
    ImageViewer viewer = new ImageViewer(filteredImage);
    viewer.show();
  }

}

In the above code, first create a Kernel object and set its data to [-1, -1, -1, -1, 9, -1, -1, -1, -1], representing a 3x3 convolution kernel. The convolution kernel is then applied to the image using the ConvolveOp class. During the filtering process, you can use the setRGB() method to write the convolved pixel data into the filtered image.

Summary

This article introduces the basic operations of image processing in Java, including reading and displaying images, image scaling, image rotation, image grayscale, image binarization and image filtering . Java provides a wealth of image processing classes and methods that can easily implement various image processing operations. Readers can further study image processing technology according to their own needs and implement richer functions in practical applications.

The above is the detailed content of Implement basic operations of image processing using Java. For more information, please follow other related articles on the PHP Chinese website!