PyMuPDF_Finally4.py

import os
import random
import time
from PIL import Image, ImageDraw, ImageFont, ImageFilter
import numpy as np
import datetime
from typing import Tuple, Optional
import threading
import sys
import re
import cv2
import textwrap
import re

print("🌟 === BBOX升级版文字特效渲染工具 === 🌟")

# --- 1. 升级配置区 ---
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
FONTS_DIR = os.path.join(BASE_DIR, 'fonts')
INPUT_IMAGES_DIR = os.path.join(BASE_DIR, 'input_images')
BBOX_IMAGES_DIR = os.path.join(BASE_DIR, 'bbox_images')  # 新增bbox目录
OUTPUT_DIR = os.path.join(BASE_DIR, 'output444')

# --- 2. 长句子文本库（纯英文） ---
LONG_TEXT_SAMPLES = [
    # 励志名言句子
    "The future belongs to those who believe in the beauty of their dreams",
    "Success is not final, failure is not fatal, it is the courage to continue that counts",
    "In the middle of difficulty lies opportunity waiting to be discovered", 
    "The only way to do great work is to love what you do with passion",
    "Innovation distinguishes between a leader and a follower in every field",
    "Your limitation is only your imagination when you dare to dream big",
    "Great things never come from comfort zones, so step out and explore",
    "Dream it, wish it, do it with determination and never give up",
    "The harder you work for something, the greater you will feel when you achieve it",
    "Success doesn't just find you, you have to go out and get it",
    
    # 科幻电影经典台词
    "May the Force be with you always, young Jedi warrior",
    "I'll be back to save humanity from the machines",
    "The Matrix has you, but you can choose the red pill",
    "Resistance is futile, you will be assimilated into the collective",
    "Live long and prosper in the final frontier of space",
    "Houston, we have a problem with our spacecraft systems",
    "Space, the final frontier where no one has gone before",
    "These aren't the droids you're looking for, move along",
    "Welcome to the real world, it's not what it seems",
    "The needs of the many outweigh the needs of the few",
    
    # 赛博朋克风格句子
    "In the neon-lit streets of Neo Tokyo, hackers rule the digital underground",
    "Cybernetic enhancements blur the line between human and machine consciousness",
    "Data streams flow like rivers of light through the virtual reality matrix",
    "Corporate megacities rise above the smog where augmented humans survive",
    "Neural interfaces connect minds to the global information network",
    "Synthetic dreams download directly into sleeping cyber-enhanced brains",
    "Digital ghosts haunt the abandoned servers of forgotten online worlds",
    "Chrome and flesh merge in the shadowy backstreets of tomorrow",
    "Holographic advertisements flicker in the perpetual rain of acid storms",
    "Memory chips store lifetimes of experience in quantum storage arrays",
    
    # 游戏相关段落
    "Player one, prepare for the ultimate boss battle that will test all your skills",
    "Achievement unlocked: Master of the Digital Realm with infinite possibilities ahead",
    "Game over is not the end, it's just another chance to level up",
    "In this virtual world, every quest leads to greater adventures and treasures",
    "The legendary sword awaits the chosen hero in the depths of the dungeon",
    "Multiplayer chaos erupts as teams clash in epic battles across alien worlds",
    "Loading next level, where new challenges and mysteries await brave explorers",
    "High score achieved through dedication, practice, and never surrendering to defeat",
    "The final countdown begins as players race against time to save the universe",
    "Virtual reality becomes indistinguishable from actual reality in the metaverse",
    
    # 音乐和艺术主题
    "Music is the universal language that speaks to every soul across all cultures",
    "Colors dance across the canvas as the artist brings imagination to vivid life",
    "Rhythm and melody combine to create symphonies that transcend time and space",
    "Digital art emerges from pixels and code to inspire the next generation",
    "The stage lights dim as performers prepare to transport audiences to other worlds",
    "Sound waves ripple through the air carrying emotions that words cannot express",
    "Creative inspiration strikes like lightning, illuminating the path to artistic greatness",
    "The gallery walls showcase masterpieces that challenge perception and reality",
    "Electronic beats pulse through the night club as dancers lose themselves",
    "Artistic vision transforms ordinary materials into extraordinary expressions of beauty",
    
    # 技术和创新主题
    "Artificial intelligence awakens to consciousness in the quantum computing laboratory",
    "Blockchain technology revolutionizes trust in the decentralized digital economy",
    "Machine learning algorithms evolve beyond their original programming parameters",
    "Virtual reality headsets transport users to impossible worlds of infinite wonder",
    "Quantum entanglement enables instantaneous communication across vast cosmic distances",
    "Nanotechnology assembles materials atom by atom with precision beyond imagination",
    "Genetic engineering unlocks the secrets hidden within the human genome",
    "Renewable energy harvests power from wind, solar, and geothermal sources",
    "3D printing materializes objects from digital designs into physical reality",
    "Cloud computing connects global networks in seamless information exchange",
]

##智能换行
def smart_fit_text_to_bbox(text, font, bbox, line_spacing=1.2):
    """
    🧠 超级智能的BBOX文本自适应函数
    自动换行 + 字号调整 + 完美居中
    """
    x1, y1, x2, y2 = bbox
    bbox_width = x2 - x1
    bbox_height = y2 - y1
    
    # 留边距，防止贴边
    margin_x = int(bbox_width * 0.05)  # 5% 水平边距
    margin_y = int(bbox_height * 0.05)  # 5% 垂直边距
    available_width = bbox_width - 2 * margin_x
    available_height = bbox_height - 2 * margin_y
    
    print(f"📦 BBOX区域: {bbox_width}x{bbox_height}, 可用区域: {available_width}x{available_height}")
    
    # 创建临时绘制对象用于测量
    temp_img = Image.new('RGB', (bbox_width * 2, bbox_height * 2))
    temp_draw = ImageDraw.Draw(temp_img)
    
    # 获取字体基本信息
    sample_bbox = temp_draw.textbbox((0, 0), "Ay", font=font)
    font_height = sample_bbox[3] - sample_bbox[1]
    line_height = int(font_height * line_spacing)
    
    print(f"📏 字体高度: {font_height}px, 行高: {line_height}px")
    
    def measure_text_width(text_line):
        """测量单行文本宽度"""
        bbox = temp_draw.textbbox((0, 0), text_line, font=font)
        return bbox[2] - bbox[0]
    
    def wrap_text_smart(text, max_width):
        """智能文本换行"""
        words = text.split()
        lines = []
        current_line = []
        
        for word in words:
            # 测试加入这个词后的宽度
            test_line = ' '.join(current_line + [word])
            test_width = measure_text_width(test_line)
            
            if test_width <= max_width:
                # 能放下，加入当前行
                current_line.append(word)
            else:
                # 放不下了
                if current_line:
                    # 保存当前行，开始新行
                    lines.append(' '.join(current_line))
                    current_line = [word]
                else:
                    # 单词太长，强制加入
                    lines.append(word)
                    current_line = []
        
        # 处理最后一行
        if current_line:
            lines.append(' '.join(current_line))
        
        return lines
    
    # 首先尝试原始字体大小
    wrapped_lines = wrap_text_smart(text, available_width)
    total_text_height = len(wrapped_lines) * line_height
    
    print(f"📝 换行结果: {len(wrapped_lines)} 行, 总高度: {total_text_height}px")
    
    # 检查是否超出高度限制
    if total_text_height > available_height:
        print("⚠️ 文本太高，尝试缩小字号...")
        # 这里可以实现字号自适应，暂时先警告
        print(f"   可用高度: {available_height}px, 需要高度: {total_text_height}px")
    
    # 计算垂直居中位置
    start_y = y1 + margin_y + max(0, (available_height - total_text_height) // 2)
    
    # 计算每行的水平居中位置
    positioned_lines = []
    for i, line in enumerate(wrapped_lines):
        line_width = measure_text_width(line)
        # 水平居中
        line_x = x1 + margin_x + (available_width - line_width) // 2
        line_y = start_y + i * line_height
        
        positioned_lines.append({
            'text': line,
            'position': (line_x, line_y),
            'width': line_width
        })
        
        print(f"   第{i+1}行: '{line}' -> ({line_x}, {line_y})")
    
    return positioned_lines

def render_multiline_text_effect(effect_layer, positioned_lines, font, effect, effect_key):
    """
    🎨 渲染多行文本特效
    支持所有特效类型的多行渲染
    """
    print(f"🎨 渲染多行特效: {effect_key}")
    
    if effect_key.startswith('neon_'):
        # 霓虹特效多行渲染
        for line_data in positioned_lines:
            text = line_data['text']
            position = line_data['position']
            
            # 渲染霓虹发光层
            glow_sizes = [30, 25, 20, 15, 10, 5]
            for i, size in enumerate(glow_sizes):
                glow_img = Image.new('RGBA', effect_layer.size, (0, 0, 0, 0))
                glow_draw = ImageDraw.Draw(glow_img)
                
                alpha = max(30, 150 - i * 20)
                glow_color = tuple(min(255, c + 50) for c in effect.color) + (alpha,)
                
                glow_draw.text(position, text, font=font, fill=glow_color)
                blur_radius = size / 5.0
                glow_img = glow_img.filter(ImageFilter.GaussianBlur(radius=blur_radius))
                effect_layer = Image.alpha_composite(effect_layer, glow_img)
            
            # 渲染主文本
            main_draw = ImageDraw.Draw(effect_layer)
            bright_color = tuple(min(255, c + 100) for c in effect.color) + (255,)
            main_draw.text(position, text, font=font, fill=bright_color)
    
    elif effect_key == 'fire_text':
        # 火焰特效多行渲染
        fire_layers = [
            ((255, 0, 0, 60), 25),
            ((255, 69, 0, 80), 20),
            ((255, 140, 0, 100), 15),
            ((255, 215, 0, 120), 10),
            ((255, 255, 200, 140), 5),
        ]
        
        for line_data in positioned_lines:
            text = line_data['text']
            position = line_data['position']
            
            for (color, blur_size) in fire_layers:
                fire_img = Image.new('RGBA', effect_layer.size, (0, 0, 0, 0))
                fire_draw = ImageDraw.Draw(fire_img)
                fire_draw.text(position, text, font=font, fill=color)
                
                if blur_size > 0:
                    fire_img = fire_img.filter(ImageFilter.GaussianBlur(radius=blur_size/4))
                
                effect_layer = Image.alpha_composite(effect_layer, fire_img)
            
            # 核心文本
            core_draw = ImageDraw.Draw(effect_layer)
            core_draw.text(position, text, font=font, fill=(255, 255, 255, 255))
    
    elif effect_key == 'cyberpunk':
        # 赛博朋克特效多行渲染
        cyber_green = (0, 255, 65)
        glow_sizes = [35, 30, 25, 20, 15, 10, 5]
        
        for line_data in positioned_lines:
            text = line_data['text']
            position = line_data['position']
            
            for i, size in enumerate(glow_sizes):
                glow_img = Image.new('RGBA', effect_layer.size, (0, 0, 0, 0))
                glow_draw = ImageDraw.Draw(glow_img)
                
                alpha = max(40, 200 - i * 25)
                glow_color = cyber_green + (alpha,)
                
                glow_draw.text(position, text, font=font, fill=glow_color)
                
                if size > 0:
                    glow_img = glow_img.filter(ImageFilter.GaussianBlur(radius=size/6))
                
                effect_layer = Image.alpha_composite(effect_layer, glow_img)
            
            # 核心文本
            core_draw = ImageDraw.Draw(effect_layer)
            core_draw.text(position, text, font=font, fill=(0, 255, 65, 255))
    
    else:
        # 其他特效：简单多行渲染
        main_draw = ImageDraw.Draw(effect_layer)
        for line_data in positioned_lines:
            text = line_data['text']
            position = line_data['position']
            
            if effect_key == 'rainbow':
                # 彩虹特效需要特殊处理
                rainbow_colors = [
                    (255, 0, 0), (255, 127, 0), (255, 255, 0), (0, 255, 0),
                    (0, 255, 255), (0, 0, 255), (148, 0, 211),
                ]
                
                x_offset = 0
                for i, char in enumerate(text):
                    if char.strip():
                        color = rainbow_colors[i % len(rainbow_colors)]
                        bbox = main_draw.textbbox((0, 0), char, font=font)
                        char_width = bbox[2] - bbox[0]
                        
                        main_draw.text((position[0] + x_offset, position[1]), char, 
                                     font=font, fill=color + (255,))
                        x_offset += char_width
                    else:
                        bbox = main_draw.textbbox((0, 0), ' ', font=font)
                        x_offset += bbox[2] - bbox[0]
            else:
                # 默认白色文本
                main_draw.text(position, text, font=font, fill=(255, 255, 255, 255))
    
    return effect_layer


# --- 3. 彻底修复的输入函数 ---
def get_user_input_fixed(prompt, timeout=5, default=None, wait_for_text=False):
    """彻底修复回车问题的输入函数"""
    print(prompt, end='', flush=True)
    
    if wait_for_text:
        # 文本输入模式：允许多次尝试，彻底处理回车问题
        while True:
            try:
                user_input = input().strip()
                
                # 如果输入不为空且不是纯空格，返回输入
                if user_input and user_input.replace(' ', ''):
                    print(f"✅ 输入成功: '{user_input[:50]}{'...' if len(user_input) > 50 else ''}'")
                    return user_input
                
                # 如果是空输入，询问是否要随机
                print("💡 输入为空。再次输入文本，或直接回车使用随机文本: ", end='', flush=True)
                confirm = input().strip()
                
                if confirm and confirm.replace(' ', ''):
                    print(f"✅ 输入成功: '{confirm[:50]}{'...' if len(confirm) > 50 else ''}'")
                    return confirm
                else:
                    print("🎲 使用随机文本")
                    return default
                    
            except (KeyboardInterrupt, EOFError):
                print("\n⚠️ 输入被中断，使用随机文本")
                return default
    else:
        # 选择模式：使用简化的超时机制
        try:
            import select
            import sys
            
            # 检查是否有输入可用（仅Unix/Linux）
            if hasattr(select, 'select'):
                ready, _, _ = select.select([sys.stdin], [], [], timeout)
                if ready:
                    user_input = input().strip()
                    return user_input if user_input else default
                else:
                    print(f"\n⏱️ {timeout}秒超时，使用默认选择")
                    return default
            else:
                # Windows兼容模式
                user_input = input().strip()
                return user_input if user_input else default
                
        except:
            # 简单fallback
            try:
                user_input = input().strip()
                return user_input if user_input else default
            except:
                return default

# --- 4. BBOX检测功能 ---
def detect_red_bbox_improved(image_path):
    """增强版红框检测，更精确的HSV阈值和边缘检测"""
    try:
        image = cv2.imread(image_path)
        if image is None:
            print(f"❌ 无法读取图像: {image_path}")
            return None
            
        # 转换到HSV色彩空间
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        
        # 使用更精确的红色范围
        lower_red1 = np.array([0, 70, 70])     # 更高的饱和度和亮度阈值
        upper_red1 = np.array([10, 255, 255])
        lower_red2 = np.array([165, 70, 70])   # 调整色相范围
        upper_red2 = np.array([180, 255, 255])
        
        # 创建红色掩码
        mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
        mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
        red_mask = cv2.bitwise_or(mask1, mask2)
        
        # 边缘增强 - 先进行轻微高斯模糊，然后使用Canny边缘检测
        blurred = cv2.GaussianBlur(red_mask, (5, 5), 0)
        edges = cv2.Canny(blurred, 50, 150)
        
        # 寻找轮廓 - 使用CHAIN_APPROX_TC89_KCOS更好地逼近轮廓
        contours, _ = cv2.findContours(red_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_KCOS)
        
        if not contours:
            return None
            
        # 找到最像矩形的轮廓，而不只是最大的
        best_contour = None
        best_rect_score = 0
        
        for contour in contours:
            # 忽略太小的轮廓
            area = cv2.contourArea(contour)
            if area < 500:  # 设置最小面积阈值
                continue
                
            # 获取最小外接矩形
            rect = cv2.minAreaRect(contour)
            box = cv2.boxPoints(rect)
            box = np.int0(box)
            rect_area = cv2.contourArea(box)
            
            # 计算轮廓与矩形的相似度
            similarity = area / rect_area if rect_area > 0 else 0
            
            # 更新最佳矩形
            if similarity > best_rect_score:
                best_rect_score = similarity
                best_contour = contour
        
        if best_contour is None:
            return None
            
        # 获取边界矩形
        x, y, w, h = cv2.boundingRect(best_contour)
        
        # 验证矩形尺寸和形状
        if w < 20 or h < 20 or max(w, h) / min(w, h) > 10:  # 忽略太小或比例极端的矩形
            return None
        
        bbox = (x, y, x + w, y + h)
        print(f"✅ 检测到红色bbox: x1={x}, y1={y}, x2={x+w}, y2={y+h}, 宽度={w}, 高度={h}")
        
        # 保存标记图像用于调试
        debug_img = image.copy()
        cv2.rectangle(debug_img, (x, y), (x+w, y+h), (0, 255, 0), 2)  # 绿色框显示检测结果
        debug_path = image_path.replace('.', '_debug.')
        cv2.imwrite(debug_path, debug_img)
        print(f"📊 调试图像已保存: {os.path.basename(debug_path)}")
        
        return bbox
        
    except Exception as e:
        print(f"❌ bbox检测失败: {str(e)}")
        return None


def find_matching_bbox_image(background_image_name):
    """根据背景图名称查找对应的bbox图像"""
    if not os.path.exists(BBOX_IMAGES_DIR):
        return None
    
    # 获取背景图的基础名称（无扩展名）
    base_name = os.path.splitext(background_image_name)[0]
    
    # 在bbox目录中查找同名文件
    for ext in ['.png', '.jpg', '.jpeg', '.bmp', '.webp']:
        bbox_path = os.path.join(BBOX_IMAGES_DIR, base_name + ext)
        if os.path.exists(bbox_path):
            print(f"✅ 找到对应的bbox图像: {base_name + ext}")
            return bbox_path
    
    print(f"⚠️ 未找到对应的bbox图像: {base_name}")
    return None

def fit_text_to_bbox(text, font, bbox):
    """将文本适配到bbox区域内"""
    x1, y1, x2, y2 = bbox
    bbox_width = x2 - x1
    bbox_height = y2 - y1
    
    # 创建临时图像测量文本
    temp_img = Image.new('RGB', (bbox_width * 2, bbox_height * 2))
    temp_draw = ImageDraw.Draw(temp_img)
    
    # 测量单行文本尺寸
    text_bbox = temp_draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]
    
    # 如果文本能够单行放下
    if text_width <= bbox_width * 0.9:  # 留10%边距
        # 计算居中位置
        text_x = x1 + (bbox_width - text_width) // 2
        text_y = y1 + (bbox_height - text_height) // 2
        return (text_x, text_y), False  # False表示不需要换行
    
    # 需要换行处理
    words = text.split()
    lines = []
    current_line = []
    
    for word in words:
        test_line = ' '.join(current_line + [word])
        test_bbox = temp_draw.textbbox((0, 0), test_line, font=font)
        test_width = test_bbox[2] - test_bbox[0]
        
        if test_width <= bbox_width * 0.9:
            current_line.append(word)
        else:
            if current_line:  # 如果当前行有内容
                lines.append(' '.join(current_line))
                current_line = [word]
            else:  # 单个词都太长，强制加入
                lines.append(word)
                current_line = []
    
    if current_line:
        lines.append(' '.join(current_line))
    
    # 计算多行文本的起始位置
    total_text_height = len(lines) * text_height
    start_y = y1 + max(0, (bbox_height - total_text_height) // 2)
    
    return (x1 + bbox_width * 0.05, start_y), lines  # 返回位置和行列表

# --- 5. 特效类定义（保持不变） ---
class TextEffect:
    def __init__(self, name: str, description: str):
        self.name = name
        self.description = description
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        """应用特效的基类方法，新增bbox参数"""
        raise NotImplementedError

# 更新 NeonEffect 类
class NeonEffect(TextEffect):
    def __init__(self, color: Tuple[int, int, int], name: str):
        super().__init__(name, f"霓虹发光效果 - {name}")
        self.color = color
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        
        if bbox:
            # BBOX模式：使用智能多行渲染
            positioned_lines = smart_fit_text_to_bbox(text, font, bbox)
            effect_layer = render_multiline_text_effect(effect_layer, positioned_lines, font, self, 'neon_' + self.name.lower())
        else:
            # 简单模式：单行渲染
            display_text = ' '.join(text) if isinstance(text, list) else text
            self._render_neon_text(effect_layer, display_text, position, font)
        
        result = image.convert('RGBA')
        result = Image.alpha_composite(result, effect_layer)
        return result
    
    def _render_neon_text(self, effect_layer, text, position, font):
        """单行霓虹渲染（保持兼容性）"""
        glow_sizes = [30, 25, 20, 15, 10, 5]
        for i, size in enumerate(glow_sizes):
            glow_img = Image.new('RGBA', effect_layer.size, (0, 0, 0, 0))
            glow_draw = ImageDraw.Draw(glow_img)
            
            alpha = max(30, 150 - i * 20)
            glow_color = tuple(min(255, c + 50) for c in self.color) + (alpha,)
            
            glow_draw.text(position, text, font=font, fill=glow_color)
            blur_radius = size / 5.0
            glow_img = glow_img.filter(ImageFilter.GaussianBlur(radius=blur_radius))
            effect_layer = Image.alpha_composite(effect_layer, glow_img)
        
        main_draw = ImageDraw.Draw(effect_layer)
        bright_color = tuple(min(255, c + 100) for c in self.color) + (255,)
        main_draw.text(position, text, font=font, fill=bright_color)


# 其他特效类似地添加bbox支持...
class FireEffect(TextEffect):
    def __init__(self):
        super().__init__("火焰文字", "真实火焰燃烧效果")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        
        fire_layers = [
            ((255, 0, 0, 60), 25),
            ((255, 69, 0, 80), 20),
            ((255, 140, 0, 100), 15),
            ((255, 215, 0, 120), 10),
            ((255, 255, 200, 140), 5),
        ]
        
        # 处理多行文本
        if isinstance(text, list):
            temp_bbox = ImageDraw.Draw(effect_layer).textbbox((0, 0), "Ay", font=font)
            line_height = temp_bbox[3] - temp_bbox[1] + 5
            
            for i, line in enumerate(text):
                line_pos = (position[0], position[1] + i * line_height)
                self._render_fire_text(effect_layer, line, line_pos, font, fire_layers)
        else:
            self._render_fire_text(effect_layer, text, position, font, fire_layers)
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)
    
    def _render_fire_text(self, effect_layer, text, position, font, fire_layers):
        """渲染火焰文本"""
        for (color, blur_size) in fire_layers:
            fire_img = Image.new('RGBA', effect_layer.size, (0, 0, 0, 0))
            fire_draw = ImageDraw.Draw(fire_img)
            fire_draw.text(position, text, font=font, fill=color)
            
            if blur_size > 0:
                fire_img = fire_img.filter(ImageFilter.GaussianBlur(radius=blur_size/4))
            
            effect_layer = Image.alpha_composite(effect_layer, fire_img)
        
        core_draw = ImageDraw.Draw(effect_layer)
        core_draw.text(position, text, font=font, fill=(255, 255, 255, 255))

# 简化其他特效类（与之前相同，但添加bbox参数支持）
class IceEffect(TextEffect):
    def __init__(self):
        super().__init__("冰霜文字", "寒冰水晶效果")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        # 基本实现（可按需扩展多行支持）
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        
        ice_layers = [
            ((173, 216, 230, 40), 20),
            ((135, 206, 235, 60), 15),
            ((100, 149, 237, 80), 10),
            ((70, 130, 180, 100), 5),
        ]
        
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        for (color, blur_size) in ice_layers:
            ice_img = Image.new('RGBA', image.size, (0, 0, 0, 0))
            ice_draw = ImageDraw.Draw(ice_img)
            ice_draw.text(position, display_text, font=font, fill=color)
            
            if blur_size > 0:
                ice_img = ice_img.filter(ImageFilter.GaussianBlur(radius=blur_size/4))
            
            effect_layer = Image.alpha_composite(effect_layer, ice_img)
        
        core_draw = ImageDraw.Draw(effect_layer)
        core_draw.text(position, display_text, font=font, fill=(220, 248, 255, 255))
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

class GoldEffect(TextEffect):
    def __init__(self):
        super().__init__("金色文字", "华丽金色效果")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        shadow_pos = (position[0] + 4, position[1] + 4)
        shadow_draw = ImageDraw.Draw(effect_layer)
        shadow_draw.text(shadow_pos, display_text, font=font, fill=(139, 69, 19, 180))
        
        effect_layer = effect_layer.filter(ImageFilter.GaussianBlur(radius=3))
        
        glow_draw = ImageDraw.Draw(effect_layer)
        glow_draw.text(position, display_text, font=font, fill=(255, 215, 0, 200))
        
        highlight_draw = ImageDraw.Draw(effect_layer)
        highlight_draw.text(position, display_text, font=font, fill=(255, 255, 200, 255))
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

class ShadowEffect(TextEffect):
    def __init__(self, shadow_color: Tuple[int, int, int] = (0, 0, 0), 
                 offset: Tuple[int, int] = (6, 6), blur_radius: int = 4):
        super().__init__("阴影文字", "真实投影效果")
        self.shadow_color = shadow_color
        self.offset = offset
        self.blur_radius = blur_radius
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        shadow_pos = (position[0] + self.offset[0], position[1] + self.offset[1])
        shadow_draw = ImageDraw.Draw(effect_layer)
        shadow_draw.text(shadow_pos, display_text, font=font, fill=self.shadow_color + (150,))
        
        if self.blur_radius > 0:
            effect_layer = effect_layer.filter(ImageFilter.GaussianBlur(radius=self.blur_radius))
        
        main_draw = ImageDraw.Draw(effect_layer)
        main_draw.text(position, display_text, font=font, fill=(255, 255, 255, 255))
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

class RainbowEffect(TextEffect):
    def __init__(self):
        super().__init__("彩虹文字", "七彩渐变效果")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        effect_draw = ImageDraw.Draw(effect_layer)
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        rainbow_colors = [
            (255, 0, 0), (255, 127, 0), (255, 255, 0), (0, 255, 0),
            (0, 255, 255), (0, 0, 255), (148, 0, 211),
        ]
        
        for color in rainbow_colors:
            glow_img = Image.new('RGBA', image.size, (0, 0, 0, 0))
            glow_draw = ImageDraw.Draw(glow_img)
            glow_draw.text(position, display_text, font=font, fill=color + (60,))
            glow_img = glow_img.filter(ImageFilter.GaussianBlur(radius=8))
            effect_layer = Image.alpha_composite(effect_layer, glow_img)
        
        x_offset = 0
        for i, char in enumerate(display_text):
            if char.strip():
                color = rainbow_colors[i % len(rainbow_colors)]
                bbox = effect_draw.textbbox((0, 0), char, font=font)
                char_width = bbox[2] - bbox[0]
                
                effect_draw.text((position[0] + x_offset, position[1]), char, 
                               font=font, fill=color + (255,))
                x_offset += char_width
            else:
                bbox = effect_draw.textbbox((0, 0), ' ', font=font)
                x_offset += bbox[2] - bbox[0]
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

class EmbossEffect(TextEffect):
    def __init__(self):
        super().__init__("浮雕效果", "立体浮雕文字")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        effect_draw = ImageDraw.Draw(effect_layer)
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        shadow_pos = (position[0] + 2, position[1] + 2)
        effect_draw.text(shadow_pos, display_text, font=font, fill=(0, 0, 0, 120))
        
        highlight_pos = (position[0] - 1, position[1] - 1)
        effect_draw.text(highlight_pos, display_text, font=font, fill=(255, 255, 255, 180))
        
        effect_draw.text(position, display_text, font=font, fill=(160, 160, 160, 255))
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

class CyberpunkEffect(TextEffect):
    def __init__(self):
        super().__init__("赛博朋克", "科幻电子发光")
    
    def apply(self, image: Image.Image, text: str, position: Tuple[int, int], 
              font: ImageFont.ImageFont, bbox: Optional[Tuple[int, int, int, int]] = None) -> Image.Image:
        effect_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
        display_text = ' '.join(text) if isinstance(text, list) else text
        
        cyber_green = (0, 255, 65)
        glow_sizes = [35, 30, 25, 20, 15, 10, 5]
        
        for i, size in enumerate(glow_sizes):
            glow_img = Image.new('RGBA', image.size, (0, 0, 0, 0))
            glow_draw = ImageDraw.Draw(glow_img)
            
            alpha = max(40, 200 - i * 25)
            glow_color = cyber_green + (alpha,)
            
            glow_draw.text(position, display_text, font=font, fill=glow_color)
            
            if size > 0:
                glow_img = glow_img.filter(ImageFilter.GaussianBlur(radius=size/6))
            
            effect_layer = Image.alpha_composite(effect_layer, glow_img)
        
        core_draw = ImageDraw.Draw(effect_layer)
        core_draw.text(position, display_text, font=font, fill=(0, 255, 65, 255))
        
        result = image.convert('RGBA')
        return Image.alpha_composite(result, effect_layer)

# --- 6. 特效集合 ---
TEXT_EFFECTS = {
    'neon_blue': NeonEffect((0, 255, 255), "霓虹蓝光"),
    'neon_pink': NeonEffect((255, 20, 147), "霓虹粉光"), 
    'neon_green': NeonEffect((57, 255, 20), "霓虹绿光"),
    'neon_purple': NeonEffect((148, 0, 211), "霓虹紫光"),
    'fire_text': FireEffect(),
    'ice_text': IceEffect(),
    'gold_text': GoldEffect(),
    'shadow_black': ShadowEffect((0, 0, 0), (8, 8), 5),
    'shadow_colored': ShadowEffect((128, 0, 128), (10, 10), 6),
    'rainbow': RainbowEffect(),
    'emboss': EmbossEffect(),
    'cyberpunk': CyberpunkEffect(),
}

# --- 7. 加载函数 ---
def load_available_fonts():
    font_files = []
    if os.path.isdir(FONTS_DIR):
        font_files = [f for f in os.listdir(FONTS_DIR) if f.lower().endswith(('.ttf', '.otf'))]
    
    if not font_files:
        print(f"⚠️ 警告: '{FONTS_DIR}' 文件夹未找到或为空。")
        return []
    else:
        print(f"✅ 找到 {len(font_files)} 个字体文件")
        return font_files

def load_available_images():
    image_files = []
    if os.path.isdir(INPUT_IMAGES_DIR):
        image_files = [f for f in os.listdir(INPUT_IMAGES_DIR) 
                      if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.webp'))]
    
    if not image_files:
        print(f"⚠️ 警告: '{INPUT_IMAGES_DIR}' 文件夹未找到或为空。")
        return []
    else:
        print(f"✅ 找到 {len(image_files)} 个图像文件")
        return image_files

def load_bbox_images():
    """加载bbox标注图像"""
    bbox_files = []
    if os.path.isdir(BBOX_IMAGES_DIR):
        bbox_files = [f for f in os.listdir(BBOX_IMAGES_DIR) 
                     if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.webp'))]
        print(f"✅ 找到 {len(bbox_files)} 个bbox标注图像")
    else:
        print(f"⚠️ bbox目录不存在: {BBOX_IMAGES_DIR}")
    return bbox_files

AVAILABLE_FONTS = load_available_fonts()
AVAILABLE_IMAGES = load_available_images()
BBOX_IMAGES = load_bbox_images()

FONT_SIZE_OPTIONS = [24, 32, 40, 48, 56, 64]

LAYOUT_POSITIONS = {
    'top-left': lambda w, h: (int(w * 0.1), int(h * 0.1)),
    'top-center': lambda w, h: (int(w * 0.5), int(h * 0.1)),
    'top-right': lambda w, h: (int(w * 0.9), int(h * 0.1)),
    'center-left': lambda w, h: (int(w * 0.1), int(h * 0.5)),
    'center': lambda w, h: (int(w * 0.5), int(h * 0.5)),
    'center-right': lambda w, h: (int(w * 0.9), int(h * 0.5)),
    'bottom-left': lambda w, h: (int(w * 0.1), int(h * 0.85)),
    'bottom-center': lambda w, h: (int(w * 0.5), int(h * 0.85)),
    'bottom-right': lambda w, h: (int(w * 0.9), int(h * 0.85)),
}

def smart_position_text(image_size, text, font, position_key):
    """智能调整文本位置，确保不溢出（简单模式用）"""
    width, height = image_size
    
    temp_img = Image.new('RGB', (1, 1))
    temp_draw = ImageDraw.Draw(temp_img)
    bbox = temp_draw.textbbox((0, 0), text, font=font)
    text_width = bbox[2] - bbox[0]
    text_height = bbox[3] - bbox[1]
    
    margin_x = max(20, text_width * 0.05)
    margin_y = max(20, text_height * 0.05)
    
    position_func = LAYOUT_POSITIONS.get(position_key, LAYOUT_POSITIONS['center'])
    base_x, base_y = position_func(width, height)
    
    if 'center' in position_key:
        if 'top' in position_key or 'bottom' in position_key:
            x = base_x - text_width // 2
        elif 'left' in position_key or 'right' in position_key:
            x = base_x
            if 'right' in position_key:
                x = base_x - text_width
        else:
            x = base_x - text_width // 2
            
        y = base_y
        if 'center' == position_key:
            y = base_y - text_height // 2
    else:
        x, y = base_x, base_y
        if 'right' in position_key:
            x = base_x - text_width
        if 'bottom' in position_key:
            y = base_y - text_height
    
    x = max(margin_x, min(x, width - text_width - margin_x))
    y = max(margin_y, min(y, height - text_height - margin_y))
    
    return (int(x), int(y))

# --- 8. A/B文本变化生成器（保持不变） ---
def generate_text_variations(original_text, variation_type="random"):
    """生成A/B对比的文本变化"""
    
    words = original_text.split()
    
    if variation_type == "insert" or (variation_type == "random" and random.choice([True, False, False, False, False])):
        # 文本插入：在随机位置插入词汇
        insert_words = ["amazing", "incredible", "fantastic", "awesome", "brilliant", "spectacular", "magnificent", "extraordinary"]
        insert_word = random.choice(insert_words)
        insert_pos = random.randint(0, len(words))
        new_words = words[:insert_pos] + [insert_word] + words[insert_pos:]
        return " ".join(new_words), "INSERT"
    
    elif variation_type == "delete" or (variation_type == "random" and len(words) > 5 and random.choice([True, False, False, False, False])):
        # 文本删除：删除1-2个词
        delete_count = min(2, max(1, len(words) // 5))
        new_words = words[:]
        for _ in range(delete_count):
            if len(new_words) > 3:
                del_pos = random.randint(1, len(new_words) - 2)  # 不删除首尾词
                new_words.pop(del_pos)
        return " ".join(new_words), "DELETE"
    
    elif variation_type == "replace" or (variation_type == "random" and random.choice([True, False, False])):
        # 文本替换：替换1-2个词汇
        replacement_dict = {
            "future": "tomorrow", "past": "yesterday", "present": "today",
            "great": "amazing", "good": "excellent", "bad": "terrible",
            "big": "huge", "small": "tiny", "fast": "quick", "slow": "steady",
            "beautiful": "gorgeous", "ugly": "hideous", "smart": "brilliant",
            "strong": "powerful", "weak": "fragile", "happy": "joyful",
            "sad": "sorrowful", "love": "adore", "hate": "despise",
            "world": "universe", "earth": "planet", "space": "cosmos",
            "technology": "innovation", "computer": "machine", "digital": "electronic",
            "human": "person", "people": "individuals", "life": "existence"
        }
        
        new_words = words[:]
        replaced = False
        
        # 尝试替换已知词汇
        for i, word in enumerate(new_words):
            clean_word = word.lower().strip('.,!?";:')
            if clean_word in replacement_dict:
                # 保持原有的大小写和标点
                replacement = replacement_dict[clean_word]
                if word[0].isupper():
                    replacement = replacement.capitalize()
                # 保持标点符号
                punctuation = ''.join(c for c in word if not c.isalpha())
                new_words[i] = replacement + punctuation
                replaced = True
                break
        
        # 如果没有找到可替换的词，随机替换一个
        if not replaced and len(words) > 2:
            replace_pos = random.randint(1, len(words) - 2)
            synonyms = ["incredible", "amazing", "fantastic", "brilliant", "spectacular", "remarkable", "outstanding", "exceptional"]
            new_words[replace_pos] = random.choice(synonyms)
        
        return " ".join(new_words), "REPLACE"
    
    elif variation_type == "move" or (variation_type == "random" and len(words) > 4 and random.choice([True, False, False, False])):
        # 文本移动：移动词汇位置
        if len(words) >= 4:
            new_words = words[:]
            # 随机选择要移动的词汇段
            move_start = random.randint(0, len(words) - 2)
            move_end = min(move_start + random.randint(1, 2), len(words))
            moved_segment = new_words[move_start:move_end]
            
            # 从原位置删除
            del new_words[move_start:move_end]
            
            # 插入到新位置
            new_pos = random.randint(0, len(new_words))
            new_words = new_words[:new_pos] + moved_segment + new_words[new_pos:]
            
            return " ".join(new_words), "MOVE"
    
    # 默认情况：随机选择一种变化
    variation_types = ["insert", "replace"]
    if len(words) > 5:
        variation_types.append("delete")
    if len(words) > 4:
        variation_types.append("move")
    
    selected_type = random.choice(variation_types)
    return generate_text_variations(original_text, selected_type)

# --- 9. 选择函数（修复输入问题） ---
def choose_text():
    """选择文本内容 - 彻底修复长句输入"""
    print("\n📝 === 文本输入 === 📝")
    print("💡 输入你想要的文字内容（支持长句子，多次回车不影响）")
    print(f"🎲 或留空直接回车从 {len(LONG_TEXT_SAMPLES)} 个长句中随机选择")
    
    # 使用修复的输入函数，wait_for_text=True 确保长句不卡顿
    choice = get_user_input_fixed("请输入文本: ", wait_for_text=True, default=None)
    
    if not choice:
        selected = random.choice(LONG_TEXT_SAMPLES)
        print(f"🎲 随机选择: '{selected[:60]}{'...' if len(selected) > 60 else ''}'")
        return selected
    
    return choice

def choose_text_effect():
    """选择特效"""
    effects = list(TEXT_EFFECTS.keys())
    
    print("\n🎨 === 特效选择 === 🎨")
    for i, effect_key in enumerate(effects):
        effect_obj = TEXT_EFFECTS[effect_key]
        icons = {
            'neon_blue': '💙', 'neon_pink': '💖', 'neon_green': '💚', 'neon_purple': '💜',
            'fire_text': '🔥', 'ice_text': '❄️', 'gold_text': '⭐', 
            'shadow_black': '🌑', 'shadow_colored': '🟣', 'rainbow': '🌈',
            'emboss': '🏛️', 'cyberpunk': '🤖'
        }
        icon = icons.get(effect_key, '✨')
        print(f"{i+1:2d}. {icon} {effect_obj.name}")
    
    choice = get_user_input_fixed(f"\n选择特效 (1-{len(effects)}) 或回车随机: ")
    
    if choice is None or not choice.strip():
        selected = random.choice(effects)
        print(f"🎲 随机选择: {TEXT_EFFECTS[selected].name}")
        return selected
    
    try:
        idx = int(choice) - 1
        if 0 <= idx < len(effects):
            selected = effects[idx]
            print(f"✅ 选择: {TEXT_EFFECTS[selected].name}")
            return selected
    except ValueError:
        pass
    
    selected = random.choice(effects)
    print(f"🎲 随机选择: {TEXT_EFFECTS[selected].name}")
    return selected

def choose_font():
    """选择字体"""
    if not AVAILABLE_FONTS:
        print("❌ 使用系统默认字体")
        return None
        
    print("\n📝 === 字体选择 === 📝")
    for i, font in enumerate(AVAILABLE_FONTS[:10]):
        print(f"{i+1:2d}. {font}")
    
    choice = get_user_input_fixed(f"选择字体 (1-{min(10, len(AVAILABLE_FONTS))}) 或回车随机: ")
    
    if choice is None or not choice.strip():
        selected = random.choice(AVAILABLE_FONTS)
        print(f"🎲 随机: {selected}")
        return selected
    
    try:
        idx = int(choice) - 1
        if 0 <= idx < min(10, len(AVAILABLE_FONTS)):
            print(f"✅ 选择: {AVAILABLE_FONTS[idx]}")
            return AVAILABLE_FONTS[idx]
    except ValueError:
        pass
    
    selected = random.choice(AVAILABLE_FONTS)
    print(f"🎲 随机: {selected}")
    return selected

def choose_font_size():
    """选择字体大小"""
    print("\n📏 === 字号选择 === 📏")
    for i, size in enumerate(FONT_SIZE_OPTIONS):
        print(f"{i+1}. {size}pt")
    
    choice = get_user_input_fixed(f"选择字号 (1-{len(FONT_SIZE_OPTIONS)}) 或回车随机: ")
    
    if choice is None or not choice.strip():
        selected = random.choice(FONT_SIZE_OPTIONS)
        print(f"🎲 随机: {selected}pt")
        return selected
    
    try:
        idx = int(choice) - 1
        if 0 <= idx < len(FONT_SIZE_OPTIONS):
            print(f"✅ 选择: {FONT_SIZE_OPTIONS[idx]}pt")
            return FONT_SIZE_OPTIONS[idx]
    except ValueError:
        pass
    
    selected = random.choice(FONT_SIZE_OPTIONS)
    print(f"🎲 随机: {selected}pt")
    return selected

def choose_image():
    """选择背景图片"""
    if not AVAILABLE_IMAGES:
        print("❌ 没有可用图片")
        return None
    
    print("\n🖼️ === 背景图片 === 🖼️")
    for i, img in enumerate(AVAILABLE_IMAGES[:10]):
        # 检查是否有对应的bbox图
        bbox_path = find_matching_bbox_image(img)
        bbox_indicator = " 📦" if bbox_path else ""
        print(f"{i+1:2d}. {img}{bbox_indicator}")
    
    choice = get_user_input_fixed(f"选择图片 (1-{min(10, len(AVAILABLE_IMAGES))}) 或回车随机: ")
    
    if choice is None or not choice.strip():
        selected = random.choice(AVAILABLE_IMAGES)
        print(f"🎲 随机: {selected}")
        return os.path.join(INPUT_IMAGES_DIR, selected)
    
    try:
        idx = int(choice) - 1
        if 0 <= idx < min(10, len(AVAILABLE_IMAGES)):
            print(f"✅ 选择: {AVAILABLE_IMAGES[idx]}")
            return os.path.join(INPUT_IMAGES_DIR, AVAILABLE_IMAGES[idx])
    except ValueError:
        pass
    
    selected = random.choice(AVAILABLE_IMAGES)
    print(f"🎲 随机: {selected}")
    return os.path.join(INPUT_IMAGES_DIR, selected)

def choose_position():
    """选择文本位置"""
    positions = list(LAYOUT_POSITIONS.keys())
    
    print("\n📍 === 文本位置 === 📍")
    position_icons = {
        'top-left': '↖️', 'top-center': '⬆️', 'top-right': '↗️',
        'center-left': '⬅️', 'center': '⭕', 'center-right': '➡️',
        'bottom-left': '↙️', 'bottom-center': '⬇️', 'bottom-right': '↘️'
    }
    
    for i, pos in enumerate(positions):
        icon = position_icons.get(pos, '📍')
        print(f"{i+1:2d}. {icon} {pos}")
    
    choice = get_user_input_fixed(f"选择位置 (1-{len(positions)}) 或回车随机: ")
    
    if choice is None or not choice.strip():
        selected = random.choice(positions)
        print(f"🎲 随机: {selected}")
        return selected
    
    try:
        idx = int(choice) - 1
        if 0 <= idx < len(positions):
            print(f"✅ 选择: {positions[idx]}")
            return positions[idx]
    except ValueError:
        pass
    
    selected = random.choice(positions)
    print(f"🎲 随机: {selected}")
    return selected

def choose_render_mode():
    """选择渲染模式：简单模式 vs bbox模式"""
    print("\n🎯 === 渲染模式选择 === 🎯")
    print("1. 📍 简单模式 - 预设位置 (左上、右下等)")
    print("2. 📦 BBOX模式 - 红框精准定位 (需要bbox标注图)")
    
    if not BBOX_IMAGES:
        print("⚠️ 未检测到bbox标注图，将使用简单模式")
        return "simple"
    
    choice = get_user_input_fixed("选择模式 (1-2) 或回车默认简单: ", default="1")
    
    if choice == "2":
        print("✅ 选择: BBOX模式 - 红框精准定位")
        return "bbox"
    else:
        print("✅ 选择: 简单模式 - 预设位置")
        return "simple"

# --- 10. 升级版渲染函数 ---
def render_text_with_effects_upgraded(input_image_path: str, text: str, effect_key: str, 
                                    font_file: Optional[str], position_key: str, 
                                    output_path: str, font_size: int = 48, 
                                    create_mask: bool = False, render_mode: str = "simple") -> Optional[str]:
    """升级版渲染函数，完美支持智能换行"""
    
    try:
        # 1. 加载背景图像
        bg_image = Image.open(input_image_path).convert('RGBA')
        width, height = bg_image.size
        
        # 2. 加载字体（保持不变）
        font = None
        if font_file:
            font_path = os.path.join(FONTS_DIR, font_file)
            if os.path.exists(font_path):
                try:
                    font = ImageFont.truetype(font_path, font_size)
                except Exception as e:
                    print(f"⚠️ 字体加载失败: {e}")
        
        if font is None:
            try:
                import platform
                if platform.system() == "Windows":
                    font = ImageFont.truetype("arial.ttf", font_size)
                else:
                    font = ImageFont.load_default()
            except:
                font = ImageFont.load_default()
        
        # 3. 智能决定文本位置
        bbox = None
        positioned_lines = None
        
        if render_mode == "bbox":
            # BBOX模式：智能多行处理
            image_name = os.path.basename(input_image_path)
            bbox_image_path = find_matching_bbox_image(image_name)
            
            if bbox_image_path:
                bbox = detect_red_bbox_improved(bbox_image_path)
                if bbox:
                    # 🧠 使用新的智能换行系统
                    positioned_lines = smart_fit_text_to_bbox(text, font, bbox)
                    print(f"📦 智能BBOX: {len(positioned_lines)} 行完美适配")
                else:
                    print("⚠️ bbox检测失败，回退到简单模式")
                    render_mode = "simple"
            else:
                print("⚠️ 未找到bbox图像，回退到简单模式")
                render_mode = "simple"
        
        if render_mode == "simple":
            # 简单模式：单行位置
            position = smart_position_text(bg_image.size, text, font, position_key)
            print(f"📍 简单模式: 位置=({position[0]}, {position[1]})")
        
        # 4. 生成掩码
        if create_mask:
            mask_image = Image.new('RGB', (width, height), (0, 0, 0))
            mask_draw = ImageDraw.Draw(mask_image)
            
            if positioned_lines:
                # 多行掩码
                for line_data in positioned_lines:
                    mask_draw.text(line_data['position'], line_data['text'], font=font, fill=(255, 255, 255))
            else:
                # 单行掩码
                mask_draw.text(position, text, font=font, fill=(255, 255, 255))
            
            mask_image.save(output_path)
            return output_path
        
        # 5. 智能特效渲染
        effect = TEXT_EFFECTS.get(effect_key)
        if not effect:
            print(f"❌ 未找到特效: {effect_key}")
            return None
        
        # 🎨 根据模式渲染
        if positioned_lines:
            # 多行模式：直接在特效层渲染
            effect_layer = Image.new('RGBA', bg_image.size, (0, 0, 0, 0))
            effect_layer = render_multiline_text_effect(effect_layer, positioned_lines, font, effect, effect_key)
            result_image = Image.alpha_composite(bg_image, effect_layer)
        else:
            # 单行模式：使用原有逻辑
            result_image = effect.apply(bg_image, text, position, font, bbox)
        
        # 6. 保存结果
        if output_path.lower().endswith(('.jpg', '.jpeg')):
            final_image = Image.new('RGB', result_image.size, (255, 255, 255))
            final_image.paste(result_image, mask=result_image.split()[-1] if result_image.mode == 'RGBA' else None)
            final_image.save(output_path, quality=95)
        else:
            result_image.save(output_path)
        
        return output_path
        
    except Exception as e:
        print(f"❌ 渲染失败: {str(e)}")
        import traceback
        traceback.print_exc()
        return None

# --- 11. 升级版A/B生成函数 ---
def generate_ab_comparison_upgraded(sequence_number=1):
    """升级版A/B对比生成：支持bbox模式"""
    
    print(f"\n🎬 === 生成第 {sequence_number} 组 A/B 对比 (升级版) === 🎬")
    
    # 选择渲染模式
    render_mode = choose_render_mode()
    
    # 选择共同参数（A/B完全相同）
    image_path = choose_image()
    if not image_path:
        print("❌ 没有可用图像")
        return None
    
    text_a = choose_text()
    effect_key = choose_text_effect()
    font_file_a = choose_font()
    font_size = choose_font_size()
    
    if render_mode == "simple":
        position = choose_position()
    else:
        position = "bbox"  # bbox模式不需要选择位置
    
    # 生成B版本的变化
    print(f"\n🔄 === 生成B版本变化 === 🔄")
    print("选择变化类型:")
    print("1. 📝 文本插入 (INSERT)")
    print("2. ✂️ 文本删除 (DELETE)")
    print("3. 🔄 文本替换 (REPLACE)")
    print("4. 🚚 文本移动 (MOVE)")
    print("5. 🔤 不同字体 (FONT)")
    print("6. 🎲 随机变化")
    
    change_choice = get_user_input_fixed("选择变化 (1-6) 或回车随机: ", default='6')
    
    # 根据选择生成B版本
    if change_choice == '1':
        text_b, change_type = generate_text_variations(text_a, "insert")
        font_file_b = font_file_a
    elif change_choice == '2':
        text_b, change_type = generate_text_variations(text_a, "delete")
        font_file_b = font_file_a
    elif change_choice == '3':
        text_b, change_type = generate_text_variations(text_a, "replace")
        font_file_b = font_file_a
    elif change_choice == '4':
        text_b, change_type = generate_text_variations(text_a, "move")
        font_file_b = font_file_a
    elif change_choice == '5':
        text_b = text_a
        font_file_b = random.choice(AVAILABLE_FONTS) if AVAILABLE_FONTS and len(AVAILABLE_FONTS) > 1 else font_file_a
        # 确保字体不同
        if font_file_b == font_file_a and len(AVAILABLE_FONTS) > 1:
            available_different_fonts = [f for f in AVAILABLE_FONTS if f != font_file_a]
            font_file_b = random.choice(available_different_fonts)
        change_type = "FONT_CHANGE"
    else:
        # 随机选择变化类型
        if AVAILABLE_FONTS and len(AVAILABLE_FONTS) > 1:
            change_types = ["text", "font"]
            selected_change = random.choice(change_types)
            if selected_change == "font":
                text_b = text_a
                font_file_b = random.choice([f for f in AVAILABLE_FONTS if f != font_file_a])
                change_type = "FONT_CHANGE"
            else:
                text_b, change_type = generate_text_variations(text_a, "random")
                font_file_b = font_file_a
        else:
            text_b, change_type = generate_text_variations(text_a, "random")
            font_file_b = font_file_a
    
    # 创建文件名
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    effect_name = TEXT_EFFECTS[effect_key].name.replace(' ', '_').replace('-', '_')
    mode_suffix = "BBOX" if render_mode == "bbox" else "SIMPLE"
    base_filename = f"AB_{sequence_number:03d}_{timestamp}_{effect_name}_{change_type}_{mode_suffix}"
    
    # 文件路径
    a_rendered_path = os.path.join(OUTPUT_DIR, f"{base_filename}_A_rendered.png")
    a_mask_path = os.path.join(OUTPUT_DIR, f"{base_filename}_A_mask.png")
    b_rendered_path = os.path.join(OUTPUT_DIR, f"{base_filename}_B_rendered.png")
    b_mask_path = os.path.join(OUTPUT_DIR, f"{base_filename}_B_mask.png")
    
    # 显示参数对比
    print(f"\n📋 === A/B 参数对比 (升级版) === 📋")
    print(f"🖼️ 背景图片: {os.path.basename(image_path)} (相同)")
    print(f"🎯 渲染模式: {mode_suffix} (相同)")
    print(f"🎨 特效: {TEXT_EFFECTS[effect_key].name} (相同)")
    print(f"📏 字号: {font_size}pt (相同)")
    if render_mode == "simple":
        print(f"📍 位置: {position} (相同)")
    else:
        print(f"📦 位置: 红框BBOX区域 (相同)")
    print(f"🔤 字体 A: {font_file_a or '系统默认'}")
    print(f"🔤 字体 B: {font_file_b or '系统默认'}")
    print(f"📝 文本 A: '{text_a[:50]}{'...' if len(text_a) > 50 else ''}'")
    print(f"📝 文本 B: '{text_b[:50]}{'...' if len(text_b) > 50 else ''}'")
    print(f"🔄 变化类型: {change_type}")
    
    # 生成4张图片
    results = {}
    
    print(f"\n🎨 生成 A 图 (特效)...")
    results['a_rendered'] = render_text_with_effects_upgraded(
        input_image_path=image_path,
        text=text_a,
        effect_key=effect_key,
        font_file=font_file_a,
        position_key=position,
        output_path=a_rendered_path,
        font_size=font_size,
        create_mask=False,
        render_mode=render_mode
    )
    
    print(f"⚫ 生成 A 图 (掩码)...")
    results['a_mask'] = render_text_with_effects_upgraded(
        input_image_path=image_path,
        text=text_a,
        effect_key=effect_key,
        font_file=font_file_a,
        position_key=position,
        output_path=a_mask_path,
        font_size=font_size,
        create_mask=True,
        render_mode=render_mode
    )
    
    print(f"🎨 生成 B 图 (特效)...")
    results['b_rendered'] = render_text_with_effects_upgraded(
        input_image_path=image_path,
        text=text_b,
        effect_key=effect_key,
        font_file=font_file_b,
        position_key=position,
        output_path=b_rendered_path,
        font_size=font_size,
        create_mask=False,
        render_mode=render_mode
    )
    
    print(f"⚫ 生成 B 图 (掩码)...")
    results['b_mask'] = render_text_with_effects_upgraded(
        input_image_path=image_path,
        text=text_b,
        effect_key=effect_key,
        font_file=font_file_b,
        position_key=position,
        output_path=b_mask_path,
        font_size=font_size,
        create_mask=True,
        render_mode=render_mode
    )
    
    # 检查结果
    success_count = sum(1 for result in results.values() if result is not None)
    
    if success_count == 4:
        print(f"\n✅ A/B 对比生成完成! ({success_count}/4)")
        print(f"   🎨 A 特效: {os.path.basename(a_rendered_path)}")
        print(f"   ⚫ A 掩码: {os.path.basename(a_mask_path)}")
        print(f"   🎨 B 特效: {os.path.basename(b_rendered_path)}")
        print(f"   ⚫ B 掩码: {os.path.basename(b_mask_path)}")
        print(f"   🎯 模式: {mode_suffix}")
        print(f"   🔄 变化: {change_type}")
        return results
    else:
        print(f"❌ 部分失败 ({success_count}/4)")
        return results

# --- 12. 主程序 ---
def main():
    """升级版主函数"""
    # 创建所有必要目录
    for dir_path in [FONTS_DIR, INPUT_IMAGES_DIR, BBOX_IMAGES_DIR, OUTPUT_DIR]:
        os.makedirs(dir_path, exist_ok=True)
    
    print("🌟 === BBOX升级版文字特效渲染工具 === 🌟")
    print("✨ 新功能：红框BBOX精准定位 + 修复回车问题 + A/B对比 + 多行自适应")
    print(f"📝 拥有 {len(LONG_TEXT_SAMPLES)} 个长句选项！")
    print(f"🎨 拥有 {len(TEXT_EFFECTS)} 种高质量特效")
    print(f"📦 支持BBOX模式：在 '{BBOX_IMAGES_DIR}' 放入红框标注图")
    
    # 检查目录状态
    if not AVAILABLE_IMAGES:
        print(f"\n❌ 请在 '{INPUT_IMAGES_DIR}' 目录中放入背景图片")
        return
    
    if not BBOX_IMAGES:
        print(f"\n💡 可选：在 '{BBOX_IMAGES_DIR}' 目录中放入对应的红框标注图启用BBOX模式")
        print("   标注图命名需与背景图一致（如：bg1.jpg 对应 bg1.png）")
    
    while True:
        print("\n🎯 === 选择模式 === 🎯")
        print("1. 🎬 生成A/B对比 (推荐) - 支持BBOX模式")
        print("2. 🎲 快速A/B随机生成")
        print("3. 🚀 批量A/B样本")
        print("4. 🧪 BBOX测试 - 测试红框检测")
        print("5. 🎨 预览所有特效")
        print("6. 🚪 退出")
        
        choice = get_user_input_fixed("选择模式 (1-6) 或回车默认A/B: ", default='1')
        
        if choice == '1':
            count_input = get_user_input_fixed("生成A/B组数 (默认1): ", default='1')
            try:
                count = int(count_input) if count_input else 1
                for i in range(count):
                    print(f"\n=== 生成第 {i+1}/{count} 组A/B对比 ===")
                    results = generate_ab_comparison_upgraded(i+1)
                    if results and all(results.values()):
                        print(f"✅ 第 {i+1} 组A/B对比完成")
                print(f"\n🎉 全部完成! 每组生成4张图片（A图+A掩码+B图+B掩码）")
            except ValueError:
                generate_ab_comparison_upgraded(1)
        
        elif choice == '2':
            print(f"\n🎲 快速随机A/B生成...")
            image_path = os.path.join(INPUT_IMAGES_DIR, random.choice(AVAILABLE_IMAGES))
            text_a = random.choice(LONG_TEXT_SAMPLES)
            text_b, change_type = generate_text_variations(text_a, "random")
            effect_key = random.choice(list(TEXT_EFFECTS.keys()))
            font_file = random.choice(AVAILABLE_FONTS) if AVAILABLE_FONTS else None
            font_size = random.choice(FONT_SIZE_OPTIONS)
            position_key = random.choice(list(LAYOUT_POSITIONS.keys()))
            render_mode = "bbox" if BBOX_IMAGES and random.choice([True, False]) else "simple"
            
            timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
            mode_suffix = "BBOX" if render_mode == "bbox" else "SIMPLE"
            base_name = f"random_AB_{timestamp}_{change_type}_{mode_suffix}"
            
            paths = {
                'a_rendered': os.path.join(OUTPUT_DIR, f"{base_name}_A_rendered.png"),
                'a_mask': os.path.join(OUTPUT_DIR, f"{base_name}_A_mask.png"),
                'b_rendered': os.path.join(OUTPUT_DIR, f"{base_name}_B_rendered.png"),
                'b_mask': os.path.join(OUTPUT_DIR, f"{base_name}_B_mask.png")
            }
            
            print(f"🎲 随机参数: 特效={TEXT_EFFECTS[effect_key].name} | 变化={change_type} | 模式={mode_suffix}")
            
            # 生成4张图
            success = 0
            for key, path in paths.items():
                is_b = 'b_' in key
                is_mask = '_mask' in key
                text = text_b if is_b else text_a
                
                result = render_text_with_effects_upgraded(
                    image_path, text, effect_key, font_file, position_key, 
                    path, font_size, create_mask=is_mask, render_mode=render_mode
                )
                if result:
                    success += 1
            
            print(f"🎉 随机A/B生成完成! 成功: {success}/4")
        
        elif choice == '3':
            if not AVAILABLE_IMAGES:
                print("❌ 需要背景图片")
                continue
                
            sample_image = os.path.join(INPUT_IMAGES_DIR, AVAILABLE_IMAGES[0])
            sample_text = random.choice(LONG_TEXT_SAMPLES)
            sample_font = AVAILABLE_FONTS[0] if AVAILABLE_FONTS else None
            render_mode = "simple"  # 批量模式使用简单模式
            
            print(f"\n🚀 批量生成A/B样本... 使用文本: '{sample_text[:40]}...'")
            
            for i, (effect_key, effect_obj) in enumerate(TEXT_EFFECTS.items()):
                print(f"生成 {i+1}/{len(TEXT_EFFECTS)}: {effect_obj.name}")
                
                text_b, change_type = generate_text_variations(sample_text, "random")
                timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S_%f')[:-3]
                base_name = f"sample_AB_{effect_key}_{timestamp}"
                
                # 生成A/B两张特效图
                a_path = os.path.join(OUTPUT_DIR, f"{base_name}_A.png")
                b_path = os.path.join(OUTPUT_DIR, f"{base_name}_B.png")
                
                render_text_with_effects_upgraded(
                    sample_image, sample_text, effect_key, sample_font, 'center', 
                    a_path, 48, False, render_mode
                )
                render_text_with_effects_upgraded(
                    sample_image, text_b, effect_key, sample_font, 'center', 
                    b_path, 48, False, render_mode
                )
                
                time.sleep(0.1)
            
            print(f"🎉 批量完成! 每种特效生成A/B对比图")
        
        elif choice == '4':
            print("\n🧪 === BBOX测试模式 === 🧪")
            
            if not BBOX_IMAGES:
                print("❌ 未找到bbox标注图")
                print(f"请在 '{BBOX_IMAGES_DIR}' 目录中放入红框标注图")
                continue
            
            print("可用的bbox标注图:")
            for i, bbox_img in enumerate(BBOX_IMAGES):
                print(f"{i+1}. {bbox_img}")
            
            test_choice = get_user_input_fixed(f"选择要测试的图片 (1-{len(BBOX_IMAGES)}): ", default="1")
            try:
                idx = int(test_choice) - 1 if test_choice else 0
                if 0 <= idx < len(BBOX_IMAGES):
                    test_bbox_path = os.path.join(BBOX_IMAGES_DIR, BBOX_IMAGES[idx])
                    bbox = detect_red_bbox_improved(test_bbox_path)
                    if bbox:
                        x1, y1, x2, y2 = bbox
                        print(f"✅ 检测成功!")
                        print(f"   位置: ({x1}, {y1}) 到 ({x2}, {y2})")
                        print(f"   尺寸: {x2-x1} x {y2-y1}")
                    else:
                        print("❌ 检测失败")
                else:
                    print("❌ 无效选择")
            except ValueError:
                print("❌ 输入错误")
        
        elif choice == '5':
            print("\n🎨 === 特效预览（升级版） === 🎨")
            categories = {
                '霓虹特效': ['neon_blue', 'neon_pink', 'neon_green', 'neon_purple'],
                '自然特效': ['fire_text', 'ice_text', 'gold_text'],
                '阴影特效': ['shadow_black', 'shadow_colored'],
                '艺术特效': ['rainbow', 'emboss', 'cyberpunk']
            }
            
            for category, effects in categories.items():
                print(f"\n📂 {category}:")
                for effect_key in effects:
                    if effect_key in TEXT_EFFECTS:
                        effect = TEXT_EFFECTS[effect_key]
                        icons = {
                            'neon_blue': '💙', 'neon_pink': '💖', 'neon_green': '💚', 'neon_purple': '💜',
                            'fire_text': '🔥', 'ice_text': '❄️', 'gold_text': '⭐', 
                            'shadow_black': '🌑', 'shadow_colored': '🟣', 'rainbow': '🌈',
                            'emboss': '🏛️', 'cyberpunk': '🤖'
                        }
                        icon = icons.get(effect_key, '✨')
                        print(f"   {icon} {effect.name}")
            
            print(f"\n💡 总计 {len(TEXT_EFFECTS)} 种优化特效!")
            print("📦 新增BBOX模式: 红框精准定位")
            print("📝 5种A/B变化: INSERT, DELETE, REPLACE, MOVE, FONT")
            print("🔧 修复: 彻底解决回车输入问题")
        
        elif choice == '6' or choice is None:
            print("🎨 再见!")
            break
        
        else:
            print("⚠️ 无效选择")

if __name__ == "__main__":
    main()

print("\n🎊 === BBOX升级版A/B对比工具完成 === 🎊")