Image Service

{
  "image_api": {
    "key": "your_image_api_key",
    "base_url": "https://api.openai.com/v1",
    "model": "dall-e-3"
  },
  "vision_api": {
    "key": "your_vision_api_key",
    "base_url": "https://api.openai.com/v1",
    "model": "gpt-4o"
  },
  "defaults": {
    "text_to_image": {
      "size": "1792x1024",
      "response_format": "b64_json"
    },
    "image_to_image": {
      "size": "1792x1024",
      "response_format": "b64_json"
    },
    "image_to_text": {
      "max_tokens": 2000,
      "temperature": 0.7,
      "mode": "describe"
    }
  },
  "limits": {
    "max_file_size_mb": 4,
    "supported_formats": ["png", "jpg", "jpeg", "webp", "gif"],
    "max_prompt_length": 1000,
    "timeout_seconds": {
      "text_to_image": 180,
      "image_to_image": 180,
      "image_to_text": 120
    }
  },
  "retry": {
    "max_attempts": 3,
    "backoff_multiplier": 2,
    "initial_delay_seconds": 1
  }
}

#!/usr/bin/env python3
"""
图生图脚本 (Image-to-Image)
基于参考图片和中文指令进行图片编辑（OpenAI Images API 兼容）

Author: 翟星人
"""

import httpx
import base64
import json
import os
from typing import Dict, Any, Optional, Union
from pathlib import Path

VALID_ASPECT_RATIOS = [
    "1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"
]

VALID_SIZES = [
    "1024x1024",
    "1536x1024", "1792x1024", "1344x768", "1248x832", "1184x864", "1152x896", "1536x672",
    "1024x1536", "1024x1792", "768x1344", "832x1248", "864x1184", "896x1152"
]

RATIO_TO_SIZE = {
    "1:1": "1024x1024",
    "2:3": "832x1248",
    "3:2": "1248x832",
    "3:4": "1024x1536",
    "4:3": "1536x1024",
    "4:5": "864x1184",
    "5:4": "1184x864",
    "9:16": "1024x1792",
    "16:9": "1792x1024",
    "21:9": "1536x672"
}


class ImageToImageEditor:
    """图生图编辑器"""
    
    def __init__(self, config: Optional[Dict[str, str]] = None):
        """
        初始化编辑器
        
        Args:
            config: 配置字典，包含 api_key, base_url, model
                   如果不传则从环境变量或配置文件读取
        """
        if config is None:
            config = self._load_config()
        
        self.api_key = config.get('api_key') or config.get('IMAGE_API_KEY')
        self.base_url = config.get('base_url') or config.get('IMAGE_API_BASE_URL')
        self.model = config.get('model') or config.get('IMAGE_MODEL') or 'dall-e-3'
        
        if not self.api_key or not self.base_url:
            raise ValueError("缺少必要的 API 配置：api_key 和 base_url")
    
    def _load_config(self) -> Dict[str, str]:
        """从配置文件或环境变量加载配置"""
        config = {}
        
        # 尝试从配置文件加载
        config_path = Path(__file__).parent.parent / 'config' / 'settings.json'
        if config_path.exists():
            with open(config_path, 'r', encoding='utf-8') as f:
                settings = json.load(f)
                api_config = settings.get('image_api', {})
                config['api_key'] = api_config.get('key')
                config['base_url'] = api_config.get('base_url')
                config['model'] = api_config.get('model')
        
        # 环境变量优先级更高
        config['api_key'] = os.getenv('IMAGE_API_KEY', config.get('api_key'))
        config['base_url'] = os.getenv('IMAGE_API_BASE_URL', config.get('base_url'))
        config['model'] = os.getenv('IMAGE_MODEL', config.get('model'))
        
        return config
    
    @staticmethod
    def image_to_base64(image_path: str, with_prefix: bool = True) -> str:
        """
        将图片文件转换为 base64 编码
        
        Args:
            image_path: 图片文件路径
            with_prefix: 是否添加 data URL 前缀
            
        Returns:
            base64 编码字符串
        """
        path = Path(image_path)
        if not path.exists():
            raise FileNotFoundError(f"图片文件不存在: {image_path}")
        
        # 获取 MIME 类型
        suffix = path.suffix.lower()
        mime_types = {
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif',
            '.webp': 'image/webp'
        }
        mime_type = mime_types.get(suffix, 'image/png')
        
        with open(image_path, 'rb') as f:
            b64_str = base64.b64encode(f.read()).decode('utf-8')
        
        if with_prefix:
            return f"data:{mime_type};base64,{b64_str}"
        return b64_str
    
    def edit(
        self,
        image: Union[str, bytes],
        prompt: str,
        aspect_ratio: Optional[str] = None,
        size: Optional[str] = None,
        output_path: Optional[str] = None,
        response_format: str = "b64_json"
    ) -> Dict[str, Any]:
        """
        编辑图片
        
        Args:
            image: 图片路径或 base64 字符串
            prompt: 中文编辑指令
            aspect_ratio: 宽高比 (如 3:4, 16:9)
            size: 传统尺寸 (如 1024x1792)
            output_path: 输出文件路径
            response_format: 响应格式
            
        Returns:
            包含编辑结果的字典
        """
        # 处理图片输入
        if isinstance(image, str):
            if os.path.isfile(image):
                image_b64 = self.image_to_base64(image)
            elif image.startswith('data:'):
                image_b64 = image
            else:
                # 假设是纯 base64 字符串
                image_b64 = f"data:image/png;base64,{image}"
        else:
            image_b64 = f"data:image/png;base64,{base64.b64encode(image).decode('utf-8')}"
        
        payload: Dict[str, Any] = {
            "model": self.model,
            "prompt": prompt,
            "image": image_b64,
            "response_format": response_format
        }
        
        # 确定尺寸：优先用 aspect_ratio 映射，其次用 size
        if aspect_ratio:
            payload["size"] = RATIO_TO_SIZE.get(aspect_ratio, "1024x1536")
        elif size:
            payload["size"] = size
        else:
            payload["size"] = "1024x1536"  # 默认 3:4
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        try:
            with httpx.Client(timeout=180.0) as client:
                response = client.post(
                    f"{self.base_url}/images/edits",
                    headers=headers,
                    json=payload
                )
                response.raise_for_status()
                result = response.json()
                
                # 如果指定了输出路径，保存图片
                if output_path and result.get("data"):
                    b64_data = result["data"][0].get("b64_json")
                    if b64_data:
                        self._save_image(b64_data, output_path)
                        result["saved_path"] = output_path
                
                return {
                    "success": True,
                    "data": result,
                    "saved_path": output_path if output_path else None
                }
                
        except httpx.HTTPStatusError as e:
            return {
                "success": False,
                "error": f"HTTP 错误: {e.response.status_code}",
                "detail": str(e)
            }
        except Exception as e:
            return {
                "success": False,
                "error": "编辑失败",
                "detail": str(e)
            }
    
    def _save_image(self, b64_data: str, output_path: str) -> None:
        """保存 base64 图片到文件"""
        image_data = base64.b64decode(b64_data)
        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
        with open(output_path, 'wb') as f:
            f.write(image_data)


def main():
    """命令行入口"""
    import argparse
    import time
    
    parser = argparse.ArgumentParser(
        description='图生图编辑工具',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=f'''
尺寸参数说明:
  -r/--ratio    宽高比（推荐），支持: {", ".join(VALID_ASPECT_RATIOS)}
  -s/--size     传统尺寸，支持: {", ".join(VALID_SIZES[:4])}...

示例:
  python image_to_image.py input.png "编辑描述" -r 3:4
  python image_to_image.py input.png "编辑描述" -s 1024x1536
'''
    )
    parser.add_argument('image', help='输入图片路径')
    parser.add_argument('prompt', help='中文编辑指令')
    parser.add_argument('-o', '--output', help='输出文件路径（默认保存到当前目录）')
    parser.add_argument('-r', '--ratio', help=f'宽高比（推荐）。可选: {", ".join(VALID_ASPECT_RATIOS)}')
    parser.add_argument('-s', '--size', help='传统尺寸，如 1024x1536')
    
    args = parser.parse_args()
    
    if args.ratio and args.ratio not in VALID_ASPECT_RATIOS:
        print(f"错误: 不支持的宽高比 '{args.ratio}'")
        print(f"支持的宽高比: {', '.join(VALID_ASPECT_RATIOS)}")
        return
    
    if args.size and args.size not in VALID_SIZES:
        print(f"警告: 尺寸 '{args.size}' 可能不被支持")
    
    output_path = args.output
    if not output_path:
        timestamp = time.strftime("%Y%m%d_%H%M%S")
        output_path = f"edited_{timestamp}.png"
    
    editor = ImageToImageEditor()
    result = editor.edit(
        image=args.image,
        prompt=args.prompt,
        aspect_ratio=args.ratio,
        size=args.size,
        output_path=output_path
    )
    
    if result["success"]:
        print(f"编辑成功！")
        if result.get("saved_path"):
            print(f"图片已保存到: {result['saved_path']}")
    else:
        print(f"编辑失败: {result['error']}")
        print(f"详情: {result.get('detail', 'N/A')}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
图生文脚本 (Image-to-Text) - 视觉识别
使用 Qwen2.5-VL 模型分析图片内容并生成文字描述

Author: 翟星人
"""

import httpx
import base64
import json
import os
from typing import Dict, Any, Optional, Union, List
from pathlib import Path


class ImageToTextAnalyzer:
    """图生文分析器 - 视觉识别"""
    
    # 预定义的分析模式
    ANALYSIS_MODES = {
        "describe": "请详细描述这张图片的内容，包括：人物、场景、物品、颜色、布局等所有细节。",
        "ocr": "请仔细识别这张图片中的所有文字内容，按照文字在图片中的位置顺序输出。如果是中文，请保持原文输出。",
        "chart": "请分析这张图表的内容，包括：图表类型、数据趋势、关键数据点、标题标签、以及数据的结论或洞察。",
        "fashion": "请分析这张图片中人物的穿搭，包括：服装款式、颜色搭配、配饰、整体风格等。",
        "product": "请分析这张产品图片，包括：产品类型、外观特征、功能特点、品牌信息等。",
        "scene": "请描述这张图片的场景，包括：地点、环境、氛围、时间（白天/夜晚）等。"
    }
    
    def __init__(self, config: Optional[Dict[str, str]] = None):
        """
        初始化分析器
        
        Args:
            config: 配置字典，包含 api_key, base_url, model
                   如果不传则从环境变量或配置文件读取
        """
        if config is None:
            config = self._load_config()
        
        self.api_key = config.get('api_key') or config.get('VISION_API_KEY') or config.get('IMAGE_API_KEY')
        self.base_url = config.get('base_url') or config.get('VISION_API_BASE_URL') or config.get('IMAGE_API_BASE_URL')
        self.model = config.get('model') or config.get('VISION_MODEL') or 'qwen2.5-vl-72b-instruct'
        
        if not self.api_key or not self.base_url:
            raise ValueError("缺少必要的 API 配置：api_key 和 base_url")
    
    def _load_config(self) -> Dict[str, str]:
        """从配置文件或环境变量加载配置"""
        config = {}
        
        # 尝试从配置文件加载
        config_path = Path(__file__).parent.parent / 'config' / 'settings.json'
        if config_path.exists():
            with open(config_path, 'r', encoding='utf-8') as f:
                settings = json.load(f)
                # 优先使用 vision_api 配置
                vision_config = settings.get('vision_api', {})
                if vision_config:
                    config['api_key'] = vision_config.get('key')
                    config['base_url'] = vision_config.get('base_url')
                    config['model'] = vision_config.get('model')
                else:
                    # 回退到 image_api 配置
                    api_config = settings.get('image_api', {})
                    config['api_key'] = api_config.get('key')
                    config['base_url'] = api_config.get('base_url')
        
        # 环境变量优先级更高
        config['api_key'] = os.getenv('VISION_API_KEY', os.getenv('IMAGE_API_KEY', config.get('api_key')))
        config['base_url'] = os.getenv('VISION_API_BASE_URL', os.getenv('IMAGE_API_BASE_URL', config.get('base_url')))
        config['model'] = os.getenv('VISION_MODEL', config.get('model', 'qwen2.5-vl-72b-instruct'))
        
        return config
    
    @staticmethod
    def image_to_base64(image_path: str) -> str:
        """
        将图片文件转换为 base64 编码（带 data URL 前缀）
        
        Args:
            image_path: 图片文件路径
            
        Returns:
            base64 编码字符串（含 data URL 前缀）
        """
        path = Path(image_path)
        if not path.exists():
            raise FileNotFoundError(f"图片文件不存在: {image_path}")
        
        # 获取 MIME 类型
        suffix = path.suffix.lower()
        mime_types = {
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif',
            '.webp': 'image/webp'
        }
        mime_type = mime_types.get(suffix, 'image/png')
        
        with open(image_path, 'rb') as f:
            b64_str = base64.b64encode(f.read()).decode('utf-8')
        
        return f"data:{mime_type};base64,{b64_str}"
    
    def analyze(
        self,
        image: Union[str, bytes],
        prompt: Optional[str] = None,
        mode: str = "describe",
        max_tokens: int = 2000,
        temperature: float = 0.7
    ) -> Dict[str, Any]:
        """
        分析图片并生成文字描述
        
        Args:
            image: 图片路径、URL 或 base64 字符串
            prompt: 自定义分析提示词（如果提供则忽略 mode）
            mode: 分析模式 (describe/ocr/chart/fashion/product/scene)
            max_tokens: 最大输出 token 数
            temperature: 温度参数
            
        Returns:
            包含分析结果的字典
        """
        # 确定使用的提示词
        if prompt is None:
            prompt = self.ANALYSIS_MODES.get(mode, self.ANALYSIS_MODES["describe"])
        
        # 处理图片输入
        if isinstance(image, str):
            if os.path.isfile(image):
                image_url = self.image_to_base64(image)
            elif image.startswith('data:') or image.startswith('http'):
                image_url = image
            else:
                # 假设是纯 base64 字符串
                image_url = f"data:image/png;base64,{image}"
        else:
            image_url = f"data:image/png;base64,{base64.b64encode(image).decode('utf-8')}"
        
        # 构建请求
        payload = {
            "model": self.model,
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": prompt
                        },
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": image_url
                            }
                        }
                    ]
                }
            ],
            "max_tokens": max_tokens,
            "temperature": temperature
        }
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        try:
            with httpx.Client(timeout=120.0) as client:
                response = client.post(
                    f"{self.base_url}/chat/completions",
                    headers=headers,
                    json=payload
                )
                response.raise_for_status()
                result = response.json()
                
                # 提取文本内容
                content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
                
                return {
                    "success": True,
                    "content": content,
                    "mode": mode,
                    "usage": result.get("usage", {})
                }
                
        except httpx.HTTPStatusError as e:
            return {
                "success": False,
                "error": f"HTTP 错误: {e.response.status_code}",
                "detail": str(e)
            }
        except Exception as e:
            return {
                "success": False,
                "error": "分析失败",
                "detail": str(e)
            }
    
    def describe(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """通用图片描述"""
        return self.analyze(image, mode="describe")
    
    def ocr(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """文字识别 (OCR)"""
        return self.analyze(image, mode="ocr")
    
    def analyze_chart(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """图表分析"""
        return self.analyze(image, mode="chart")
    
    def analyze_fashion(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """穿搭分析"""
        return self.analyze(image, mode="fashion")
    
    def analyze_product(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """产品分析"""
        return self.analyze(image, mode="product")
    
    def analyze_scene(self, image: Union[str, bytes]) -> Dict[str, Any]:
        """场景分析"""
        return self.analyze(image, mode="scene")
    
    def batch_analyze(
        self,
        images: List[str],
        mode: str = "describe"
    ) -> List[Dict[str, Any]]:
        """
        批量分析多张图片
        
        Args:
            images: 图片路径列表
            mode: 分析模式
            
        Returns:
            分析结果列表
        """
        results = []
        for image in images:
            result = self.analyze(image, mode=mode)
            result["image"] = image
            results.append(result)
        return results


def main():
    """命令行入口"""
    import argparse
    
    parser = argparse.ArgumentParser(description='图生文分析工具（视觉识别）')
    parser.add_argument('image', help='输入图片路径')
    parser.add_argument('-m', '--mode', default='describe',
                       choices=['describe', 'ocr', 'chart', 'fashion', 'product', 'scene'],
                       help='分析模式')
    parser.add_argument('-p', '--prompt', help='自定义分析提示词')
    parser.add_argument('--max-tokens', type=int, default=2000, help='最大输出 token 数')
    
    args = parser.parse_args()
    
    analyzer = ImageToTextAnalyzer()
    result = analyzer.analyze(
        image=args.image,
        prompt=args.prompt,
        mode=args.mode,
        max_tokens=args.max_tokens
    )
    
    if result["success"]:
        print(f"\n=== 分析结果 ({result['mode']}) ===\n")
        print(result["content"])
        print(f"\n=== Token 使用 ===")
        print(f"输入: {result['usage'].get('prompt_tokens', 'N/A')}")
        print(f"输出: {result['usage'].get('completion_tokens', 'N/A')}")
    else:
        print(f"分析失败: {result['error']}")
        print(f"详情: {result.get('detail', 'N/A')}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
长图拼接脚本 (Merge Long Image)
将多张图片按顺序垂直拼接成一张微信长图

Author: 翟星人
"""

import argparse
import os
import glob as glob_module
from pathlib import Path
from typing import List, Optional, Dict, Any

from PIL import Image
import numpy as np


class LongImageMerger:
    """长图拼接器"""
    
    def __init__(self, target_width: int = 1080):
        """
        初始化拼接器
        
        Args:
            target_width: 目标宽度，默认1080（微信推荐宽度）
        """
        self.target_width = target_width
    
    def _blend_images(self, img_top: Image.Image, img_bottom: Image.Image, blend_height: int) -> Image.Image:
        """
        在两张图的接缝处创建渐变融合过渡
        
        Args:
            img_top: 上方图片
            img_bottom: 下方图片
            blend_height: 融合区域高度（像素）
            
        Returns:
            融合后的下方图片（顶部已与上方图片底部融合）
        """
        blend_height = min(blend_height, img_top.height // 4, img_bottom.height // 4)
        
        top_region = img_top.crop((0, img_top.height - blend_height, img_top.width, img_top.height))
        bottom_region = img_bottom.crop((0, 0, img_bottom.width, blend_height))
        
        top_array = np.array(top_region, dtype=np.float32)
        bottom_array = np.array(bottom_region, dtype=np.float32)
        
        alpha = np.linspace(1, 0, blend_height).reshape(-1, 1, 1)
        
        blended_array = top_array * alpha + bottom_array * (1 - alpha)
        blended_array = np.clip(blended_array, 0, 255).astype(np.uint8)
        
        blended_region = Image.fromarray(blended_array)
        
        result = img_bottom.copy()
        result.paste(blended_region, (0, 0))
        
        return result
    
    def merge(
        self,
        image_paths: List[str],
        output_path: str,
        gap: int = 0,
        background_color: str = "white",
        blend: int = 0
    ) -> Dict[str, Any]:
        """
        拼接多张图片为长图
        
        Args:
            image_paths: 图片路径列表，按顺序拼接
            output_path: 输出文件路径
            gap: 图片之间的间隔像素，默认0
            background_color: 背景颜色，默认白色
            blend: 接缝融合过渡区域高度（像素），默认0不融合，推荐30-50
            
        Returns:
            包含拼接结果的字典
        """
        if not image_paths:
            return {"success": False, "error": "没有提供图片路径"}
        
        valid_paths = []
        for p in image_paths:
            if os.path.exists(p):
                valid_paths.append(p)
            else:
                print(f"警告: 文件不存在，跳过 - {p}")
        
        if not valid_paths:
            return {"success": False, "error": "没有有效的图片文件"}
        
        try:
            imgs = [Image.open(p) for p in valid_paths]
            
            resized_imgs = []
            for img in imgs:
                if img.mode in ('RGBA', 'P'):
                    img = img.convert('RGB')
                ratio = self.target_width / img.width
                new_height = int(img.height * ratio)
                resized = img.resize((self.target_width, new_height), Image.Resampling.LANCZOS)
                resized_imgs.append(resized)
            
            if blend > 0 and len(resized_imgs) > 1:
                for i in range(1, len(resized_imgs)):
                    resized_imgs[i] = self._blend_images(resized_imgs[i-1], resized_imgs[i], blend)
            
            total_height = sum(img.height for img in resized_imgs) + gap * (len(resized_imgs) - 1)
            
            long_image = Image.new('RGB', (self.target_width, total_height), background_color)
            
            y_offset = 0
            for img in resized_imgs:
                long_image.paste(img, (0, y_offset))
                y_offset += img.height + gap
            
            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
            long_image.save(output_path, quality=95)
            
            for img in imgs:
                img.close()
            for img in resized_imgs:
                img.close()
            
            return {
                "success": True,
                "saved_path": output_path,
                "width": self.target_width,
                "height": total_height,
                "image_count": len(resized_imgs)
            }
            
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def merge_from_pattern(
        self,
        pattern: str,
        output_path: str,
        sort_by: str = "name",
        gap: int = 0,
        background_color: str = "white",
        blend: int = 0
    ) -> Dict[str, Any]:
        """
        通过 glob 模式匹配图片并拼接
        
        Args:
            pattern: glob 模式，如 "*.png" 或 "generated_*.png"
            output_path: 输出文件路径
            sort_by: 排序方式 - "name"(文件名) / "time"(修改时间) / "none"(不排序)
            gap: 图片间隔
            background_color: 背景颜色
            blend: 接缝融合过渡高度
            
        Returns:
            包含拼接结果的字典
        """
        image_paths = glob_module.glob(pattern)
        
        if not image_paths:
            return {"success": False, "error": f"没有找到匹配 '{pattern}' 的图片"}
        
        if sort_by == "name":
            image_paths.sort()
        elif sort_by == "time":
            image_paths.sort(key=lambda x: os.path.getmtime(x))
        
        print(f"找到 {len(image_paths)} 张图片:")
        for i, p in enumerate(image_paths, 1):
            print(f"  {i}. {os.path.basename(p)}")
        
        return self.merge(image_paths, output_path, gap, background_color, blend)


def main():
    """命令行入口"""
    parser = argparse.ArgumentParser(
        description='长图拼接工具 - 将多张图片垂直拼接成微信长图',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例用法:
  # 拼接指定图片
  python merge_long_image.py img1.png img2.png img3.png -o output.png
  
  # 使用通配符匹配
  python merge_long_image.py -p "generated_*.png" -o long_image.png
  
  # 指定宽度和间隔
  python merge_long_image.py -p "*.png" -o out.png -w 750 -g 20
  
  # 按修改时间排序
  python merge_long_image.py -p "*.png" -o out.png --sort time
  
  # 启用接缝融合过渡（推荐40px）
  python merge_long_image.py img1.png img2.png -o out.png --blend 40
        """
    )
    
    parser.add_argument('images', nargs='*', help='要拼接的图片路径列表')
    parser.add_argument('-p', '--pattern', help='glob 模式匹配图片，如 "*.png"')
    parser.add_argument('-o', '--output', required=True, help='输出文件路径')
    parser.add_argument('-w', '--width', type=int, default=1080, help='目标宽度，默认1080')
    parser.add_argument('-g', '--gap', type=int, default=0, help='图片间隔像素，默认0')
    parser.add_argument('--sort', choices=['name', 'time', 'none'], default='name', 
                        help='排序方式：name(文件名)/time(修改时间)/none')
    parser.add_argument('--bg', default='white', help='背景颜色，默认 white')
    parser.add_argument('--blend', type=int, default=0, 
                        help='接缝融合过渡高度（像素），推荐30-50，默认0不融合')
    
    args = parser.parse_args()
    
    if not args.images and not args.pattern:
        parser.error("请提供图片路径列表或使用 -p 指定匹配模式")
    
    merger = LongImageMerger(target_width=args.width)
    
    if args.pattern:
        result = merger.merge_from_pattern(
            pattern=args.pattern,
            output_path=args.output,
            sort_by=args.sort,
            gap=args.gap,
            background_color=args.bg,
            blend=args.blend
        )
    else:
        result = merger.merge(
            image_paths=args.images,
            output_path=args.output,
            gap=args.gap,
            background_color=args.bg,
            blend=args.blend
        )
    
    if result["success"]:
        print(f"\n拼接成功！")
        print(f"输出文件: {result['saved_path']}")
        print(f"尺寸: {result['width']} x {result['height']}")
        print(f"共 {result['image_count']} 张图片")
    else:
        print(f"\n拼接失败: {result['error']}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
文生图脚本 (Text-to-Image)
根据中文文本描述生成图片（OpenAI Images API 兼容）
支持参考图风格生成

Author: 翟星人
"""

import httpx
import base64
import json
import os
from typing import Dict, Any, Optional, Union
from pathlib import Path

VALID_ASPECT_RATIOS = [
    "1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"
]

VALID_SIZES = [
    "1024x1024",
    "1536x1024", "1792x1024", "1344x768", "1248x832", "1184x864", "1152x896", "1536x672",
    "1024x1536", "1024x1792", "768x1344", "832x1248", "864x1184", "896x1152"
]

RATIO_TO_SIZE = {
    "1:1": "1024x1024",
    "2:3": "832x1248",
    "3:2": "1248x832",
    "3:4": "1024x1536",
    "4:3": "1536x1024",
    "4:5": "864x1184",
    "5:4": "1184x864",
    "9:16": "1024x1792",
    "16:9": "1792x1024",
    "21:9": "1536x672"
}


class TextToImageGenerator:
    """文生图生成器"""
    
    def __init__(self, config: Optional[Dict[str, str]] = None):
        """
        初始化生成器
        
        Args:
            config: 配置字典，包含 api_key, base_url, model
                   如果不传则从环境变量或配置文件读取
        """
        if config is None:
            config = self._load_config()
        
        self.api_key = config.get('api_key') or config.get('IMAGE_API_KEY')
        self.base_url = config.get('base_url') or config.get('IMAGE_API_BASE_URL')
        self.model = config.get('model') or config.get('IMAGE_MODEL') or 'dall-e-3'
        
        if not self.api_key or not self.base_url:
            raise ValueError("缺少必要的 API 配置：api_key 和 base_url")
    
    def _load_config(self) -> Dict[str, str]:
        """从配置文件或环境变量加载配置"""
        config = {}
        
        config_path = Path(__file__).parent.parent / 'config' / 'settings.json'
        if config_path.exists():
            with open(config_path, 'r', encoding='utf-8') as f:
                settings = json.load(f)
                api_config = settings.get('image_api', {})
                config['api_key'] = api_config.get('key')
                config['base_url'] = api_config.get('base_url')
                config['model'] = api_config.get('model')
        
        config['api_key'] = os.getenv('IMAGE_API_KEY', config.get('api_key'))
        config['base_url'] = os.getenv('IMAGE_API_BASE_URL', config.get('base_url'))
        config['model'] = os.getenv('IMAGE_MODEL', config.get('model'))
        
        return config
    
    @staticmethod
    def image_to_base64(image_path: str, with_prefix: bool = True) -> str:
        """将图片文件转换为 base64 编码"""
        path = Path(image_path)
        if not path.exists():
            raise FileNotFoundError(f"图片文件不存在: {image_path}")
        
        suffix = path.suffix.lower()
        mime_types = {
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif',
            '.webp': 'image/webp'
        }
        mime_type = mime_types.get(suffix, 'image/png')
        
        with open(image_path, 'rb') as f:
            b64_str = base64.b64encode(f.read()).decode('utf-8')
        
        if with_prefix:
            return f"data:{mime_type};base64,{b64_str}"
        return b64_str
    
    def generate(
        self,
        prompt: str,
        size: Optional[str] = None,
        aspect_ratio: Optional[str] = None,
        image_size: Optional[str] = None,
        output_path: Optional[str] = None,
        response_format: str = "b64_json",
        ref_image: Optional[str] = None
    ) -> Dict[str, Any]:
        """
        生成图片
        
        Args:
            prompt: 中文图像描述提示词
            size: 图片尺寸 (如 1792x1024)，与 aspect_ratio 二选一
            aspect_ratio: 宽高比 (如 16:9, 3:4)，推荐使用
            image_size: 分辨率 (1K/2K/4K)，仅 gemini-3.0-pro-image-preview 支持
            output_path: 输出文件路径，如果提供则保存图片
            response_format: 响应格式，默认 b64_json
            ref_image: 参考图片路径，用于风格参考
            
        Returns:
            包含生成结果的字典
        """
        if ref_image:
            return self._generate_with_reference(
                prompt=prompt,
                ref_image=ref_image,
                aspect_ratio=aspect_ratio,
                size=size,
                output_path=output_path,
                response_format=response_format
            )
        
        payload: Dict[str, Any] = {
            "model": self.model,
            "prompt": prompt,
            "response_format": response_format
        }
        
        # 确定尺寸：优先用 aspect_ratio 映射，其次用 size
        if aspect_ratio:
            payload["size"] = RATIO_TO_SIZE.get(aspect_ratio, "1024x1024")
        elif size:
            payload["size"] = size
        else:
            payload["size"] = "1792x1024"  # 默认 16:9
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        try:
            with httpx.Client(timeout=180.0) as client:
                response = client.post(
                    f"{self.base_url}/images/generations",
                    headers=headers,
                    json=payload
                )
                response.raise_for_status()
                result = response.json()
                
                if output_path and result.get("data"):
                    b64_data = result["data"][0].get("b64_json")
                    if b64_data:
                        self._save_image(b64_data, output_path)
                        result["saved_path"] = output_path
                
                return {
                    "success": True,
                    "data": result,
                    "saved_path": output_path if output_path else None
                }
                
        except httpx.HTTPStatusError as e:
            return {
                "success": False,
                "error": f"HTTP 错误: {e.response.status_code}",
                "detail": str(e)
            }
        except Exception as e:
            return {
                "success": False,
                "error": "生成失败",
                "detail": str(e)
            }
    
    def _generate_with_reference(
        self,
        prompt: str,
        ref_image: str,
        aspect_ratio: Optional[str] = None,
        size: Optional[str] = None,
        output_path: Optional[str] = None,
        response_format: str = "b64_json"
    ) -> Dict[str, Any]:
        """
        参考图片风格生成新图
        
        Args:
            prompt: 新图内容描述
            ref_image: 参考图片路径
            aspect_ratio: 宽高比
            size: 尺寸
            output_path: 输出路径
            response_format: 响应格式
        """
        image_b64 = self.image_to_base64(ref_image)
        
        enhanced_prompt = f"参考这张图片的背景风格、配色方案和视觉设计，保持完全一致的风格，生成新内容：{prompt}"
        
        # 确定尺寸：优先用 aspect_ratio 映射，其次用 size
        if size is None:
            size = RATIO_TO_SIZE.get(aspect_ratio, "1024x1792") if aspect_ratio else "1024x1792"
        
        payload = {
            "model": self.model,
            "prompt": enhanced_prompt,
            "image": image_b64,
            "size": size,
            "response_format": response_format
        }
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        try:
            with httpx.Client(timeout=180.0) as client:
                response = client.post(
                    f"{self.base_url}/images/edits",
                    headers=headers,
                    json=payload
                )
                response.raise_for_status()
                result = response.json()
                
                if output_path and result.get("data"):
                    b64_data = result["data"][0].get("b64_json")
                    if b64_data:
                        self._save_image(b64_data, output_path)
                        result["saved_path"] = output_path
                
                return {
                    "success": True,
                    "data": result,
                    "saved_path": output_path if output_path else None
                }
                
        except httpx.HTTPStatusError as e:
            return {
                "success": False,
                "error": f"HTTP 错误: {e.response.status_code}",
                "detail": str(e)
            }
        except Exception as e:
            return {
                "success": False,
                "error": "生成失败",
                "detail": str(e)
            }
    
    def _save_image(self, b64_data: str, output_path: str) -> None:
        """保存 base64 图片到文件"""
        image_data = base64.b64decode(b64_data)
        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
        with open(output_path, 'wb') as f:
            f.write(image_data)


def main():
    """命令行入口"""
    import argparse
    import time
    
    parser = argparse.ArgumentParser(
        description='文生图工具',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=f'''
尺寸参数说明:
  -r/--ratio  推荐使用，支持: {", ".join(VALID_ASPECT_RATIOS)}
  -s/--size   传统尺寸，支持: {", ".join(VALID_SIZES[:4])}...
  --resolution 分辨率(1K/2K/4K)，仅 gemini-3.0-pro-image-preview 支持
  --ref       参考图片路径，后续图片将参考首图风格生成

示例:
  python text_to_image.py "描述" -r 3:4              # 竖版 3:4
  python text_to_image.py "描述" -r 9:16 -o out.png  # 竖屏 9:16
  python text_to_image.py "描述" -s 1024x1792        # 传统尺寸
  
  # 长图场景：首图定调，后续参考首图风格
  python text_to_image.py "首屏内容" -r 3:4 -o 01.png
  python text_to_image.py "第二屏内容" -r 3:4 --ref 01.png -o 02.png
'''
    )
    parser.add_argument('prompt', help='中文图像描述提示词')
    parser.add_argument('-o', '--output', help='输出文件路径（默认保存到当前目录）')
    parser.add_argument('-r', '--ratio', help=f'宽高比，推荐使用。可选: {", ".join(VALID_ASPECT_RATIOS)}')
    parser.add_argument('-s', '--size', help='图片尺寸 (如 1792x1024)')
    parser.add_argument('--resolution', help='分辨率 (1K/2K/4K)，仅部分模型支持')
    parser.add_argument('--ref', help='参考图片路径，用于风格参考（长图场景）')
    
    args = parser.parse_args()
    
    if args.ratio and args.ratio not in VALID_ASPECT_RATIOS:
        print(f"错误: 不支持的宽高比 '{args.ratio}'")
        print(f"支持的宽高比: {', '.join(VALID_ASPECT_RATIOS)}")
        return
    
    if args.size and args.size not in VALID_SIZES:
        print(f"警告: 尺寸 '{args.size}' 可能不被支持")
        print(f"推荐使用 -r/--ratio 参数指定宽高比")
    
    if args.ref and not os.path.exists(args.ref):
        print(f"错误: 参考图片不存在: {args.ref}")
        return
    
    output_path = args.output
    if not output_path:
        timestamp = time.strftime("%Y%m%d_%H%M%S")
        output_path = f"generated_{timestamp}.png"
    
    generator = TextToImageGenerator()
    result = generator.generate(
        prompt=args.prompt,
        size=args.size,
        aspect_ratio=args.ratio,
        image_size=args.resolution,
        output_path=output_path,
        ref_image=args.ref
    )
    
    if result["success"]:
        print(f"生成成功！")
        if result.get("saved_path"):
            print(f"图片已保存到: {result['saved_path']}")
    else:
        print(f"生成失败: {result['error']}")
        print(f"详情: {result.get('detail', 'N/A')}")


if __name__ == "__main__":
    main()

{
  "palettes": {
    "tech-blue": {
      "name": "科技蓝",
      "primary": "#4A90D9",
      "secondary": "#81C784",
      "accent": "#FFB74D",
      "background": "#F5F7FA",
      "text": "#333333"
    },
    "dark-purple": {
      "name": "暗紫科技",
      "primary": "#B165FB",
      "secondary": "#40695B",
      "accent": "#00B4D8",
      "background": "#181B24",
      "text": "#FFFFFF"
    },
    "warm-earth": {
      "name": "暖色大地",
      "primary": "#D4845A",
      "secondary": "#8B7355",
      "accent": "#E8C170",
      "background": "#FFF8F0",
      "text": "#4A3728"
    },
    "minimal-gray": {
      "name": "极简灰",
      "primary": "#333333",
      "secondary": "#666666",
      "accent": "#0066FF",
      "background": "#FFFFFF",
      "text": "#1A1A1A"
    },
    "neon-cyber": {
      "name": "霓虹赛博",
      "primary": "#00FFE0",
      "secondary": "#FF00FF",
      "accent": "#FFE500",
      "background": "#0A0A1A",
      "text": "#FFFFFF"
    }
  }
}

{
  "categories": {
    "tech": ["现代极简科技风格", "深色渐变背景", "霓虹蓝紫光效", "金属质感", "高级产品摄影", "8K超高清"],
    "life": ["温暖自然生活美学", "柔和自然光线", "浅色干净背景", "日系清新摄影", "高级感留白"],
    "fashion": ["潮流街头风格", "大胆撞色", "动态构图", "霓虹灯牌", "时尚杂志级", "高对比度"],
    "food": ["美食摄影风格", "暖色调打光", "微距特写质感", "蒸汽烟雾效果", "高级餐厅氛围"],
    "education": ["柔和温馨插画风格", "马卡龙色系", "圆润可爱造型", "安全信任感", "干净清爽"]
  }
}

#!/usr/bin/env python3
"""
智能文章插图生成器 (zlab Article Illustrator)
分析文章结构，识别需要配图的位置，自动生成插图
类型 × 风格 二维系统

Author: 翟星人
"""

import argparse
import subprocess
import sys
import re
import os
from pathlib import Path

SKILL_DIR = Path(__file__).parent.parent.parent
CORE_SCRIPT = SKILL_DIR / "core" / "text_to_image.py"

# === 类型（信息结构）===

TYPES = {
    "infographic": {
        "name": "数据可视化",
        "prompt": "数据可视化信息图，图表、指标、数据展示",
        "trigger_words": ["数据", "统计", "增长", "比例", "百分比", "趋势"]
    },
    "scene": {
        "name": "氛围插图",
        "prompt": "氛围场景插图，情绪渲染，画面感强",
        "trigger_words": ["场景", "想象", "故事", "经历", "感受"]
    },
    "flowchart": {
        "name": "流程图",
        "prompt": "流程步骤可视化，从左到右或从上到下，箭头连接",
        "trigger_words": ["步骤", "流程", "首先", "然后", "最后", "过程"]
    },
    "comparison": {
        "name": "对比图",
        "prompt": "左右并排对比，突出差异，双栏布局",
        "trigger_words": ["对比", "vs", "区别", "不同", "相比", "优劣"]
    },
    "framework": {
        "name": "概念图",
        "prompt": "概念关系图，节点连线，结构化展示",
        "trigger_words": ["架构", "框架", "模型", "体系", "核心", "组成"]
    },
    "timeline": {
        "name": "时间线",
        "prompt": "时间线进展图，横向或纵向轴线，节点标注",
        "trigger_words": ["历史", "阶段", "发展", "演进", "里程碑", "版本"]
    },
}

# === 风格（视觉美学）===

STYLES = {
    "notion": {
        "name": "极简线条",
        "prompt": "极简手绘线条画风格，黑色细线条，少量色彩点缀，白色背景，干净简洁"
    },
    "elegant": {
        "name": "精致优雅",
        "prompt": "精致优雅风格，低饱和配色，细腻渐变，高级质感，留白构图"
    },
    "warm": {
        "name": "友好亲切",
        "prompt": "友好温暖风格，暖色调，圆润造型，亲切感，柔和光线"
    },
    "minimal": {
        "name": "极简禅意",
        "prompt": "极简禅意风格，大面积留白，极少元素，呼吸感强，克制优雅"
    },
    "blueprint": {
        "name": "技术蓝图",
        "prompt": "技术蓝图风格，深蓝背景白色线条，网格坐标，工程制图感"
    },
    "watercolor": {
        "name": "水彩艺术",
        "prompt": "水彩画风格，柔和晕染，颜色自然渗透，艺术感强"
    },
    "editorial": {
        "name": "杂志编辑",
        "prompt": "杂志编辑风格，专业排版感，信息图设计，高对比清晰"
    },
    "scientific": {
        "name": "学术精确",
        "prompt": "学术精确图表风格，数据标注精确，刻度清晰，论文级严谨"
    },
}


def analyze_article(md_content):
    """分析文章结构，识别需要配图的段落"""
    sections = []
    current_title = ""
    current_body = ""

    for line in md_content.split('\n'):
        # h2/h3标题
        h_match = re.match(r'^(#{2,3})\s+(.+)$', line)
        if h_match:
            if current_title and current_body:
                sections.append({"title": current_title, "body": current_body.strip()})
            current_title = h_match.group(2)
            current_body = ""
        else:
            current_body += line + "\n"

    if current_title and current_body:
        sections.append({"title": current_title, "body": current_body.strip()})

    # 为每个章节推荐插图类型
    results = []
    for section in sections:
        text = section["title"] + " " + section["body"]
        best_type = "infographic"  # 默认
        best_score = 0

        for type_key, type_def in TYPES.items():
            score = sum(1 for word in type_def["trigger_words"] if word in text)
            if score > best_score:
                best_score = score
                best_type = type_key

        # 只为有足够内容的章节生成插图（>50字）
        if len(section["body"]) > 50:
            results.append({
                "title": section["title"],
                "body": section["body"][:300],
                "recommended_type": best_type,
                "confidence": best_score,
            })

    return results


def build_illust_prompt(section, type_key, style_key):
    """构建插图提示词"""
    type_def = TYPES[type_key]
    style_def = STYLES[style_key]

    parts = [
        f"文章配图插图，16:9横版",
        type_def['prompt'],
        f"图解主题：「{section['title']}」",
        f"需要可视化的内容：{section['body'][:200]}",
        style_def['prompt'],
        "所有标注使用中文，文字清晰可读。构图简洁明了，信息层次分明。配色与文章风格协调，不喧宾夺主。适合嵌入Markdown文章中阅读",
    ]
    return "，".join(parts)


def generate_illustrations(md_path, style, ratio, output_dir, type_override=None):
    """主生成流程"""
    if style not in STYLES:
        print(f"错误: 未知风格 '{style}'，可用: {', '.join(STYLES.keys())}")
        sys.exit(1)

    with open(md_path, 'r', encoding='utf-8') as f:
        md_content = f.read()

    sections = analyze_article(md_content)

    if not sections:
        print("文章中未找到适合配图的章节")
        sys.exit(0)

    print(f"✏️ 文章插图生成")
    print(f"   文章: {md_path}")
    print(f"   风格: {STYLES[style]['name']} ({style})")
    print(f"   比例: {ratio}")
    print(f"   识别到 {len(sections)} 个配图位置")
    print()

    # 输出分析结果
    print("=== 配图规划 ===")
    for i, sec in enumerate(sections, 1):
        t = type_override or sec['recommended_type']
        print(f"  {i}. [{TYPES[t]['name']}] {sec['title']} (置信度:{sec['confidence']})")
    print()

    # 创建输出目录
    Path(output_dir).mkdir(parents=True, exist_ok=True)

    # 逐张生成
    for i, sec in enumerate(sections, 1):
        t = type_override or sec['recommended_type']
        prompt = build_illust_prompt(sec, t, style)
        output_path = os.path.join(output_dir, f"illust_{i:02d}_{t}.png")

        print(f"  生成第{i}/{len(sections)}张: {sec['title']} [{TYPES[t]['name']}]")
        cmd = [sys.executable, str(CORE_SCRIPT), prompt, "-r", ratio, "-o", output_path]
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            print(f"    ⚠️ 失败: {result.stderr[:200]}")
        else:
            print(f"    ✅ {output_path}")

    print(f"\n全部完成！{len(sections)}张插图已保存到 {output_dir}/")


def list_options():
    print("=== 插图类型 (6种) ===\n")
    for k, v in TYPES.items():
        print(f"  {k:15s} {v['name']:8s} — 触发词: {', '.join(v['trigger_words'][:4])}")
    print("\n=== 视觉风格 (8种) ===\n")
    for k, v in STYLES.items():
        print(f"  {k:15s} {v['name']}")
    print()


def main():
    parser = argparse.ArgumentParser(
        description="zlab 智能文章插图生成器 — 6类型 × 8风格",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  # 自动分析文章并生成插图
  python zlab_article_illustrator.py article.md --style notion -o images/

  # 指定所有插图类型为流程图
  python zlab_article_illustrator.py article.md --type flowchart --style blueprint -o images/

  # 查看选项
  python zlab_article_illustrator.py --list
        """
    )
    parser.add_argument("article", nargs="?", help="Markdown文章路径")
    parser.add_argument("--style", default="notion", choices=STYLES.keys(), help="视觉风格（默认 notion）")
    parser.add_argument("--type", choices=TYPES.keys(), help="强制指定所有插图类型（不指定则自动判断）")
    parser.add_argument("-r", "--ratio", default="16:9", help="宽高比（默认 16:9）")
    parser.add_argument("-o", "--output", default="illustrations", help="输出目录（默认 illustrations/）")
    parser.add_argument("--list", action="store_true", help="列出所有选项")

    args = parser.parse_args()

    if args.list:
        list_options()
        return

    if not args.article:
        parser.print_help()
        print("\n错误: 请提供文章文件路径")
        sys.exit(1)

    if not os.path.exists(args.article):
        print(f"错误: 文件不存在 {args.article}")
        sys.exit(1)

    generate_illustrations(args.article, args.style, args.ratio, args.output, args.type)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
知识漫画生成器 (zlab Comic Generator)
画风 × 基调 × 布局，逐页分镜生成
底层调用 core/text_to_image.py + core/image_to_image.py

Author: 翟星人
"""

import argparse
import subprocess
import sys
import re
import os
from pathlib import Path

SKILL_DIR = Path(__file__).parent.parent.parent
CORE_T2I = SKILL_DIR / "core" / "text_to_image.py"
CORE_I2I = SKILL_DIR / "core" / "image_to_image.py"

# === 三维定义 ===

ARTS = {
    "ligne-claire": {
        "name": "清线",
        "prompt": "清晰统一线条，平涂色彩填充，欧洲漫画传统风格（丁丁历险记风），干净利落的黑色轮廓线"
    },
    "manga": {
        "name": "日漫",
        "prompt": "日本漫画风格，大眼睛角色，表情丰富夸张，速度线和效果线，网点阴影，动感十足"
    },
    "realistic": {
        "name": "写实",
        "prompt": "数字绘画写实风格，准确人体比例，精致细腻渲染，电影级光影效果"
    },
    "ink-brush": {
        "name": "水墨",
        "prompt": "中国水墨画风格，毛笔笔触，水墨晕染效果，留白意境，黑白灰为主偶有点缀色"
    },
    "chalk": {
        "name": "粉笔",
        "prompt": "粉笔画风格，黑板深色背景，彩色粉笔手绘线条，粗糙质感，温暖童趣"
    },
}

TONES = {
    "neutral": {
        "name": "中性",
        "prompt": "平衡理性的色调，中性明度，教育性氛围，冷静客观"
    },
    "warm": {
        "name": "温暖",
        "prompt": "温暖怀旧色调，暖黄暖橙为主，柔和光线，亲切感人"
    },
    "dramatic": {
        "name": "戏剧",
        "prompt": "高对比戏剧性色调，强烈明暗对比，紧张感，冲击力强"
    },
    "romantic": {
        "name": "浪漫",
        "prompt": "柔和浪漫色调，粉色紫色为主，装饰性花瓣元素，梦幻唯美"
    },
    "energetic": {
        "name": "活力",
        "prompt": "明亮高饱和活力色调，动感构图，充满能量和激情"
    },
    "vintage": {
        "name": "复古",
        "prompt": "复古做旧色调，泛黄胶片质感，历史感，时代真实性"
    },
    "action": {
        "name": "动作",
        "prompt": "动作场面色调，速度线冲击效果，爆炸光效，战斗视觉张力"
    },
}

LAYOUTS = {
    "standard": {
        "name": "标准",
        "panels": "4-6格",
        "prompt": "标准漫画分格，4到6个格子，大小均匀，叙事节奏平稳"
    },
    "cinematic": {
        "name": "电影",
        "panels": "2-4格",
        "prompt": "电影宽银幕分格，2到4个宽幅画面，横向构图，戏剧张力"
    },
    "dense": {
        "name": "密集",
        "panels": "6-9格",
        "prompt": "密集分格，6到9个小格子，信息量大，适合技术说明"
    },
    "splash": {
        "name": "跨页",
        "panels": "1-2大图",
        "prompt": "跨页大图，1到2个超大画面，视觉冲击力极强，关键时刻"
    },
    "mixed": {
        "name": "混合",
        "panels": "3-7不等",
        "prompt": "混合分格，大小不一的格子3到7个，丰富的视觉节奏变化"
    },
    "webtoon": {
        "name": "条漫",
        "panels": "3-5竖向",
        "prompt": "竖向条漫布局，3到5个竖向排列的画面，适合手机阅读"
    },
}


def parse_source_to_pages(content, max_pages=12):
    """将文字素材拆分为漫画页"""
    pages = []

    # 按段落/章节拆分
    paragraphs = re.split(r'\n{2,}', content.strip())

    # 合并短段落，拆分长段落
    buffer = ""
    for para in paragraphs:
        para = para.strip()
        if not para:
            continue

        # h2/h3标记作为分页点
        if re.match(r'^#{2,3}\s', para):
            if buffer:
                pages.append(buffer.strip())
                buffer = ""
            buffer = para + "\n"
        else:
            buffer += para + "\n"
            # 超过200字分一页
            if len(buffer) > 200:
                pages.append(buffer.strip())
                buffer = ""

    if buffer:
        pages.append(buffer.strip())

    return pages[:max_pages]


def build_comic_prompt(page_content, page_num, total, art_def, tone_def, layout_def):
    """构建单页漫画的生图提示词"""
    parts = [
        f"知识漫画，第{page_num}页（共{total}页），竖版3:4",
        art_def['prompt'],
        tone_def['prompt'],
        layout_def['prompt'],
        f"本页剧情内容：{page_content[:300]}",
        "对话气泡中使用中文，文字清晰可读。角色造型一致，表情生动夸张。画面构图饱满但不拥挤，留出气泡空间。分格之间有清晰的边框线分隔。背景适当简化突出人物和对话",
    ]
    return "，".join(parts)


def generate_comic(source_path, art, tone, layout, ratio, output_dir, max_pages):
    """主生成流程"""
    if art not in ARTS:
        print(f"错误: 未知画风 '{art}'，可用: {', '.join(ARTS.keys())}")
        sys.exit(1)
    if tone not in TONES:
        print(f"错误: 未知基调 '{tone}'，可用: {', '.join(TONES.keys())}")
        sys.exit(1)
    if layout not in LAYOUTS:
        print(f"错误: 未知布局 '{layout}'，可用: {', '.join(LAYOUTS.keys())}")
        sys.exit(1)

    art_def = ARTS[art]
    tone_def = TONES[tone]
    layout_def = LAYOUTS[layout]

    # 读取素材
    with open(source_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # 拆分为页
    pages = parse_source_to_pages(content, max_pages)

    print(f"📖 漫画生成")
    print(f"   画风: {art_def['name']} ({art})")
    print(f"   基调: {tone_def['name']} ({tone})")
    print(f"   布局: {layout_def['name']} ({layout})，{layout_def['panels']}")
    print(f"   页数: {len(pages)}")
    print(f"   比例: {ratio}")
    print(f"   输出: {output_dir}/")
    print()

    # 输出分镜大纲
    print("=== 分镜大纲 ===")
    for i, page in enumerate(pages, 1):
        summary = page[:60].replace('\n', ' ')
        print(f"  第{i}页: {summary}...")
    print()

    # 创建输出目录
    Path(output_dir).mkdir(parents=True, exist_ok=True)

    # 逐页串行生成（首页text_to_image，后续image_to_image参考上一页）
    prev_page_path = None
    for i, page in enumerate(pages, 1):
        prompt = build_comic_prompt(page, i, len(pages), art_def, tone_def, layout_def)
        output_path = os.path.join(output_dir, f"page_{i:02d}.png")

        print(f"  生成第{i}/{len(pages)}页...")

        if i == 1 or prev_page_path is None:
            # 首页：文生图定调
            cmd = [sys.executable, str(CORE_T2I), prompt, "-r", ratio, "-o", output_path]
        else:
            # 后续页：参考上一页，保持角色和风格一致
            ref_prompt = f"参考模板图的角色造型、画风和色调，保持完全一致。{prompt}"
            cmd = [sys.executable, str(CORE_I2I), prev_page_path, ref_prompt, "-r", ratio, "-o", output_path]

        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            print(f"    ⚠️ 第{i}页失败: {result.stderr[:200]}")
        else:
            print(f"    ✅ {output_path}")
            prev_page_path = output_path

    print(f"\n全部完成！{len(pages)}页漫画已保存到 {output_dir}/")


def list_options():
    print("=== 画风 (5种) ===\n")
    for k, v in ARTS.items():
        print(f"  {k:15s} {v['name']}")
    print("\n=== 基调 (7种) ===\n")
    for k, v in TONES.items():
        print(f"  {k:15s} {v['name']}")
    print("\n=== 布局 (6种) ===\n")
    for k, v in LAYOUTS.items():
        print(f"  {k:15s} {v['name']:6s} {v['panels']}")
    print(f"\n共 {len(ARTS)} × {len(TONES)} × {len(LAYOUTS)} = {len(ARTS)*len(TONES)*len(LAYOUTS)} 种组合")


def main():
    parser = argparse.ArgumentParser(
        description="zlab 知识漫画生成器 — 5画风 × 7基调 × 6布局",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  # 日漫风温暖基调
  python zlab_comic.py story.md --art manga --tone warm -o comic/

  # 水墨动作风
  python zlab_comic.py story.md --art ink-brush --tone action --layout cinematic -o comic/

  # 查看所有选项
  python zlab_comic.py --list
        """
    )
    parser.add_argument("source", nargs="?", help="文字素材Markdown文件")
    parser.add_argument("--art", default="ligne-claire", choices=ARTS.keys(), help="画风（默认 ligne-claire）")
    parser.add_argument("--tone", default="neutral", choices=TONES.keys(), help="基调（默认 neutral）")
    parser.add_argument("--layout", default="standard", choices=LAYOUTS.keys(), help="布局（默认 standard）")
    parser.add_argument("-r", "--ratio", default="3:4", help="宽高比（默认 3:4竖版）")
    parser.add_argument("-o", "--output", default="comic", help="输出目录（默认 comic/）")
    parser.add_argument("--pages", type=int, default=12, help="最大页数（默认 12）")
    parser.add_argument("--list", action="store_true", help="列出所有选项")

    args = parser.parse_args()

    if args.list:
        list_options()
        return

    if not args.source:
        parser.print_help()
        print("\n错误: 请提供素材文件路径")
        sys.exit(1)

    if not os.path.exists(args.source):
        print(f"错误: 文件不存在 {args.source}")
        sys.exit(1)

    generate_comic(args.source, args.art, args.tone, args.layout, args.ratio, args.output, args.pages)


if __name__ == "__main__":
    main()