Rotar una imagen en Java

1. Rotar una imagen en Java usando BufferedImage y Graphics2D.rotate()
2. Rotar una imagen en Java usando Affine Transform

Este artículo presentará cómo podemos rotar una imagen en Java usando dos formas nativas.

Rotar una imagen en Java usando BufferedImage y Graphics2D.rotate()

El primer método para rotar una imagen incluye el uso de la clase BufferedImage y la clase Graphics2d que viene con el paquete AWT. A continuación, creamos una función rotateImage() que recibe un objeto BufferedImage como parámetro y devuelve un objeto BufferedImage girado.

En rotateImage(), obtenemos el ancho, alto y tipo de la imagen usando los métodos getWidth(), getHeight() y getType(). Ahora llamamos al constructor BufferedImage() y pasamos las tres variables como argumentos y devuelve un objeto BufferedImage newImageFromBuffer.

Creamos una nueva imagen rotada usando el método createGraphics() que devuelve un objeto Graphics2D graphics2D. Usando este objeto, llamamos a la función rotate() que toma tres argumentos; el primero es el ángulo para rotar la imagen ya que queremos rotarla 90 grados pasamos Math.radians(90), el segundo y tercer argumento son las coordenadas x e y.

Finalmente, llamamos graphics2D.drawImage() para dibujar la imagen rotada, que toma cuatro argumentos, el objeto BufferedImage, el filtro a aplicar y las coordenadas x e y. Luego devolvemos el objeto newImageFromBuffer.

En la función main, leemos el archivo con File y lo convertimos en un objeto BufferedImage con ImageIO.read(). Ahora llamamos a la función rotateImage() y pasamos el objeto BufferedImage devuelto y almacenamos el objeto BufferedImage rotado. Ahora que tenemos la imagen rotada, necesitamos crear un nuevo archivo para almacenarla usando File y ImageIO.write() que toma el objeto BufferedImage, su extensión y la ubicación del archivo vacío.

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

Producción :

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

Imagen original:

Imagen rotada:

Rotar una imagen en Java usando Affine Transform

Este ejemplo utiliza la clase AffineTransform que mapea una imagen desde sus coordenadas 2D originales a otras coordenadas 2D linealmente sin perder la calidad original. En el siguiente programa, tenemos tres métodos, uno para leer y llamar a otras funciones, el segundo es rotar la imagen en el sentido de las agujas del reloj y la última función gira la imagen en el sentido contrario a las agujas del reloj.

En la función rotateImage(), leemos la imagen usando new File() y la convertimos en un objeto BufferedImage usando ImageIO.read(). Luego creamos otro objeto BufferedImage que conserva las propiedades de la imagen original y lo llamamos output. A continuación, llamamos al método rotateImageClockWise() y pasamos la BufferedImage original que devuelve un objeto de la clase AffineTransorm.

rotateImageClockWise() recibe la image y obtiene la altura y el ancho. Creamos un objeto AffineTransform y llamamos al método rotate() usándolo. En rotate(), pasamos tres argumentos; el primero es el ángulo de rotación medido en radianes, aquí pasamos Math.PI / 2, los dos últimos argumentos son las coordenadas x e y que son la mitad del ancho y alto de la imagen.

Ahora, a medida que se gira la imagen, traducimos la imagen en las nuevas coordenadas usando la función translate() que toma dos argumentos: la distancia para rotar en la dirección x y la distancia para rotar en la dirección y. Calculamos los argumentos x e y usando (imageWidth - imageHeight) / 2.

Para rotar la imagen en sentido antihorario, podemos llamar al método rotateImageCounterClockwise() en rotate() en lugar 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();
    }
  }
}

Producción:

Imagen original:

Imagen girada en el sentido de las agujas del reloj:

Imagen girada en sentido antihorario: