bmp格式图片-Rust图像处理：image库自动裁剪加水印，摄影师的效率利器！

摄影师的日常工作除了拍照，还有大量的后期处理。想象一下，一场婚礼拍了上千张照片，每张都要裁剪、调整、加水印......简直是噩梦！手动处理可能需要几天时间，而且极其枯燥。用Rust语言配合image库，你可以几分钟内创建一个自动化工具，批量处理成百上千张图片，解放双手的同时保证一致的处理质量。不必再盯着屏幕一张一张点了！

image库介绍：Rust的图像处理瑞士军刀

image是Rust生态中的图像处理基础库，提供了丰富的功能：读写多种格式图片、调整大小、裁剪、滤镜、色彩调整等等。它速度快、内存安全，完美符合Rust的设计理念。

要用image库，先在Cargo.toml中添加依赖：

[dependencies]
image = "0.24.5"

或者直接用命令添加：

cargo add image

装好就能开始玩了！

基础操作：读取和保存图片

图片处理的第一步是读取图片，这很简单：

use image::GenericImageView;

fn main() -> Result {
    // 读取图片
    let img = image::open("input.jpg")?;
    
    // 获取图片的基本信息
    println!("图片尺寸: {}x{}", img.width(), img.height());
    println!("图片色彩类型: {:?}", img.color());
    
    // 保存为新文件
    img.save("output.jpg")?;
    
    Ok(())
}

这段代码读取了一张图片bmp格式图片，打印出它的尺寸和色彩信息，然后原封不动地保存为新文件。很基础，但也很重要，这是后续所有操作的起点。

温馨提示：image库支持jpg、png、gif、bmp、tiff等多种图片格式bmp格式图片，但要使用特定格式，可能需要开启对应的。比如在Cargo.toml中写image = { = "0.24.5", = ["jpeg", "png", "gif"] }。

智能裁剪：找到最佳构图

一张好照片的关键是构图。如果你有一堆照片需要转换成正方形（比如发帖），又不想简单粗暴地居中裁剪，可以尝试智能裁剪——根据图片内容找到最有价值的区域：

use image::{GenericImageView, DynamicImage};

fn smart_crop(img: &DynamicImage, target_width: u32, target_height: u32) -> DynamicImage {
    let (width, height) = (img.width(), img.height());
    
    // 简单版的智能裁剪：计算图像的能量分布（这里用简化版）
    // 实际应用中可以用更复杂的算法，如Sobel边缘检测
    let mut max_energy = 0.0;
    let mut best_x = 0;
    let mut best_y = 0;
    
    // 在可能的裁剪范围内找能量最高的区域
    for x in 0..=width.saturating_sub(target_width) {
        for y in 0..=height.saturating_sub(target_height) {
            let crop = img.view(x, y, target_width, target_height);
            let energy = calculate_energy(&crop);
            
            if energy > max_energy {
                max_energy = energy;
                best_x = x;
                best_y = y;
            }
        }
    }
    
    // 裁剪出最佳区域
    img.crop_imm(best_x, best_y, target_width, target_height)
}

// 简单计算图像区域的"能量"（边缘复杂度）
fn calculate_energy(view: &image::SubImage) -> f32 {
    let mut energy = 0.0;
    
    for (_x, _y, pixel) in view.pixels() {
        // 简单地将每个像素的RGB值贡献到能量中
        // 真正的算法会计算梯度或边缘检测
        let [r, g, b, _] = pixel.0;
        energy += (r as f32 + g as f32 + b as f32) / 3.0;
    }
    
    energy
}

fn main() -> Result {
    let img = image::open("portrait.jpg")?;
    
    // 创建1:1正方形裁剪
    let size = img.width().min(img.height());
    let cropped = smart_crop(&img, size, size);
    
    cropped.save("square_portrait.jpg")?;
    println!("智能裁剪完成！");
    
    Ok(())
}

这个简化版的智能裁剪算法基于像素值计算"能量"，但实际应用中你可能想用更高级的算法，比如边缘检测或内容识别。不管咋样，这比固定位置裁剪好多了！

批量加水印：品牌保护必备

摄影师都知道，未经授权使用作品是常见问题。加水印是一种简单的保护方法，但手动一张张加太痛苦了。这段代码能批量给图片添加半透明文字水印：

use image::{DynamicImage, GenericImageView, Rgba, ImageBuffer};
use imageproc::drawing::draw_text_mut;
use rusttype::{Font, Scale};
use std::path::Path;
use walkdir::WalkDir;

fn add_watermark(img: &DynamicImage, text: &str) -> DynamicImage {
    let mut img = img.clone();
    
    // 读取字体
    let font_data = include_bytes!("../assets/DejaVuSans.ttf");
    let font = Font::try_from_bytes(font_data as &[u8]).unwrap();
    
    // 设置字体大小（根据图片尺寸调整）
    let height = img.height() as f32;
    let scale = Scale {
        x: height * 0.05,
        y: height * 0.05,
    };
    
    // 半透明白色
    let color = Rgba([255u8, 255u8, 255u8, 128u8]);
    
    // 在右下角绘制水印文字
    let x = img.width() as i32 - 300;
    let y = img.height() as i32 - 80;
    
    draw_text_mut(&mut img, color, x, y, scale, &font, text);
    
    img
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 遍历指定目录下所有jpg图片
    for entry in WalkDir::new("./photos")
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| {
            if let Some(ext) = e.path().extension() {
                return ext == "jpg" || ext == "jpeg";
            }
            false
        })
    {
        let path = entry.path();
        println!("处理图片: {}", path.display());
        
        // 读取图片
        let img = image::open(path)?;
        
        // 添加水印
        let watermarked = add_watermark(&img, "© 2023 我的摄影工作室");
        
        // 构建输出路径
        let out_dir = Path::new("./watermarked");
        std::fs::create_dir_all(out_dir)?;
        
        let file_name = path.file_name().unwrap();
        let out_path = out_dir.join(file_name);
        
        // 保存带水印的图片
        watermarked.save(out_path)?;
    }
    
    println!("所有图片已处理完毕!");
    Ok(())
}

温馨提示：要使用上面的代码，还需要添加这些依赖： = "0.23.0", = "0.9.3", = "2.3.2"。别忘记创建目录并放入字体文件！

这段代码用到了的绘图功能和的字体渲染，能够给大量照片添加统一的水印，还能自动调整水印大小以适应不同尺寸的图片。再也不用担心图片被盗用时没有标识了！

专业照片调整：自动优化曝光和对比度

有时候拍出来的照片曝光不够理想，需要简单调整。这里有个自动调整亮度和对比度的简单例子：

use image::{DynamicImage, GenericImageView, Rgba};

fn auto_adjust(img: &DynamicImage) -> DynamicImage {
    // 将图像转换为RGB格式
    let rgb_img = img.to_rgb8();
    let (width, height) = rgb_img.dimensions();
    
    // 计算图像的平均亮度和对比度
    let mut total_brightness = 0.0;
    let mut pixels = Vec::new();
    
    for pixel in rgb_img.pixels() {
        let brightness = (pixel[0] as f32 + pixel[1] as f32 + pixel[2] as f32) / 3.0;
        total_brightness += brightness;
        pixels.push(brightness);
    }
    
    let avg_brightness = total_brightness / (width * height) as f32;
    let target_brightness = 128.0;  // 中等亮度
    
    // 计算亮度调整因子
    let brightness_factor = target_brightness / avg_brightness;
    
    // 创建新图像并应用调整
    let mut adjusted = DynamicImage::new_rgb8(width, height);
    
    for (x, y, pixel) in img.pixels() {
        let r = (pixel[0] as f32 * brightness_factor).min(255.0) as u8;
        let g = (pixel[1] as f32 * brightness_factor).min(255.0) as u8;
        let b = (pixel[2] as f32 * brightness_factor).min(255.0) as u8;
        
        adjusted.put_pixel(x, y, Rgba([r, g, b, 255]));
    }
    
    adjusted
}

fn main() -> Result {
    let img = image::open("dark_photo.jpg")?;
    let adjusted = auto_adjust(&img);
    adjusted.save("brightened_photo.jpg")?;
    
    println!("照片已优化!");
    Ok(())
}

这是个简化版的自动调整算法，真正专业的程序还会做直方图均衡化、色彩校正等更复杂的处理。这段代码主要是演示思路——把重复的图像处理工作交给程序自动完成。

批处理流水线：一条龙服务

真正强大的图片处理不是单独做某一项任务，而是把多个处理步骤组合成流水线，一次性完成所有工作：

use image::{DynamicImage, GenericImageView};
use std::path::Path;
use rayon::prelude::*;
use walkdir::WalkDir;

// 结合前面介绍的所有功能
fn process_image(
    img: &DynamicImage,
    target_size: Option<(u32, u32)>,
    watermark: Option<&str>,
    auto_enhance: bool
) -> DynamicImage {
    let mut processed = img.clone();
    
    // 步骤1: 如果需要，调整大小或裁剪
    if let Some((width, height)) = target_size {
        processed = smart_crop(&processed, width, height);
    }
    
    // 步骤2: 如果需要，自动增强
    if auto_enhance {
        processed = auto_adjust(&processed);
    }
    
    // 步骤3: 如果需要，添加水印
    if let Some(text) = watermark {
        processed = add_watermark(&processed, text);
    }
    
    processed
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 收集所有需要处理的图片路径
    let image_paths: Vec = WalkDir::new("./input")
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| {
            let path = e.path();
            path.is_file() && matches!(
                path.extension().and_then(|s| s.to_str()),
                Some("jpg" | "jpeg" | "png")
            )
        })
        .map(|e| e.path().to_owned())
        .collect();
    
    println!("找到 {} 张图片需要处理", image_paths.len());
    
    // 创建输出目录
    std::fs::create_dir_all("./output")?;
    
    // 并行处理所有图片
    let results: Vec<Result<(), Box<dyn std::error::Error + Send + Sync>>> = image_paths.par_iter()
        .map(|path| {
            let img = image::open(path)?;
            
            // 设置处理参数 - 在实际应用中可能来自配置文件
            let processed = process_image(
                &img,
                Some((1080, 1080)),  // Instagram尺寸
                Some("© 2023 我的摄影工作室"),
                true
            );
            
            // 保存处理后的图片
            let file_name = path.file_name().unwrap();
            let out_path = Path::new("./output").join(file_name);
            processed.save(&out_path)?;
            
            println!("处理完成: {}", path.display());
            Ok(())
        })
        .collect();
    
    // 检查处理结果
    let success_count = results.iter().filter(|r| r.is_ok()).count();
    let error_count = results.len() - success_count;
    
    println!("批处理完成! 成功: {}, 失败: {}", success_count, error_count);
    
    Ok(())
}