Girar uma imagem em Java

1. Gire uma imagem em Java usando BufferedImage e Graphics2D.rotate()
2. Girar uma imagem em Java usando Affine Transform

Este artigo irá apresentar como podemos girar uma imagem em Java usando duas maneiras nativas.

Gire uma imagem em Java usando BufferedImage e Graphics2D.rotate()

O primeiro método para girar uma imagem inclui o uso de BufferedImage e da classe Graphics2d que vem com o pacote AWT. Abaixo, criamos uma função rotateImage() que recebe um objeto BufferedImage como parâmetro e retorna um objeto BufferedImage girado.

Em rotateImage(), obtemos a largura, altura e o tipo da imagem usando os métodos getWidth(), getHeight() e getType(). Agora chamamos o construtor BufferedImage() e passamos as três variáveis ​​como argumentos e ele retorna um objeto BufferedImage newImageFromBuffer.

Criamos uma nova imagem girada usando o método createGraphics() que retorna um objeto Graphics2D graphics2D. Usando este objeto, chamamos a função rotate() que recebe três argumentos; o primeiro é o ângulo para girar a imagem, pois queremos girá-la 90 graus, passamos por Math.radians(90), o segundo e o terceiro argumentos são as coordenadas x e y.

Finalmente, chamamos graphics2D.drawImage() para desenhar a imagem girada, que leva quatro argumentos, o objeto BufferedImage, o filtro a ser aplicado e as coordenadas x e y. Em seguida, retornamos o objeto newImageFromBuffer.

Na função main, lemos o arquivo usando File e então o convertemos em um objeto BufferedImage usando ImageIO.read(). Agora chamamos a função rotateImage() e passamos o objeto BufferedImage retornado e armazenamos o objeto BufferedImage girado. Agora que temos a imagem girada, precisamos criar um novo arquivo para armazená-lo usando File e ImageIO.write() que leva o objeto BufferedImage, sua extensão é a localização do arquivo vazio.

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

Produção:

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

Imagem original:

Imagem girada:

Girar uma imagem em Java usando Affine Transform

Este exemplo usa a classe AffineTransform que mapeia uma imagem de suas coordenadas 2D originais para outras coordenadas 2D linearmente sem perder a qualidade original. No programa a seguir, temos três métodos, um para ler e chamar outras funções, o segundo é girar a imagem no sentido horário e a última função gira a imagem no sentido anti-horário.

Na função rotateImage(), lemos a imagem usando new File() e a convertemos em um objeto BufferedImage usando ImageIO.read(). Em seguida, criamos outro objeto BufferedImage que preserva as propriedades da imagem original e o chamamos de output. Em seguida, chamamos o método rotateImageClockWise() e passamos o BufferedImage original nele que retorna um objeto da classe AffineTransorm.

rotateImageClockWise() recebe a imagem e obtém a altura e largura. Criamos um objeto AffineTransform e chamamos o método rotate() usando-o. Em rotate(), passamos três argumentos; o primeiro é o ângulo de rotação medido em radianos, aqui passamos Math.PI / 2, os dois últimos argumentos são as coordenadas x e y que são metade da largura e altura da imagem.

Agora, conforme a imagem é girada, traduzimos a imagem nas novas coordenadas usando a função translate() que leva dois argumentos: a distância para girar na direção xe a distância para girar na direção y. Calculamos os argumentos x e y usando (imageWidth - imageHeight) / 2.

Para girar a imagem no sentido anti-horário, podemos chamar o método rotateImageCounterClockwise() em rotate() em vez de rotateImageClockWise().

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

Produção:

Imagem original:

Imagem girada no sentido horário:

Imagem girada no sentido anti-horário: