[JAVA] Bildverarbeitung: Spielen wir mit dem Bild

Einführung

• Dieser Artikel basiert auf "Bildverarbeitung: Grundstruktur des vom Programm gelesenen Bildes". Wenn Sie es nicht gelesen haben, lesen Sie bitte zuerst diesen Artikel.

Das letzte Mal habe ich mir angesehen, wie das Programm das Bild speichert und es mit dem tatsächlichen Code anzeigt. Lassen Sie uns dieses Mal tatsächlich verschiedene Bilder daraus machen (?).

Vorbereitungen

** Dieses Mal verwendetes Bild **

** Grundlegender 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 ")); //Bringen Sie das Bild zum Bearbeiten
		} catch (IOException e) {
			e.printStackTrace();
		}
		int iWidth = original.getWidth();				//Bildbreite
		int iHeight = original.getHeight();				//Vertikale Breite des Bildes
		int[] iColor = new int[iWidth * iHeight];		//Erstellen Sie ein Array, das Farbinformationen basierend auf Breite und Höhe speichert
		int[] iChangeColor = new int[iWidth * iHeight]; //Ein Array zum Speichern geänderter Daten derselben Größe
		
		//Erstellen Sie eine BufferedImage-Variable, die im Voraus geändert werden soll.
		BufferedImage img = new BufferedImage(iWidth, iHeight, BufferedImage.TYPE_4BYTE_ABGR);
		
		//Bringen Sie Bildfarbeninformationen mit getRGB
		original.getRGB(0, 0, iWidth, iHeight, iColor, 0, iWidth);
		
		/**********************
		 *Schreiben Sie den Code hier.*
		 **********************/

		//Stellen Sie die geänderten Farbinformationen im gepufferten Bild zur Änderung ein
		img.setRGB(0, 0, iWidth, iHeight, iChangeColor, 0, iWidth);
		
		try {
			ImageIO.write(img, "png", new File("Route der zu speichernden Bilddatei")); //Bild speichern
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Es gibt Fälle, in denen die Deklarationsanweisung in der Mitte geändert wird, aber die Grundlagen sind wie folgt.

Bilddrehung

Dieses Mal drehen wir uns nicht frei um 360 °, sondern nur im rechten Winkel (90 °). (Da eine Dreiecksfunktion unbedingt erforderlich ist, um sie frei zu drehen)

** * Hinterlasse einen Kommentar nur dort, wo er sich geändert hat **

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);

		//Da sich Breite und Höhe je nach Situation ändern, deklarieren Sie dies vorerst
		BufferedImage img = null;
		
		/**Image Rotate(Rotate 90)**/
		int iRotate = 90;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//Stellen Sie den Drehwinkel ein
		int iRotateS = iRotate / 90;
		int iChangeWidth = 0, iChangeHeight = 0;

		//Einstellungen für Breite und Höhe(0, 180,360 Grad= 0 / 90,270 Grad= 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++) {
				//Überprüfen Sie den Rest so, dass er 360 ° oder mehr aufnehmen kann
				switch(iRotateS % 4) {
				case 0: //Wie es ist
					iTargetRow = i;
					iTargetCol = j;
					break;
				case 1: //90 ° von links unten nach oben im Bild
					iTargetRow = iChangeWidth - (j + 1);
					iTargetCol = i;
					break;
				case 2: //180 ° von rechts unten nach links im Bild
					iTargetRow = iChangeHeight - (i + 1);
					iTargetCol = iChangeWidth - (j + 1);
					break;
				case 3: //270 ° von oben rechts nach unten im Bild
					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();
		}
	}
}

Die Formel für die Koordinatenindizierung ist dieselbe wie im vorherigen Artikel. Das Wichtigste in diesem Artikel ist die Koordinatenberechnung. Es ist wichtig, welche Farbe des Originalbildes wo platziert wird. Bei einer Drehung im rechten Winkel ist es wichtig, von wo und in welche Richtung zu lesen. Sehen wir uns das aktuelle Bild an.

** Original Bild **

** 90 ° Drehung **

Das Originalbild und das Bild wurden um 90 ° gedreht. Wichtig ist hier, woher die 0. Farbe im Bild kommt. Bei 90 ° sind die Farben von rechts unten nach rechts oben in einer geraden Linie ausgerichtet.

Andere Winkel sind die gleichen, aber durch Bestimmen der Farbkoordinaten, wenn sich der Winkel auf diese Weise ändert, Es ist in Ordnung, wenn Sie es gemäß den zu ändernden Koordinaten eingeben.

Bildinversion

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; //auf den Kopf stellen
		boolean isHorizonChange = true; //Horizontal spiegeln
		for(int i = 0; i < iHeight; i++) {
			for(int j = 0; j < iWidth; j++) {
				int iChangeRow = (isVerticalChange) ? iHeight - ( i + 1 ) : i; //Umgedreht von unten nach oben
				int iChangeCol = (isHorizonChange) ? iWidth - ( j + 1 ) : j;  //Umkehrung von links nach rechts von ganz rechts nach links
				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();
		}
	}
}

Es ist fast das gleiche wie zuvor. Überprüfen Sie mit Boolean, ob es vertikal oder horizontal gespiegelt wird, und ändern Sie die Koordinaten entsprechend. Wenn beide auf true gesetzt sind, sind 180 ° -Drehung und Betrieb gleich.

Schneiden Sie einen Teil des Bildes aus

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);
		
		//Koordinaten, um mit dem Schneiden zu beginnen
		int iChangeY = 50;
		int iChangeX = 50;
		//Schnittgröße
		int iChangeWidth = 100;
		int iChangeHeight = 100;

		//Deklarieren Sie ein Array und eine BufferedImage-Variable basierend auf der zu schneidenden Größe.
		int[] iChangeColor = new int[iChangeWidth * iChangeHeight]; 
		BufferedImage img = new BufferedImage(iChangeWidth, iChangeHeight, BufferedImage.TYPE_4BYTE_ABGR);

		//Schleife basierend auf der zu schneidenden Größe
		for(int i = 0; i < iChangeHeight; i++) {
			for(int j = 0; j < iChangeWidth; j++) {
				//Bestimmen Sie die Koordinaten der Farbinformationen anhand der Koordinaten, an denen Sie mit dem Schneiden beginnen.
				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();
		}
	}
}

Wenn Sie einen Teil des Bildes ausschneiden möchten, beginnen Sie oben links an der Stelle, an der Sie die Startkoordinaten ausschneiden möchten Es ist in Ordnung, wenn Sie es mit der Größe zum Ausschneiden mischen. Wenn dies jedoch unverändert bleibt, kann die Schleife die Größe des Bildes überschreiten. Versuchen Sie daher, das Problem zu beheben.

Teilen Sie wie ein 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; //Anzahl der horizontalen Teile
		int iPieceH = 4; //Anzahl der vertikalen Teile

		//Größeneinstellung basierend auf der Anzahl der Teile
		int iChangeWidth = iWidth / iPieceW;
		int iChangeHeight = iHeight / iPieceH;

		//Deklarieren Sie ein Array für Farbinformationen als zweidimensionales Array basierend auf der Größe und der Anzahl der Teile
		int[][] iChangeColor = new int[iPieceW * iPieceH][iChangeWidth * iChangeHeight];

		//BufferedImage wird auch als Array deklariert
		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; //Welche Linie ist das Stück
			if(iNowY >= iPieceH) break;　　　　　//Beenden Sie das Programm, wenn eine Pause eingelegt ist und die Anzahl der Koordinaten die festgelegte Anzahl überschreitet
			for(int j = 0; j < iWidth; j++) {
				int iNowX = j / iChangeWidth; //Wie viele Reihen sind die Stücke
				if(iNowX >= iPieceW) continue;　　　　　//Ignorieren, wenn eine Pause eingelegt ist und die Anzahl der Koordinaten die eingestellte Anzahl überschreitet

				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();
		}
	}
}

Es ist ein Code, der das Bild gleichmäßig wie ein Bildrätsel teilt. Deklarieren Sie BufferedImage als Array, teilen Sie die Koordinaten noch einmal und passen Sie die zu teilende Größe an Es wäre einfach, wenn wir den Schlüssel ändern könnten.

Bildbearbeitung mit 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();
		}
		//Bringen Sie die Grafiken des Bildes
		Graphics g = original.getGraphics();
		
		//Zeichnen Sie Kreise in verschiedenen Farben auf das Bild.
		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();
		}
	}
}

Ergebnis

Verwenden der von JAVA unterstützten Grafikbibliothek Code, der ein Bild mithilfe einer Methode in der Bibliothek ändert. Sie müssen nicht so genau über RGB-Code oder Koordinaten nachdenken.

Es hat jedoch keine komplizierten Bildverarbeitungsfunktionen. Grafik allein reicht nicht aus. Wie bei der vorherigen Methode gibt es viele Funktionen, die nur durch Umschalten des RGB-Codes und der Koordinaten erstellt werden können. Bitte versuchen Sie es direkt zu machen.

Am Ende

Diesmal ist es am schwierigsten zu verstehen, was ich im vorherigen Artikel geschrieben habe. Ich habe einige Codes eingeführt, die die Indizierung von RGB-Codekoordinaten verwenden, aber wie war das? Dies ist eine der Grundlagen in der Bildverarbeitung, aber die Grundlagen sind die wichtigsten. Beherrschen wir es gut und betreten wir die Welt der Bildverarbeitung!