Rotar una imagen en Java

Rupam Yadav 12 octubre 2023
  1. Rotar una imagen en Java usando BufferedImage y Graphics2D.rotate()
  2. Rotar una imagen en Java usando Affine Transform
Rotar una imagen en Java

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:

rotar imagen en java - imagen original

Imagen rotada:

rotar imagen en java - 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:

rotar imagen en java - imagen original

Imagen girada en el sentido de las agujas del reloj:

rotar imagen en java - imagen rotada en el sentido de las agujas del reloj

Imagen girada en sentido antihorario:

rotar imagen en java - imagen rotada en sentido antihorario

Rupam Yadav avatar Rupam Yadav avatar

Rupam Saini is an android developer, who also works sometimes as a web developer., He likes to read books and write about various things.

LinkedIn

Artículo relacionado - Java Image