Zuletzt aktualisiert: 11. September

Bildverarbeitung in Rust mit Parallelität und Rayon optimieren

Tim Koschützki

Mitgründer · Berlin, Deutschland ·

Die Verarbeitung von Bildern, etwa das Konvertieren von Formaten und das Ändern von Abmessungen, gehört in vielen Anwendungen zu den alltäglichen Aufgaben. Rust ist mit seinen Performance- und Sicherheitsgarantien eine ausgezeichnete Wahl, um effiziente Werkzeuge für die Bildverarbeitung zu entwickeln. In diesem Leitfaden zeigen wir, wie Sie Bilder mit Rust und Open-Source-Bibliotheken konvertieren und in der Größe ändern.

Einführung in die Bildverarbeitung in Rust

Das leistungsfähige Ökosystem und die Performance von Rust machen die Sprache ideal für Aufgaben der Bildverarbeitung. Mit Open-Source-Bibliotheken erstellen Sie Anwendungen zur Bildverarbeitung, die zugleich effizient und zuverlässig sind.

Ihre Rust-Umgebung einrichten

Installieren Sie Rust mit rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Überprüfen Sie die Installation:

rustup --version
cargo --version

Erstellen Sie ein neues Projekt:

cargo new image_processor
cd image_processor

Open-Source-Bibliotheken für die Bildverarbeitung nutzen

Wir verwenden das Crate image, eine beliebte Open-Source-Bibliothek in Rust für Aufgaben der Bildverarbeitung. Fügen Sie die folgenden Abhängigkeiten in Ihrer Datei Cargo.toml hinzu:

[dependencies]
image = "0.24.8"
anyhow = "1.0.79"
rayon = "1.8.0"
thiserror = "1.0.56"
log = "0.4.20"
env_logger = "0.10.1"

Bilder konvertieren: Schritt-für-Schritt-Anleitung

Um Bilder zwischen Formaten zu konvertieren (zum Beispiel von PNG zu JPEG), verwenden Sie das Crate image wie folgt:

use anyhow::{Context, Result};
use image::ImageFormat;
use std::path::Path;

fn convert_image(input_path: &Path, output_path: &Path, output_format: ImageFormat) -> Result<()> {
    let img = image::open(input_path)
        .with_context(|| format!("Failed to open image: {}", input_path.display()))?;
    img.save_with_format(output_path, output_format)
        .with_context(|| format!("Failed to save image: {}", output_path.display()))?;
    Ok(())
}

Verwendung:

use std::path::Path;
use anyhow::Result;
use image::ImageFormat;

fn main() -> Result<()> {
    let input_path = Path::new("input.png");
    let output_path = Path::new("output.jpg");
    convert_image(input_path, output_path, ImageFormat::Jpeg)?;
    Ok(())
}

Größenänderung von Bildern: praktische Beispiele

Die Methode resize behält das Seitenverhältnis bei und passt das Bild in den angegebenen Rahmen ein. Das Ergebnis muss nicht exakt beide angeforderten Abmessungen aufweisen:

use image::imageops::FilterType;
use anyhow::Result;
use std::path::Path;

fn resize_image(input_path: &Path, output_path: &Path, new_width: u32, new_height: u32) -> Result<()> {
    let img = image::open(input_path)?;
    let resized = img.resize(new_width, new_height, FilterType::Lanczos3);
    resized.save(output_path)?;
    Ok(())
}

Verwendung:

use std::path::Path;
use anyhow::Result;

fn main() -> Result<()> {
    let input_path = Path::new("input.jpg");
    let output_path = Path::new("resized.jpg");
    resize_image(input_path, output_path, 800, 600)?;
    Ok(())
}

Richtlinien zur Performance

So erzielen Sie bei der Bildverarbeitung optimale Performance:

Verwenden Sie FilterType::Lanczos3 für Größenänderungen in höchster Qualität.
Verwenden Sie FilterType::Triangle für schnellere Größenänderungen mit geringerer Qualität.
Messen Sie die Parallelität von Batches mit repräsentativen Bildern; der Overhead durch Threads kann die Einsparungen übersteigen.
Begrenzen Sie die Abmessungen decodierter Bilder und die parallele Arbeitslast entsprechend dem Speicherbudget Ihrer Anwendung.

Parallele Verarbeitung mit Rayon

Um mehrere Bilder effizient im Batch zu verarbeiten, nutzen Sie Rayon, um die Arbeit zu parallelisieren:

use rayon::prelude::*;
use anyhow::Result;
use std::path::Path;

fn process_directory(input_dir: &Path, output_dir: &Path) -> Result<()> {
    std::fs::create_dir_all(output_dir)?;

    let entries: Vec<_> = std::fs::read_dir(input_dir)?
        .filter_map(Result::ok)
        .filter(|entry| {
            entry.path().extension()
                .map(|ext| ext.eq_ignore_ascii_case("jpg") || ext.eq_ignore_ascii_case("png"))
                .unwrap_or(false)
        })
        .collect();

    entries.par_iter()
        .try_for_each(|entry| {
            let input_path = entry.path();
            let output_path = output_dir.join(entry.file_name());
            resize_image(&input_path, &output_path, 800, 600)
        })?;

    Ok(())
}

Anwendungsbeispiel für die Batch-Verarbeitung:

use anyhow::Result;
use std::path::Path;

fn main() -> Result<()> {
    env_logger::init();

    let input_dir = Path::new("input_images");
    let output_dir = Path::new("processed_images");

    process_directory(input_dir, output_dir)?;
    Ok(())
}

Vorteile von Rust für die Bildverarbeitung

Rust bietet mehrere Vorteile für Aufgaben der Bildverarbeitung:

Performance: Rust bietet eine Performance, die mit C/C++ vergleichbar ist, und eignet sich damit ideal für rechenintensive Aufgaben.
Sicherheit: Das Ownership-Modell von Rust verhindert häufige Fehler wie das Dereferenzieren von Null-Zeigern und Data Races.
Nebenläufigkeit: Rust vereinfacht das Schreiben nebenläufigen Codes und ermöglicht so eine effiziente Verarbeitung mit mehreren Threads.
Ökosystem: Die Verfügbarkeit von Crates wie image vereinfacht Aufgaben der Bildverarbeitung.

Für skalierbare und cloudbasierte Lösungen zur Bildverarbeitung sollten Sie die API zur Bildverarbeitung von Transloadit in Betracht ziehen.