[JAVA] Image processing: Let's play with the image

Introduction

• This article will be based on "Image processing: Basic structure of images read by the program". If you haven't read it, please read this article first.

Last time I looked at how the program saves the image and displays it with the actual code. This time, let's actually bully (?) The image based on it.

Advance preparation

** Image used this time **

** Basic JAVA code **

ImageProcessing02.java

package ImageProcessing;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png ")); //Bring the image to edit
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();				//Image width
		int iHeight = original.getHeight();				//Vertical width of the image
		int[] iColor = new int[iWidth * iHeight];		//Create an array that saves color information based on the width and height
		int[] iChangeColor = new int[iWidth * iHeight]; //Array for storing modified data of the same size
		
		//Create a BufferedImage variable to modify in advance.
		BufferedImage img = new BufferedImage(iWidth, iHeight, BufferedImage.TYPE_4BYTE_ABGR);
		
		//Bring the color information of the image with getRGB
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);
		
		/**********************
		 *Write the code here.*
		 **********************/

		//Set the modified color information in the Buffered Image for modification
		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			ImageIO.write(img, "png", new File("Path of image file to save")); //Save image
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

There are cases where the declaration statement in the middle is changed, but the basics are like this.

Image rotation

This time, we will only rotate at right angles (90 °), not 360 ° free rotation. (Because trigonometric functions are absolutely necessary to rotate freely)

** * Leave a comment only where it has changed **

ImageProcessing02_1.java

package ImageProcessing;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02_1 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();
		int iHeight = original.getHeight();
		int[] iColor = new int[iWidth * iHeight];
		int[] iChangeColor = new int[iWidth * iHeight];
		
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);

		//Since the width and height change depending on the situation, just declare it for the time being
		BufferedImage img = null;
		
		/**Image Rotate(Rotate 90)**/
		int iRotate = 90;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//Set the turning angle
		int iRotateS = iRotate / 90;
		int iChangeWidth = 0, iChangeHeight = 0;

		//Width and height settings(0, 180,360 degrees= 0 / 90,270 degrees= 1)
		switch(iRotateS % 2) {
		case 0:
			iChangeWidth = iWidth;
			iChangeHeight = iHeight;
			break;
		case 1:
			iChangeWidth = iHeight;
			iChangeHeight = iWidth;
			break;
		}
		img = new BufferedImage(iChangeWidth, iChangeHeight, BufferedImage.TYPE_4BYTE_ABGR);
		int iTargetRow = 0, iTargetCol = 0;
		for(int i = 0; i < iChangeHeight; i++) {
			for(int j = 0; j < iChangeWidth; j++) {
				//Check the rest so that it can handle 360 ° or more
				switch(iRotateS % 4) {
				case 0: //As it is
					iTargetRow = i;
					iTargetCol = j;
					break;
				case 1: //90 °, from bottom left to top of the image
					iTargetRow = iChangeWidth - (j + 1);
					iTargetCol = i;
					break;
				case 2: //180 °, from bottom right to left of the image
					iTargetRow = iChangeHeight - (i + 1);
					iTargetCol = iChangeWidth - (j + 1);
					break;
				case 3: //270 °, from top right to bottom of the image
					iTargetRow = j;
					iTargetCol = iChangeHeight - (i + 1);
					break;
				}
				
				int iTargetIndex = (iTargetRow * iWidth) + iTargetCol;
				int iChangeIndex = (i * iChangeWidth) + j;
				iChangeColor[iChangeIndex] = iColor[iTargetIndex]; 
			}
		}

		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			ImageIO.write(img, "png", new File("ImageRotate.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

The coordinate indexing formula is the same as in the previous article. The most important thing in this article is coordinate calculation. It is important which color of the original image is placed where. In the case of rotation at a right angle, it is important to start from where and in which direction to read. Let's see the actual image.

** Original image **

** 90 ° rotation **

The original image and the image rotated 90 °. The important thing here is where the 0th color in the image comes from. At 90 °, the colors from the lower right to the upper right are lined up in a straight line.

Other angles are the same, but the coordinates of the color when the angle changes in this way are calculated. It is OK if you put it according to the coordinates to be changed.

Image inversion

ImageProcessing02_2.java

package ImageProcessing;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02_2 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();		
		int iHeight = original.getHeight();		
		int[] iColor = new int[iWidth * iHeight];	
		int[] iChangeColor = new int[iWidth * iHeight]; 
		
		BufferedImage img = new BufferedImage(iWidth, iHeight, BufferedImage.TYPE_4BYTE_ABGR);
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);
		
		boolean isVerticalChange = true; //flip upside down
		boolean isHorizonChange = true; //Flip horizontal
		for(int i = 0; i < iHeight; i++) {
			for(int j = 0; j < iWidth; j++) {
				int iChangeRow = (isVerticalChange) ? iHeight - ( i + 1 ) : i; //Upside down from bottom to top
				int iChangeCol = (isHorizonChange) ? iWidth - ( j + 1 ) : j;  //Left-right reversal from rightmost to left
				int iChangeIndex = (iChangeRow * iWidth) + iChangeCol;
				
				int iTargetIndex = (i * iWidth) + j;
				
				iChangeColor[iChangeIndex] = iColor[iTargetIndex];
			}
		}
		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			ImageIO.write(img, "png", new File("ImageReverse.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

It's almost the same as before. Check whether it is flipped vertically or horizontally with Boolean, and change the coordinates accordingly. If both are set to true, 180 ° rotation and operation are the same.

Cut out a part of the image

ImageProcessing02_3.java

package ImageProcessing;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02_3 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();		
		int iHeight = original.getHeight();		
		int[] iColor = new int[iWidth * iHeight];	
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);
		
		//Coordinates to start cutting
		int iChangeY = 50;
		int iChangeX = 50;
		//Cut size
		int iChangeWidth = 100;
		int iChangeHeight = 100;

		//Declare an array and a BufferedImage variable based on the size to cut.
		int[] iChangeColor = new int[iChangeWidth * iChangeHeight]; 
		BufferedImage img = new BufferedImage(iChangeWidth, iChangeHeight, BufferedImage.TYPE_4BYTE_ABGR);

		//Loop based on the size to cut
		for(int i = 0; i < iChangeHeight; i++) {
			for(int j = 0; j < iChangeWidth; j++) {
				//Determine the coordinates of the color information from the coordinates where you start cutting.
				int iTargetRow = iChangeY + i;
				int iTargetCol = iChangeX + j;
				int iTargetIndex = (iTargetRow * iWidth) + iTargetCol;
				
				int iChangeIndex = (i * iChangeWidth) + j;
				
				iChangeColor[iChangeIndex] = iColor[iTargetIndex];
			}
		}

		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			ImageIO.write(img, "png", new File("ImageSlice.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

If you want to cut a part of the image, start from the upper left of the place where you want to cut the starting coordinates It's OK if you mix it with the size to cut out. However, if this is left as it is, the loop may go beyond the size of the image, so please try to fix it.

Divide like a puzzle

ImageProcessing02_4.java

package ImageProcessing;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02_4 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();		
		int iHeight = original.getHeight();		
		int[] iColor = new int[iWidth * iHeight];	
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);

		int iPieceW = 3; //Number of horizontal pieces
		int iPieceH = 4; //Number of vertical pieces

		//Size setting based on the number of pieces
		int iChangeWidth = iWidth / iPieceW;
		int iChangeHeight = iHeight / iPieceH;

		//Declare an array for color information as a two-dimensional array based on the size and the number of pieces
		int[][] iChangeColor = new int[iPieceW * iPieceH][iChangeWidth * iChangeHeight];

		//BufferedImage is also declared as an array
		BufferedImage[] img = new BufferedImage[iPieceW * iPieceH];
		for(int i = 0; i < img.length; i++) {
			img[i] = new BufferedImage(iChangeWidth, iChangeHeight, BufferedImage.TYPE_4BYTE_ABGR);
		}

		for(int i = 0; i < iHeight; i++) {
			int iNowY = i / iChangeHeight; //What line is the piece
			if(iNowY >= iPieceH) break;　　　　　//Exit when there is a rest and the coordinates exceed the set number
			for(int j = 0; j < iWidth; j++) {
				int iNowX = j / iChangeWidth; //How many rows are the pieces
				if(iNowX >= iPieceW) continue;　　　　　//Ignore when there is a rest and the coordinates exceed the set number

				int iChangeRow = i % iChangeHeight;
				int iChangeCol = j % iChangeWidth;
				
				int iTargetIndex = (i * iWidth) + j;
				int iChangeIndex = (iChangeRow * iChangeWidth) + iChangeCol;
				int iChangeKey = iNowY * iPieceW + iNowX;
				
				iChangeColor[iChangeKey][iChangeIndex] = iColor[iTargetIndex];
			}
		}

		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			for(int i = 0; i < img.length; i++) {
				ImageIO.write(img[i], "png", new File("ImageSlice" + String.format("%03d", i) + ".png "));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

A code that divides an image evenly like an image puzzle. Declare BufferedImage as an array and divide the coordinates once more to fit the size to divide It would be easy if we could change the Key.

Image editing using getGraphics ()

ImageProcessing02_5.java

package ImageProcessing;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageProcessing02_5 {
	public static void main(String[] args) {
		BufferedImage original = null;
		try {
			original = ImageIO.read(new File("image.png "));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//Bring the graphics of the image
		Graphics g = original.getGraphics();
		
		//Draw circles of various colors on the image.
		g.setColor(Color.RED);
		g.fillOval(70, 70, 100, 100);
		g.setColor(Color.GREEN);
		g.fillOval(20, 120, 100, 100);
		g.setColor(Color.BLUE);
		g.fillOval(70, 170, 100, 100);
		g.setColor(Color.BLACK);
		g.fillOval(120, 120, 100, 100);
		
		try {
			ImageIO.write(original, "png", new File("ImageEdit.png "));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

result

Using the Graphics library supported by JAVA Code that modifies the image using the methods in the library. You don't have to think about RGB code or coordinates so hard.

However, it does not have complicated image processing functions. Graphics alone is not enough. So, like the previous method, there are many functions that can be created just by switching the RGB code and coordinates. Please try to make it directly.

At the end

This time it's the most difficult to understand I wrote in the previous article, I've introduced some codes that use RGB code coordinate indexing, but how was it? This is one of the basics in image processing, but the basics are the most important. Let's master it well and let's enter the world of image processing!