Rust में इमेज प्रोसेसिंग: image, fast_image_resize और अन्य लाइब्रेरीज़ की गाइड

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

Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जो हाई परफॉर्मेंस और विश्वसनीयता वाले क्षेत्रों में तेज़ी से लोकप्रिय हो रही है। इमेज प्रोसेसिंग भी इसका अपवाद नहीं है: Rust की इकोसिस्टम में इमेज को लोड करने, एडिट करने, कन्वर्ट करने और एनालाइज़ करने के लिए कई परिपक्व लाइब्रेरीज़ मौजूद हैं। इस आर्टिकल में हम मुख्य टूल्स: image, fast_image_resize और photon-rs पर चर्चा करेंगे, साथ ही सामान्य कार्यों के लिए कोड उदाहरण भी देंगे।

मुख्य लाइब्रेरी: image

क्रेट image (वर्जन 0.25.x) Rust में इमेज प्रोसेसिंग का डी-फैक्टो स्टैंडर्ड है। यह कई फॉर्मेट्स को पढ़ने और लिखने का सपोर्ट करता है: PNG, JPEG, BMP, GIF, TIFF, WebP और अन्य। यह लाइब्रेरी इमेज को रिप्रेजेंट करने के लिए सुविधाजनक डेटा स्ट्रक्चर (DynamicImage, RgbImage, GrayImage) और कई ऑपरेशन्स प्रदान करती है: रीसाइज़, क्रॉप, रोटेट, फिल्टर, कलर स्पेस ट्रांसफॉर्मेशन।

रीसाइज़ के साथ इमेज लोड और सेव करने का उदाहरण:

use image::{DynamicImage, GenericImageView, imageops::FilterType};

fn resize_image(input_path: &str, output_path: &str, new_width: u32, new_height: u32) {
    let img = image::open(input_path).expect("इमेज खोलने में विफल");
    let resized = img.resize_exact(new_width, new_height, FilterType::Lanczos3);
    resized.save(output_path).expect("इमेज सेव करने में विफल");
    println!("इमेज रीसाइज़ होकर {} में सेव हो गई", output_path);
}

fn main() {
    resize_image("input.jpg", "output.png", 800, 600);
}

image लाइब्रेरी सीधे पिक्सल के साथ काम करने की भी सुविधा देती है। उदाहरण के लिए, हर पिक्सल तक पहुँचकर उसका रंग बदला जा सकता है:

use image::{GenericImage, Rgba};

fn invert_colors(path: &str) {
    let mut img = image::open(path).expect("खोलने में त्रुटि");
    for (x, y, pixel) in img.enumerate_pixels_mut() {
        let inverted = Rgba([
            255 - pixel[0],
            255 - pixel[1],
            255 - pixel[2],
            pixel[3],
        ]);
        img.put_pixel(x, y, inverted);
    }
    img.save("inverted.png").unwrap();
}

हाई-परफॉर्मेंस रीसाइज़िंग: fast_image_resize

अगर आपको बार-बार इमेज का साइज़ बदलना है और अधिकतम स्पीड चाहिए, तो fast_image_resize क्रेट पर ध्यान दें। यह SIMD इंस्ट्रक्शन्स (SSE, AVX2, NEON) और ऑप्टिमाइज़्ड एल्गोरिदम (Lanczos, Catmull-Rom, Mitchell) का उपयोग करता है। यह लाइब्रेरी सीधे रॉ पिक्सल ऐरे के साथ काम करती है, जिससे ओवरहेड कम होता है।

fast_image_resize का उपयोग करने का उदाहरण:

use fast_image_resize as fr;
use image::GenericImageView;

fn resize_fast(input_path: &str, output_path: &str, new_width: u32, new_height: u32) {
    // image के ज़रिए इमेज लोड करें
    let img = image::open(input_path).expect("खोलने में त्रुटि");
    let (width, height) = img.dimensions();
    let rgba = img.to_rgba8();

    // fast_image_resize के लिए व्यू बनाएँ
    let src_view = fr::ImageView::new(&rgba, width, height, fr::PixelType::U8x4);
    let mut dst_image = fr::Image::new(new_width, new_height, fr::PixelType::U8x4);
    let mut dst_view = dst_image.view_mut();

    // रीसाइज़र सेट करें
    let mut resizer = fr::Resizer::new(fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3));
    resizer.resize(&src_view, &mut dst_view).expect("रीसाइज़ में त्रुटि");

    // image के ज़रिए रिज़ल्ट सेव करें
    let result_img = image::RgbaImage::from_raw(new_width, new_height, dst_image.into_vec()).unwrap();
    result_img.save(output_path).unwrap();
}

टेस्ट के अनुसार, fast_image_resize मानक image रीसाइज़ से 2-5 गुना तेज़ हो सकता है, खासकर बड़ी इमेज के लिए।