Simple manga character design sheet, Yotsuba&! style by Kiyohiko Azuma, 
young Japanese man age 25, short black hair, round friendly eyes, 
soft facial features, wearing plain gray t-shirt and black sweatpants, 
standing pose with 3 expression variations (normal, surprised with sweat drop, 
happy with sparkle effects), full body in center, white background, 
clean line art, flat colors, warm and approachable expression, 
manga illustration, pastel color palette

ページ,コマ,コマサイズ,シーン説明,キャラクター,セリフ,漫画部分プロンプト,実写料理プロンプト,備考
1,1,大,ユウタが和食を洋食っぽく盛り付けてしまう,ユウタ,肉じゃが作った！大皿にドーンと盛ったよ！,"被写体：ユウタがダイニングテーブルの前に立ち、大きな白い丸皿を持っている。得意げな笑顔。 構図：テーブルを挟んでユウタの上半身。 場所：1LDKマンションのダイニング、夜。 スタイル：よつばと!風、フルカラー、パステルカラー。","肉じゃがを白い丸皿に山盛り、洋食風の盛り付け、違和感がある",導入
1,2,中,ミナが微妙な反応,ミナ,美味しそうだけど…なんか和食っぽくないかも,"被写体：ミナがテーブルに座り、皿を見ている。首をかしげている。 構図：バストアップ。 スタイル：よつばと!風、フルカラー。",,

"""
Nano Banana Pro 画像生成（複数画像対応）

Usage:
    python -m tools.generate_image "猫のイラスト"
    python -m tools.generate_image "猫のイラスト" -o cat.png
    python -m tools.generate_image "猫" "犬" "鳥" -o cat.png dog.png bird.png
    python -m tools.generate_image "風景" --aspect 16:9 --size 2K
"""

import argparse
import sys
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed
from io import BytesIO

from PIL import Image
from google.genai import types
from google import genai
from retry import retry


def load_and_resize_images(image_paths: list[str | Path], size: tuple[int, int] = (200, 200)) -> list[bytes]:
    """
    画像を読み込んでリサイズし、バイトデータのリストとして返す

    Args:
        image_paths: 画像ファイルのパスのリスト
        size: リサイズ後のサイズ (width, height)

    Returns:
        リサイズされた画像のバイトデータのリスト
    """
    images = []
    for path in image_paths:
        img = Image.open(path)
        img_resized = img.resize(size, Image.Resampling.LANCZOS)
        buffer = BytesIO()
        img_resized.save(buffer, format="PNG")
        images.append(buffer.getvalue())
    return images


@retry(
    exceptions=Exception,
    tries=5,
    delay=2,
    backoff=2,
    jitter=(0, 1),
)
def generate_image(
    prompt: str,
    aspect_ratio: str = "1:1",
    image_size: str = "1K",
    model: str = "gemini-3-pro-image-preview",
    input_images: list[bytes] | None = None,
) -> dict | None:
    """
    Nano Banana Pro で画像を生成

    Args:
        prompt: 生成プロンプト
        aspect_ratio: アスペクト比 ("1:1", "16:9", "9:16", "3:2", "4:3")
        image_size: 解像度 ("1K", "2K", "4K")
        model: 使用するモデル名
        input_images: 入力画像のバイトデータのリスト（オプション）

    Returns:
        {"data": bytes, "text": str | None, "prompt": str} 失敗時は None
    """
    client = genai.Client(vertexai=True, project="your-project", location="global")

    contents = []
    if input_images:
        for img_data in input_images:
            contents.append(
                types.Part.from_bytes(
                    data=img_data,
                    mime_type="image/png",
                )
            )
    contents.append(prompt)

    response = client.models.generate_content(
        model=model,
        contents=contents,
        config=types.GenerateContentConfig(
            response_modalities=["TEXT", "IMAGE"],
            image_config=types.ImageConfig(
                aspect_ratio=aspect_ratio,
                image_size=image_size,
            ),
        ),
    )

    result = {"data": None, "text": None, "prompt": prompt}

    for part in response.candidates[0].content.parts:
        if hasattr(part, "inline_data") and part.inline_data:
            result["data"] = part.inline_data.data
        elif hasattr(part, "text") and part.text:
            result["text"] = part.text

    if not result["data"]:
        raise ValueError("Failed to generate image: no image data returned")

    return result


def generate_images(
    prompts: list[str],
    aspect_ratio: str = "1:1",
    image_size: str = "1K",
    model: str = "gemini-3-pro-image-preview",
    max_workers: int = 3,
) -> list[dict]:
    """
    複数の画像を同時に生成

    Args:
        prompts: 生成プロンプトのリスト
        aspect_ratio: アスペクト比
        image_size: 解像度
        model: 使用するモデル名
        max_workers: 並列実行数

    Returns:
        生成結果のリスト [{"data": bytes, "text": str | None, "prompt": str}, ...]
    """
    results = []
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_prompt = {
            executor.submit(
                generate_image,
                prompt=prompt,
                aspect_ratio=aspect_ratio,
                image_size=image_size,
                model=model,
            ): prompt
            for prompt in prompts
        }
        
        for future in as_completed(future_to_prompt):
            prompt = future_to_prompt[future]
            try:
                result = future.result()
                results.append(result)
            except Exception as e:
                print(f"Error generating image for '{prompt}': {e}", file=sys.stderr)
                results.append({"data": None, "text": None, "prompt": prompt, "error": str(e)})
    
    return results


def save_image(data: bytes, output_path: str) -> str:
    """画像を保存"""
    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
    Path(output_path).write_bytes(data)
    return output_path

"""
漫画生成メインスクリプト

data/baseの画像を読み込み、200x200にresizeし、
CSVファイルに基づいてページごとに漫画を生成する
"""

import argparse
import csv
import sys
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from tqdm import tqdm
from tools.generate_image import generate_image, load_and_resize_images


PROMPT_PREFIX = """このキャラと家をベースに漫画を作って
【重要！！】
時系列は右上->左上->右下->左下に必ず、進んでください。
左下 -> 右下にならないように！！
"""


def load_csv(csv_path: Path) -> dict[int, list[dict]]:
    """
    CSVファイルを読み込んで、ページごとにグループ化

    Args:
        csv_path: CSVファイルのパス

    Returns:
        ページ番号をキー、コマ情報のリストを値とする辞書
    """
    pages = defaultdict(list)
    
    with open(csv_path, "r", encoding="utf-8-sig") as f:
        reader = csv.DictReader(f)
        for row in reader:
            page_num = int(row["ページ"].strip())
            pages[page_num].append(row)
    
    return dict(sorted(pages.items()))


def build_page_prompt(page_data: list[dict]) -> str:
    """
    ページデータからプロンプトを組み立てる
    """
    prompt_parts = []
    
    for i, panel in enumerate(page_data, 1):
        panel_size = panel.get("コマサイズ", "")
        scene = panel.get("シーン説明", "")
        character = panel.get("キャラクター", "")
        dialogue = panel.get("セリフ", "")
        manga_prompt = panel.get("漫画部分プロンプト", "")
        
        prompt_parts.append(f"コマ{i}（{panel_size}）")
        
        if scene:
            prompt_parts.append(f"【シーン】{scene}")
        if character:
            prompt_parts.append(f"【{character}】")
        if manga_prompt:
            prompt_parts.append(f"【プロンプト】{manga_prompt}")
        if dialogue:
            prompt_parts.append(f"【セリフ】{dialogue}")
        
        prompt_parts.append("")
    
    return "\n".join(prompt_parts)


def main():
    parser = argparse.ArgumentParser(description="CSVファイルから漫画を生成")
    parser.add_argument("csv_file", type=Path, help="CSVファイルのパス")
    args = parser.parse_args()
    
    csv_path = args.csv_file
    base_dir = Path("data/base")
    
    print(f"Loading CSV from {csv_path}...")
    pages = load_csv(csv_path)
    print(f"Found {len(pages)} pages")
    
    # 参照画像を読み込み（キャラ設定画、背景など）
    image_files = sorted(base_dir.glob("*.png")) + sorted(base_dir.glob("*.jpg"))
    print(f"Loading {len(image_files)} reference images...")
    resized_images = load_and_resize_images(image_files, size=(200, 200))
    
    output_dir = Path("output") / csv_path.stem
    output_dir.mkdir(parents=True, exist_ok=True)
    
    def generate_page(page_num: int, page_data: list[dict]) -> tuple[int, bool, str]:
        """ページを生成する関数"""
        output_file = output_dir / f"{page_num}.png"
        
        if output_file.exists():
            return (page_num, False, f"Page {page_num}: Already exists, skipping...")
        
        page_prompt = build_page_prompt(page_data)
        full_prompt = PROMPT_PREFIX + page_prompt
        
        result = generate_image(
            prompt=full_prompt,
            aspect_ratio="9:16",
            image_size="2K",
            input_images=resized_images,
        )
        
        output_file.write_bytes(result["data"])
        return (page_num, True, f"Page {page_num} saved to {output_file}")
    
    # 並列生成
    pages_to_generate = [
        (page_num, page_data)
        for page_num, page_data in pages.items()
        if not (output_dir / f"{page_num}.png").exists()
    ]
    
    print(f"Generating {len(pages_to_generate)} pages in parallel...")
    
    with ThreadPoolExecutor(max_workers=3) as executor:
        future_to_page = {
            executor.submit(generate_page, page_num, page_data): page_num
            for page_num, page_data in pages_to_generate
        }
        
        with tqdm(total=len(pages_to_generate), desc="Generating pages") as pbar:
            for future in as_completed(future_to_page):
                page_num, success, message = future.result()
                pbar.update(1)
    
    print(f"Completed! Output: {output_dir}")


if __name__ == "__main__":
    main()

"""
PNG/JPG を WebP に変換して軽量化
"""

from pathlib import Path
from PIL import Image
from tqdm import tqdm


def convert_to_webp(input_path: Path, output_path: Path, quality: int = 85):
    """画像をWebP形式に変換"""
    with Image.open(input_path) as img:
        if img.mode == 'RGBA':
            img.save(output_path, 'WEBP', quality=quality, method=6)
        else:
            img = img.convert('RGB')
            img.save(output_path, 'WEBP', quality=quality, method=6)


def main():
    finished_dir = Path("output")
    compressed_dir = Path("compressed")
    
    image_extensions = {'.png', '.jpg', '.jpeg', '.PNG', '.JPG', '.JPEG'}
    
    all_images = []
    for subdir in finished_dir.iterdir():
        if subdir.is_dir():
            for img_file in subdir.iterdir():
                if img_file.suffix in image_extensions:
                    all_images.append((subdir, img_file))
    
    print(f"Found {len(all_images)} images to convert")
    
    for subdir, img_file in tqdm(all_images, desc="Converting to WebP"):
        relative_subdir = subdir.relative_to(finished_dir)
        output_subdir = compressed_dir / relative_subdir
        output_subdir.mkdir(parents=True, exist_ok=True)
        
        output_file = output_subdir / f"{img_file.stem}.webp"
        
        if not output_file.exists():
            convert_to_webp(img_file, output_file)
    
    print(f"Output: {compressed_dir}")


if __name__ == "__main__":
    main()

project/
├── data/
│   └── base/           # 参照画像（キャラ設定画、背景）
│       ├── yuta.png
│       ├── mina.png
│       ├── kitchen.png
│       └── dining.png
├── output/
│   └── chapter1/       # 生成された漫画ページ
│       ├── 1.png
│       ├── 2.png
│       └── ...
├── compressed/
│   └── chapter1/       # webpに圧縮された漫画ページ
│       ├── 1.png
│       ├── 2.png
│       └── ...
├── main.py
└── tools/
    └── generate_image.py

python convert_to_webp.py