Optimizar el procesamiento paralelo de imágenes en Rust con Rayon

Tim Koschützki

Cofundador · Berlín, Alemania · Mostrar bio

Procesar imágenes, por ejemplo convertir formatos y cambiar dimensiones, es una tarea común en muchas aplicaciones. Rust, con sus garantías de rendimiento y seguridad, es una excelente opción para crear herramientas eficientes de procesamiento de imágenes. En esta guía exploraremos cómo usar Rust y bibliotecas de código abierto para convertir y redimensionar imágenes.

Introducción al procesamiento de imágenes en Rust

El potente ecosistema y el rendimiento de Rust lo hacen ideal para gestionar tareas de procesamiento de imágenes. Al aprovechar bibliotecas de código abierto, puedes crear aplicaciones de procesamiento de imágenes que son eficientes y confiables a la vez.

Configuración de tu entorno de Rust

Instala Rust con rustup⁠:

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

Verifica la instalación:

rustup --version
cargo --version

Crea un proyecto nuevo:

cargo new image_processor
cd image_processor

Uso de bibliotecas de código abierto para el procesamiento de imágenes

Usaremos el crate image, una biblioteca de código abierto muy popular en Rust para tareas de procesamiento de imágenes. Añade las siguientes dependencias a tu Cargo.toml:

[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"

Conversión de imágenes: guía paso a paso

Para convertir imágenes entre formatos (por ejemplo, de PNG a JPEG), usa el crate image de la siguiente manera:

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

Uso:

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

Redimensionamiento de imágenes: ejemplos prácticos

El método resize conserva la relación de aspecto y ajusta la imagen dentro del cuadro delimitador indicado. El resultado no tiene por qué cumplir exactamente las dos dimensiones solicitadas:

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

Uso:

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

Pautas de rendimiento

Para lograr un rendimiento óptimo al procesar imágenes:

• Usa FilterType::Lanczos3 para el redimensionamiento de mayor calidad.
• Usa FilterType::Triangle para un redimensionamiento más rápido y de menor calidad.
• Mide el paralelismo por lotes con imágenes representativas; la sobrecarga de los hilos puede superar el ahorro.
• Limita las dimensiones de las imágenes decodificadas y el trabajo concurrente según el presupuesto de memoria de tu aplicación.

Procesamiento paralelo con Rayon

Para procesar varias imágenes por lotes de forma eficiente, aprovecha Rayon para paralelizar el trabajo:

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

Ejemplo de uso para el procesamiento por lotes:

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

Ventajas de usar Rust para el procesamiento de imágenes

Rust ofrece varias ventajas para las tareas de procesamiento de imágenes:

• Rendimiento: Rust ofrece un rendimiento comparable al de C/C++, lo que lo hace ideal para tareas de cómputo intensivo.
• Seguridad: el modelo de propiedad de Rust evita errores comunes como el desreferenciado de punteros nulos y las condiciones de carrera de datos.
• Concurrencia: Rust simplifica la escritura de código concurrente, lo que permite un procesamiento multihilo eficiente.
• Ecosistema: la disponibilidad de crates como image agiliza las tareas de procesamiento de imágenes.

Para soluciones de procesamiento de imágenes escalables y basadas en la nube, considera usar la API de procesamiento de imágenes de Transloadit.