pil批量分割图片、旋转图片，恢复旋转，并重新拼合图片。

一、分割

问题：批量将图片按照从左到右的顺序将图片分割成四个子图，并且将子图按顺序保存。

import os
from PIL import Image

def split_image(image_path, output_dir):
    # 创建输出目录（如果不存在）
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    
    # 打开图像
    with Image.open(image_path) as img:
        # 获取图像的宽度和高度
        width, height = img.size
        
        # 计算分割后每张图片的宽度
        split_width = width // 4
        
        # 遍历四个分割区域，并保存图像
        for i in range(4):
            left = i * split_width
            right = (i + 1) * split_width
            top = 0
            bottom = height
            
            # 裁剪图像
            cropped_img = img.crop((left, top, right, bottom))
            
            # 生成输出文件名
            output_file_name = os.path.join(output_dir, f"{os.path.splitext(os.path.basename(image_path))[0]}_part_{i+1}.png")
            
            # 保存裁剪后的图像
            cropped_img.save(output_file_name)

def batch_split_images(input_dir, output_dir):
    # 遍历输入目录中的所有文件
    for file_name in os.listdir(input_dir):
        if file_name.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
            input_file_path = os.path.join(input_dir, file_name)
            split_image(input_file_path, output_dir)

# 示例使用
input_directory = 'path/to/your/input/directory'  # 替换为你的输入目录路径
output_directory = 'path/to/your/output/directory'  # 替换为你的输出目录路径

batch_split_images(input_directory, output_directory)

说明：

1. split_image函数：这个函数负责读取一张图片，将其按从左到右的形式分割成四张图片，并按顺序保存到指定的输出目录中。
2. batch_split_images函数：这个函数遍历输入目录中的所有文件，对于符合条件的图片文件（如 .png, .jpg, .jpeg, .bmp, .gif），调用 split_image 函数进行分割。
3. 输入和输出目录：你需要将 input_directory 和 output_directory 替换为你实际的目录路径。

确保你已经安装了Pillow库，可以使用以下命令进行安装：

pip install Pillow

运行这段代码后，输入目录中的所有符合条件的图片都会被分割成四张图片，并按顺序保存到输出目录中。

二、旋转

旋转图片：

from PIL import Image
import os

# 定义旋转函数
def rotate_image(image_path, output_path, degrees=90):
    try:
        # 打开图片
        img = Image.open(image_path)
        # 旋转图片
        rotated_img = img.rotate(degrees, expand=True)
        # 保存图片
        rotated_img.save(output_path)
        print(f"图片 {image_path} 已旋转并保存为 {output_path}")
    except IOError:
        print(f"无法打开图片 {image_path}")

# 要处理的文件夹路径
input_folder = 'path/to/your/input/folder'
# 输出文件夹路径
output_folder = 'path/to/your/output/folder'

# 确保输出文件夹存在
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# 遍历文件夹中的所有文件
for filename in os.listdir(input_folder):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
        # 构建完整的文件路径
        input_path = os.path.join(input_folder, filename)
        output_path = os.path.join(output_folder, filename)
        # 旋转并保存图片
        rotate_image(input_path, output_path)

这段代码会将指定输入文件夹中的所有图片横向旋转90度，并保存到输出文件夹中。请将input_folder和output_folder变量的值替换为你的实际文件夹路径。

三、恢复旋转

from PIL import Image
import os


# 定义旋转函数
def rotate_image(image_path, output_path, degrees=270):
    try:
        # 打开图片
        img = Image.open(image_path)
        # 旋转图片
        rotated_img = img.rotate(degrees, expand=True)
        # 保存图片
        rotated_img.save(output_path)
        print(f"图片 {image_path} 已旋转并保存为 {output_path}")
    except IOError:
        print(f"无法打开图片 {image_path}")


# 要处理的文件夹路径
input_folder = 'data_photo/rota_data'
# 输出文件夹路径
output_folder = 'data_photo/re_rota_data'

# 确保输出文件夹存在
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# 遍历文件夹中的所有文件
for filename in os.listdir(input_folder):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
        # 构建完整的文件路径
        input_path = os.path.join(input_folder, filename)
        output_path = os.path.join(output_folder, filename)
        # 旋转并保存图片
        rotate_image(input_path, output_path)

四、重新拼合

from PIL import Image
import os
import re

def combine_images(part1, part2, part3, part4, output_path):
    # 打开四张图片
    img1 = Image.open(part1)
    img2 = Image.open(part2)
    img3 = Image.open(part3)
    img4 = Image.open(part4)
    
    # 获取单张图片的尺寸
    width, height = img1.size
    
    # 创建新图片，尺寸是单张图片的四倍宽度
    new_im = Image.new('RGB', (4 * width, height))
    
    # 将四张图片粘贴到正确的位置
    new_im.paste(img1, (0, 0))
    new_im.paste(img2, (width, 0))
    new_im.paste(img3, (2 * width, 0))
    new_im.paste(img4, (3 * width, 0))
    
    # 保存新图片
    new_im.save(output_path)
    print(f"图片已保存到 {output_path}")

# 输入和输出文件夹路径
input_folder = 'path/to/your/input/folder'
output_folder = 'path/to/your/output/folder'

# 确保输出文件夹存在
if not os.path.exists(output_folder):
    os.makedirs(output_folder)

# 用于存储每组图片的路径
image_groups = {}

# 遍历输入文件夹中的所有文件
for filename in os.listdir(input_folder):
    match = re.match(r'(\d+)_part_(\d+).jpg', filename)
    if match:
        group_id, part_id = match.groups()
        if group_id not in image_groups:
            image_groups[group_id] = {}
        part_id = int(part_id)
        if part_id in [1, 2, 3, 4]:
            image_groups[group_id][part_id] = os.path.join(input_folder, filename)

# 处理每组图片
for group_id, parts in image_groups.items():
    if len(parts) == 4:
        part1_path = parts[1]
        part2_path = parts[2]
        part3_path = parts[3]
        part4_path = parts[4]
        
        # 构建输出路径
        output_path = os.path.join(output_folder, f'recover{group_id}.jpg')
        
        # 组合图片
        combine_images(part1_path, part2_path, part3_path, part4_path, output_path)

说明：

1. 正则表达式：使用正则表达式re.match(r'(\d+)_part_(\d+).jpg', filename)来匹配文件名，并提取组ID和部分ID。
2. 图片分组：将相同组ID的图片路径存储在image_groups字典中，键是组ID，值是另一个字典，存储该组的四部分图片路径。
3. 图片组合：对于每组完整的四部分图片，使用combine_images函数将它们组合成一张图片，并保存到输出文件夹。

请将input_folder和output_folder变量的值替换为你的实际文件夹路径。这个脚本会按照你的要求处理图片，并按照recover1、recover2等格式命名输出文件。

重新拼合方法二：

import os
from PIL import Image

def recover_images(input_dir, output_dir):
    # 确保输出目录存在
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    # 获取所有图片文件名
    files = os.listdir(input_dir)
    files.sort()  # 确保文件按名称排序

    # 用于存储每个图片的完整路径
    image_parts = {}
    for file in files:
        base, part = file.split('_part_')
        num = int(base)
        if num not in image_parts:
            image_parts[num] = []
        image_parts[num].append(os.path.join(input_dir, file))

    # 拼接图片
    recover_count = 1
    for num, parts in image_parts.items():
        # 加载所有部分
        images = [Image.open(part) for part in parts]

        # 获取每张图片的宽度和高度（假设所有部分的高度相同）
        widths, heights = zip(*(img.size for img in images))
        total_width = sum(widths)
        max_height = max(heights)

        # 创建一个新的空白图片来放置拼接后的图片
        new_image = Image.new('RGB', (total_width, max_height))

        # 粘贴每张图片到新的图片中
        x_offset = 0
        for img in images:
            new_image.paste(img, (x_offset, 0))
            x_offset += img.width

        # 保存拼接后的图片
        output_file = os.path.join(output_dir, f'recover{recover_count}.jpg')
        new_image.save(output_file)
        recover_count += 1

# 输入目录和输出目录
input_directory = 'path/to/your/input/directory'  # 替换为你的输入目录路径
output_directory = 'path/to/your/output/directory'  # 替换为你的输出目录路径

recover_images(input_directory, output_directory)

这个脚本将遍历输入目录中的所有图片文件，按文件名排序并分组，然后将每组中的图片拼接成一个新的图片，并保存到输出目录中。拼接后的图片文件将命名为recover1.jpg、recover2.jpg等。