Rust图像尺寸处理库imsz的使用：高效解析、调整和优化图片尺寸

imsz是一个高效的Rust库，专门用于处理图像尺寸相关的操作，包括解析图像尺寸信息、调整大小和优化图片尺寸。

主要功能

1. 快速解析图像尺寸而不加载完整图像
2. 高效调整图像尺寸
3. 优化图像尺寸以适应不同需求

安装方法

在Cargo.toml中添加依赖：

[dependencies]
imsz = "0.3"

基本使用方法

1. 解析图像尺寸

use imsz::ImageSize;

fn main() {
    let data = std::fs::read("example.jpg").unwrap();
    let size = imsz::get_size(&data).unwrap();
    
    println!("Image dimensions: {}x{}", size.width, size.height);
}

2. 调整图像尺寸

use imsz::{resize, FilterType};

fn main() {
    let input_data = std::fs::read("input.jpg").unwrap();
    
    // 调整到指定宽高
    let output_data = resize(
        &input_data,
        800,  // 新宽度
        600,  // 新高度
        FilterType::Lanczos3
    ).unwrap();
    
    std::fs::write("output.jpg", output_data).unwrap();
}

3. 保持宽高比调整尺寸

use imsz::{resize_keep_aspect, FilterType};

fn main() {
    let input_data = std::fs::read("input.jpg").unwrap();
    
    // 调整到最大宽度或高度为800，保持原始宽高比
    let output_data = resize_keep_aspect(
        &input_data,
        800,  // 最大尺寸
        true, // 基于宽度(true)还是高度(false)
        FilterType::CatmullRom
    ).unwrap();
    
    std::fs::write("output_proportional.jpg", output_data).unwrap();
}

高级功能

批量处理图片

use imsz::{resize, FilterType};
use std::path::Path;

fn process_directory(input_dir: &Path, output_dir: &Path, target_width: u32, target_height: u32) {
    for entry in std::fs::read_dir(input_dir).unwrap() {
        let entry = entry.unwrap();
        let path = entry.path();
        
        if path.is_file() {
            let data = std::fs::read(&path).unwrap();
            if let Ok(resized) = resize(&data, target_width, target_height, FilterType::Lanczos3) {
                let output_path = output_dir.join(path.file_name().unwrap());
                std::fs::write(output_path, resized).unwrap();
            }
        }
    }
}

性能优化示例

use imsz::{resize_with_config, FilterType, ResizeConfig};

fn optimize_for_web(input: &[u8]) -> Vec<u8> {
    let config = ResizeConfig {
        width: 1200,
        height: 800,
        filter: FilterType::Lanczos3,
        maintain_aspect: true,
        optimize: true,
        quality: 80,
    };
    
    resize_with_config(input, &config).unwrap()
}

支持的图像格式

imsz支持多种常见图像格式：

• JPEG
• PNG
• GIF
• BMP
• WebP
• TIFF

性能提示

1. 对于批量处理，考虑使用多线程
2. 选择合适的FilterType平衡速度和质量
3. 对于超大图像，考虑分块处理

错误处理

use imsz::{get_size, ImageSizeError};

fn safe_get_size(data: &[u8]) -> Result<(u32, u32), ImageSizeError> {
    match get_size(data) {
        Ok(size) => Ok((size.width, size.height)),
        Err(e) => {
            eprintln!("Failed to get image size: {}", e);
            Err(e)
        }
    }
}

完整示例代码

下面是一个结合了多个功能的完整示例，展示如何批量处理图像并生成缩略图：

use imsz::{resize_keep_aspect, FilterType, ImageSize, get_size};
use std::path::Path;
use std::sync::mpsc;
use std::thread;

// 定义缩略图配置
struct ThumbnailConfig {
    max_size: u32,
    quality: u8,
    filter: FilterType,
}

// 处理单个图像的线程函数
fn process_image(path: &Path, output_dir: &Path, config: &ThumbnailConfig) -> anyhow::Result<()> {
    // 读取原始图像数据
    let data = std::fs::read(path)?;
    
    // 获取原始尺寸
    let size = get_size(&data)?;
    println!("Processing {} ({}x{})", path.display(), size.width, size.height);
    
    // 生成缩略图
    let thumbnail = resize_keep_aspect(
        &data,
        config.max_size,
        true, // 基于宽度
        config.filter
    )?;
    
    // 保存缩略图
    let output_path = output_dir.join(path.file_name().unwrap());
    std::fs::write(output_path, thumbnail)?;
    
    Ok(())
}

fn main() -> anyhow::Result<()> {
    let input_dir = Path::new("images");
    let output_dir = Path::new("thumbnails");
    
    // 创建输出目录
    std::fs::create_dir_all(output_dir)?;
    
    // 配置缩略图参数
    let config = ThumbnailConfig {
        max_size: 300,
        quality: 85,
        filter: FilterType::Lanczos3,
    };
    
    // 使用多线程处理图像
    let (tx, rx) = mpsc::channel();
    let mut handles = vec![];
    
    for entry in std::fs::read_dir(input_dir)? {
        let entry = entry?;
        let path = entry.path();
        
        if path.is_file() {
            let tx = tx.clone();
            let output_dir = output_dir.to_path_buf();
            let config = config;
            
            let handle = thread::spawn(move || {
                let result = process_image(&path, &output_dir, &config);
                tx.send(result).unwrap();
            });
            
            handles.push(handle);
        }
    }
    
    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }
    
    // 检查处理结果
    for result in rx.try_iter() {
        result?;
    }
    
    println!("所有图像处理完成！");
    Ok(())
}

这个完整示例展示了：

1. 多线程批量处理图像
2. 保持宽高比生成缩略图
3. 完整的错误处理
4. 进度反馈

imsz库提供了简单而强大的API来处理各种图像尺寸相关的任务，是Rust生态中处理图像尺寸的优秀选择。