Processamento de imagens em Rust: redimensionamento e corte com image e imageproc

Processamento de imagens em Rust: redimensionamento e corte

Rust é uma linguagem de programação de sistemas moderna, cada vez mais utilizada para tarefas que exigem alto desempenho e confiabilidade. O processamento de imagens não é exceção. Neste artigo, abordaremos duas operações principais — redimensionamento (resize) e corte (crop) — usando o ecossistema Rust. As principais bibliotecas são: image (carregamento, salvamento, manipulações básicas) e imageproc (processamento avançado).

Por que Rust para trabalhar com imagens?

Rust oferece:

• Gerenciamento seguro de memória — sem vazamentos ou condições de corrida.
• Desempenho máximo — comparável a C/C++.
• Ecossistema rico — o crate image suporta JPEG, PNG, GIF, BMP, WEBP e outros formatos.
• Paralelismo — fácil escalar o processamento em processadores multi-core.

Instalação de dependências

Adicione ao Cargo.toml:

[dependencies]image = "0.25"imageproc = "0.25"  # para filtros avançados (opcional)

Verifique as versões atuais em crates.io.

Carregamento e salvamento de imagem

Vamos começar com um exemplo básico — abrir um arquivo e salvar uma cópia:

use image::{GenericImageView, ImageFormat};

fn main() -> Result<(), Box<dyn std::error::Error>> {    // Carregar a imagem    let img = image::open("input.jpg")?;        // Exibir dimensões    println!("Largura: {}, Altura: {}", img.width(), img.height());        // Salvar em outro formato    img.save("output.png")?;    Ok(())}

O método image::open detecta automaticamente o formato pela extensão ou conteúdo do arquivo.

Redimensionamento (resize)

A função resize recebe nova largura e altura, além de um filtro de interpolação. Filtros disponíveis: Nearest, Triangle, CatmullRom, Gaussian, Lanczos3 e outros.

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

fn resize_image(path: &str, new_width: u32, new_height: u32) -> Result<(), Box<dyn std::error::Error>> {    let img = image::open(path)?;        // Redimensionar com filtro Lanczos3 (alta qualidade)    let resized = img.resize(new_width, new_height, FilterType::Lanczos3);        // Salvar o resultado    resized.save("resized.jpg")?;    println!("Tamanho alterado: {}x{} → {}x{}", img.width(), img.height(), new_width, new_height);    Ok(())}

Dica: Para processamento rápido, use FilterType::Nearest (sem interpolação); para máxima qualidade, use Lanczos3.

Redimensionamento proporcional

Para manter a proporção, use resize_to_fill (preenche a área) ou resize_to_fit (encaixa no retângulo):

use image::imageops::FilterType;

fn resize_proportional(path: &str, max_width: u32, max_height: u32) -> Result<(), Box<dyn std::error::Error>> {    let img = image::open(path)?;        // Encaixar no retângulo (mantendo proporções)    let fitted = img.resize_to_fit(max_width, max_height, FilterType::Triangle);    fitted.save("fitted.jpg")?;        // Preencher a área (cortará o excesso)    let filled = img.resize_to_fill(max_width, max_height, FilterType::Triangle);    filled.save("filled.jpg")?;        Ok(())}

Corte de imagem (crop)

O corte é feito através do método crop, que recebe as coordenadas do canto superior esquerdo (x, y) e as dimensões da área:

use image::Gener