[Java / Kotlin] Redimensionner en tenant compte de l'orientation de l'image

Aperçu

--Lorsque vous créez une image avec l'appareil photo de l'iPhone, l'orientation de l'image est enregistrée dans l'orientation EXIF. --EXIF peut être confirmé avec la commande ʻidentify` d'imagemagic.

$ identify -verbose IMG_1046.png | grep Orient
  Orientation: TopLeft

--EXIF doit être pris en compte lors du redimensionnement de l'image.

• J'utilise une bibliothèque car elle est difficile à mettre en œuvre par moi-même.

Bibliothèque à utiliser

• sksamuel/scrimage - Java, Scala and Kotlin image processing library

la mise en oeuvre

build.gradle

dependencies {
    ...
    implementation "com.sksamuel.scrimage:scrimage-core:4.0.4"
    ...
}

ImageResizer.kt

object ImageResizer {
    enum class ImageFormat {
        JPEG,
        PNG;

        companion object {
            fun fromName(formatName: String): ImageFormat? {
                return when (formatName) {
                    "jpg", "jpeg" -> JPEG
                    "png" -> PNG
                    else -> null
                }
            }
        }
    }

    /**
     *Long côté[size]Et redimensionner
     *
     *Le côté long est[size]S'il est plus petit que, ne redimensionnez pas
     */
    fun resize(inputStream: InputStream, size: Int, formatName: String): File {
        //Lire le fichier original
        val original = ImmutableImage.loader().fromStream(inputStream)
        val originalWidth = original.width.toDouble()
        val originalHeight = original.height.toDouble()

        if (originalWidth <= size && originalHeight <= size) {
            //Si le côté long est plus petit que la taille, ne redimensionnez pas
            return createImageTempFile(original, formatName)
        }

        val resizedWidth: Double
        val resizedHeight: Double
        if (originalWidth > originalHeight) {
            resizedWidth = size.toDouble()
            resizedHeight = size * originalHeight / originalWidth
        } else {
            resizedHeight = size.toDouble()
            resizedWidth = size * originalWidth / originalHeight
        }

        val resized = original.fit(resizedWidth.roundToInt(), resizedHeight.roundToInt())
        return createImageTempFile(resized, formatName)
    }

    private fun createImageTempFile(image: ImmutableImage, formatName: String): File {
        val format = ImageFormat.fromName(formatName)
            ?: throw BadRequestException("The image format $formatName is not supported ")
        val outFile = createTempFile(suffix = ".$formatName")
        when (format) {
            ImageFormat.JPEG -> image.output(JpegWriter(), outFile)
            ImageFormat.PNG -> image.output(PngWriter(), outFile)
        }
        return outFile
    }
}

Cela créera une image redimensionnée avec l'orientation correcte (l'orientation EXIF sera perdue de l'image redimensionnée)

Remarques

• Thumbnailator est célèbre comme bibliothèque de création de vignettes Java, mais il ne semble pas prendre en compte l'orientation EXIF.
  • https://github.com/coobird/thumbnailator/issues/108

référence