Drehen eines Bildes in Java

1. Drehen Sie ein Bild in Java mit BufferedImage und Graphics2D.rotate()
2. Drehen eines Bildes in Java mit affiner Transformation

In diesem Artikel wird vorgestellt, wie wir ein Bild in Java auf zwei native Weisen drehen können.

Drehen Sie ein Bild in Java mit BufferedImage und Graphics2D.rotate()

Die erste Methode zum Drehen eines Bildes umfasst die Verwendung der Klasse BufferedImage und der Klasse Graphics2d, die mit dem AWT-Paket geliefert werden. Nachfolgend erstellen wir eine Funktion rotateImage(), die als Parameter ein BufferedImage-Objekt erhält und ein gedrehtes BufferedImage-Objekt zurückgibt.

In rotateImage() erhalten wir die Breite, Höhe und den Typ des Bildes mit den Methoden getWidth(), getHeight() und getType(). Nun rufen wir den BufferedImage()-Konstruktor auf und übergeben die drei Variablen als Argumente und er gibt ein BufferedImage-Objekt newImageFromBuffer zurück.

Wir erstellen ein neues gedrehtes Bild mit der Methode createGraphics(), die ein Graphics2D-Objekt graphics2D zurückgibt. Mit diesem Objekt rufen wir die Funktion rotate() auf, die drei Argumente benötigt; Der erste ist der Winkel, um das Bild zu drehen, da wir es um 90 Grad drehen möchten. Wir übergeben Math.radians(90), das zweite und dritte Argument sind die x- und y-Koordinaten.

Schließlich rufen wir graphics2D.drawImage() auf, um das gedrehte Bild zu zeichnen, das vier Argumente, das BufferedImage-Objekt, den anzuwendenden Filter und die x- und y-Koordinaten benötigt. Dann geben wir das Objekt newImageFromBuffer zurück.

In der Funktion main lesen wir die Datei mit File ein und konvertieren sie dann mit ImageIO.read() in ein BufferedImage-Objekt. Nun rufen wir die Funktion rotateImage() auf und übergeben das zurückgegebene BufferedImage-Objekt und speichern das gedrehte BufferedImage-Objekt. Jetzt, da wir das gedrehte Bild haben, müssen wir eine neue Datei erstellen, um es mit File und ImageIO.write() zu speichern, die das BufferedImage-Objekt nimmt, seine Erweiterung den Speicherort der leeren Datei.

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

public class RotateImage {
  public static BufferedImage rotateImage(BufferedImage imageToRotate) {
    int widthOfImage = imageToRotate.getWidth();
    int heightOfImage = imageToRotate.getHeight();
    int typeOfImage = imageToRotate.getType();

    BufferedImage newImageFromBuffer = new BufferedImage(widthOfImage, heightOfImage, typeOfImage);

    Graphics2D graphics2D = newImageFromBuffer.createGraphics();

    graphics2D.rotate(Math.toRadians(90), widthOfImage / 2, heightOfImage / 2);
    graphics2D.drawImage(imageToRotate, null, 0, 0);

    return newImageFromBuffer;
  }

  public static void main(String[] args) {
    try {
      BufferedImage originalImage = ImageIO.read(new File("mountains.jpeg"));

      BufferedImage subImage = rotateImage(originalImage);

      File rotatedImageFile = new File("C:\\Users\\User1\\Documents\\mountainsRotated.jpeg");

      ImageIO.write(subImage, "jpg", rotatedImageFile);

      System.out.println("New Rotated Image File Path: " + rotatedImageFile.getPath());

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Ausgabe:

New Rotated Image File Path: C:\Users\User1\Documents\mountainsRotated.jpeg

Original Bild:

Gedrehtes Bild:

Drehen eines Bildes in Java mit affiner Transformation

In diesem Beispiel wird die Klasse AffineTransform verwendet, die ein Bild von seinen ursprünglichen 2D-Koordinaten auf andere 2D-Koordinaten linear abbildet, ohne die ursprüngliche Qualität zu verlieren. Im folgenden Programm haben wir drei Methoden, eine zum Lesen und Aufrufen anderer Funktionen, die zweite zum Drehen des Bildes im Uhrzeigersinn und die letzte Funktion zum Drehen des Bildes gegen den Uhrzeigersinn.

In der Funktion rotateImage() lesen wir das Bild mit new File() ein und konvertieren es mit ImageIO.read() in ein BufferedImage-Objekt. Dann erstellen wir ein weiteres BufferedImage-Objekt, das die Eigenschaften des Originalbildes beibehält und nennen es output. Als nächstes rufen wir die Methode rotateImageClockWise() auf und übergeben darin das ursprüngliche BufferedImage, das ein Objekt der Klasse AffineTransorm zurückgibt.

rotateImageClockWise() empfängt das Bild und erhält die Höhe und Breite. Wir erstellen ein AffineTransform-Objekt affineTransform und rufen damit die Methode rotate() auf. In rotate() übergeben wir drei Argumente; der erste ist der in Radiant gemessene Drehwinkel, hier übergeben wir Math.PI / 2, die letzten beiden Argumente sind die x- und y-Koordinaten, die der Hälfte der Breite und Höhe des Bildes entsprechen.

Jetzt, während das Bild gedreht wird, übersetzen wir das Bild in die neuen Koordinaten mit der Funktion translate(), die zwei Argumente benötigt: den zu drehenden Abstand in x-Richtung und den zu drehenden Abstand in die y-Richtung. Wir berechnen die x- und y-Argumente mit (imageWidth - imageHeight) / 2.

Um das Bild gegen den Uhrzeigersinn zu drehen, können wir in rotate() statt rotateImageClockWise() die Methode rotateImageCounterClockwise() aufrufen.

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

public class RotateImage {
  private static final String INPUT_FILE_NAME = "mountains.jpeg";
  private static final String OUTPUT_FILE_NAME = "mountainsRotated.jpeg";

  private AffineTransform rotateImageClockWise(BufferedImage image) {
    int imageWidth = image.getWidth();
    int imageHeight = image.getHeight();

    AffineTransform affineTransform = new AffineTransform();
    affineTransform.rotate(Math.PI / 2, imageWidth / 2, imageHeight / 2);

    double offset = (imageWidth - imageHeight) / 2;
    affineTransform.translate(offset, offset);
    return affineTransform;
  }

  private AffineTransform rotateImageCounterClockwise(BufferedImage image) {
    int imageWidth = image.getWidth();
    int imageHeight = image.getHeight();

    AffineTransform affineTransform = new AffineTransform();
    affineTransform.rotate(-Math.PI / 2, imageWidth / 2, imageHeight / 2);

    double offset = (imageWidth - imageHeight) / 2;
    affineTransform.translate(-offset, -offset);

    return affineTransform;
  }

  private void rotateImage() throws Exception {
    BufferedImage bufferedImage = ImageIO.read(new File(INPUT_FILE_NAME));

    BufferedImage output = new BufferedImage(
        bufferedImage.getHeight(), bufferedImage.getWidth(), bufferedImage.getType());

    AffineTransform affineTransform = rotateImageClockWise(bufferedImage);
    AffineTransformOp affineTransformOp =
        new AffineTransformOp(affineTransform, AffineTransformOp.TYPE_BILINEAR);
    affineTransformOp.filter(bufferedImage, output);

    ImageIO.write(output, "jpg", new File(OUTPUT_FILE_NAME));
  }

  public static void main(String[] args) {
    try {
      RotateImage rotateImage = new RotateImage();
      rotateImage.rotateImage();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ausgabe:

Original Bild:

Bild im Uhrzeigersinn gedreht:

Bild gegen den Uhrzeigersinn gedreht: