AIStoryBoard/python/merge_images.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
图片拼接工具 - 针对GPT优化
将多张图片缩放后拼接，生成GPT可读取的最大尺寸图片
"""

import os
import sys
import json
from pathlib import Path
from PIL import Image

# GPT图片尺寸限制（根据实际API限制调整）
# 为了减小base64编码后的体积，使用较小的尺寸
# 2048x2048 对于黑白漫画来说足够清晰，AI可以识别文字和内容
# 这样可以显著减小文件大小（约减少75%的体积）
GPT_MAX_WIDTH = 2048
GPT_MAX_HEIGHT = 2048
GPT_MAX_PIXELS = GPT_MAX_WIDTH * GPT_MAX_HEIGHT  # 约4.2MP

# 为了保证文字清晰，单张图片的最小尺寸（针对黑白漫画优化）
MIN_IMAGE_WIDTH = 600  # 最小宽度，保证文字可读（黑白漫画可以稍小）
MIN_IMAGE_HEIGHT = 450  # 最小高度

def calculate_grid_layout(images, max_width=GPT_MAX_WIDTH, max_height=GPT_MAX_HEIGHT):
    """
    计算网格布局参数，最大化利用空间（确保单张网格图不超过限制）
    
    参数:
        images: 图片列表
        max_width: 最大宽度
        max_height: 最大高度
    
    返回:
        (cols, rows, scale_factor, single_width, single_height)
    """
    if not images:
        return 1, 1, 1.0, 0, 0
    
    # 获取单张图片的尺寸（假设所有图片尺寸相同）
    single_width = images[0].width
    single_height = images[0].height
    
    # 尝试不同的行列组合，找到能放最多图片且不超过限制的组合
    best_cols = 1
    best_rows = 1
    best_scale = 1.0
    max_images_per_grid = 0
    
    # 遍历可能的列数（从1开始，最多到能放下的最大列数）
    max_possible_cols = min(int(max_width / MIN_IMAGE_WIDTH), len(images))
    
    for cols in range(1, max_possible_cols + 1):
        # 计算需要的宽度
        needed_width = single_width * cols
        
        # 如果宽度超过限制，需要缩放
        if needed_width > max_width:
            scale_w = max_width / needed_width
        else:
            scale_w = 1.0
        
        # 计算缩放后单张图片的宽度
        scaled_single_width = single_width * scale_w
        
        # 确保缩放后宽度不小于最小值
        if scaled_single_width < MIN_IMAGE_WIDTH:
            continue
        
        # 计算缩放后单张图片的高度（保持宽高比）
        scaled_single_height = single_height * scale_w
        
        # 计算能放多少行
        max_rows = int(max_height / scaled_single_height)
        if max_rows < 1:
            continue
        
        # 计算这个布局能放多少张图片
        images_per_grid = cols * max_rows
        
        # 如果这个布局能放更多图片，记录它
        if images_per_grid > max_images_per_grid:
            max_images_per_grid = images_per_grid
            best_cols = cols
            best_rows = max_rows
            best_scale = scale_w
    
    # 如果没找到合适的，使用保守方案
    if max_images_per_grid == 0:
        # 计算最小缩放因子，确保单张图片能放下
        scale_w = min(max_width / single_width, max_height / single_height)
        # 确保缩放后不小于最小值
        if single_width * scale_w < MIN_IMAGE_WIDTH:
            scale_w = MIN_IMAGE_WIDTH / single_width
        if single_height * scale_w < MIN_IMAGE_HEIGHT:
            scale_w = MIN_IMAGE_HEIGHT / single_height
        
        best_scale = scale_w
        scaled_single_width = single_width * best_scale
        scaled_single_height = single_height * best_scale
        best_cols = max(1, int(max_width / scaled_single_width))
        best_rows = max(1, int(max_height / scaled_single_height))
        max_images_per_grid = best_cols * best_rows
    
    return best_cols, best_rows, best_scale, single_width, single_height

def resize_image(img, scale_factor):
    """缩放图片"""
    # 如果缩放因子大于等于1.0，不放大（只缩小）
    if scale_factor >= 1.0:
        return img
    
    new_width = int(img.width * scale_factor)
    new_height = int(img.height * scale_factor)
    
    # 确保尺寸至少为1
    new_width = max(1, new_width)
    new_height = max(1, new_height)
    
    # 使用高质量缩放算法（LANCZOS）
    return img.resize((new_width, new_height), Image.Resampling.LANCZOS)

def merge_images_for_gpt(image_dir, output_path, max_width=GPT_MAX_WIDTH, max_height=GPT_MAX_HEIGHT):
    """
    将目录下的所有图片缩放后拼接，生成GPT可读取的图片
    
    参数:
        image_dir: 图片目录（包含单页图片）
        output_path: 输出文件路径
        max_width: 单张图片最大宽度
        max_height: 单张图片最大高度
    """
    image_dir = Path(image_dir)
    
    if not image_dir.exists():
        print(f"❌ 错误：目录不存在 - {image_dir}")
        return False
    
    # 获取所有图片文件（按文件名排序）
    image_files = sorted(image_dir.glob("*.jpeg")) + sorted(image_dir.glob("*.jpg")) + \
                  sorted(image_dir.glob("*.png"))
    
    # 过滤掉已拼接的图片
    image_files = [f for f in image_files if 'merged' not in f.name.lower() and 'part' not in f.name.lower()]
    
    if not image_files:
        print(f"❌ 在 {image_dir} 中未找到图片文件")
        return False
    
    print(f"📚 找到 {len(image_files)} 张图片")
    print(f"📁 图片目录: {image_dir}")
    print(f"📁 输出路径: {output_path}")
    print(f"🖼️  GPT最大尺寸: {max_width} x {max_height} 像素")
    print("-" * 60)
    
    # 加载所有图片
    print("📖 正在加载图片...")
    images = []
    for i, img_path in enumerate(image_files, 1):
        try:
            img = Image.open(img_path)
            # 转换为RGB模式（如果是灰度，保持灰度）
            if img.mode not in ('L', 'RGB'):
                img = img.convert('RGB')
            images.append(img)
            if i % 50 == 0:
                print(f"   已加载 {i}/{len(image_files)} 张...")
        except Exception as e:
            print(f"   ⚠️  跳过 {img_path.name}: {e}")
    
    if not images:
        print("❌ 没有成功加载的图片")
        return False
    
    print(f"✅ 成功加载 {len(images)} 张图片")
    
    # 检查所有图片尺寸是否一致
    first_width = images[0].width
    first_height = images[0].height
    all_same_size = all(img.width == first_width and img.height == first_height for img in images)
    
    if not all_same_size:
        print(f"⚠️  警告：图片尺寸不一致，将使用第一张图片的尺寸作为基准")
        print(f"   第一张: {first_width}x{first_height}, 其他图片将被缩放")
    
    print(f"📊 单张图片尺寸: {first_width} x {first_height} 像素")
    
    # 计算最佳网格布局
    print("🔍 正在计算最佳网格布局（从右到左、从上到下，日式漫画阅读顺序）...")
    cols, rows, scale_factor, single_width, single_height = calculate_grid_layout(images, max_width, max_height)
    
    scaled_single_width = int(single_width * scale_factor)
    scaled_single_height = int(single_height * scale_factor)
    grid_width = scaled_single_width * cols
    grid_height = scaled_single_height * rows
    
    print(f"📐 布局方案: {cols}列 x {rows}行")
    print(f"📉 缩放比例: {scale_factor:.2%}")
    print(f"📊 单张图片缩放后: {scaled_single_width} x {scaled_single_height} 像素")
    print(f"📊 网格总尺寸: {grid_width} x {grid_height} 像素 ({grid_width * grid_height/1e6:.2f} MP)")
    print(f"📈 每张网格图可容纳: {cols * rows} 张原图")
    
    # 缩放所有图片
    print("🔄 正在缩放图片...")
    scaled_images = []
    
    for i, img in enumerate(images, 1):
        # 如果尺寸不一致，需要缩放
        if img.width != single_width or img.height != single_height:
            # 先缩放到标准尺寸
            img = img.resize((single_width, single_height), Image.Resampling.LANCZOS)
        
        # 应用缩放因子
        scaled_img = resize_image(img, scale_factor)
        scaled_images.append(scaled_img)
        
        if i % 50 == 0:
            print(f"   已缩放 {i}/{len(images)} 张...")
    
    # 创建输出子文件夹
    output_dir = Path(output_path).parent
    # 如果output_path已经在gpt_merged文件夹中，需要回到上一级
    if output_dir.name == "gpt_merged":
        output_dir = output_dir.parent
    
    output_folder_name = "gpt_merged"
    output_folder = output_dir / output_folder_name
    output_folder.mkdir(parents=True, exist_ok=True)
    
    output_stem = "gpt_merged"
    output_suffix = Path(output_path).suffix if Path(output_path).suffix else ".jpg"
    
    # 计算需要多少张网格图
    images_per_grid = cols * rows
    total_grids = (len(scaled_images) + images_per_grid - 1) // images_per_grid
    
    print(f"\n📦 需要生成 {total_grids} 张网格图片（每张包含最多 {images_per_grid} 张原图）")
    
    merged_files = []
    
    for grid_num in range(total_grids):
        start_idx = grid_num * images_per_grid
        end_idx = min(start_idx + images_per_grid, len(scaled_images))
        grid_images = scaled_images[start_idx:end_idx]
        
        # 计算当前网格的实际行数
        current_rows = (len(grid_images) + cols - 1) // cols
        current_grid_height = scaled_single_height * current_rows
        
        # 创建网格图（从右到左、从上到下排列，符合日式漫画阅读顺序）
        print(f"\n🔗 正在生成第 {grid_num + 1}/{total_grids} 张网格图（{cols}列 x {current_rows}行，包含{len(grid_images)}张原图，从右到左排列）...")
        grid_image = Image.new('L' if grid_images[0].mode == 'L' else 'RGB', (grid_width, current_grid_height))
        
        for idx, img in enumerate(grid_images):
            row = idx // cols
            # 从右到左排列（日式漫画阅读顺序）：第一张图片在最右边，然后向左排列
            col = (cols - 1) - (idx % cols)
            x = col * scaled_single_width
            y = row * scaled_single_height
            grid_image.paste(img, (x, y))
            
            if (idx + 1) % 50 == 0 or (idx + 1) == len(grid_images):
                print(f"   已拼接 {idx + 1}/{len(grid_images)} 张...")
        
        # 如果是最后一张图片且图片数量不足以填满整行，裁剪掉左侧空白
        is_last_grid = (grid_num == total_grids - 1)
        current_grid_width = grid_width
        
        if is_last_grid and len(grid_images) % cols != 0:
            # 由于是从右到左排列，空白在左侧
            # 计算最后一行的实际列数
            actual_cols_in_last_row = len(grid_images) % cols
            # 从右到左排列时，最后一行的图片在右侧，左侧是空白
            # 需要裁剪掉的左侧空白宽度 = (cols - actual_cols_in_last_row) * scaled_single_width
            left_blank_width = (cols - actual_cols_in_last_row) * scaled_single_width
            
            if left_blank_width > 0 and left_blank_width < grid_width:
                # 裁剪掉左侧空白
                actual_width = grid_width - left_blank_width
                cropped_image = grid_image.crop((left_blank_width, 0, grid_width, current_grid_height))
                grid_image = cropped_image
                current_grid_width = actual_width
                print(f"   ✂️  裁剪左侧空白: {left_blank_width}px，实际尺寸: {current_grid_width}x{current_grid_height}")
        
        # 保存
        if total_grids == 1:
            part_path = output_folder / f"{output_stem}{output_suffix}"
        else:
            part_path = output_folder / f"{output_stem}_part{grid_num + 1:02d}{output_suffix}"
        
        grid_image.save(part_path, 'JPEG', quality=85, optimize=True, progressive=True)
        file_size = part_path.stat().st_size / 1024 / 1024
        merged_files.append(part_path.name)
        print(f"   ✅ 已保存: {part_path.name} ({current_grid_width}x{current_grid_height}, {file_size:.2f}MB)")
    
    print(f"\n✅ 拼接完成！共生成 {len(merged_files)} 张网格图片")
    return merged_files


def main():
    """主函数"""
    # 获取项目根目录
    project_root = Path(__file__).parent.parent
    
    if len(sys.argv) > 1:
        # 如果提供了参数，使用指定的目录
        image_dir = Path(sys.argv[1])
        if len(sys.argv) > 2:
            output_path = Path(sys.argv[2])
        else:
            # 在图片目录下创建gpt_merged子文件夹
            output_folder = image_dir / "gpt_merged"
            output_folder.mkdir(parents=True, exist_ok=True)
            output_path = output_folder / "gpt_merged.jpg"
    else:
        # 默认使用漫画图片目录
        image_dir = project_root / "static" / "漫画" / "image" / "金-田-一-少-年-之-事-件-簿-日-文-版-第001卷"
        # 输出到子文件夹
        output_folder = image_dir / "gpt_merged"
        output_folder.mkdir(parents=True, exist_ok=True)
        output_path = output_folder / "gpt_merged.jpg"
    
    print("📖 图片拼接工具 - GPT优化版")
    print("=" * 60)
    
    result = merge_images_for_gpt(image_dir, output_path)
    
    if result:
        print("\n" + "=" * 60)
        print("✅ 处理完成！")
        if isinstance(result, list):
            print(f"📊 共生成 {len(result)} 张图片")
            for name in result:
                print(f"   - {name}")
        else:
            print(f"📊 生成图片: {result}")
    else:
        print("\n❌ 处理失败")


if __name__ == "__main__":
    main()