Traitement des images en Kotlin : bibliothèques et…

Traitement des images en Kotlin : aperçu des bibliothèques et exemples pratiques

Kotlin est un langage de programmation moderne fonctionnant sur la JVM. Grâce à sa compatibilité totale avec Java, toutes les bibliothèques Java standard peuvent être utilisées pour le traitement d'images, telles que javax.imageio, java.awt et javax.swing. Dans cet article, nous examinerons les approches principales pour travailler avec des images en Kotlin : lecture, écriture, redimensionnement, application de filtres et conversion de formats.

Bibliothèques nécessaires

Pour travailler avec des images en Kotlin (JVM), il n'est pas nécessaire d'installer des dépendances supplémentaires — la bibliothèque standard du JDK suffit. Cependant, pour des tâches plus complexes (par exemple, le traitement de grandes images ou le travail avec des métadonnées), des bibliothèques tierces peuvent être nécessaires :

java.awt.image.BufferedImage — classe principale pour représenter une image en mémoire.
javax.imageio.ImageIO — lecture et écriture d'images dans différents formats (PNG, JPEG, BMP, GIF).
java.awt.Graphics2D — dessin et transformations.
Thumbnailator (optionnel) — simplifie le redimensionnement et la création de miniatures.
BoofCV (optionnel) — bibliothèque de vision par ordinateur avec support de Kotlin.

Lecture et écriture d'images

La façon la plus simple de charger une image est d'utiliser ImageIO.read().

import java.awt.image.BufferedImageimport java.io.Fileimport javax.imageio.ImageIO

fun main() {    // Lecture de l'image    val inputFile = File("input.jpg")    val image: BufferedImage = ImageIO.read(inputFile) ?: throw Exception("Impossible de charger l'image")

    // Écriture dans un autre format    val outputFile = File("output.png")    ImageIO.write(image, "png", outputFile)

    println("Image enregistrée : ${outputFile.absolutePath}")}

Redimensionnement d'image

Pour redimensionner, nous utilisons Graphics2D avec des paramètres d'anticrénelage.

import java.awt.Graphics2Dimport java.awt.RenderingHintsimport java.awt.image.BufferedImageimport javax.imageio.ImageIOimport java.io.File

fun resizeImage(inputPath: String, outputPath: String, targetWidth: Int, targetHeight: Int) {    val original: BufferedImage = ImageIO.read(File(inputPath))    val resized = BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB)    val g2d: Graphics2D = resized.createGraphics()

    // Activation de l'anticrénelage pour un redimensionnement de qualité    g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR)    g2d.drawImage(original, 0, 0, targetWidth, targetHeight, null)    g2d.dispose()

    ImageIO.write(resized, "jpg", File(outputPath))    println("Image redimensionnée : $outputPath")}

fun main() {    resizeImage("input.jpg", "resized.jpg", 800, 600)}

Application de filtres (flou, contraste)

Pour des effets simples, on peut utiliser BufferedImageOp (par exemple, ConvolveOp pour le flou).

import java.awt.image.BufferedImageimport java.awt.image.ConvolveOpimport java.awt.image.Kernelimport javax.imageio.ImageIOimport java.io.File

fun applyBlur(inputPath: String, outputPath: String) {    val image: BufferedImage = ImageIO.read(File(inputPath))

    // Noyau de flou 5x5    val size = 5    val weight = 1.0f / (size * size)    val kernelData = FloatArray(size * size) { weight }    val kernel = Kernel(size, size, kernelData)    val blurOp = ConvolveOp(kernel)

    val blurred = blurOp.filter(image, null)    ImageIO.write(blurred, "jpg", File(outputPath))}

fun main() {    applyBlur("input.jpg", "blurred.jpg")}