Kotlin में इमेज प्रोसेसिंग: लाइब्रेरी, टूल्स और उदाहरण

Kotlin में इमेज प्रोसेसिंग: लाइब्रेरी और व्यावहारिक उदाहरण

Kotlin एक आधुनिक प्रोग्रामिंग भाषा है जो JVM पर काम करती है। Java के साथ पूर्ण संगतता के कारण, इमेज प्रोसेसिंग के लिए आप सभी मानक Java लाइब्रेरी जैसे javax.imageio, java.awt और javax.swing का उपयोग कर सकते हैं। इस लेख में हम Kotlin में इमेज प्रोसेसिंग के मुख्य तरीकों को कवर करेंगे: इमेज पढ़ना, लिखना, साइज़ बदलना, फ़िल्टर लगाना और फ़ॉर्मेट बदलना।

आवश्यक लाइब्रेरी

Kotlin (JVM) में इमेज प्रोसेसिंग के लिए कोई अतिरिक्त डिपेंडेंसी इंस्टॉल करने की ज़रूरत नहीं है - बस मानक JDK लाइब्रेरी काफी है। हालांकि, जटिल कार्यों (जैसे बड़ी इमेज प्रोसेसिंग या मेटाडेटा के साथ काम) के लिए थर्ड-पार्टी लाइब्रेरी की आवश्यकता हो सकती है:

• java.awt.image.BufferedImage — मेमोरी में इमेज को स्टोर करने के लिए मुख्य क्लास।
• javax.imageio.ImageIO — विभिन्न फ़ॉर्मेट (PNG, JPEG, BMP, GIF) में इमेज पढ़ना और लिखना।
• java.awt.Graphics2D — ड्राइंग और ट्रांसफ़ॉर्मेशन के लिए।
• Thumbnailator (वैकल्पिक) — साइज़ बदलने और थंबनेल बनाने को आसान बनाता है।
• BoofCV (वैकल्पिक) — कंप्यूटर विज़न लाइब्रेरी जो Kotlin को सपोर्ट करती है।

इमेज पढ़ना और लिखना

इमेज लोड करने का सबसे आसान तरीका ImageIO.read() का उपयोग करना है।

import java.awt.image.BufferedImage
import java.io.File
import javax.imageio.ImageIO

fun main() {
    // इमेज पढ़ना
    val inputFile = File("input.jpg")
    val image: BufferedImage = ImageIO.read(inputFile) ?: throw Exception("इमेज लोड नहीं हो सकी")

    // दूसरे फ़ॉर्मेट में सेव करना
    val outputFile = File("output.png")
    ImageIO.write(image, "png", outputFile)

    println("इमेज सेव हो गई: ${outputFile.absolutePath}")
}

इमेज का साइज़ बदलना

साइज़ बदलने के लिए हम स्मूथिंग पैरामीटर्स के साथ Graphics2D का उपयोग करेंगे।

import java.awt.Graphics2D
import java.awt.RenderingHints
import java.awt.image.BufferedImage
import javax.imageio.ImageIO
import 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()

    // क्वालिटी स्केलिंग के लिए स्मूथिंग ऑन करें
    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("इमेज का साइज़ बदल दिया गया: $outputPath")
}

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

फ़िल्टर लगाना (ब्लर, कंट्रास्ट)

सरल इफ़ेक्ट के लिए BufferedImageOp (जैसे ब्लर के लिए ConvolveOp) का उपयोग करें।

import java.awt.image.BufferedImage
import java.awt.image.ConvolveOp
import java.awt.image.Kernel
import javax.imageio.ImageIO
import java.io.File

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

    // 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")
}

फ़ॉर्मेट कन्वर्ज़न

फ़ॉर्मेट के बीच आसानी से बदलें (जैसे JPEG → PNG) क्वालिटी बनाए रखते हुए।

import java.awt.image.BufferedImage
import javax.imageio.ImageIO
import java.io.File

fun convertFormat(inputPath: String, outputPath: String, format: String) {
    val image: BufferedImage = ImageIO.read(File(inputPath))
    ImageIO.write(image, format, File(outputPath))
    println("फ़ॉर्मेट बदल दिया गया: $outputPath")
}

fun main() {
    convertFormat("input.jpg", "output.png", "png")
}