Arbeiten mit Bildern in Rust: Überblick über die Bibliotheken image, fast_image_resize und andere

Arbeiten mit Bildern in Rust: Überblick über Bibliotheken und praktische Beispiele

Rust ist eine moderne systemnahe Programmiersprache, die in Bereichen, die hohe Leistung und Zuverlässigkeit erfordern, an Popularität gewinnt. Die Bildverarbeitung bildet hier keine Ausnahme: Das Rust-Ökosystem bietet mehrere ausgereifte Bibliotheken zum Laden, Verarbeiten, Konvertieren und Analysieren von Bildern. In diesem Artikel betrachten wir die wichtigsten Werkzeuge: image, fast_image_resize und photon-rs, und geben Codebeispiele für typische Aufgaben.

Die Hauptbibliothek: image

Die Crate image (Version 0.25.x) ist der De-facto-Standard für die Arbeit mit Bildern in Rust. Sie unterstützt das Lesen und Schreiben vieler Formate: PNG, JPEG, BMP, GIF, TIFF, WebP und andere. Die Bibliothek bietet praktische Datenstrukturen zur Darstellung von Bildern (DynamicImage, RgbImage, GrayImage) und eine breite Palette von Operationen: Größenänderung, Zuschneiden, Drehen, Filter, Farbraumkonvertierung.

Beispiel für das Laden und Speichern eines Bildes mit Größenänderung:

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("Bild konnte nicht geöffnet werden");    let resized = img.resize_exact(new_width, new_height, FilterType::Lanczos3);    resized.save(output_path).expect("Bild konnte nicht gespeichert werden");    println!("Bild geändert und gespeichert unter {}", output_path);}

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

Die Bibliothek image unterstützt auch die direkte Arbeit mit Pixeln. Beispielsweise kann man auf jeden Pixel zugreifen und seine Farbe ändern:

use image::{GenericImage, Rgba};

fn invert_colors(path: &str) {    let mut img = image::open(path).expect("Fehler beim Öffnen");    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();}

Hochleistungsfähige Größenänderung: fast_image_resize

Wenn Ihre Aufgabe das wiederholte Ändern der Bildgröße mit maximaler Geschwindigkeit ist, sollten Sie die Crate fast_image_resize in Betracht ziehen. Sie verwendet SIMD-Instruktionen (SSE, AVX2, NEON) und optimierte Algorithmen (Lanczos, Catmull-Rom, Mitchell). Die Bibliothek arbeitet direkt mit rohen Pixel-Arrays, was den Overhead minimiert.

Beispiel für die Verwendung von 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) {    // Bild über image laden    let img = image::open(input_path).expect("Fehler beim Öffnen");    let (width, height) = img.dimensions();    let rgba = img.to_rgba8();

    // Ansicht für fast_image_resize erstellen    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();

    // Resizer konfigurieren    let mut resizer = fr::Resizer::new(fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3));    resizer.resize(&src_view, &mut dst_view).expect("Fehler beim Resizen");

    // Ergebnis über image speichern    let result_img = image::RgbaImage::from_raw(new_width, new_height, dst_image.into_vec()).unwrap();    result_img.save(output_path).unwrap();}

Laut Tests kann fast_image_resize 2-5 mal schneller sein als das standardmäßige Resizen