Trabalho com imagens em Rust: visão geral das bibliotecas image, fast_image_resize e outras

Trabalho com imagens em Rust: visão geral das bibliotecas e exemplos práticos

Rust é uma linguagem de programação de sistemas moderna que está ganhando popularidade em áreas que exigem alto desempenho e confiabilidade. O processamento de imagens não é exceção: o ecossistema Rust oferece várias bibliotecas maduras para carregamento, processamento, conversão e análise de imagens. Neste artigo, veremos as principais ferramentas: image, fast_image_resize e photon-rs, além de fornecer exemplos de código para tarefas típicas.

Biblioteca principal: image

A crate image (versão 0.25.x) é o padrão de facto para trabalhar com imagens em Rust. Ela suporta leitura e gravação de vários formatos: PNG, JPEG, BMP, GIF, TIFF, WebP e outros. A biblioteca fornece estruturas de dados convenientes para representar imagens (DynamicImage, RgbImage, GrayImage) e um amplo conjunto de operações: redimensionamento, corte, rotação, filtros, transformação de espaços de cores.

Exemplo de carregamento e salvamento de imagem com redimensionamento:

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("Não foi possível abrir a imagem");    let resized = img.resize_exact(new_width, new_height, FilterType::Lanczos3);    resized.save(output_path).expect("Não foi possível salvar a imagem");    println!("Imagem redimensionada e salva em {}", output_path);}

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

A biblioteca image também suporta trabalho direto com pixels. Por exemplo, é possível acessar cada pixel e alterar sua cor:

use image::{GenericImage, Rgba};

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

Redimensionamento de alto desempenho: fast_image_resize

Se sua tarefa é redimensionar imagens repetidamente com máxima velocidade, observe a crate fast_image_resize. Ela utiliza instruções SIMD (SSE, AVX2, NEON) e algoritmos otimizados (Lanczos, Catmull-Rom, Mitchell). A biblioteca trabalha diretamente com arrays brutos de pixels, minimizando a sobrecarga.

Exemplo de uso do 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) {    // Carrega a imagem através do image    let img = image::open(input_path).expect("Erro ao abrir");    let (width, height) = img.dimensions();    let rgba = img.to_rgba8();

    // Cria a representação para o 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();

    // Configuração do redimensionador    let mut resizer = fr::Resizer::new(fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3));    resizer.resize(&src_view, &mut dst_view).expect("Erro no redimensionamento");

    // Salva o resultado através do image    let result_img = image::RgbaImage::from_raw(new_width, new_height, dst_image.into_vec()).unwrap();    result_img.save(output_path).unwrap();}

De acordo com testes, o fast_image_resize pode ser 2 a 5 vezes mais rápido que o redimensionamento padrão