Python实现批量裁剪图片白边的完整代码

# 创建一个名为`image-trim`的新环境，并指定python版本（比如3.9）
conda create -n image-trim python=3.9
# 激活该环境
conda activate image-trim

# 在你的项目目录下
python -m venv venv
# 激活环境
# windows:
venv\scripts\activate
# macos/linux:
source venv/bin/activate

pip install pillow

pip install pillow -i https://pypi.tuna.tsinghua.edu.cn/simple

from pil import image
print(image.__version__)

from pil import image

def trim_image(image, background_color=none, tolerance=10):
    """
    裁剪图片的纯色边框。
    
    参数:
        image: pil image对象，或图片文件路径（字符串）。
        background_color: 背景色的rgb元组，如(255,255,255)。为none则自动检测。
        tolerance: 颜色容差。值越大，被视为背景的颜色范围越宽。
    
    返回:
        裁剪后的pil image对象。
    """
    # 如果传入的是文件路径，则打开图片
    if isinstance(image, str):
        img = image.open(image).convert('rgb') # 确保是rgb模式
    else:
        img = image.convert('rgb')
    
    width, height = img.size
    pixels = img.load() # 获取像素访问对象，便于快速读取
    
    # 1. 确定背景色
    if background_color is none:
        # 自动检测：取四个角的颜色平均值
        corners = [
            pixels[0, 0],          # 左上
            pixels[width-1, 0],    # 右上
            pixels[0, height-1],   # 左下
            pixels[width-1, height-1] # 右下
        ]
        # 计算平均rgb值
        bg_r = sum(c[0] for c in corners) // 4
        bg_g = sum(c[1] for c in corners) // 4
        bg_b = sum(c[2] for c in corners) // 4
        background_color = (bg_r, bg_g, bg_b)
    
    # 辅助函数：判断一个像素颜色是否在背景色容差范围内
    def is_background(pixel):
        r, g, b = pixel
        br, bg, bb = background_color
        # 计算曼哈顿距离或欧氏距离作为颜色差异。这里使用简单的分量差绝对值。
        return (abs(r - br) <= tolerance and 
                abs(g - bg) <= tolerance and 
                abs(b - bb) <= tolerance)
    
    # 2. 扫描左边界
    left = 0
    for x in range(width):
        # 检查x列的所有y像素
        column_is_bg = all(is_background(pixels[x, y]) for y in range(height))
        if not column_is_bg:
            left = x
            break
    else:
        # 如果循环完都没找到非背景列，说明整张图都是背景
        left = width
    
    # 3. 扫描右边界 (从右向左)
    right = width - 1
    for x in range(width - 1, left - 1, -1): # 从最右扫描到left，避免重复
        if not all(is_background(pixels[x, y]) for y in range(height)):
            right = x
            break
    else:
        right = left # 特殊情况处理
    
    # 4. 扫描上边界
    top = 0
    for y in range(height):
        if not all(is_background(pixels[x, y]) for x in range(left, right + 1)):
            top = y
            break
    else:
        top = height
    
    # 5. 扫描下边界 (从下向上)
    bottom = height - 1
    for y in range(height - 1, top - 1, -1):
        if not all(is_background(pixels[x, y]) for x in range(left, right + 1)):
            bottom = y
            break
    else:
        bottom = top
    
    # 6. 计算裁剪区域，确保区域有效
    # 如果边界重合，说明没找到内容，返回原图或一个小像素图
    if left >= right or top >= bottom:
        print(f"警告：未能检测到有效内容区域，返回原图。")
        return img
    
    bbox = (left, top, right + 1, bottom + 1) # pil的crop需要右下标+1
    trimmed_img = img.crop(bbox)
    return trimmed_img

import os
from pathlib import path

def batch_trim_images(input_dir, output_dir, background_color=none, tolerance=10, supported_extensions=('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.tiff')):
    """
    批量裁剪一个文件夹内所有图片的白边。
    
    参数:
        input_dir: 输入图片所在的文件夹路径。
        output_dir: 输出裁剪后图片的文件夹路径。如果不存在会自动创建。
        background_color: 同`trim_image`函数。
        tolerance: 同`trim_image`函数。
        supported_extensions: 支持处理的图片文件扩展名元组。
    """
    input_path = path(input_dir)
    output_path = path(output_dir)
    
    # 创建输出目录（如果不存在）
    output_path.mkdir(parents=true, exist_ok=true)
    
    processed_count = 0
    error_list = []
    
    # 遍历输入目录下的所有文件
    for file_path in input_path.iterdir():
        if file_path.is_file() and file_path.suffix.lower() in supported_extensions:
            try:
                print(f"正在处理: {file_path.name}")
                # 调用裁剪函数
                trimmed_img = trim_image(str(file_path), background_color, tolerance)
                
                # 构建输出文件路径，保持原名
                output_file = output_path / file_path.name
                # 保存图片。保留原始格式，可优化为根据后缀选择保存参数
                trimmed_img.save(output_file)
                print(f"  已保存至: {output_file}")
                processed_count += 1
                
            except exception as e:
                error_msg = f"处理文件 {file_path.name} 时出错: {e}"
                print(error_msg)
                error_list.append(error_msg)
    
    print(f"\n批量处理完成！")
    print(f"成功处理: {processed_count} 张图片")
    if error_list:
        print(f"处理失败: {len(error_list)} 张图片")
        for err in error_list:
            print(f"  - {err}")

def main():
    import argparse
    
    parser = argparse.argumentparser(description='批量裁剪图片纯色边框工具')
    parser.add_argument('input_dir', help='输入图片文件夹路径')
    parser.add_argument('output_dir', help='输出图片文件夹路径')
    parser.add_argument('--color', nargs=3, type=int, metavar=('r', 'g', 'b'),
                        help='手动指定背景色rgb值，例如 --color 255 255 255')
    parser.add_argument('--tolerance', type=int, default=10,
                        help='颜色容差 (默认: 10)')
    parser.add_argument('--ext', nargs='+', default=['.png', '.jpg', '.jpeg'],
                        help='支持的文件扩展名列表 (默认: .png .jpg .jpeg)')
    
    args = parser.parse_args()
    
    bg_color = tuple(args.color) if args.color else none
    
    print("="*50)
    print("批量图片白边裁剪工具")
    print(f"输入目录: {args.input_dir}")
    print(f"输出目录: {args.output_dir}")
    print(f"背景色: {bg_color if bg_color else '自动检测'}")
    print(f"颜色容差: {args.tolerance}")
    print("="*50)
    
    # 执行批量处理
    batch_trim_images(
        input_dir=args.input_dir,
        output_dir=args.output_dir,
        background_color=bg_color,
        tolerance=args.tolerance,
        supported_extensions=tuple(args.ext)
    )

if __name__ == '__main__':
    main()

# 基本用法：自动检测白边
python auto_trim.py ./原始图片 ./裁剪后图片

# 指定背景色为纯白色，容差为5
python auto_trim.py ./input ./output --color 255 255 255 --tolerance 5

# 指定处理png和jpg格式
python auto_trim.py ./input ./output --ext .png .jpg

# 示例：垂直方向每10个像素采样一次
scan_interval = 10
column_is_bg = all(is_background(pixels[x, y]) for y in range(0, height, scan_interval))

import numpy as np
img_array = np.array(img)
# 然后可以使用numpy的布尔索引和`np.all`, `np.any`来快速判断行列

def open_image_robustly(image_path):
    img = image.open(image_path)
    # 如果图片有透明度，将其合成到白色背景上
    if img.mode in ('rgba', 'la', 'p'):
        background = image.new('rgb', img.size, (255, 255, 255))
        if img.mode == 'p':
            img = img.convert('rgba')
        background.paste(img, mask=img.split()[-1] if img.mode == 'rgba' else none)
        img = background
    else:
        img = img.convert('rgb')
    return img

pip install tqdm

from tqdm import tqdm
import os

def batch_trim_images_with_progress(input_dir, output_dir, **kwargs):
    # ... [前面的目录准备代码] ...
    file_list = [f for f in input_path.iterdir() if f.is_file() and f.suffix.lower() in supported_extensions]
    
    print(f"找到 {len(file_list)} 张待处理图片。")
    
    for file_path in tqdm(file_list, desc="处理进度"):
        try:
            # ... [处理单个文件的代码] ...
        except exception as e:
            # ... [错误处理] ...
    # ... [后续统计代码] ...

print(f"自动检测的背景色: {background_color}")

print(f"裁剪区域: left={left}, top={top}, right={right}, bottom={bottom}")

pyinstaller --onefile --name autoimagetrimmer auto_trim.py

import tkinter as tk
from tkinter import filedialog, messagebox, ttk
from pathlib import path
# ... 导入之前写好的 trim_image, batch_trim_images 函数 ...

class imagetrimapp:
    def __init__(self, root):
        self.root = root
        self.root.title("批量图片白边裁剪工具")
        # 创建输入目录选择框、输出目录选择框、容差滑动条、颜色选择按钮、开始按钮等控件
        # ... [gui布局代码，篇幅较长，此处省略] ...
        # 核心是绑定按钮事件，调用我们之前写好的 `batch_trim_images` 函数。

if __name__ == '__main__':
    root = tk.tk()
    app = imagetrimapp(root)
    root.mainloop()