Trabajo con imágenes en Kotlin: bibliotecas y ejemplos de…

Trabajo con imágenes en Kotlin: resumen de bibliotecas y ejemplos prácticos

Kotlin es un lenguaje de programación moderno que funciona sobre la JVM. Gracias a su total compatibilidad con Java, para el procesamiento de imágenes se pueden utilizar todas las bibliotecas estándar de Java, como javax.imageio, java.awt y javax.swing. En este artículo veremos los enfoques principales para trabajar con imágenes en Kotlin: lectura, escritura, cambio de tamaño, aplicación de filtros y conversión de formatos.

Bibliotecas necesarias

Para trabajar con imágenes en Kotlin (JVM) no es necesario instalar dependencias adicionales — basta con la biblioteca estándar del JDK. Sin embargo, para tareas más complejas (por ejemplo, procesamiento de imágenes grandes o trabajo con metadatos) pueden ser necesarias bibliotecas de terceros:

java.awt.image.BufferedImage — clase principal para representar una imagen en memoria.
javax.imageio.ImageIO — lectura y escritura de imágenes en varios formatos (PNG, JPEG, BMP, GIF).
java.awt.Graphics2D — dibujo y transformaciones.
Thumbnailator (opcional) — simplifica el cambio de tamaño y la creación de miniaturas.
BoofCV (opcional) — biblioteca de visión artificial con soporte para Kotlin.

Lectura y escritura de imágenes

La forma más sencilla de cargar una imagen es usar ImageIO.read().

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

fun main() {    // Lectura de la imagen    val inputFile = File("input.jpg")    val image: BufferedImage = ImageIO.read(inputFile) ?: throw Exception("No se pudo cargar la imagen")

    // Escritura en otro formato    val outputFile = File("output.png")    ImageIO.write(image, "png", outputFile)

    println("Imagen guardada: ${outputFile.absolutePath}")}

Cambio de tamaño de imagen

Para cambiar el tamaño usamos Graphics2D con parámetros de suavizado.

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

    // Activamos el suavizado para un escalado de calidad    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("Imagen redimensionada: $outputPath")}

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

Aplicación de filtros (desenfoque, contraste)

Para efectos simples se puede usar BufferedImageOp (por ejemplo, ConvolveOp para desenfoque).

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))

    // Núcleo de desenfoque 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")}