Comment faire pivoter les images JPEG en fonction des métadonnées d'orientation?

La bibliothèqueThumbnailator honore les indicateurs d'orientation EXIF. Pour lire une image en taille réelle avec une orientation correcte:

BufferedImage image = Thumbnails.of(inputStream).scale(1).asBufferedImage();

Cela peut être fait étonnamment facilement en utilisant la partie image de la bibliothèque JavaXT core :

// Browsers today can't handle images with Exif Orientation tag
Image image = new Image(uploadedFilename);
// Auto-rotate based on Exif Orientation tag, and remove all Exif tags
image.rotate(); 
image.saveAs(permanentFilename);

C'est ça!

J'ai essayé Apache Commons Imaging, mais c'était un gâchis. JavaXT est beaucoup plus élégant.

Exif semble être difficile à écrire à cause de choses propriétaires en elle. Cependant, vous pouvez envisager une autre option

Lire l'original mais seulement écrire la balise d'orientation pour les vignettes.

Apache Sanselan semble avoir une belle collection d'outils pour le faire.

Http://commons.apache.org/proper/commons-imaging/

Regardez la classe ExifRewriter, par exemple.

Si vous voulez juste qu'il ait l'air juste. Vous pouvez simplement ajouter une" rotation " - PI / 2 (-90 degrés), PI/2 (90 degrés) ou PI (+180 degrés) selon l'orientation que vous avez déjà extraite. Le navigateur ou tout autre programme affichera correctement l'image car l'orientation aura été appliquée et les métadonnées supprimées de la sortie de la vignette.

Sur la base des réponses D'Antoine Martin, j'ai créé une propre classe pour corriger l'orientation d'une image jpeg donnée (dans mon cas en tant que flux d'entrée) en fonction des informations exif de l'image. Avec sa solution, j'ai eu le problème, que les couleurs de l'image résultante étaient fausses, donc j'ai créé celui-ci. Pour récupérer les métadonnées de l'image, j'ai utilisé le métadonnées-extracteur bibliothèque.

J'espère que cela aidera certaines personnes.

public class ImageOrientationUtil {

/**
 * Checks the orientation of the image and corrects it if necessary.
 * <p>If the orientation of the image does not need to be corrected, no operation will be performed.</p>
 * @param inputStream
 * @return
 * @throws ImageProcessingException
 * @throws IOException
 * @throws MetadataException
 */
public static BufferedImage correctOrientation(InputStream inputStream) throws ImageProcessingException, IOException, MetadataException {
    Metadata metadata = ImageMetadataReader.readMetadata(inputStream);
    if(metadata != null) {
        if(metadata.containsDirectoryOfType(ExifIFD0Directory.class)) {
            // Get the current orientation of the image
            Directory directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
            int orientation = directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);

            // Create a buffered image from the input stream
            BufferedImage bimg = ImageIO.read(inputStream);


            // Get the current width and height of the image
            int[] imageSize = {bimg.getWidth(), bimg.getHeight()};
            int width = imageSize[0];
            int height = imageSize[1];

            // Determine which correction is needed
            AffineTransform t = new AffineTransform();
            switch(orientation) {
            case 1:
                // no correction necessary skip and return the image
                return bimg;
            case 2: // Flip X
                t.scale(-1.0, 1.0);
                t.translate(-width, 0);
                return transform(bimg, t);
            case 3: // PI rotation 
                t.translate(width, height);
                t.rotate(Math.PI);
                return transform(bimg, t);
            case 4: // Flip Y
                t.scale(1.0, -1.0);
                t.translate(0, -height);
                return transform(bimg, t);
            case 5: // - PI/2 and Flip X
                t.rotate(-Math.PI / 2);
                t.scale(-1.0, 1.0);
                return transform(bimg, t);
            case 6: // -PI/2 and -width
                t.translate(height, 0);
                t.rotate(Math.PI / 2);
                return transform(bimg, t);
            case 7: // PI/2 and Flip
                t.scale(-1.0, 1.0);
                t.translate(height, 0);
                t.translate(0, width);
                t.rotate(  3 * Math.PI / 2);
                return transform(bimg, t);
            case 8: // PI / 2
                t.translate(0, width);
                t.rotate(  3 * Math.PI / 2);
                return transform(bimg, t);
            }
        }
    }

    return null;
}

/**
 * Performs the tranformation
 * @param bimage
 * @param transform
 * @return
 * @throws IOException
 */
private static BufferedImage transform(BufferedImage bimage, AffineTransform transform) throws IOException {
    // Create an transformation operation
    AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BICUBIC);

    // Create an instance of the resulting image, with the same width, height and image type than the referenced one
    BufferedImage destinationImage = new BufferedImage( bimage.getWidth(), bimage.getHeight(), bimage.getType() );
    op.filter(bimage, destinationImage);

   return destinationImage;
}
}

Comme dnault mentionné dans le commentaire précédent, Thumbnaliator bibliothèque résout le problème. Mais vous devez utiliser des formats d'entrée/sortie corrects pour éviter le changement de couleur lors de cette rotation automatique.

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ByteArrayInputStream in = new ByteArrayInputStream(file.getContents());
Thumbnails.of(in)
    .scale(1)
    .toOutputStream(baos);
byte[] bytes = baos.toByteArray();