Faire pivoter une image en Java

1. Faire pivoter une image en Java à l’aide de BufferedImage et Graphics2D.rotate()
2. Faire pivoter une image en Java à l’aide de la transformation affine

Cet article présentera comment nous pouvons faire pivoter une image en Java en utilisant deux méthodes natives.

Faire pivoter une image en Java à l’aide de BufferedImage et Graphics2D.rotate()

La première méthode pour faire pivoter une image comprend l’utilisation des classes BufferedImage et Graphics2d fournies avec le package AWT. Ci-dessous, nous créons une fonction rotateImage() qui reçoit un objet BufferedImage en tant que paramètre et renvoie un objet BufferedImage pivoté.

Dans rotateImage(), on obtient la largeur, la hauteur et le type de l’image en utilisant les méthodes getWidth(), getHeight() et getType(). Maintenant, nous appelons le constructeur BufferedImage() et passons les trois variables en arguments et il renvoie un objet BufferedImage newImageFromBuffer.

Nous créons une nouvelle image pivotée en utilisant la méthode createGraphics() qui renvoie un objet Graphics2D graphics2D. À l’aide de cet objet, nous appelons la fonction rotate() qui prend trois arguments ; le premier est l’angle pour faire pivoter l’image car nous voulons la faire pivoter de 90 degrés, nous passons Math.radians(90), les deuxième et troisième arguments sont les coordonnées x et y.

Enfin, nous appelons graphics2D.drawImage() pour dessiner l’image pivotée, qui prend quatre arguments, l’objet BufferedImage, le filtre à appliquer et les coordonnées x et y. Puis nous retournons l’objet newImageFromBuffer.

Dans la fonction main, nous lisons le fichier à l’aide de File puis le convertissons en un objet BufferedImage à l’aide de ImageIO.read(). Maintenant, nous appelons la fonction rotateImage() et passons l’objet BufferedImage renvoyé et stockons l’objet BufferedImage pivoté. Maintenant que nous avons l’image pivotée, nous devons créer un nouveau fichier pour le stocker en utilisant File et ImageIO.write() qui prend l’objet BufferedImage, son extension l’emplacement du fichier vide.

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

Production:

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

Image originale:

Image pivotée :

Faire pivoter une image en Java à l’aide de la transformation affine

Cet exemple utilise la classe AffineTransform qui mappe une image de ses coordonnées 2D d’origine à d’autres coordonnées 2D de manière linéaire sans perdre la qualité d’origine. Dans le programme suivant, nous avons trois méthodes, une pour lire et appeler d’autres fonctions, la seconde consiste à faire pivoter l’image dans le sens des aiguilles d’une montre et la dernière fonction fait pivoter l’image dans le sens inverse des aiguilles d’une montre.

Dans la fonction rotateImage(), nous lisons l’image en utilisant new File() et la convertissons en un objet BufferedImage en utilisant ImageIO.read(). Ensuite, nous créons un autre objet BufferedImage qui préserve les propriétés de l’image d’origine et l’appelons output. Ensuite, nous appelons la méthode rotateImageClockWise() et passons l’original BufferedImage qui renvoie un objet de la classe AffineTransorm.

rotateImageClockWise() reçoit l’image et obtient la hauteur et la largeur. Nous créons un objet AffineTransform affineTransform et appelons la méthode rotate() en l’utilisant. Dans rotate(), nous passons trois arguments ; le premier est l’angle de rotation mesuré en radians, ici nous passons Math.PI / 2, les deux derniers arguments sont les coordonnées x et y qui sont la moitié de la largeur et de la hauteur de l’image.

Maintenant, lorsque l’image est tournée, nous traduisons l’image dans les nouvelles coordonnées en utilisant la fonction translate() qui prend deux arguments : la distance à faire pivoter dans la direction x et la distance à faire pivoter dans la direction y. Nous calculons les arguments x et y en utilisant (imageWidth - imageHeight) / 2.

Pour faire pivoter l’image dans le sens inverse des aiguilles d’une montre, nous pouvons appeler la méthode rotateImageCounterClockwise() dans rotate() au lieu 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();
    }
  }
}

Production:

Image originale:

Image tournée dans le sens des aiguilles d’une montre :

Image tournée dans le sens inverse des aiguilles d’une montre :