WYF-koubo/python/advanced_cover_generator.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
高级封面生成器 - 支持完整的模板功能
Advanced Cover Generator - Full Template Support

功能：
- 背景模糊
- 人物抠图
- 人物描边
- 蒙版叠加
- 自定义字体和文字样式
- 步骤化生成，每步生成预览图
"""

import os
import sys
import json
import argparse
from typing import Dict, Any, Optional, Tuple
from pathlib import Path

# ⚠️ 修复模块路径：确保 Python 能找到 modules 和其他本地模块
# 将脚本所在目录（python 目录）添加到 sys.path
script_dir = os.path.dirname(os.path.abspath(__file__))

# 🔧 关键修复：在打包环境中，modules可能在当前目录或上级目录
# 添加多个可能的路径
possible_paths = [
    script_dir,                          # 脚本所在目录
    os.path.join(script_dir, '..'),     # 上一级目录（如果python-scripts是子目录）
    os.getcwd(),                         # 当前工作目录
]

for path in possible_paths:
    abs_path = os.path.abspath(path)
    if abs_path not in sys.path:
        sys.path.insert(0, abs_path)
        print(f"[PATH] Added to sys.path: {abs_path}", file=sys.stderr, flush=True)

print(f"[PATH] Current sys.path (first 3): {sys.path[:3]}", file=sys.stderr, flush=True)  # 显示前3个路径用于诊断

# ⚠️ 强制输出：验证Python脚本确实在运行
print("=" * 60, file=sys.stderr, flush=True)
print("ADVANCED_COVER_GENERATOR.PY STARTED", file=sys.stderr, flush=True)
print("=" * 60, file=sys.stderr, flush=True)
sys.stderr.flush()

# 导入基础库
try:
    import cv2
    import numpy as np
    from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance
    print("✅ Basic libraries loaded (cv2, numpy, PIL)", file=sys.stderr, flush=True)
except ImportError as e:
    print(f"❌ Error: Missing required library - {e}", file=sys.stderr, flush=True)
    sys.exit(1)

# 导入人像分割模块（支持MODNet和rembg）
try:
    from modules.segment import PersonSegmenter
    SEGMENT_AVAILABLE = True
    diag_segment = "✅ PersonSegmenter loaded successfully (supports MODNet + rembg)"
    print(diag_segment, file=sys.stderr)
    sys.stderr.flush()
except ImportError as e:
    SEGMENT_AVAILABLE = False
    PersonSegmenter = None
    diag_segment = f"❌ PersonSegmenter failed to load: {e}"
    print(diag_segment, file=sys.stderr)
    print(f"[DIAGNOSTIC] Attempted module paths:", file=sys.stderr)
    for p in sys.path[:5]:
        modules_path = os.path.join(p, 'modules', 'segment.py')
        exists = "EXISTS" if os.path.exists(modules_path) else "NOT FOUND"
        print(f"  {modules_path} - {exists}", file=sys.stderr)
    sys.stderr.flush()

    # 尝试其他可能的导入方式
    try:
        import modules.segment as seg_module
        PersonSegmenter = seg_module.PersonSegmenter
        SEGMENT_AVAILABLE = True
        print("✅ PersonSegmenter loaded via alternative import path", file=sys.stderr)
    except Exception as e2:
        print(f"❌ Alternative import also failed: {e2}", file=sys.stderr)
    sys.stderr.flush()


class AdvancedCoverGenerator:
    """高级封面生成器"""

    def __init__(self, config: Dict[str, Any]):
        """
        初始化生成器

        Args:
            config: 配置字典
        """
        self.config = config
        self.template = config
        self.output_dir = os.path.dirname(config.get('output', './output/cover.png'))
        self.output_path = config.get('output', './output/cover.png')

        # 创建输出目录
        os.makedirs(self.output_dir, exist_ok=True)

        # 步骤预览图列表
        self.preview_images = []
        
        # 初始化人像分割器（支持MODNet优先级，与参考项目一致）
        self.segmenter = None
        self.current_model = "none"
        if SEGMENT_AVAILABLE:
            self._init_segmenter()

    def _init_segmenter(self):
        """
        初始化人像分割器，按优先级尝试加载模型
        
        模型优先级（修复：优先使用rembg模型，避免依赖MODNet本地模型）：
        1. u2net - 通用高质量模型（rembg默认，会自动下载）
        2. u2net_human_seg - 人像专用模型
        3. u2netp - 轻量版模型
        4. silueta - 通用抠图模型
        5. modnet - MODNet专业人像抠图（仅作为备选）
        6. simple - 简化方法（后备）
        """
        model_priority = [
            "u2net",            # 通用高质量（rembg默认，优先使用）
            "u2net_human_seg",  # 人像专用
            "u2netp",           # 轻量版
            "silueta",          # 备用
            "modnet",           # MODNet专业人像（仅作为备选，避免本地模型依赖）
            "simple"            # 简化方法
        ]
        
        for model_name in model_priority:
            try:
                print(f"[COVER_GENERATOR] Trying to load segmentation model: {model_name}", file=sys.stderr)
                self.segmenter = PersonSegmenter(model_name=model_name)
                print(f"[COVER_GENERATOR] Successfully loaded segmentation model: {model_name}", file=sys.stderr)
                self.current_model = model_name
                return
            except Exception as e:
                print(f"[COVER_GENERATOR] Failed to load model {model_name}: {e}", file=sys.stderr)
                import traceback
                traceback.print_exc(file=sys.stderr)
                continue
        
        # 如果所有模型都失败
        print("[COVER_GENERATOR] Warning: All segmentation models failed", file=sys.stderr)
        self.segmenter = None
        self.current_model = "none"

    def _segment_person_with_modnet(self, pil_image: Image.Image) -> Image.Image:
        """
        使用PersonSegmenter进行人像分割（支持MODNet优先级）

        Args:
            pil_image: PIL Image对象（RGB或RGBA）

        Returns:
            分割后的PIL Image（RGBA格式，背景完全透明）
        """
        if self.segmenter is None:
            raise RuntimeError("PersonSegmenter not initialized")

        # 转换PIL Image到numpy数组（BGR格式，PersonSegmenter需要）
        img_np = np.array(pil_image)
        if img_np.shape[2] == 4:  # RGBA
            img_np = cv2.cvtColor(img_np, cv2.COLOR_RGBA2BGR)
        elif img_np.shape[2] == 3:  # RGB
            img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)

        # 使用PersonSegmenter进行分割（获取mask，而不是预处理后的图像）
        print(f"Using segmentation model: {self.current_model}", file=sys.stderr)

        # 关键修复：使用 return_mask=True 获取分割mask，而不是预处理后的图像
        # 这样可以确保背景被正确处理为透明
        _, mask = self.segmenter.segment_person(img_np, return_mask=True)

        # 确保mask是uint8格式
        if mask.dtype != np.uint8:
            if mask.max() <= 1.0:
                mask = (mask * 255).astype(np.uint8)
            else:
                mask = mask.astype(np.uint8)

        print(f"Segmentation mask: shape={mask.shape}, dtype={mask.dtype}, min={mask.min()}, max={mask.max()}", file=sys.stderr)

        # 将mask应用到原始图像，创建带透明背景的图像
        # 原始图像是RGB，需要转换为RGBA
        img_rgb = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)

        # 创建RGBA图像：RGB来自原始图像，A来自mask
        segmented_rgba = np.dstack([img_rgb, mask])

        print(f"Result image: shape={segmented_rgba.shape}, dtype={segmented_rgba.dtype}", file=sys.stderr)

        return Image.fromarray(segmented_rgba)

    def refine_mask(self, mask: np.ndarray) -> np.ndarray:
        """
        优化mask，提高人像分割精度，严格过滤背景物体
        
        改进策略：
        1. 高斯模糊平滑
        2. OTSU 自适应阈值
        3. 形态学操作（开运算去噪点，闭运算填充小洞）
        4. 智能轮廓过滤（基于位置、形状、面积多重条件）
        5. 边缘平滑
        
        Args:
            mask: 输入的 mask（numpy 数组）
            
        Returns:
            优化后的 mask
        """
        try:
            # 确保mask是uint8格式
            if mask.dtype != np.uint8:
                if mask.max() <= 1.0:
                    mask = (mask * 255).astype(np.uint8)
                else:
                    mask = mask.astype(np.uint8)
            
            h, w = mask.shape[:2]
            print(f"Refining mask: shape={mask.shape}, dtype={mask.dtype}", file=sys.stderr)
            
            # 1. 第一次高斯模糊（sigma=0.3）
            mask_blurred = cv2.GaussianBlur(mask, (3, 3), 0.3)
            
            # 2. 使用 OTSU 自适应阈值
            _, mask_binary = cv2.threshold(mask_blurred, 0, 255,
                                           cv2.THRESH_BINARY + cv2.THRESH_OTSU)
            
            # 3. 形态学操作
            # 开运算（去除噪点）- 使用小kernel保持细节
            kernel_small = np.ones((3, 3), np.uint8)
            mask_cleaned = cv2.morphologyEx(mask_binary, cv2.MORPH_OPEN,
                                           kernel_small, iterations=1)
            
            # 闭运算（填充小洞）- 使用中等kernel
            kernel_medium = np.ones((5, 5), np.uint8)
            mask_filled = cv2.morphologyEx(mask_cleaned, cv2.MORPH_CLOSE,
                                          kernel_medium, iterations=1)
            
            # 4. 智能轮廓过滤（严格过滤背景物体）
            contours, _ = cv2.findContours(mask_filled, cv2.RETR_EXTERNAL,
                                           cv2.CHAIN_APPROX_SIMPLE)
            
            if len(contours) > 0:
                # 找到最大轮廓（通常是人物主体）
                largest_contour = max(contours, key=cv2.contourArea)
                largest_area = cv2.contourArea(largest_contour)
                
                # 计算最大轮廓的中心点和边界框
                M = cv2.moments(largest_contour)
                if M["m00"] != 0:
                    largest_cx = int(M["m10"] / M["m00"])
                    largest_cy = int(M["m01"] / M["m00"])
                else:
                    largest_cx, largest_cy = w // 2, h // 2
                
                largest_x, largest_y, largest_w, largest_h = cv2.boundingRect(largest_contour)
                
                print(f"Largest contour: area={largest_area}, center=({largest_cx},{largest_cy}), bbox=({largest_x},{largest_y},{largest_w},{largest_h})", file=sys.stderr)
                
                # 创建新的mask，只保留符合条件的轮廓
                mask_refined = np.zeros_like(mask_filled)
                cv2.fillPoly(mask_refined, [largest_contour], 255)
                
                # 过滤其他轮廓（更严格的条件）
                kept_contours = 1
                for contour in contours:
                    if contour is largest_contour:
                        continue
                    
                    area = cv2.contourArea(contour)
                    
                    # 条件1: 面积必须大于最大轮廓的5%（提高阈值从1.5%到5%）
                    if area < largest_area * 0.05:
                        continue
                    
                    # 计算轮廓的中心点和边界框
                    M = cv2.moments(contour)
                    if M["m00"] != 0:
                        cx = int(M["m10"] / M["m00"])
                        cy = int(M["m01"] / M["m00"])
                    else:
                        continue
                    
                    x, y, cw, ch = cv2.boundingRect(contour)
                    
                    # 条件2: 必须与最大轮廓在垂直方向上有重叠（人物的手臂、腿等）
                    vertical_overlap = not (y + ch < largest_y or y > largest_y + largest_h)
                    if not vertical_overlap:
                        print(f"Filtered contour: no vertical overlap, area={area}, pos=({x},{y})", file=sys.stderr)
                        continue
                    
                    # 条件3: 水平距离不能太远（必须在最大轮廓宽度的1.5倍范围内）
                    horizontal_distance = min(abs(x - largest_x), abs((x + cw) - (largest_x + largest_w)))
                    max_horizontal_distance = largest_w * 1.5
                    if horizontal_distance > max_horizontal_distance:
                        print(f"Filtered contour: too far horizontally, distance={horizontal_distance}, area={area}", file=sys.stderr)
                        continue
                    
                    # 条件4: 长宽比检查（避免保留细长的背景物体）
                    aspect_ratio = cw / ch if ch > 0 else 0
                    # 人体部位的长宽比通常在0.2到5之间
                    if aspect_ratio < 0.2 or aspect_ratio > 5:
                        print(f"Filtered contour: abnormal aspect ratio={aspect_ratio:.2f}, area={area}", file=sys.stderr)
                        continue
                    
                    # 条件5: 位置检查（避免保留图像边缘的物体）
                    # 如果轮廓紧贴图像边缘且不是最大轮廓，很可能是背景物体
                    edge_margin = 10  # 边缘容差
                    is_at_edge = (x < edge_margin or y < edge_margin or
                                 x + cw > w - edge_margin or y + ch > h - edge_margin)
                    if is_at_edge and area < largest_area * 0.3:
                        print(f"Filtered contour: at edge with small area={area}, pos=({x},{y})", file=sys.stderr)
                        continue
                    
                    # 通过所有条件，保留此轮廓
                    cv2.fillPoly(mask_refined, [contour], 255)
                    kept_contours += 1
                    print(f"Kept contour: area={area}, center=({cx},{cy}), aspect_ratio={aspect_ratio:.2f}", file=sys.stderr)
                
                print(f"Contour filtering: kept {kept_contours}/{len(contours)} contours", file=sys.stderr)
                mask_filled = mask_refined
            
            # 5. 第二次高斯模糊使边缘自然（sigma=0.2）
            mask_smooth = cv2.GaussianBlur(mask_filled, (3, 3), 0.2)

            # 最终二值化（使用OTSU自动计算阈值，而不是固定值100）
            # 这样可以避免背景被误认为是人物
            _, mask_final = cv2.threshold(mask_smooth, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

            print(f"Mask refinement completed. Final mask: non-zero pixels={np.count_nonzero(mask_final)}", file=sys.stderr)
            return mask_final
            
        except Exception as e:
            print(f"Mask refinement failed: {e}", file=sys.stderr)
            import traceback
            traceback.print_exc(file=sys.stderr)
            return mask

    def hex_to_rgb(self, hex_color: str) -> Tuple[int, int, int]:
        """
        将十六进制颜色转换为RGB元组

        Args:
            hex_color: 十六进制颜色字符串（如 "#FFFFFF"）

        Returns:
            RGB元组
        """
        hex_color = hex_color.lstrip('#')
        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))

    def load_image(self, image_path: str) -> Image.Image:
        """
        加载图像

        Args:
            image_path: 图像路径

        Returns:
            PIL图像对象
        """
        print(f"Loading image: {image_path}", file=sys.stderr)

        if image_path.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp', '.webp')):
            # 直接加载图像
            return Image.open(image_path).convert('RGB')
        else:
            # 从视频提取帧
            cap = cv2.VideoCapture(image_path)
            ret, frame = cap.read()
            cap.release()

            if not ret:
                raise Exception("Failed to extract frame from video")

            # 转换BGR到RGB
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            return Image.fromarray(frame_rgb)

    def save_preview(self, image: Image.Image, step_name: str) -> str:
        """
        保存步骤预览图

        Args:
            image: PIL图像对象
            step_name: 步骤名称

        Returns:
            预览图路径
        """
        preview_path = os.path.join(
            self.output_dir,
            f"preview_{len(self.preview_images) + 1}_{step_name}.png"
        )
        image.save(preview_path, quality=95)
        self.preview_images.append({
            'step': len(self.preview_images) + 1,
            'name': step_name,
            'path': preview_path
        })
        print(f"Preview saved: {step_name} -> {preview_path}", file=sys.stderr)
        return preview_path

    def apply_background_blur(self, image: Image.Image) -> Image.Image:
        """
        步骤1: 应用背景模糊

        Args:
            image: 输入图像

        Returns:
            模糊后的图像
        """
        blur_enabled = self.template.get('backgroundBlurEnabled', False)

        if not blur_enabled:
            print("Step 1: Background blur disabled, skipping", file=sys.stderr)
            return image

        blur_intensity = self.template.get('backgroundBlurIntensity', 10)
        print(f"Step 1: Applying background blur (intensity: {blur_intensity})", file=sys.stderr)

        # 应用高斯模糊
        blurred = image.filter(ImageFilter.GaussianBlur(radius=blur_intensity))

        # 保存预览
        self.save_preview(blurred, "background_blur")

        return blurred

    def extract_and_composite_person(self, background: Image.Image) -> Image.Image:
        """
        步骤2: 人物抠图和合成

        Args:
            background: 背景图像

        Returns:
            合成后的图像
        """
        person_border_enabled = self.template.get('personBorderEnabled', False)

        if not person_border_enabled or not SEGMENT_AVAILABLE:
            print("Step 2: Person extraction disabled or PersonSegmenter not available, skipping", file=sys.stderr)
            return background

        print("Step 2: Extracting person from original image", file=sys.stderr)

        # 从原始图像抠图（不是从模糊的背景）
        original_image = self.load_image(self.config.get('video', ''))

        # 调整大小以匹配背景
        if original_image.size != background.size:
            original_image = original_image.resize(background.size, Image.Resampling.LANCZOS)

        # 使用PersonSegmenter进行抠图（支持MODNet优先级）
        try:
            person_rgba = self._segment_person_with_modnet(original_image)
            print("Person extraction completed with PersonSegmenter", file=sys.stderr)
        except Exception as e:
            print(f"PersonSegmenter extraction failed: {e}", file=sys.stderr)
            import traceback
            traceback.print_exc(file=sys.stderr)
            return background

        # 确保是 RGBA 模式
        if person_rgba.mode != 'RGBA':
            person_rgba = person_rgba.convert('RGBA')
        
        # 提取 alpha 通道并优化
        alpha_channel = np.array(person_rgba.split()[3])
        refined_alpha = self.refine_mask(alpha_channel)
        
        # 将优化后的 alpha 通道应用回图像
        person_rgba.putalpha(Image.fromarray(refined_alpha))
        
        print("Mask refinement applied to extracted person", file=sys.stderr)

        # 保存抠图预览（带透明背景）
        self.save_preview(person_rgba, "person_extracted")

        # 调整人物大小
        person_size = self.template.get('personSize', 100)
        person_rotation = self.template.get('personRotation', 0)
        if person_size != 100:
            print(f"Step 2: Resizing person to {person_size}%", file=sys.stderr)
            new_width = int(person_rgba.width * person_size / 100)
            new_height = int(person_rgba.height * person_size / 100)
            person_rgba = person_rgba.resize((new_width, new_height), Image.Resampling.LANCZOS)

        # 调整人物位置
        person_position = self.template.get('personPosition', {'x': 50, 'y': 50})

        # ✅ 新增：人像旋转
        if person_rotation != 0:
            print(f"Rotating person by {person_rotation}°", file=sys.stderr)
            # 旋转人像（使用expand=True以保留完整旋转结果）
            person_rgba = person_rgba.rotate(-person_rotation, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
            print(f"Person rotated, new size: {person_rgba.size}", file=sys.stderr)

        person_x = int(background.width * person_position['x'] / 100) - person_rgba.width // 2
        person_y = int(background.height * person_position['y'] / 100) - person_rgba.height // 2

        # 合成到背景（保持 RGBA 模式以保留透明度）
        result = background.convert('RGBA')
        result.paste(person_rgba, (person_x, person_y), person_rgba)
        
        # 保存预览（保持RGBA模式）
        self.save_preview(result, "person_composited")

        return result

    def apply_person_outline(self, image: Image.Image) -> Image.Image:
        """
        步骤3: 应用人物描边
        
        注意：此方法已废弃，描边逻辑已移至 _apply_outline_to_person
        保留此方法仅为兼容性

        Args:
            image: 输入图像

        Returns:
            添加描边后的图像
        """
        person_border_enabled = self.template.get('personBorderEnabled', False)

        if not person_border_enabled or not SEGMENT_AVAILABLE:
            print("Step 3: Person outline disabled or PersonSegmenter not available, skipping", file=sys.stderr)
            return image

        print("Step 3: Applying person outline (legacy method)", file=sys.stderr)
        print("Warning: This method is deprecated, use the new generate() flow instead", file=sys.stderr)

        # 从原始图像抠图（使用PersonSegmenter）
        original_image = self.load_image(self.config.get('video', ''))
        if original_image.size != image.size:
            original_image = original_image.resize(image.size, Image.Resampling.LANCZOS)

        # 使用PersonSegmenter进行抠图
        try:
            person_rgba = self._segment_person_with_modnet(original_image)
        except Exception as e:
            print(f"PersonSegmenter extraction failed: {e}", file=sys.stderr)
            import traceback
            traceback.print_exc(file=sys.stderr)
            return image
        
        # 确保是 RGBA 模式
        if person_rgba.mode != 'RGBA':
            person_rgba = person_rgba.convert('RGBA')
        
        # 提取 alpha 通道并优化
        alpha_channel = np.array(person_rgba.split()[3])
        refined_alpha = self.refine_mask(alpha_channel)
        person_rgba.putalpha(Image.fromarray(refined_alpha))

        # 应用描边
        person_rgba = self._apply_outline_to_person(person_rgba)

        # 调整人物大小
        person_size = self.template.get('personSize', 100)
        person_rotation = self.template.get('personRotation', 0)
        if person_size != 100:
            new_width = int(person_rgba.width * person_size / 100)
            new_height = int(person_rgba.height * person_size / 100)
            person_rgba = person_rgba.resize((new_width, new_height), Image.Resampling.LANCZOS)

        # 调整大小和位置
        person_position = self.template.get('personPosition', {'x': 50, 'y': 50})
        person_x = int(image.width * person_position['x'] / 100) - person_rgba.width // 2
        person_y = int(image.height * person_position['y'] / 100) - person_rgba.height // 2

        # 合成
        result = image.convert('RGBA')
        result.paste(person_rgba, (person_x, person_y), person_rgba)
        
        # 保存预览（保持RGBA模式）
        self.save_preview(result, "person_outlined")

        return result

    def apply_mask(self, image: Image.Image) -> Image.Image:
        """
        步骤4: 应用蒙版

        Args:
            image: 输入图像

        Returns:
            添加蒙版后的图像
        """
        mask_enabled = self.template.get('maskEnabled', False)

        if not mask_enabled:
            print("Step 4: Mask disabled, skipping", file=sys.stderr)
            return image

        mask_path = self.template.get('maskImagePath', '')
        if not mask_path or not os.path.exists(mask_path):
            print(f"Step 4: Mask image not found: {mask_path}, skipping", file=sys.stderr)
            return image

        print(f"Step 4: Applying mask from {mask_path}", file=sys.stderr)

        # 加载蒙版
        mask_img = Image.open(mask_path).convert('RGBA')

        # 获取蒙版参数
        mask_size = self.template.get('maskSize', 100)
        mask_position = self.template.get('maskPosition', {'x': 50, 'y': 50})
        mask_opacity = self.template.get('maskOpacity', 100)

        # 调整蒙版大小
        mask_width = int(image.width * mask_size / 100)
        mask_height = int(image.height * mask_size / 100)
        mask_img = mask_img.resize((mask_width, mask_height), Image.Resampling.LANCZOS)

        # 调整透明度
        if mask_opacity < 100:
            alpha = mask_img.split()[3]
            alpha = ImageEnhance.Brightness(alpha).enhance(mask_opacity / 100)
            mask_img.putalpha(alpha)

        # 计算位置
        mask_x = int(image.width * mask_position['x'] / 100) - mask_width // 2
        mask_y = int(image.height * mask_position['y'] / 100) - mask_height // 2

        # 合成
        result = image.convert('RGBA')
        result.paste(mask_img, (mask_x, mask_y), mask_img)
        
        # 保存预览（保持RGBA模式）
        self.save_preview(result, "mask_applied")

        return result

    def add_text(self, image: Image.Image) -> Image.Image:
        """
        步骤5: 添加文字（主标题和副标题）

        Args:
            image: 输入图像

        Returns:
            添加文字后的图像
        """
        title_text = self.config.get('title', self.template.get('titleText', ''))
        subtitle_text = self.template.get('subtitleText', '')

        if not title_text and not subtitle_text:
            print("Step 5: No title or subtitle text, skipping", file=sys.stderr)
            return image

        print(f"Step 5: Adding text - Title: {title_text}, Subtitle: {subtitle_text}", file=sys.stderr)

        # 转换为RGBA以支持透明度
        result = image.convert('RGBA')
        draw = ImageDraw.Draw(result)

        width, height = result.size
        print(f"[add_text] Image size: {width}x{height}", file=sys.stderr)

        # 获取文字参数
        font_family = self.template.get('titleFontFamily', 'NotoSerifCJK-VF')
        font_size = self.template.get('titleFontSize', 120)
        font_weight = self.template.get('titleFontWeight', 700)
        text_color = self.hex_to_rgb(self.template.get('titleColor', '#FFFFFF'))
        stroke_color = self.hex_to_rgb(self.template.get('titleStrokeColor', '#000000'))
        stroke_width = self.template.get('titleStrokeWidth', 2)

        # 修复：处理文本位置参数，确保是字典类型
        text_position = self.template.get('titlePosition', {'x': 50, 'y': 80})
        print(f"[add_text] Title position (percentage): x={text_position['x']}%, y={text_position['y']}%", file=sys.stderr)
        
        # 如果是字符串（旧格式），转换为字典
        if isinstance(text_position, str):
            position_map = {
                'top': {'x': 50, 'y': 20},
                'center': {'x': 50, 'y': 50},
                'bottom': {'x': 50, 'y': 80}
            }
            text_position = position_map.get(text_position, {'x': 50, 'y': 80})
            print(f"Converted text position from string to dict: {text_position}", file=sys.stderr)

        # 加载字体
        font_path = self._get_font_path(font_family)
        try:
            font = ImageFont.truetype(font_path, font_size)
        except:
            print(f"Warning: Failed to load font {font_path}, using default", file=sys.stderr)
            font = ImageFont.load_default()

        # ✅ 关键修复：支持多行文字，使用anchor='mm'实现中心对齐
        # 计算文字中心点位置（百分比转像素）
        # 主标题不需要坐标反转
        text_x_from_config = text_position['x']
        text_y_from_config = text_position['y']
        text_x = int(width * text_x_from_config / 100)
        text_y = int(height * text_y_from_config / 100)
        print(f"[add_text] Title initial position (pixels): x={text_x}px, y={text_y}px (from {text_x_from_config}%, {text_y_from_config}%)", file=sys.stderr)
        
        if '\n' in title_text:
            lines = title_text.split('\n')
            print(f"Rendering multiline text: {len(lines)} lines, center=({text_x},{text_y}), text='{title_text}'", file=sys.stderr)
        else:
            print(f"Rendering single line text, center=({text_x},{text_y}), text='{title_text}'", file=sys.stderr)

        # 绘制装饰图层1（原文字背景，现为独立装饰层）
        if self.template.get('titleBackgroundEnabled', False):
            bg_color = self.hex_to_rgb(self.template.get('titleBackgroundColor', '#000000'))
            bg_opacity = self.template.get('titleBackgroundOpacity', 70)
            bg_shape = self.template.get('titleBackgroundShape', 'rectangle')
            bg_size = self.template.get('titleBackgroundSize', {'width': 30, 'height': 10})
            bg_position = self.template.get('titleBackgroundPosition', {'x': 50, 'y': 30})
            bg_radius = self.template.get('titleBackgroundRadius', 10)
            bg_points = self.template.get('titleBackgroundPoints', [])
            title_background_rotation = self.template.get('titleBackgroundRotation', 0)

            bg_alpha = int(255 * bg_opacity / 100)

            print(f"Title background: color={bg_color}, opacity={bg_opacity}%, alpha={bg_alpha}, shape={bg_shape}", file=sys.stderr)
            # 🔧 调试：输出多边形点数据
            print(f"[DEBUG] titleBackgroundPoints: {bg_points}, type: {type(bg_points)}, len: {len(bg_points) if isinstance(bg_points, (list, tuple)) else 'N/A'}", file=sys.stderr)

            # 创建单独的图层来绘制背景（确保透明度正确）
            bg_layer = Image.new('RGBA', result.size, (0, 0, 0, 0))
            bg_draw = ImageDraw.Draw(bg_layer)

            # 使用独立的位置和大小参数（百分比转像素）
            bg_width = int(width * bg_size['width'] / 100)
            bg_height = int(height * bg_size['height'] / 100)
            bg_center_x = int(width * bg_position['x'] / 100)
            bg_center_y = int(height * bg_position['y'] / 100)
            
            bg_left = bg_center_x - bg_width // 2
            bg_top = bg_center_y - bg_height // 2
            bg_right = bg_center_x + bg_width // 2
            bg_bottom = bg_center_y + bg_height // 2

            # 🔧 调试：记录每个条件的结果
            print(f"[DEBUG] Shape check: bg_shape='{bg_shape}' (type: {type(bg_shape).__name__})", file=sys.stderr)
            print(f"[DEBUG] Points check: bg_points={bg_points}, type={type(bg_points).__name__}, len={len(bg_points) if isinstance(bg_points, list) else 'N/A'}, bool(bg_points)={bool(bg_points)}", file=sys.stderr)

            # 🔧 详细输出：模板中的所有背景相关字段
            print(f"[DEBUG] Template background fields:", file=sys.stderr)
            print(f"  titleBackgroundEnabled: {self.template.get('titleBackgroundEnabled')}", file=sys.stderr)
            print(f"  titleBackgroundShape: {self.template.get('titleBackgroundShape')}", file=sys.stderr)
            print(f"  titleBackgroundPoints raw: {self.template.get('titleBackgroundPoints')}", file=sys.stderr)
            print(f"[DEBUG] Polygon condition: bg_shape=='polygon'={bg_shape == 'polygon'}, bg_points truthy={bool(bg_points)}", file=sys.stderr)

            if bg_shape == 'rectangle':
                # 矩形背景
                print(f"[DEBUG] Drawing RECTANGLE background", file=sys.stderr)
                bg_draw.rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    fill=(*bg_color, bg_alpha)
                )
            elif bg_shape == 'rounded':
                # 圆角矩形背景
                print(f"[DEBUG] Drawing ROUNDED RECTANGLE background", file=sys.stderr)
                bg_draw.rounded_rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    radius=bg_radius,
                    fill=(*bg_color, bg_alpha)
                )
            elif bg_shape == 'polygon' and bg_points:
                # 自定义多边形背景
                print(f"[DEBUG] Drawing POLYGON background with {len(bg_points)} points", file=sys.stderr)
                polygon_points = []
                for i, point in enumerate(bg_points):
                    try:
                        px = bg_center_x + int(point['x'] * bg_width / 100)
                        py = bg_center_y + int(point['y'] * bg_height / 100)
                        polygon_points.append((px, py))
                        print(f"[DEBUG] Point {i}: {point} -> ({px}, {py})", file=sys.stderr)
                    except Exception as e:
                        print(f"[DEBUG] Error processing point {i}: {point}, error: {e}", file=sys.stderr)

                if len(polygon_points) >= 3:
                    print(f"[DEBUG] Drawing polygon with {len(polygon_points)} points: {polygon_points}", file=sys.stderr)
                    bg_draw.polygon(polygon_points, fill=(*bg_color, bg_alpha))
                else:
                    print(f"[DEBUG] Not enough points for polygon (need >= 3, got {len(polygon_points)}). Falling back to rectangle.", file=sys.stderr)
                    bg_draw.rectangle(
                        [bg_left, bg_top, bg_right, bg_bottom],
                        fill=(*bg_color, bg_alpha)
                    )
            else:
                # 默认使用矩形
                print(f"[DEBUG] Drawing DEFAULT RECTANGLE (didn't match any shape type)", file=sys.stderr)
                bg_draw.rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    fill=(*bg_color, bg_alpha)
                )

            # ✅ 如果需要旋转，旋转背景图层
            if title_background_rotation != 0:
                print(f"Rotating title background by {title_background_rotation}°", file=sys.stderr)
                bg_layer = bg_layer.rotate(-title_background_rotation, resample=Image.BICUBIC, expand=False, fillcolor=(0, 0, 0, 0))

            # 使用alpha_composite合成背景层
            result = Image.alpha_composite(result, bg_layer)
            draw = ImageDraw.Draw(result)  # 重新创建draw对象

        # 绘制装饰图层2（副标题背景，现为独立装饰层）
        if self.template.get('subtitleBackgroundEnabled', False):
            bg_color = self.hex_to_rgb(self.template.get('subtitleBackgroundColor', '#000000'))
            bg_opacity = self.template.get('subtitleBackgroundOpacity', 70)
            bg_shape = self.template.get('subtitleBackgroundShape', 'rectangle')
            bg_size = self.template.get('subtitleBackgroundSize', {'width': 30, 'height': 10})
            bg_position = self.template.get('subtitleBackgroundPosition', {'x': 50, 'y': 60})
            bg_radius = self.template.get('subtitleBackgroundRadius', 10)
            bg_points = self.template.get('subtitleBackgroundPoints', [])
            subtitle_background_rotation = self.template.get('subtitleBackgroundRotation', 0)

            bg_alpha = int(255 * bg_opacity / 100)

            print(f"Subtitle background: color={bg_color}, opacity={bg_opacity}%, alpha={bg_alpha}, shape={bg_shape}", file=sys.stderr)
            # 🔧 调试：输出副标题多边形点数据
            print(f"[DEBUG] subtitleBackgroundPoints: {bg_points}, type: {type(bg_points)}, len: {len(bg_points) if isinstance(bg_points, (list, tuple)) else 'N/A'}", file=sys.stderr)

            # 创建单独的图层来绘制背景（确保透明度正确）
            bg_layer = Image.new('RGBA', result.size, (0, 0, 0, 0))
            bg_draw = ImageDraw.Draw(bg_layer)

            # 使用独立的位置和大小参数（百分比转像素）
            bg_width = int(width * bg_size['width'] / 100)
            bg_height = int(height * bg_size['height'] / 100)
            bg_center_x = int(width * bg_position['x'] / 100)
            bg_center_y = int(height * bg_position['y'] / 100)

            bg_left = bg_center_x - bg_width // 2
            bg_top = bg_center_y - bg_height // 2
            bg_right = bg_center_x + bg_width // 2
            bg_bottom = bg_center_y + bg_height // 2

            # 🔧 调试：记录每个条件的结果
            print(f"[DEBUG-SUB] Shape check: bg_shape='{bg_shape}' (type: {type(bg_shape).__name__})", file=sys.stderr)
            print(f"[DEBUG-SUB] Points check: bg_points={bg_points}, bool(bg_points)={bool(bg_points)}", file=sys.stderr)
            print(f"[DEBUG-SUB] Polygon condition: bg_shape=='polygon'={bg_shape == 'polygon'}, bg_points truthy={bool(bg_points)}", file=sys.stderr)

            if bg_shape == 'rectangle':
                # 矩形背景
                print(f"[DEBUG-SUB] Drawing RECTANGLE background", file=sys.stderr)
                bg_draw.rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    fill=(*bg_color, bg_alpha)
                )
            elif bg_shape == 'rounded':
                # 圆角矩形背景
                print(f"[DEBUG-SUB] Drawing ROUNDED RECTANGLE background", file=sys.stderr)
                bg_draw.rounded_rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    radius=bg_radius,
                    fill=(*bg_color, bg_alpha)
                )
            elif bg_shape == 'polygon' and bg_points:
                # 自定义多边形背景
                print(f"[DEBUG-SUB] Drawing POLYGON background with {len(bg_points)} points", file=sys.stderr)
                polygon_points = []
                for i, point in enumerate(bg_points):
                    try:
                        px = bg_center_x + int(point['x'] * bg_width / 100)
                        py = bg_center_y + int(point['y'] * bg_height / 100)
                        polygon_points.append((px, py))
                        print(f"[DEBUG-SUB] Point {i}: {point} -> ({px}, {py})", file=sys.stderr)
                    except Exception as e:
                        print(f"[DEBUG-SUB] Error processing point {i}: {point}, error: {e}", file=sys.stderr)

                if len(polygon_points) >= 3:
                    print(f"[DEBUG-SUB] Drawing polygon with {len(polygon_points)} points: {polygon_points}", file=sys.stderr)
                    bg_draw.polygon(polygon_points, fill=(*bg_color, bg_alpha))
                else:
                    print(f"[DEBUG-SUB] Not enough points for polygon (need >= 3, got {len(polygon_points)}). Falling back to rectangle.", file=sys.stderr)
                    bg_draw.rectangle(
                        [bg_left, bg_top, bg_right, bg_bottom],
                        fill=(*bg_color, bg_alpha)
                    )
            else:
                # 默认使用矩形
                print(f"[DEBUG-SUB] Drawing DEFAULT RECTANGLE (didn't match any shape type)", file=sys.stderr)
                bg_draw.rectangle(
                    [bg_left, bg_top, bg_right, bg_bottom],
                    fill=(*bg_color, bg_alpha)
                )

            # ✅ 如果需要旋转，旋转背景图层
            if subtitle_background_rotation != 0:
                print(f"Rotating subtitle background by {subtitle_background_rotation}°", file=sys.stderr)
                bg_layer = bg_layer.rotate(-subtitle_background_rotation, resample=Image.BICUBIC, expand=False, fillcolor=(0, 0, 0, 0))
            
            # 使用alpha_composite合成背景层
            result = Image.alpha_composite(result, bg_layer)
            draw = ImageDraw.Draw(result)  # 重新创建draw对象

        # ✅ 修复：直接在原始图层上绘制，不使用临时图层
        # 这样可以确保坐标计算和前端Canvas完全一致
        print(f"Drawing title text directly on original layer (no temp layer)", file=sys.stderr)
        title_draw = draw
        
        # 绘制标题文字（带描边），使用anchor='mm'实现中心对齐
        # ✅ 新增：检查是否使用titles参数（支持direction、charSpacing、lineSpacing、maxLength）
        titles_config = self.template.get('titles')

        # 📋 调试日志：显示 titles_config 的完整信息
        print(f"[DEBUG-TITLES] titles_config exists: {titles_config is not None}", file=sys.stderr)
        if titles_config and 'main' in titles_config:
            print(f"[DEBUG-TITLES] titles.main exists", file=sys.stderr)
            print(f"[DEBUG-TITLES] titles.main keys: {list(titles_config['main'].keys())}", file=sys.stderr)
            print(f"[DEBUG-TITLES] titles.main.maxLength: {titles_config['main'].get('maxLength')}", file=sys.stderr)
        else:
            print(f"[DEBUG-TITLES] titles.main does NOT exist, will use defaults or titleMaxCharsPerLine", file=sys.stderr)
            print(f"[DEBUG-TITLES] template.titleMaxCharsPerLine: {self.template.get('titleMaxCharsPerLine')}", file=sys.stderr)

        # ✅ 修复：总是使用图层渲染方式（支持旋转），即使没有titles配置
        # 从顶级模板读取direction等参数，确保走新逻辑分支
        if not titles_config or 'main' not in titles_config:
            # 创建默认的titles配置，从顶级模板读取参数
            titles_config = {
                'main': {
                    'direction': self.template.get('titleDirection', 'horizontal'),
                    'charSpacing': self.template.get('titleCharSpacing'),
                    'lineSpacing': self.template.get('titleLineSpacing'),
                    'maxLength': self.template.get('titleMaxCharsPerLine', 10),
                    'rotation': self.template.get('titleRotation', 0),
                    'backgroundRotation': self.template.get('titleBackgroundRotation', 0),
                }
            }

        if titles_config and 'main' in titles_config:
            # 使用titles参数配置绘制主标题（支持横竖排、字符间距、行间距、自动折行）
            print(f"[advanced_cover_generator] Using titles.main config for title rendering", file=sys.stderr)
            main_config = titles_config['main']

            # ✅ 修复：优先从 titles.main 读取字体大小，确保与前端一致
            font_size_from_config = main_config.get('fontSize', font_size)
            if font_size_from_config != font_size:
                print(f"  [INFO] Using fontSize from titles.main: {font_size_from_config} (was {font_size})", file=sys.stderr)
                font_size = font_size_from_config
                # 重新加载字体
                try:
                    font = ImageFont.truetype(font_path, font_size)
                except:
                    pass

            # 获取排版参数 - 优先使用 titles.main 中的值，否则使用顶级配置，最后使用默认值
            direction = main_config.get('direction', self.template.get('titleDirection', 'horizontal'))

            # ✅ 修复：优先使用 titles.main 中的间距值，然后是顶级配置，最后是默认值
            char_spacing = main_config.get('charSpacing')
            if char_spacing is None:
                char_spacing = self.template.get('titleCharSpacing')
            if char_spacing is None:
                char_spacing = int(font_size * 0.2)

            line_spacing = main_config.get('lineSpacing')
            if line_spacing is None:
                line_spacing = self.template.get('titleLineSpacing')
            if line_spacing is None:
                line_spacing = int(font_size * 1.2)

            max_chars_per_line = main_config.get('maxLength', self.template.get('titleMaxCharsPerLine', 10))

            # 📋 调试日志：显示 maxLength 的实际值和来源
            print(f"[DEBUG-MAXLENGTH] main_config.get('maxLength'): {main_config.get('maxLength')}", file=sys.stderr)
            print(f"[DEBUG-MAXLENGTH] self.template.get('titleMaxCharsPerLine'): {self.template.get('titleMaxCharsPerLine')}", file=sys.stderr)
            print(f"[DEBUG-MAXLENGTH] Final max_chars_per_line: {max_chars_per_line}", file=sys.stderr)

            # ✅ 新增：获取阴影参数
            shadow_enabled = main_config.get('shadowEnabled', self.template.get('titleShadowEnabled', False))
            shadow_color = self.hex_to_rgb(main_config.get('shadowColor', self.template.get('titleShadowColor', '#000000')))
            shadow_offset_x = main_config.get('shadowOffsetX', self.template.get('titleShadowOffsetX', 0))
            shadow_offset_y = main_config.get('shadowOffsetY', self.template.get('titleShadowOffsetY', 0))
            shadow_blur = main_config.get('shadowBlur', self.template.get('titleShadowBlur', 0))

            # ✅ 新增：获取多层阴影参数
            shadow_layers = main_config.get('shadowLayers', self.template.get('titleShadowLayers', []))
            print(f"  📦 Shadow layers: {len(shadow_layers)} layer(s)", file=sys.stderr)
            if shadow_layers:
                for i, layer in enumerate(shadow_layers):
                    if layer.get('enabled', True):
                        print(f"    Layer {i}: offset=({layer.get('offsetX', 0)}, {layer.get('offsetY', 0)}), blur={layer.get('blur', 0)}, color={layer.get('color', '#000000')}, opacity={layer.get('opacity', 100)}", file=sys.stderr)
            rotation_angle = main_config.get('rotation', self.template.get('titleRotation', 0))
            title_background_rotation = main_config.get('backgroundRotation', self.template.get('titleBackgroundRotation', 0))

            # ✅ 修复旋转坐标问题：根据旋转角度使用不同的变换
            # 将角度归一化到0-360范围
            normalized_angle = rotation_angle % 360

            if 45 <= normalized_angle < 135:
                # ~90度旋转：X=Y, Y=100-X
                text_x = int(width * text_y_from_config / 100)
                text_y = int(height * (100 - text_x_from_config) / 100)
                print(f"[ROTATION 90°] Main title: ({text_x_from_config}%, {text_y_from_config}%) → ({text_y_from_config}%, {100-text_x_from_config}%) → ({text_x}px, {text_y}px)", file=sys.stderr)
            elif 135 <= normalized_angle < 225:
                # ~180度旋转：X=100-X, Y=100-Y
                text_x = int(width * (100 - text_x_from_config) / 100)
                text_y = int(height * (100 - text_y_from_config) / 100)
                print(f"[ROTATION 180°] Main title: ({text_x_from_config}%, {text_y_from_config}%) → ({100-text_x_from_config}%, {100-text_y_from_config}%) → ({text_x}px, {text_y}px)", file=sys.stderr)
            elif 225 <= normalized_angle < 315:
                # ~270度旋转：X=100-Y, Y=X
                text_x = int(width * (100 - text_y_from_config) / 100)
                text_y = int(height * text_x_from_config / 100)
                print(f"[ROTATION 270°] Main title: ({text_x_from_config}%, {text_y_from_config}%) → ({100-text_y_from_config}%, {text_x_from_config}%) → ({text_x}px, {text_y}px)", file=sys.stderr)
            else:
                # ~0度或360度：不变换
                text_x = int(width * text_x_from_config / 100)
                text_y = int(height * text_y_from_config / 100)
                print(f"[NO ROTATION] Main title: ({text_x_from_config}%, {text_y_from_config}%) → ({text_x}px, {text_y}px)", file=sys.stderr)

            # ✅ 新增：计算文字实际高度并调整Y坐标，与前端getElementStyleWithSize保持一致
            # 不限制范围，允许文字超出边界
            try:
                bbox = draw.textbbox((text_x, text_y), title_text, font=font, anchor='mm')
                text_height = bbox[3] - bbox[1]
                # 调整Y坐标：top = centerY - height/2（与前端一致）
                text_y = text_y - text_height // 2
                print(f"[TITLE HEIGHT ADJUST] text_height={text_height}, adjusted text_y={text_y}", file=sys.stderr)
            except Exception as e:
                print(f"[TITLE HEIGHT ADJUST] Warning: {e}", file=sys.stderr)

            print(f"[DEBUG] Main title config:", file=sys.stderr)
            print(f"  Text: '{title_text}' (length: {len(title_text)})", file=sys.stderr)
            print(f"  maxLength: {max_chars_per_line}", file=sys.stderr)
            print(f"  Direction: {direction}", file=sys.stderr)
            print(f"  Char spacing: {char_spacing}px, Line spacing: {line_spacing}px", file=sys.stderr)
            print(f"  Position: ({text_x}, {text_y})", file=sys.stderr)
            print(f"  ⚠️ Shadow params: color={shadow_color}, offsetX={shadow_offset_x}, offsetY={shadow_offset_y}, blur={shadow_blur}", file=sys.stderr)
            print(f"  🔄 Rotation angle: {rotation_angle}°", file=sys.stderr)

            # 将文字分行
            lines = []
            for i in range(0, len(title_text), max_chars_per_line):
                lines.append(title_text[i:i + max_chars_per_line])

            print(f"  Split into {len(lines)} lines: {lines}", file=sys.stderr)

            if direction == 'vertical':
                # ✅ 修复：与前端一致，竖排从左到右排列，每列从上到下
                total_width = (len(lines) - 1) * line_spacing + font_size
                max_col_chars = max(len(line) for line in lines) if lines else 1
                total_height = (max_col_chars - 1) * (font_size + char_spacing) + font_size

                # ✅ 修复：计算起始位置（整体居中）
                # 前端：left = centerX - totalWidth/2，第一列colX=0
                # 所以第一列中心 = centerX - totalWidth/2 + fontSize/2
                start_x = text_x - total_width // 2
                start_y = text_y - total_height // 2
                print(f"  [Vertical] total_size=({total_width},{total_height}), start=({start_x},{start_y})", file=sys.stderr)

                # ✅ 计算padding：确保文字+阴影+模糊完全在图层内
                # 基础padding：考虑负坐标和超出边界
                base_padding = max(
                    abs(min(0, start_x)),
                    abs(min(0, start_y)),
                    max(0, start_x + total_width - width),
                    max(0, start_y + total_height - height),
                    shadow_blur * 3,
                    abs(shadow_offset_x),
                    abs(shadow_offset_y)
                )
                # 旋转padding：旋转会扩大边界框，预留足够空间
                # 对角线长度作为旋转后的最大可能尺寸
                diagonal = int(((total_width ** 2 + total_height ** 2) ** 0.5) / 2)
                rotation_padding = diagonal if rotation_angle != 0 else 0

                padding = max(base_padding, rotation_padding) + 100  # 额外安全边距

                expanded_width = width + padding * 2
                expanded_height = height + padding * 2
                print(f"  [Vertical Title] Using expanded layer: {width}x{height} → {expanded_width}x{expanded_height}, padding={padding} (base={base_padding}, rotation={rotation_padding})", file=sys.stderr)

                # ✅ 步骤1: 处理多层阴影或单层阴影
                has_shadow = shadow_enabled and (shadow_blur > 0 or shadow_offset_x != 0 or shadow_offset_y != 0)
                has_multiple_shadows = len(shadow_layers) > 0 and any(layer.get('enabled', True) for layer in shadow_layers)

                if has_multiple_shadows or has_shadow:
                    print(f"  [Vertical Title] Creating shadow layer(s): {len([l for l in shadow_layers if l.get('enabled', True)])} multi-layer + single={has_shadow}", file=sys.stderr)
                    shadow_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))

                    # ✅ 首先绘制多层阴影（如果有）
                    if has_multiple_shadows:
                        for layer_idx, layer in enumerate(shadow_layers):
                            if layer.get('enabled', True):
                                layer_color = self.hex_to_rgb(layer.get('color', '#000000'))
                                layer_opacity = int(255 * (layer.get('opacity', 100) / 100))
                                layer_offset_x = layer.get('offsetX', 0)
                                layer_offset_y = layer.get('offsetY', 0)
                                layer_blur = layer.get('blur', 0)

                                shadow_draw = ImageDraw.Draw(shadow_layer)

                                # 为这一层绘制文字
                                for col_idx, line in enumerate(lines):
                                    col_x = start_x + padding + col_idx * line_spacing
                                    for char_idx, char in enumerate(line):
                                        char_y = start_y + padding + char_idx * (font_size + char_spacing) + font_size // 2
                                        char_x = col_x
                                        shadow_x = char_x + layer_offset_x
                                        shadow_y = char_y + layer_offset_y
                                        shadow_draw.text((shadow_x, shadow_y), char, font=font, fill=(*layer_color, layer_opacity), anchor='mm')

                                # 对这一层应用模糊
                                if layer_blur > 0:
                                    print(f"    [Vertical Title] Applying blur={layer_blur} to shadow layer {layer_idx}", file=sys.stderr)
                                    shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=layer_blur))

                                print(f"    [Vertical Title] Shadow layer {layer_idx} composited", file=sys.stderr)

                    # ✅ 然后绘制传统单层阴影（如果有）
                    if has_shadow:
                        shadow_draw = ImageDraw.Draw(shadow_layer)
                        for col_idx, line in enumerate(lines):
                            col_x = start_x + padding + col_idx * line_spacing
                            for char_idx, char in enumerate(line):
                                char_y = start_y + padding + char_idx * (font_size + char_spacing) + font_size // 2
                                char_x = col_x
                                shadow_x = char_x + shadow_offset_x
                                shadow_y = char_y + shadow_offset_y
                                shadow_draw.text((shadow_x, shadow_y), char, font=font, fill=(*shadow_color, 160), anchor='mm')

                        # 应用真正的高斯模糊（如果blur > 0）
                        if shadow_blur > 0:
                            print(f"  [Vertical Title] Applying GaussianBlur with radius={shadow_blur}", file=sys.stderr)
                            shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=shadow_blur))

                    # ✅ 旋转扩展图层并裁剪回原始尺寸
                    if rotation_angle != 0:
                        print(f"  [Vertical Title] Rotating shadow layer by {rotation_angle}°", file=sys.stderr)
                        shadow_layer = shadow_layer.rotate(-rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                        crop_x = (shadow_layer.width - width) // 2
                        crop_y = (shadow_layer.height - height) // 2
                        shadow_layer = shadow_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                        result = Image.alpha_composite(result, shadow_layer)
                    else:
                        shadow_layer = shadow_layer.crop((padding, padding, padding + width, padding + height))
                        result = Image.alpha_composite(result, shadow_layer)
                    title_draw = ImageDraw.Draw(result)  # 重新创建draw对象
                    print(f"  [Vertical Title] Shadow layer composited", file=sys.stderr)

                # ✅ 步骤2: 在扩展图层绘制描边和主文字
                print(f"  [Vertical Title] Creating text layer", file=sys.stderr)
                text_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))
                text_draw = ImageDraw.Draw(text_layer)

                for col_idx, line in enumerate(lines):
                    col_x = start_x + padding + col_idx * line_spacing

                    for char_idx, char in enumerate(line):
                        char_y = start_y + padding + char_idx * (font_size + char_spacing) + font_size // 2
                        char_x = col_x

                        # 绘制描边
                        if stroke_width > 0:
                            for offset_x in range(-stroke_width, stroke_width + 1):
                                for offset_y in range(-stroke_width, stroke_width + 1):
                                    if offset_x == 0 and offset_y == 0:
                                        continue
                                    text_draw.text((char_x + offset_x, char_y + offset_y),
                                                 char, font=font, fill=(*stroke_color, 255), anchor='mm')

                        # 绘制主体
                        text_draw.text((char_x, char_y), char, font=font, fill=(*text_color, 255), anchor='mm')

                # ✅ 步骤3: 旋转扩展图层并裁剪回原始尺寸
                if rotation_angle != 0:
                    print(f"  [Vertical Title] Rotating text layer by {rotation_angle}°", file=sys.stderr)
                    text_layer = text_layer.rotate(-rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                    crop_x = (text_layer.width - width) // 2
                    crop_y = (text_layer.height - height) // 2
                    text_layer = text_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                    result = Image.alpha_composite(result, text_layer)
                else:
                    text_layer = text_layer.crop((padding, padding, padding + width, padding + height))
                    result = Image.alpha_composite(result, text_layer)
                title_draw = ImageDraw.Draw(result)  # 重新创建draw对象
                print(f"  [Vertical Title] Text layer composited", file=sys.stderr)
            else:
                # 横排：从左到右，从上到下（默认）
                # ✅ 修复：与前端一致，行间距 = font_size + line_spacing
                total_height = (len(lines) - 1) * (font_size + line_spacing) + font_size

                # ✅ 修复：计算最长行的宽度，所有行都基于此宽度左对齐（与前端一致）
                max_line_chars = max(len(line) for line in lines) if lines else 1
                total_width = (max_line_chars - 1) * (font_size + char_spacing) + font_size

                # 计算整体起始位置（基于最长行居中，然后所有行左对齐）
                start_x = text_x - total_width // 2
                start_y = text_y - total_height // 2
                print(f"  [Horizontal] total_size=({total_width},{total_height}), start=({start_x},{start_y})", file=sys.stderr)

                # ✅ 计算padding：确保文字+阴影+模糊完全在图层内
                base_padding = max(
                    abs(min(0, start_x)),
                    abs(min(0, start_y)),
                    max(0, start_x + total_width - width),
                    max(0, start_y + total_height - height),
                    shadow_blur * 3,
                    abs(shadow_offset_x),
                    abs(shadow_offset_y)
                )
                diagonal = int(((total_width ** 2 + total_height ** 2) ** 0.5) / 2)
                rotation_padding = diagonal if rotation_angle != 0 else 0
                padding = max(base_padding, rotation_padding) + 100

                expanded_width = width + padding * 2
                expanded_height = height + padding * 2
                print(f"  [Horizontal Title] Using expanded layer: {width}x{height} → {expanded_width}x{expanded_height}, padding={padding} (base={base_padding}, rotation={rotation_padding})", file=sys.stderr)

                # ✅ 步骤1: 处理多层阴影或单层阴影
                has_shadow = shadow_enabled and (shadow_blur > 0 or shadow_offset_x != 0 or shadow_offset_y != 0)
                has_multiple_shadows = len(shadow_layers) > 0 and any(layer.get('enabled', True) for layer in shadow_layers)

                if has_multiple_shadows or has_shadow:
                    print(f"  [Horizontal Title] Creating shadow layer(s): {len([l for l in shadow_layers if l.get('enabled', True)])} multi-layer + single={has_shadow}", file=sys.stderr)
                    shadow_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))

                    # ✅ 首先绘制多层阴影（如果有）
                    if has_multiple_shadows:
                        for layer_idx, layer in enumerate(shadow_layers):
                            if layer.get('enabled', True):
                                layer_color = self.hex_to_rgb(layer.get('color', '#000000'))
                                layer_opacity = int(255 * (layer.get('opacity', 100) / 100))
                                layer_offset_x = layer.get('offsetX', 0)
                                layer_offset_y = layer.get('offsetY', 0)
                                layer_blur = layer.get('blur', 0)

                                shadow_draw = ImageDraw.Draw(shadow_layer)

                                # 为这一层绘制文字
                                for row_idx, line in enumerate(lines):
                                    line_y = start_y + padding + row_idx * (font_size + line_spacing) + font_size // 2
                                    for char_idx, char in enumerate(line):
                                        char_x = start_x + padding + char_idx * (font_size + char_spacing) + font_size // 2
                                        char_y = line_y
                                        shadow_x = char_x + layer_offset_x
                                        shadow_y = char_y + layer_offset_y
                                        shadow_draw.text((shadow_x, shadow_y), char, font=font, fill=(*layer_color, layer_opacity), anchor='mm')

                                # 对这一层应用模糊
                                if layer_blur > 0:
                                    print(f"    [Horizontal Title] Applying blur={layer_blur} to shadow layer {layer_idx}", file=sys.stderr)
                                    shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=layer_blur))

                                print(f"    [Horizontal Title] Shadow layer {layer_idx} composited", file=sys.stderr)

                    # ✅ 然后绘制传统单层阴影（如果有）
                    if has_shadow:
                        shadow_draw = ImageDraw.Draw(shadow_layer)
                        for row_idx, line in enumerate(lines):
                            line_y = start_y + padding + row_idx * (font_size + line_spacing) + font_size // 2
                            for char_idx, char in enumerate(line):
                                char_x = start_x + padding + char_idx * (font_size + char_spacing) + font_size // 2
                                char_y = line_y
                                shadow_x = char_x + shadow_offset_x
                                shadow_y = char_y + shadow_offset_y
                                shadow_draw.text((shadow_x, shadow_y), char, font=font, fill=(*shadow_color, 160), anchor='mm')

                        # 应用真正的高斯模糊（如果blur > 0）
                        if shadow_blur > 0:
                            print(f"  [Horizontal Title] Applying GaussianBlur with radius={shadow_blur}", file=sys.stderr)
                            shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=shadow_blur))

                    # ✅ 旋转扩展图层并裁剪回原始尺寸
                    if rotation_angle != 0:
                        print(f"  [Horizontal Title] Rotating shadow layer by {rotation_angle}°", file=sys.stderr)
                        shadow_layer = shadow_layer.rotate(-rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                        crop_x = (shadow_layer.width - width) // 2
                        crop_y = (shadow_layer.height - height) // 2
                        shadow_layer = shadow_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                        result = Image.alpha_composite(result, shadow_layer)
                    else:
                        shadow_layer = shadow_layer.crop((padding, padding, padding + width, padding + height))
                        result = Image.alpha_composite(result, shadow_layer)
                    title_draw = ImageDraw.Draw(result)  # 重新创建draw对象
                    print(f"  [Horizontal Title] Shadow layer composited", file=sys.stderr)

                # ✅ 步骤2: 在扩展图层绘制描边和主文字
                print(f"  [Horizontal Title] Creating text layer", file=sys.stderr)
                text_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))
                text_draw = ImageDraw.Draw(text_layer)

                for row_idx, line in enumerate(lines):
                    line_y = start_y + padding + row_idx * (font_size + line_spacing) + font_size // 2

                    for char_idx, char in enumerate(line):
                        char_x = start_x + padding + char_idx * (font_size + char_spacing) + font_size // 2
                        char_y = line_y

                        # 绘制描边
                        if stroke_width > 0:
                            for offset_x in range(-stroke_width, stroke_width + 1):
                                for offset_y in range(-stroke_width, stroke_width + 1):
                                    if offset_x == 0 and offset_y == 0:
                                        continue
                                    text_draw.text((char_x + offset_x, char_y + offset_y),
                                                 char, font=font, fill=(*stroke_color, 255), anchor='mm')

                        # 绘制主体
                        text_draw.text((char_x, char_y), char, font=font, fill=(*text_color, 255), anchor='mm')

                # ✅ 步骤3: 旋转扩展图层并裁剪回原始尺寸
                if rotation_angle != 0:
                    print(f"  [Horizontal Title] Rotating text layer by {rotation_angle}°", file=sys.stderr)
                    text_layer = text_layer.rotate(-rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                    crop_x = (text_layer.width - width) // 2
                    crop_y = (text_layer.height - height) // 2
                    text_layer = text_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                    result = Image.alpha_composite(result, text_layer)
                else:
                    text_layer = text_layer.crop((padding, padding, padding + width, padding + height))
                    result = Image.alpha_composite(result, text_layer)
                title_draw = ImageDraw.Draw(result)  # 重新创建draw对象
                print(f"  [Horizontal Title] Text layer composited", file=sys.stderr)
        elif '\n' in title_text:
            # 多行文字渲染（原有逻辑）
            if stroke_width > 0:
                title_draw.multiline_text(
                    (text_x, text_y),  # 直接使用text_x, text_y
                    title_text,
                    font=font,
                    fill=(*text_color, 255),
                    align='center',
                    anchor='mm',
                    stroke_width=stroke_width,
                    stroke_fill=(*stroke_color, 255)
                )
            else:
                title_draw.multiline_text(
                    (text_x, text_y),  # 直接使用text_x, text_y
                    title_text,
                    font=font,
                    fill=(*text_color, 255),
                    align='center',
                    anchor='mm'
                )
        else:
            # 单行文字渲染（原有逻辑）
            if stroke_width > 0:
                title_draw.text(
                    (text_x, text_y),  # 直接使用text_x, text_y
                    title_text,
                    font=font,
                    fill=(*text_color, 255),
                    anchor='mm',
                    stroke_width=stroke_width,
                    stroke_fill=(*stroke_color, 255)
                )
            else:
                title_draw.text(
                    (text_x, text_y),  # 直接使用text_x, text_y
                    title_text,
                    font=font,
                    fill=(*text_color, 255),
                    anchor='mm'
                )

        # 绘制副标题（如果有）
        if subtitle_text:
            print(f"Adding subtitle text: {subtitle_text}", file=sys.stderr)
            
            # 获取副标题参数
            subtitle_font_family = self.template.get('subtitleFontFamily', 'NotoSerifCJK-VF')
            subtitle_font_size = self.template.get('subtitleFontSize', 60)
            subtitle_font_weight = self.template.get('subtitleFontWeight', 500)
            subtitle_text_color = self.hex_to_rgb(self.template.get('subtitleColor', '#FFFFFF'))
            subtitle_stroke_color = self.hex_to_rgb(self.template.get('subtitleStrokeColor', '#000000'))
            subtitle_stroke_width = self.template.get('subtitleStrokeWidth', 1)
            
            # 修复：处理副标题位置参数
            subtitle_position = self.template.get('subtitlePosition', {'x': 50, 'y': 90})
            
            # 如果是字符串（旧格式），转换为字典
            if isinstance(subtitle_position, str):
                position_map = {
                    'top': {'x': 50, 'y': 30},
                    'center': {'x': 50, 'y': 50},
                    'bottom': {'x': 50, 'y': 90}
                }
                subtitle_position = position_map.get(subtitle_position, {'x': 50, 'y': 90})
                print(f"Converted subtitle position from string to dict: {subtitle_position}", file=sys.stderr)
            
            # 加载副标题字体
            subtitle_font_path = self._get_font_path(subtitle_font_family)
            try:
                subtitle_font = ImageFont.truetype(subtitle_font_path, subtitle_font_size)
            except:
                print(f"Warning: Failed to load subtitle font {subtitle_font_path}, using default", file=sys.stderr)
                subtitle_font = ImageFont.load_default()
            
            # 计算副标题中心点位置（百分比转像素）
            # ✅ 修复旋转坐标问题：有旋转时Y轴需要反转，无旋转时不需要
            subtitle_x = int(width * subtitle_position['x'] / 100)
            # 注意：这里还没有读取到rotation_angle，先使用正常计算，后面会根据rotation调整
            subtitle_y_from_config = subtitle_position['y']
            subtitle_y = int(height * subtitle_y_from_config / 100)

            print(f"Rendering subtitle, initial center=({subtitle_x},{subtitle_y}), text='{subtitle_text}' (from {subtitle_position['x']}%, {subtitle_y_from_config}%)", file=sys.stderr)
            
            # ✅ 直接在原图上绘制副标题（不使用临时图层）
            print(f"Drawing subtitle directly on original image at ({subtitle_x},{subtitle_y})", file=sys.stderr)

            # 直接在原图上绘制，不使用临时图层
            subtitle_draw = draw
            
            # 绘制副标题（使用anchor='mm'实现中心对齐）
            # ✅ 新增：检查是否使用titles.sub参数（支持direction、charSpacing、lineSpacing、maxLength）

            # ✅ 修复：总是使用图层渲染方式（支持旋转），即使没有titles配置
            if not titles_config or 'sub' not in titles_config:
                # 创建默认的titles配置，从顶级模板读取参数
                if not titles_config:
                    titles_config = {}
                titles_config['sub'] = {
                    'direction': self.template.get('subtitleDirection', 'horizontal'),
                    'charSpacing': self.template.get('subtitleCharSpacing'),
                    'lineSpacing': self.template.get('subtitleLineSpacing'),
                    'maxLength': self.template.get('subtitleMaxCharsPerLine', 15),
                    'rotation': self.template.get('subtitleRotation', 0),
                    'backgroundRotation': self.template.get('subtitleBackgroundRotation', 0),
                }

            if titles_config and 'sub' in titles_config:
                # 使用titles.sub参数配置绘制副标题（支持横竖排、字符间距、行间距、自动折行）
                print(f"[advanced_cover_generator] Using titles.sub config for subtitle rendering", file=sys.stderr)
                sub_config = titles_config['sub']

                # ✅ 修复：优先从 titles.sub 读取字体大小，确保与前端一致
                subtitle_font_size_from_config = sub_config.get('fontSize', subtitle_font_size)
                if subtitle_font_size_from_config != subtitle_font_size:
                    print(f"  [INFO] Using fontSize from titles.sub: {subtitle_font_size_from_config} (was {subtitle_font_size})", file=sys.stderr)
                    subtitle_font_size = subtitle_font_size_from_config
                    # 重新加载字体
                    try:
                        subtitle_font = ImageFont.truetype(subtitle_font_path, subtitle_font_size)
                    except:
                        pass

                # 获取排版参数 - 优先使用 titles.sub 中的值，否则使用顶级配置，最后使用默认值
                direction = sub_config.get('direction', self.template.get('subtitleDirection', 'horizontal'))

                # ✅ 修复：优先使用 titles.sub 中的间距值，然后是顶级配置，最后是默认值
                char_spacing = sub_config.get('charSpacing')
                if char_spacing is None:
                    char_spacing = self.template.get('subtitleCharSpacing')
                if char_spacing is None:
                    char_spacing = int(subtitle_font_size * 0.2)

                line_spacing = sub_config.get('lineSpacing')
                if line_spacing is None:
                    line_spacing = self.template.get('subtitleLineSpacing')
                if line_spacing is None:
                    line_spacing = int(subtitle_font_size * 1.2)

                max_chars_per_line = sub_config.get('maxLength', self.template.get('subtitleMaxCharsPerLine', 15))

                # ✅ 新增：获取副标题阴影参数
                subtitle_shadow_enabled = sub_config.get('shadowEnabled', self.template.get('subtitleShadowEnabled', False))
                subtitle_shadow_color = self.hex_to_rgb(sub_config.get('shadowColor', self.template.get('subtitleShadowColor', '#000000')))
                subtitle_shadow_offset_x = sub_config.get('shadowOffsetX', self.template.get('subtitleShadowOffsetX', 0))
                subtitle_shadow_offset_y = sub_config.get('shadowOffsetY', self.template.get('subtitleShadowOffsetY', 0))
                subtitle_shadow_blur = sub_config.get('shadowBlur', self.template.get('subtitleShadowBlur', 0))
                subtitle_rotation_angle = sub_config.get('rotation', self.template.get('subtitleRotation', 0))
                subtitle_background_rotation = sub_config.get('backgroundRotation', self.template.get('subtitleBackgroundRotation', 0))

                # ✅ 修复旋转坐标问题：根据旋转角度使用不同的变换（和主标题一致）
                normalized_subtitle_angle = subtitle_rotation_angle % 360

                if 45 <= normalized_subtitle_angle < 135:
                    # ~90度旋转
                    subtitle_x = int(width * subtitle_y_from_config / 100)
                    subtitle_y = int(height * (100 - subtitle_position['x']) / 100)
                    print(f"[ROTATION 90°] Subtitle: ({subtitle_position['x']}%, {subtitle_y_from_config}%) → ({subtitle_y_from_config}%, {100-subtitle_position['x']}%) → ({subtitle_x}px, {subtitle_y}px)", file=sys.stderr)
                elif 135 <= normalized_subtitle_angle < 225:
                    # ~180度旋转
                    subtitle_x = int(width * (100 - subtitle_position['x']) / 100)
                    subtitle_y = int(height * (100 - subtitle_y_from_config) / 100)
                    print(f"[ROTATION 180°] Subtitle: ({subtitle_position['x']}%, {subtitle_y_from_config}%) → ({100-subtitle_position['x']}%, {100-subtitle_y_from_config}%) → ({subtitle_x}px, {subtitle_y}px)", file=sys.stderr)
                elif 225 <= normalized_subtitle_angle < 315:
                    # ~270度旋转
                    subtitle_x = int(width * (100 - subtitle_y_from_config) / 100)
                    subtitle_y = int(height * subtitle_position['x'] / 100)
                    print(f"[ROTATION 270°] Subtitle: ({subtitle_position['x']}%, {subtitle_y_from_config}%) → ({100-subtitle_y_from_config}%, {subtitle_position['x']}%) → ({subtitle_x}px, {subtitle_y}px)", file=sys.stderr)
                else:
                    # ~0度或360度
                    print(f"[NO ROTATION] Subtitle: ({subtitle_position['x']}%, {subtitle_y_from_config}%) → ({subtitle_x}px, {subtitle_y}px)", file=sys.stderr)

                # ✅ 新增：计算副标题实际高度并调整Y坐标，与前端getElementStyleWithSize保持一致
                # 不限制范围，允许文字超出边界
                try:
                    subtitle_bbox = draw.textbbox((subtitle_x, subtitle_y), subtitle_text, font=subtitle_font, anchor='mm')
                    subtitle_height = subtitle_bbox[3] - subtitle_bbox[1]
                    # 调整Y坐标：top = centerY - height/2（与前端一致）
                    subtitle_y = subtitle_y - subtitle_height // 2
                    print(f"[SUBTITLE HEIGHT ADJUST] subtitle_height={subtitle_height}, adjusted subtitle_y={subtitle_y}", file=sys.stderr)
                except Exception as e:
                    print(f"[SUBTITLE HEIGHT ADJUST] Warning: {e}", file=sys.stderr)

                print(f"[DEBUG] Sub title config:", file=sys.stderr)
                print(f"  Text: '{subtitle_text}' (length: {len(subtitle_text)})", file=sys.stderr)
                print(f"  maxLength: {max_chars_per_line}", file=sys.stderr)
                print(f"  Direction: {direction}", file=sys.stderr)
                print(f"  Char spacing: {char_spacing}px, Line spacing: {line_spacing}px", file=sys.stderr)
                print(f"  Position: ({subtitle_x}, {subtitle_y})", file=sys.stderr)

                # 将文字分行
                lines = []
                for i in range(0, len(subtitle_text), max_chars_per_line):
                    lines.append(subtitle_text[i:i + max_chars_per_line])

                print(f"  Split into {len(lines)} lines: {lines}", file=sys.stderr)

                if direction == 'vertical':
                    # ✅ 修复：与前端一致，竖排从左到右排列，每列从上到下
                    total_width = (len(lines) - 1) * line_spacing + subtitle_font_size
                    max_col_chars = max(len(line) for line in lines) if lines else 1
                    total_height = (max_col_chars - 1) * (subtitle_font_size + char_spacing) + subtitle_font_size

                    # ✅ 修复：计算起始位置（整体居中），与前端一致
                    start_x = subtitle_x - total_width // 2
                    start_y = subtitle_y - total_height // 2

                    print(f"  [Vertical] total_size=({total_width},{total_height}), start=({start_x},{start_y})", file=sys.stderr)

                    # ✅ 计算padding：确保文字+阴影+模糊完全在图层内
                    base_padding = max(
                        abs(min(0, start_x)),
                        abs(min(0, start_y)),
                        max(0, start_x + total_width - width),
                        max(0, start_y + total_height - height),
                        subtitle_shadow_blur * 3,
                        abs(subtitle_shadow_offset_x),
                        abs(subtitle_shadow_offset_y)
                    )
                    diagonal = int(((total_width ** 2 + total_height ** 2) ** 0.5) / 2)
                    rotation_padding = diagonal if subtitle_rotation_angle != 0 else 0
                    padding = max(base_padding, rotation_padding) + 100

                    expanded_width = width + padding * 2
                    expanded_height = height + padding * 2
                    print(f"  [Vertical Subtitle] Using expanded layer: {width}x{height} → {expanded_width}x{expanded_height}, padding={padding} (base={base_padding}, rotation={rotation_padding})", file=sys.stderr)

                    # ✅ 步骤1: 处理多层阴影或单层阴影（与主标题逻辑一致）
                    subtitle_has_shadow = subtitle_shadow_enabled and (subtitle_shadow_blur > 0 or subtitle_shadow_offset_x != 0 or subtitle_shadow_offset_y != 0)
                    subtitle_shadow_layers = sub_config.get('shadowLayers', self.template.get('subtitleShadowLayers', []))
                    subtitle_has_multiple_shadows = len(subtitle_shadow_layers) > 0 and any(layer.get('enabled', True) for layer in subtitle_shadow_layers)

                    if subtitle_has_multiple_shadows or subtitle_has_shadow:
                        print(f"  [Vertical Subtitle] Creating shadow layer(s): {len([l for l in subtitle_shadow_layers if l.get('enabled', True)])} multi-layer + single={subtitle_has_shadow}", file=sys.stderr)
                        shadow_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))

                        # ✅ 首先绘制多层阴影（如果有）
                        if subtitle_has_multiple_shadows:
                            for layer_idx, layer in enumerate(subtitle_shadow_layers):
                                if layer.get('enabled', True):
                                    layer_color = self.hex_to_rgb(layer.get('color', '#000000'))
                                    layer_opacity = int(255 * (layer.get('opacity', 100) / 100))
                                    layer_offset_x = layer.get('offsetX', 0)
                                    layer_offset_y = layer.get('offsetY', 0)
                                    layer_blur = layer.get('blur', 0)

                                    shadow_draw = ImageDraw.Draw(shadow_layer)

                                    # 为这一层绘制文字
                                    for col_idx, line in enumerate(lines):
                                        col_x = start_x + padding + col_idx * line_spacing
                                        for char_idx, char in enumerate(line):
                                            char_y = start_y + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                                            char_x = col_x
                                            shadow_x = char_x + layer_offset_x
                                            shadow_y = char_y + layer_offset_y
                                            shadow_draw.text((shadow_x, shadow_y), char, font=subtitle_font, fill=(*layer_color, layer_opacity), anchor='mm')

                                    # 对这一层应用模糊
                                    if layer_blur > 0:
                                        print(f"    [Vertical Subtitle] Applying blur={layer_blur} to shadow layer {layer_idx}", file=sys.stderr)
                                        shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=layer_blur))

                                    print(f"    [Vertical Subtitle] Shadow layer {layer_idx} composited", file=sys.stderr)

                        # ✅ 然后绘制传统单层阴影（如果有）
                        if subtitle_has_shadow:
                            shadow_draw_temp = ImageDraw.Draw(shadow_layer)
                            for col_idx, line in enumerate(lines):
                                col_x = start_x + padding + col_idx * line_spacing
                                for char_idx, char in enumerate(line):
                                    char_y = start_y + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                                    char_x = col_x
                                    shadow_x = char_x + subtitle_shadow_offset_x
                                    shadow_y = char_y + subtitle_shadow_offset_y
                                    shadow_draw_temp.text((shadow_x, shadow_y), char, font=subtitle_font, fill=(*subtitle_shadow_color, 160), anchor='mm')

                            if subtitle_shadow_blur > 0:
                                print(f"  [Vertical Subtitle] Applying GaussianBlur with radius={subtitle_shadow_blur}", file=sys.stderr)
                                shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=subtitle_shadow_blur))

                        # ✅ 旋转扩展图层并裁剪回原始尺寸
                        if subtitle_rotation_angle != 0:
                            print(f"  [Vertical Subtitle] Rotating shadow layer by {subtitle_rotation_angle}°", file=sys.stderr)
                            shadow_layer = shadow_layer.rotate(-subtitle_rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                            crop_x = (shadow_layer.width - width) // 2
                            crop_y = (shadow_layer.height - height) // 2
                            shadow_layer = shadow_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                            result = Image.alpha_composite(result, shadow_layer)
                        else:
                            shadow_layer = shadow_layer.crop((padding, padding, padding + width, padding + height))
                            result = Image.alpha_composite(result, shadow_layer)
                        subtitle_draw = ImageDraw.Draw(result)
                        print(f"  [Vertical Subtitle] Shadow layer composited", file=sys.stderr)

                    # ✅ 步骤2: 在扩展图层绘制描边和主文字
                    print(f"  [Vertical Subtitle] Creating text layer", file=sys.stderr)
                    text_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))
                    text_draw = ImageDraw.Draw(text_layer)

                    for col_idx, line in enumerate(lines):
                        col_x = start_x + padding + col_idx * line_spacing

                        for char_idx, char in enumerate(line):
                            char_y = start_y + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                            char_x = col_x

                            # 绘制描边
                            if subtitle_stroke_width > 0:
                                for offset_x in range(-subtitle_stroke_width, subtitle_stroke_width + 1):
                                    for offset_y in range(-subtitle_stroke_width, subtitle_stroke_width + 1):
                                        if offset_x == 0 and offset_y == 0:
                                            continue
                                        text_draw.text((char_x + offset_x, char_y + offset_y),
                                                     char, font=subtitle_font, fill=(*subtitle_stroke_color, 255), anchor='mm')

                            # 绘制主体
                            text_draw.text((char_x, char_y), char, font=subtitle_font, fill=(*subtitle_text_color, 255), anchor='mm')

                    # ✅ 步骤3: 旋转扩展图层并裁剪回原始尺寸
                    if subtitle_rotation_angle != 0:
                        print(f"  [Vertical Subtitle] Rotating text layer by {subtitle_rotation_angle}°", file=sys.stderr)
                        text_layer = text_layer.rotate(-subtitle_rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                        crop_x = (text_layer.width - width) // 2
                        crop_y = (text_layer.height - height) // 2
                        text_layer = text_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                        result = Image.alpha_composite(result, text_layer)
                    else:
                        text_layer = text_layer.crop((padding, padding, padding + width, padding + height))
                        result = Image.alpha_composite(result, text_layer)
                    subtitle_draw = ImageDraw.Draw(result)
                    print(f"  [Vertical Subtitle] Text layer composited", file=sys.stderr)
                else:
                    # 横排：从左到右，从上到下（默认）
                    # ✅ 修复：与前端一致，行间距 = subtitle_font_size + line_spacing
                    total_height = (len(lines) - 1) * (subtitle_font_size + line_spacing) + subtitle_font_size

                    # ✅ 修复：计算最长行的宽度，所有行都基于此宽度左对齐（与前端一致）
                    max_line_chars = max(len(line) for line in lines) if lines else 1
                    total_width = (max_line_chars - 1) * (subtitle_font_size + char_spacing) + subtitle_font_size

                    # 计算整体起始位置（基于最长行居中，然后所有行左对齐）
                    start_x = subtitle_x - total_width // 2
                    start_y = subtitle_y - total_height // 2

                    print(f"  [Horizontal] total_size=({total_width},{total_height}), start=({start_x},{start_y})", file=sys.stderr)

                    # ✅ 计算padding：确保文字+阴影+模糊完全在图层内
                    base_padding = max(
                        abs(min(0, start_x)),
                        abs(min(0, start_y)),
                        max(0, start_x + total_width - width),
                        max(0, start_y + total_height - height),
                        subtitle_shadow_blur * 3,
                        abs(subtitle_shadow_offset_x),
                        abs(subtitle_shadow_offset_y)
                    )
                    diagonal = int(((total_width ** 2 + total_height ** 2) ** 0.5) / 2)
                    rotation_padding = diagonal if subtitle_rotation_angle != 0 else 0
                    padding = max(base_padding, rotation_padding) + 100

                    expanded_width = width + padding * 2
                    expanded_height = height + padding * 2
                    print(f"  [Horizontal Subtitle] Using expanded layer: {width}x{height} → {expanded_width}x{expanded_height}, padding={padding} (base={base_padding}, rotation={rotation_padding})", file=sys.stderr)

                    # ✅ 步骤1: 处理多层阴影或单层阴影（与主标题逻辑一致）
                    subtitle_has_shadow = subtitle_shadow_enabled and (subtitle_shadow_blur > 0 or subtitle_shadow_offset_x != 0 or subtitle_shadow_offset_y != 0)
                    subtitle_shadow_layers = sub_config.get('shadowLayers', self.template.get('subtitleShadowLayers', []))
                    subtitle_has_multiple_shadows = len(subtitle_shadow_layers) > 0 and any(layer.get('enabled', True) for layer in subtitle_shadow_layers)

                    if subtitle_has_multiple_shadows or subtitle_has_shadow:
                        print(f"  [Horizontal Subtitle] Creating shadow layer(s): {len([l for l in subtitle_shadow_layers if l.get('enabled', True)])} multi-layer + single={subtitle_has_shadow}", file=sys.stderr)
                        shadow_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))

                        # ✅ 首先绘制多层阴影（如果有）
                        if subtitle_has_multiple_shadows:
                            for layer_idx, layer in enumerate(subtitle_shadow_layers):
                                if layer.get('enabled', True):
                                    layer_color = self.hex_to_rgb(layer.get('color', '#000000'))
                                    layer_opacity = int(255 * (layer.get('opacity', 100) / 100))
                                    layer_offset_x = layer.get('offsetX', 0)
                                    layer_offset_y = layer.get('offsetY', 0)
                                    layer_blur = layer.get('blur', 0)

                                    shadow_draw = ImageDraw.Draw(shadow_layer)

                                    # 为这一层绘制文字
                                    for row_idx, line in enumerate(lines):
                                        line_y = start_y + padding + row_idx * (subtitle_font_size + line_spacing) + subtitle_font_size // 2
                                        for char_idx, char in enumerate(line):
                                            char_x = start_x + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                                            char_y = line_y
                                            shadow_x = char_x + layer_offset_x
                                            shadow_y = char_y + layer_offset_y
                                            shadow_draw.text((shadow_x, shadow_y), char, font=subtitle_font, fill=(*layer_color, layer_opacity), anchor='mm')

                                    # 对这一层应用模糊
                                    if layer_blur > 0:
                                        print(f"    [Horizontal Subtitle] Applying blur={layer_blur} to shadow layer {layer_idx}", file=sys.stderr)
                                        shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=layer_blur))

                                    print(f"    [Horizontal Subtitle] Shadow layer {layer_idx} composited", file=sys.stderr)

                        # ✅ 然后绘制传统单层阴影（如果有）
                        if subtitle_has_shadow:
                            shadow_draw_temp = ImageDraw.Draw(shadow_layer)
                            for row_idx, line in enumerate(lines):
                                line_y = start_y + padding + row_idx * (subtitle_font_size + line_spacing) + subtitle_font_size // 2
                                for char_idx, char in enumerate(line):
                                    char_x = start_x + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                                    char_y = line_y
                                    shadow_x = char_x + subtitle_shadow_offset_x
                                    shadow_y = char_y + subtitle_shadow_offset_y
                                    shadow_draw_temp.text((shadow_x, shadow_y), char, font=subtitle_font, fill=(*subtitle_shadow_color, 160), anchor='mm')

                            if subtitle_shadow_blur > 0:
                                print(f"  [Horizontal Subtitle] Applying GaussianBlur with radius={subtitle_shadow_blur}", file=sys.stderr)
                                shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=subtitle_shadow_blur))

                        # ✅ 旋转扩展图层并裁剪回原始尺寸
                        if subtitle_rotation_angle != 0:
                            print(f"  [Horizontal Subtitle] Rotating shadow layer by {subtitle_rotation_angle}°", file=sys.stderr)
                            shadow_layer = shadow_layer.rotate(-subtitle_rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                            # 裁剪回原始尺寸：计算中心位置
                            crop_x = (shadow_layer.width - width) // 2
                            crop_y = (shadow_layer.height - height) // 2
                            shadow_layer = shadow_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                            result = Image.alpha_composite(result, shadow_layer)
                        else:
                            # 裁剪掉padding
                            shadow_layer = shadow_layer.crop((padding, padding, padding + width, padding + height))
                            result = Image.alpha_composite(result, shadow_layer)
                        subtitle_draw = ImageDraw.Draw(result)
                        print(f"  [Horizontal Subtitle] Shadow layer composited", file=sys.stderr)

                    # ✅ 步骤2: 在扩展图层绘制描边和主文字
                    print(f"  [Horizontal Subtitle] Creating text layer", file=sys.stderr)
                    text_layer = Image.new('RGBA', (expanded_width, expanded_height), (0, 0, 0, 0))
                    text_draw = ImageDraw.Draw(text_layer)

                    for row_idx, line in enumerate(lines):
                        line_y = start_y + padding + row_idx * (subtitle_font_size + line_spacing) + subtitle_font_size // 2

                        for char_idx, char in enumerate(line):
                            char_x = start_x + padding + char_idx * (subtitle_font_size + char_spacing) + subtitle_font_size // 2
                            char_y = line_y

                            # 绘制描边
                            if subtitle_stroke_width > 0:
                                for offset_x in range(-subtitle_stroke_width, subtitle_stroke_width + 1):
                                    for offset_y in range(-subtitle_stroke_width, subtitle_stroke_width + 1):
                                        if offset_x == 0 and offset_y == 0:
                                            continue
                                        text_draw.text((char_x + offset_x, char_y + offset_y),
                                                     char, font=subtitle_font, fill=(*subtitle_stroke_color, 255), anchor='mm')

                            # 绘制主体
                            text_draw.text((char_x, char_y), char, font=subtitle_font, fill=(*subtitle_text_color, 255), anchor='mm')

                    # ✅ 步骤3: 旋转扩展图层并裁剪回原始尺寸
                    if subtitle_rotation_angle != 0:
                        print(f"  [Horizontal Subtitle] Rotating text layer by {subtitle_rotation_angle}°", file=sys.stderr)
                        text_layer = text_layer.rotate(-subtitle_rotation_angle, resample=Image.BICUBIC, expand=True, fillcolor=(0, 0, 0, 0))
                        crop_x = (text_layer.width - width) // 2
                        crop_y = (text_layer.height - height) // 2
                        text_layer = text_layer.crop((crop_x, crop_y, crop_x + width, crop_y + height))
                        result = Image.alpha_composite(result, text_layer)
                    else:
                        # 裁剪掉padding
                        text_layer = text_layer.crop((padding, padding, padding + width, padding + height))
                        result = Image.alpha_composite(result, text_layer)
                    subtitle_draw = ImageDraw.Draw(result)
                    print(f"  [Horizontal Subtitle] Text layer composited", file=sys.stderr)
            elif subtitle_stroke_width > 0:
                # 原有逻辑：带描边（回退到简单multiline_text）
                subtitle_draw.text(
                    (subtitle_x, subtitle_y),
                    subtitle_text,
                    font=subtitle_font,
                    fill=(*subtitle_text_color, 255),
                    anchor='mm',
                    stroke_width=subtitle_stroke_width,
                    stroke_fill=(*subtitle_stroke_color, 255)
                )
            else:
                # 原有逻辑：不带描边（回退到简单multiline_text）
                subtitle_draw.text(
                    (subtitle_x, subtitle_y),
                    subtitle_text,
                    font=subtitle_font,
                    fill=(*subtitle_text_color, 255),
                    anchor='mm'
                )

        # 保存预览（保持RGBA模式）
        self.save_preview(result, "text_added")

        return result

    
    def _get_font_path(self, font_family: str) -> str:
        app_root = os.environ.get('APP_ROOT')
        resource_bundle_root = os.environ.get('RESOURCE_BUNDLE_ROOT')
        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        font_candidates = []
        if resource_bundle_root:
            font_candidates.extend([
                os.path.join(resource_bundle_root, 'fonts', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(resource_bundle_root, 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(resource_bundle_root, 'fonts', 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
            ])
        if app_root:
            font_candidates.extend([
                os.path.join(app_root, 'resources-bundles', 'fonts', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(app_root, 'resources-bundles', 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(app_root, 'resources-bundles', 'fonts', 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(app_root, 'extra', 'common', 'fonts', 'NotoSerifCJK-VF.ttf.ttc'),
                os.path.join(app_root, 'extra', 'common', 'fonts', 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
            ])
        font_candidates.extend([
            os.path.join(project_root, 'fonts', 'bundled', 'NotoSerifCJK-VF.ttf.ttc'),
            os.path.join(project_root, 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
            os.path.join(os.getcwd(), 'fonts', 'bundled', 'NotoSerifCJK-VF.ttf.ttc'),
            os.path.join(os.getcwd(), 'ziti', 'NotoSerifCJK-VF.ttf.ttc'),
        ])

        for font_path in font_candidates:
            if font_path and os.path.exists(font_path):
                return font_path

        raise RuntimeError("Packaged cover font not found: NotoSerifCJK-VF.ttf.ttc")

    COVER_WIDTH = 1080
    COVER_HEIGHT = 1440  # 3:4 比例

    def _resize_to_cover_size(self, image: Image.Image) -> Image.Image:
        """
        将图片调整到标准封面尺寸 (1080x1920)，保持比例并居中裁剪

        Args:
            image: 输入图像

        Returns:
            调整后的图像
        """
        target_width = self.COVER_WIDTH
        target_height = self.COVER_HEIGHT
        target_ratio = target_width / target_height  # 9:16 = 0.5625

        orig_width, orig_height = image.size
        orig_ratio = orig_width / orig_height

        print(f"[resize_to_cover_size] Original: {orig_width}x{orig_height} (ratio: {orig_ratio:.4f})", file=sys.stderr)
        print(f"[resize_to_cover_size] Target: {target_width}x{target_height} (ratio: {target_ratio:.4f})", file=sys.stderr)

        # 计算缩放和裁剪
        if orig_ratio > target_ratio:
            # 原图更宽，以高度为基准缩放，然后裁剪宽度
            new_height = target_height
            new_width = int(orig_width * (target_height / orig_height))
            resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
            # 居中裁剪
            left = (new_width - target_width) // 2
            cropped = resized.crop((left, 0, left + target_width, target_height))
        else:
            # 原图更高或相等，以宽度为基准缩放，然后裁剪高度
            new_width = target_width
            new_height = int(orig_height * (target_width / orig_width))
            resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
            # 居中裁剪
            top = (new_height - target_height) // 2
            cropped = resized.crop((0, top, target_width, top + target_height))

        print(f"[resize_to_cover_size] Result: {cropped.size}", file=sys.stderr)
        return cropped

    def generate(self) -> Dict[str, Any]:
        """
        生成封面（完整流程）

        正确流程：
        1. 人物抠图（带透明背景）
        2. 人物描边（在抠图上添加描边）
        3. 模糊背景（原图模糊处理）
        4. 合成2和3（将描边后的人物合成到模糊背景上）
        5. 添加文字和其他信息（文字背景半透明）

        Returns:
            生成结果
        """
        try:
            print("=" * 80, file=sys.stderr)
            print("Starting advanced cover generation", file=sys.stderr)
            print(f"Target cover size: {self.COVER_WIDTH}x{self.COVER_HEIGHT}", file=sys.stderr)
            print("=" * 80, file=sys.stderr)

            # 加载原始图像
            original_image = self.load_image(self.config.get('video', ''))

            # ✅ 关键修复：将图片调整到标准封面尺寸，与前端画布一致
            original_image = self._resize_to_cover_size(original_image)

            self.save_preview(original_image, "original")

            # 步骤1: 人物抠图（如果启用）
            person_rgba = None
            if self.template.get('personBorderEnabled', False) and SEGMENT_AVAILABLE:
                print("Step 1: Extracting person from original image using PersonSegmenter", file=sys.stderr)
                try:
                    # 使用PersonSegmenter进行抠图（支持MODNet优先级）
                    person_rgba = self._segment_person_with_modnet(original_image)

                    if person_rgba.mode != 'RGBA':
                        person_rgba = person_rgba.convert('RGBA')

                    # 提取 alpha 通道并优化（确保只有人物轮廓，其他部分完全透明）
                    alpha_channel = np.array(person_rgba.split()[3])
                    print(f"Alpha channel before refinement: min={alpha_channel.min()}, max={alpha_channel.max()}, unique_values={len(np.unique(alpha_channel))}", file=sys.stderr)

                    refined_alpha = self.refine_mask(alpha_channel)
                    print(f"Alpha channel after refinement: min={refined_alpha.min()}, max={refined_alpha.max()}, unique_values={len(np.unique(refined_alpha))}", file=sys.stderr)

                    # 关键修复：确保只有人物形状是不透明的，周围完全透明
                    # 使用严格的二值化，避免灰度值导致的半透明边缘扩展
                    _, refined_alpha_binary = cv2.threshold(refined_alpha, 127, 255, cv2.THRESH_BINARY)

                    person_rgba.putalpha(Image.fromarray(refined_alpha_binary))

                    self.save_preview(person_rgba, "step1_person_extracted")
                    print("Step 1: Person extraction completed with PersonSegmenter and mask refinement", file=sys.stderr)
                except Exception as e:
                    print(f"Step 1: Person extraction failed: {e}", file=sys.stderr)
                    import traceback
                    traceback.print_exc(file=sys.stderr)
                    person_rgba = None

            # 步骤2: 人物描边（如果有抠图）
            if person_rgba is not None:
                print("Step 2: Applying person outline", file=sys.stderr)
                person_rgba = self._apply_outline_to_person(person_rgba)
                self.save_preview(person_rgba, "step2_person_outlined")

            # 步骤3: 模糊背景
            print("Step 3: Applying background blur", file=sys.stderr)
            blurred_background = self.apply_background_blur(original_image)
            
            # 步骤4: 合成人物到模糊背景
            if person_rgba is not None:
                print("Step 4: Compositing person onto blurred background", file=sys.stderr)
                result = self._composite_person_to_background(person_rgba, blurred_background)
                self.save_preview(result, "step4_person_composited")
            else:
                result = blurred_background.convert('RGBA')

            # 步骤5: 蒙版叠加
            result = self.apply_mask(result)

            # 步骤6: 添加文字（文字背景半透明）
            result = self.add_text(result)

            # 保存最终结果（PNG格式保留透明度）
            print(f"Saving final cover to: {self.output_path}", file=sys.stderr)
            
            # 确保输出为PNG格式以保留透明度
            if not self.output_path.lower().endswith('.png'):
                print("Warning: Output format should be PNG to preserve transparency", file=sys.stderr)
            
            # 保存为RGBA模式的PNG
            if result.mode != 'RGBA':
                result = result.convert('RGBA')
            
            result.save(self.output_path, 'PNG', quality=95)

            print("=" * 80, file=sys.stderr)
            print("Cover generation completed successfully", file=sys.stderr)
            print(f"Total preview images: {len(self.preview_images)}", file=sys.stderr)
            print("=" * 80, file=sys.stderr)

            return {
                'success': True,
                'coverPath': self.output_path,
                'previewImages': self.preview_images,
                'message': 'Cover generated successfully'
            }

        except Exception as e:
            print(f"Error generating cover: {e}", file=sys.stderr)
            import traceback
            traceback.print_exc(file=sys.stderr)
            return {
                'success': False,
                'error': str(e),
                'message': f'Cover generation failed: {str(e)}'
            }
    
    def _apply_outline_to_person(self, person_rgba: Image.Image) -> Image.Image:
        """
        对抠出的人物应用描边
        
        正确方案：扩大画布 → 绘制完整描边 → 保持扩大后的尺寸
        
        Args:
            person_rgba: 抠出的人物图像（RGBA模式）
            
        Returns:
            添加描边后的人物图像（尺寸会比原图大）
        """
        # 获取描边参数
        border_color = self.hex_to_rgb(self.template.get('personBorderColor', '#FFFFFF'))
        border_width = self.template.get('personBorderWidth', 6)
        border_style = self.template.get('personBorderStyle', 'solid')
        
        # 使用文档规定的默认值
        dash_length = self.template.get('personBorderDashLength')
        gap_length = self.template.get('personBorderGapLength')
        
        if dash_length is None:
            dash_length = border_width * 3
        if gap_length is None:
            gap_length = border_width * 2

        print(f"Outline params: color={border_color}, width={border_width}, style={border_style}, dash={dash_length}, gap={gap_length}", file=sys.stderr)

        # 步骤1: 扩大画布（给描边留出空间）
        padding = border_width + 2  # 描边宽度 + 2像素余量
        original_width, original_height = person_rgba.size
        
        # 创建扩大后的画布
        expanded_person = Image.new('RGBA',
                                    (original_width + padding * 2, original_height + padding * 2),
                                    (0, 0, 0, 0))
        # 将原始人物图像粘贴到中心
        expanded_person.paste(person_rgba, (padding, padding), person_rgba)
        
        print(f"Expanded person canvas: original={person_rgba.size}, expanded={expanded_person.size}, padding={padding}", file=sys.stderr)
        
        # 步骤2: 从扩大后的图像提取 alpha 通道
        alpha = expanded_person.split()[3]
        alpha_np = np.array(alpha)
        
        # 确保是uint8格式
        if alpha_np.dtype != np.uint8:
            if alpha_np.max() <= 1.0:
                alpha_np = (alpha_np * 255).astype(np.uint8)
            else:
                alpha_np = alpha_np.astype(np.uint8)
        
        # 二值化mask（与参考项目一致 - cover.py:1221）
        # 这一步很关键：确保mask只有0和255两个值，提高轮廓检测精度
        _, alpha_binary = cv2.threshold(alpha_np, 127, 255, cv2.THRESH_BINARY)
        print(f"Alpha channel binarized: non-zero pixels = {np.count_nonzero(alpha_binary)}", file=sys.stderr)

        # 步骤3: 创建描边 mask - 使用轮廓检测（向外扩散，不覆盖人物）
        border_mask = None

        # 方法1: 轮廓检测（在扩大的画布上，描边不会被截断）
        try:
            contours, _ = cv2.findContours(alpha_binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

            if len(contours) > 0:
                print(f"Using contour detection method, found {len(contours)} contours", file=sys.stderr)

                # 创建空白 mask（与扩大后的画布同尺寸）
                border_mask = np.zeros_like(alpha_np)

                # 🔧 优化：使用 border_width * 2 作为绘制宽度
                # 因为后面会减去人物本身，实际描边只会保留外部的一半
                # 所以需要加倍线宽才能达到用户期望的描边粗细
                draw_width = border_width * 2
                cv2.drawContours(border_mask, contours, -1, 255, draw_width)

                # 🔧 关键修复：从描边mask中减去人物本身，确保描边只在外部
                # 这样描边就是向外扩散的，不会覆盖人物边缘
                border_mask = cv2.subtract(border_mask, alpha_binary)

                print(f"Contour detection succeeded, border_pixels={np.count_nonzero(border_mask)} (外部描边, 实际宽度≈{border_width}px)", file=sys.stderr)
        except Exception as e:
            print(f"Contour detection failed: {e}", file=sys.stderr)

        # 方法2: 形态学操作（后备）- 这个方法本身就是向外扩散的
        if border_mask is None or np.sum(border_mask) == 0:
            print("Using morphological operation method (fallback)", file=sys.stderr)

            # 计算 kernel 大小和迭代次数
            kernel_size = border_width * 2 + 1
            kernel = np.ones((kernel_size, kernel_size), np.uint8)
            iterations = max(1, border_width // 2)

            # 膨胀操作（使用二值化的alpha_binary以获得更清晰的边缘）
            dilated_mask = cv2.dilate(alpha_binary, kernel, iterations=iterations)

            # 边缘 = 膨胀后的mask - 原始mask（这就是向外扩散的描边）
            border_mask = cv2.subtract(dilated_mask, alpha_binary)

            print(f"Morphological method: kernel_size={kernel_size}, iterations={iterations}", file=sys.stderr)

        # 根据描边样式处理
        if border_style == 'dashed':
            print("Applying dashed border style", file=sys.stderr)
            border_mask = self._create_dashed_border(border_mask, border_width, dash_length, gap_length)
        
        # 步骤4: 在扩大的画布上应用描边
        person_width, person_height = expanded_person.size
        person_array = np.array(expanded_person)
        border_mask_3d = np.stack([border_mask] * 3, axis=2) / 255.0  # 归一化到0-1
        
        # 确保border_mask尺寸与人物图像匹配
        if border_mask.shape[:2] != (person_height, person_width):
            border_mask = cv2.resize(border_mask, (person_width, person_height), interpolation=cv2.INTER_NEAREST)
            border_mask_3d = np.stack([border_mask] * 3, axis=2) / 255.0
            print(f"Resized border_mask to match person image: {border_mask.shape}", file=sys.stderr)
        
        # 应用描边颜色到透明画布
        border_rgb_array = np.array(border_color, dtype=np.float32)
        h, w = person_array.shape[:2]
        border_rgb_3d = np.tile(border_rgb_array.reshape(1, 1, 3), (h, w, 1))
        
        # 分离RGB和Alpha通道
        person_rgb = person_array[:, :, :3].astype(np.float32)
        person_alpha = person_array[:, :, 3:4].astype(np.float32) / 255.0  # 归一化alpha到0-1
        
        # 关键修复：处理透明区域的RGB值
        # 在完全透明的区域（alpha=0），RGB值应该被保留为原值（通常是0）
        # 只在有描边和人物的地方应用颜色混合

        # 对RGB通道应用描边：只在border_mask > 0的地方混合颜色
        person_rgb = (person_rgb * (1 - border_mask_3d) +
                     border_rgb_3d * border_mask_3d).astype(np.uint8)

        # 对Alpha通道：描边区域应该是不透明的（255），人物区域保持原有alpha
        # border_mask是单通道的，值在0-255之间
        border_alpha_mask = border_mask[:, :, np.newaxis] / 255.0  # 归一化到0-1

        # 关键修复：确保完全透明的区域保持透明
        # 只在border_mask有值或person_alpha > 0的地方设置alpha
        # 这样可以避免扩大画布周围被填充成白色
        person_alpha_new = np.where(
            (border_alpha_mask > 0) | (person_alpha > 0),
            np.maximum(person_alpha, border_alpha_mask),
            0  # 透明区域保持完全透明
        ) * 255.0
        person_alpha_new = person_alpha_new.astype(np.uint8)
        
        # 合并RGB和Alpha通道
        person_array = np.concatenate([person_rgb, person_alpha_new], axis=2)
        
        person_with_border = Image.fromarray(person_array, 'RGBA')
        print(f"Border applied on expanded canvas, final size={person_with_border.size}, color RGB: {border_color}", file=sys.stderr)
        
        # 步骤5: 返回扩大后的图像（不裁剪，保持描边完整）
        return person_with_border
    
    def _create_dashed_border(self, border_mask: np.ndarray, border_width: int,
                             dash_length: int, gap_length: int) -> np.ndarray:
        """
        将实线描边转换为虚线描边
        
        使用轮廓路径追踪算法，沿着轮廓路径交替绘制虚线段和间隔
        关键优化：扩展画布以避免边缘虚线被截断
        
        Args:
            border_mask: 实线描边 mask
            border_width: 描边宽度
            dash_length: 虚线长度
            gap_length: 间隔长度
            
        Returns:
            虚线描边 mask
        """
        # 扩展画布以避免边缘虚线被截断
        padding = border_width * 2
        h, w = border_mask.shape
        
        # 创建扩展后的画布
        padded_border_mask = np.zeros((h + padding * 2, w + padding * 2), dtype=np.uint8)
        padded_border_mask[padding:padding+h, padding:padding+w] = border_mask
        
        print(f"Padded border_mask for dashed border: original={border_mask.shape}, padded={padded_border_mask.shape}, padding={padding}", file=sys.stderr)
        
        # 在扩展后的画布上找到轮廓
        contours, _ = cv2.findContours(padded_border_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        # 在扩展后的画布上创建虚线mask
        padded_dashed_mask = np.zeros_like(padded_border_mask)
        
        print(f"Creating dashed border: {len(contours)} contours, dash={dash_length}px, gap={gap_length}px", file=sys.stderr)
        
        # 对每个轮廓绘制虚线
        for contour_idx, contour in enumerate(contours):
            if len(contour) < 2:
                continue
            
            # 将轮廓点连接成连续的路径
            contour_points = [tuple(pt[0]) for pt in contour]
            
            # 计算轮廓总长度
            total_length = 0.0
            for i in range(len(contour_points) - 1):
                pt1 = contour_points[i]
                pt2 = contour_points[i + 1]
                total_length += np.sqrt((pt2[0] - pt1[0])**2 + (pt2[1] - pt1[1])**2)
            
            print(f"Contour {contour_idx}: {len(contour_points)} points, length={total_length:.1f}px", file=sys.stderr)
            
            # 沿着轮廓路径绘制虚线
            is_dash = True  # 当前是否在绘制虚线段
            dash_remaining = float(dash_length)  # 当前虚线段剩余长度
            gap_remaining = float(gap_length)    # 当前间隔剩余长度
            
            for i in range(len(contour_points) - 1):
                pt1 = contour_points[i]
                pt2 = contour_points[i + 1]
                
                # 计算两点间距离
                segment_dist = np.sqrt((pt2[0] - pt1[0])**2 + (pt2[1] - pt1[1])**2)
                
                if segment_dist < 0.1:  # 跳过太短的点
                    continue
                
                # 沿着这个线段绘制虚线
                remaining_in_segment = segment_dist
                segment_offset = 0.0  # 在当前线段中的偏移
                
                while remaining_in_segment > 0.01:  # 还有剩余距离
                    if is_dash:
                        # 绘制虚线段
                        draw_length = min(dash_remaining, remaining_in_segment)
                        
                        # 计算起点和终点在 pt1-pt2 线段上的位置
                        t1 = segment_offset / segment_dist
                        t2 = (segment_offset + draw_length) / segment_dist
                        
                        # 确保 t 在 [0, 1] 范围内
                        t1 = max(0.0, min(1.0, t1))
                        t2 = max(0.0, min(1.0, t2))
                        
                        x1 = int(pt1[0] + (pt2[0] - pt1[0]) * t1)
                        y1 = int(pt1[1] + (pt2[1] - pt1[1]) * t1)
                        x2 = int(pt1[0] + (pt2[0] - pt1[0]) * t2)
                        y2 = int(pt1[1] + (pt2[1] - pt1[1]) * t2)
                        
                        # 绘制虚线段（在扩展画布上）
                        if abs(x2 - x1) > 0 or abs(y2 - y1) > 0:  # 确保不是同一个点
                            cv2.line(padded_dashed_mask, (x1, y1), (x2, y2), 255, border_width)
                        
                        segment_offset += draw_length
                        remaining_in_segment -= draw_length
                        dash_remaining -= draw_length
                        
                        # 如果虚线段绘制完成，切换到间隔
                        if dash_remaining <= 0.01:
                            is_dash = False
                            gap_remaining = float(gap_length)  # 重置间隔长度
                    else:
                        # 跳过间隔段
                        skip_length = min(gap_remaining, remaining_in_segment)
                        segment_offset += skip_length
                        remaining_in_segment -= skip_length
                        gap_remaining -= skip_length
                        
                        # 如果间隔段完成，切换到虚线
                        if gap_remaining <= 0.01:
                            is_dash = True
                            dash_remaining = float(dash_length)  # 重置虚线长度
        
        # 裁剪回原始尺寸
        dashed_mask = padded_dashed_mask[padding:padding+h, padding:padding+w]
        print(f"Dashed border created and cropped back to original size", file=sys.stderr)
        
        return dashed_mask
    
    def _composite_person_to_background(self, person_rgba: Image.Image, background: Image.Image) -> Image.Image:
        """
        将人物合成到背景上
        
        Args:
            person_rgba: 人物图像（RGBA模式，可能带描边）
            background: 背景图像（RGB模式）
            
        Returns:
            合成后的图像（RGBA模式）
        """
        # 调整人物大小
        person_size = self.template.get('personSize', 100)
        person_rotation = self.template.get('personRotation', 0)
        if person_size != 100:
            new_width = int(person_rgba.width * person_size / 100)
            new_height = int(person_rgba.height * person_size / 100)
            person_rgba = person_rgba.resize((new_width, new_height), Image.Resampling.LANCZOS)

        # 调整人物位置
        person_position = self.template.get('personPosition', {'x': 50, 'y': 50})
        person_x = int(background.width * person_position['x'] / 100) - person_rgba.width // 2
        person_y = int(background.height * person_position['y'] / 100) - person_rgba.height // 2

        # 合成
        result = background.convert('RGBA')
        result.paste(person_rgba, (person_x, person_y), person_rgba)
        
        return result

    def run_and_output_json(self):
        """
        运行生成器并输出JSON结果（只输出一行JSON）
        """
        result = self.generate()
        # 确保只输出一行JSON
        sys.stdout.write(json.dumps(result, ensure_ascii=False))
        sys.stdout.flush()


def main():
    parser = argparse.ArgumentParser(description='Advanced Cover Generator')
    parser.add_argument('--video', required=True, help='Path to video or image file')
    parser.add_argument('--title', required=True, help='Title text')
    parser.add_argument('--output', required=True, help='Output cover path')
    parser.add_argument('--config', default='{}', help='JSON configuration')

    args = parser.parse_args()

    try:
        # 确保系统编码支持中文
        import sys
        import locale
        if sys.platform == 'win32':
            # Windows 设置控制台编码
            import ctypes
            kernel32 = ctypes.windll.kernel32
            kernel32.SetConsoleOutputCP(65001)  # UTF-8

        # 解析配置
        config = json.loads(args.config)

        # ⚠️ 诊断日志：同时输出到 stdout 和 stderr，确保能看到
        import sys
        diag_msg = f"""
=== ADVANCED COVER GENERATOR DIAGNOSTIC ===
[CONFIG] Received config keys: {list(config.keys())[:20]}... (showing first 20)
[CONFIG] titleStrokeWidth: {config.get('titleStrokeWidth', 'NOT SET')}
[CONFIG] titleStrokeColor: {config.get('titleStrokeColor', 'NOT SET')}
[CONFIG] titleFontFamily: {config.get('titleFontFamily', 'NOT SET')}
[CONFIG] personBorderEnabled: {config.get('personBorderEnabled', 'NOT SET')}
[CONFIG] personBorderWidth: {config.get('personBorderWidth', 'NOT SET')}
[CONFIG] personBorderColor: {config.get('personBorderColor', 'NOT SET')}
[CONFIG] backgroundBlurEnabled: {config.get('backgroundBlurEnabled', 'NOT SET')}
===========================================
"""
        print(diag_msg, file=sys.stderr, flush=True)
        sys.stderr.flush()

        # 添加命令行参数到配置
        config['video'] = args.video
        config['title'] = args.title
        config['output'] = args.output

        # 创建生成器
        generator = AdvancedCoverGenerator(config)

        # 运行并输出结果（只输出一行JSON）
        generator.run_and_output_json()

    except Exception as e:
        error_result = {
            'success': False,
            'error': str(e),
            'message': f'Error: {str(e)}'
        }
        sys.stdout.write(json.dumps(error_result, ensure_ascii=False))
        sys.stdout.flush()
        sys.exit(1)


if __name__ == '__main__':
    main()