scripts/prepare_all_data.py

"""
一站式数据准备脚本。

自动完成：
  1. 下载 COCO 2017 检测数据（val 子集，约 5K 图，~1GB）
  2. 生成预训练 grounding 数据（JSONL）
  3. 生成 Counting 冷启动数据（基于 COCO）
  4. 生成 Spatial Reasoning 数据（CLEVR 风格，纯程序生成）
  5. 调用 maze / path 生成脚本

用法:
  python scripts/prepare_all_data.py --output_dir data --coco_split val
"""

import os
import sys
import json
import argparse
import random
import math
from pathlib import Path
from typing import List, Tuple
from collections import defaultdict

from PIL import Image, ImageDraw, ImageFont
from tqdm import tqdm

PROJECT_ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(PROJECT_ROOT))


IRREGULAR_PLURALS = {
    "person": "people",
    "mouse": "mice",
    "sheep": "sheep",
    "knife": "knives",
    "child": "children",
}


def pluralize(word: str) -> str:
    """Simple English pluralization for COCO category names."""
    low = word.lower()
    if low in IRREGULAR_PLURALS:
        return IRREGULAR_PLURALS[low]
    if " " in word:
        parts = word.rsplit(" ", 1)
        return parts[0] + " " + pluralize(parts[1])
    if word.endswith(("s", "sh", "ch", "x", "z")):
        return word + "es"
    if word.endswith("y") and word[-2] not in "aeiou":
        return word[:-1] + "ies"
    return word + "s"

from model.special_tokens import normalize_coordinate


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--output_dir", type=str, default="data")
    parser.add_argument("--coco_split", type=str, default="val", choices=["train", "val"])
    parser.add_argument("--coco_subset", type=int, default=5000, help="最多使用多少张 COCO 图片")
    parser.add_argument("--num_counting", type=int, default=2000, help="生成 counting 样本数")
    parser.add_argument("--num_spatial", type=int, default=2000, help="生成 spatial 样本数")
    parser.add_argument("--num_maze", type=int, default=5000, help="生成 maze 样本数")
    parser.add_argument("--num_path", type=int, default=3000, help="生成 path tracing 样本数")
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args()


# ---------------------------------------------------------------------------
# 1. COCO 下载 & 导出
# ---------------------------------------------------------------------------

def download_coco(output_dir: Path, split: str = "val", max_images: int = 5000):
    """使用 datasets 库下载 COCO，导出为图片+标注文件。"""
    try:
        from datasets import load_dataset
    except ImportError:
        print("请先安装 datasets: pip install datasets")
        sys.exit(1)

    print(f"正在下载 COCO 2017 {split} ...")
    ds = load_dataset("detection-datasets/coco", split=split, streaming=True)

    img_dir = output_dir / "coco" / split / "images"
    img_dir.mkdir(parents=True, exist_ok=True)
    ann_path = output_dir / "coco" / split / "annotations.json"

    annotations = {"images": [], "annotations": [], "categories": []}
    category_map = {}
    cat_counter = 1

    count = 0
    for sample in tqdm(ds, desc="COCO download"):
        if count >= max_images:
            break
        # sample keys: image, image_id, width, height, objects
        img = sample["image"]
        img_id = sample.get("image_id", count)
        w, h = sample.get("width", img.width), sample.get("height", img.height)

        img_path = img_dir / f"{img_id:012d}.jpg"
        img.save(img_path)

        annotations["images"].append({
            "id": img_id,
            "file_name": img_path.name,
            "width": w,
            "height": h,
        })

        objects = sample.get("objects", {})
        bboxes = objects.get("bbox", [])
        labels = objects.get("category", [])
        for bbox, label in zip(bboxes, labels):
            if label not in category_map:
                category_map[label] = cat_counter
                annotations["categories"].append({
                    "id": cat_counter,
                    "name": str(label),
                })
                cat_counter += 1
            annotations["annotations"].append({
                "id": len(annotations["annotations"]) + 1,
                "image_id": img_id,
                "category_id": category_map[label],
                "bbox": bbox,  # [x1, y1, x2, y2]
            })
        count += 1

    with open(ann_path, "w") as f:
        json.dump(annotations, f)
    print(f"COCO 导出完成: {img_dir} ({count} 张图), 标注: {ann_path}")
    return img_dir, ann_path, annotations


# ---------------------------------------------------------------------------
# 2. 预训练 Grounding 数据
# ---------------------------------------------------------------------------

def generate_pretrain_data(annotations: dict, output_path: Path):
    """从 COCO 标注生成 grounding JSONL。"""
    output_path.parent.mkdir(parents=True, exist_ok=True)
    # 按图分组
    img_anns = defaultdict(list)
    for ann in annotations["annotations"]:
        img_anns[ann["image_id"]].append(ann)

    cats = {c["id"]: c["name"] for c in annotations["categories"]}

    records = []
    for img_info in annotations["images"]:
        img_id = img_info["id"]
        W, H = img_info["width"], img_info["height"]
        anns = img_anns.get(img_id, [])
        if not anns:
            continue
        # 按类别分组
        by_cat = defaultdict(list)
        for ann in anns:
            cat_name = cats[ann["category_id"]]
            x1, y1, x2, y2 = ann["bbox"]  # HuggingFace COCO: [x1,y1,x2,y2]
            x1 = max(0.0, min(x1, W))
            y1 = max(0.0, min(y1, H))
            x2 = max(0.0, min(x2, W))
            y2 = max(0.0, min(y2, H))
            box = (
                normalize_coordinate(x1, W),
                normalize_coordinate(y1, H),
                normalize_coordinate(x2, W),
                normalize_coordinate(y2, H),
            )
            by_cat[cat_name].append(box)

        for cat_name, boxes in by_cat.items():
            records.append({
                "image": str(Path("images") / img_info["file_name"]),
                "label": cat_name,
                "boxes": boxes,
                "points": [],
                "normalized": True,
            })

    with open(output_path, "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    print(f"预训练 grounding 数据: {len(records)} 条 -> {output_path}")


# ---------------------------------------------------------------------------
# 3. Counting 冷启动数据（基于 COCO）
# ---------------------------------------------------------------------------

def generate_counting_thinking(category: str, boxes: List[Tuple[int, int, int, int]], count: int) -> str:
    """程序生成 Counting 的 thinking 内容（统一模板：与 grounding 格式一致）。"""
    lines = []
    lines.append("1. **Analyzing the request**")
    lines.append(f"The user asks me to count the {category} in this image.")
    lines.append("2. **Object grounding**")
    box_strs = []
    for x1, y1, x2, y2 in boxes:
        box_strs.append(f"[{x1},{y1},{x2},{y2}]")
    lines.append(f"I see {count} instance(s) of <|ref|>{category}<|/ref|><|box|>[{','.join(box_strs)}]<|/box|>.")
    lines.append("3. **Conclusion**")
    lines.append(f"There are {count} {category} in this image.")
    return "\n".join(lines)


def generate_counting_data(annotations: dict, output_path: Path, num_samples: int):
    """从 COCO 生成 counting 数据。"""
    from utils.coco_categories import COCO_CATS, get_category_name

    output_path.parent.mkdir(parents=True, exist_ok=True)
    img_anns = defaultdict(list)
    for ann in annotations["annotations"]:
        img_anns[ann["image_id"]].append(ann)
    cats = {c["id"]: c["name"] for c in annotations["categories"]}

    # 筛选出实例数 >=2 的图
    candidates = []
    for img_info in annotations["images"]:
        img_id = img_info["id"]
        W, H = img_info["width"], img_info["height"]
        anns = img_anns.get(img_id, [])
        by_cat = defaultdict(list)
        for ann in anns:
            raw_name = cats[ann["category_id"]]
            cat_name = get_category_name(raw_name)
            x1, y1, x2, y2 = ann["bbox"]  # HuggingFace COCO: [x1,y1,x2,y2]
            x1 = max(0.0, min(x1, W))
            y1 = max(0.0, min(y1, H))
            x2 = max(0.0, min(x2, W))
            y2 = max(0.0, min(y2, H))
            box = (
                normalize_coordinate(x1, W),
                normalize_coordinate(y1, H),
                normalize_coordinate(x2, W),
                normalize_coordinate(y2, H),
            )
            by_cat[cat_name].append(box)
        for cat_name, boxes in by_cat.items():
            if len(boxes) >= 2:
                candidates.append((img_info, cat_name, boxes))

    random.shuffle(candidates)
    candidates = candidates[:num_samples]

    records = []
    templates = [
        "How many {category} are in this image?",
        "How many {category} are in the image?",
        "How many {plural} are in this image?",
        "How many {plural} are in the image?",
        "Count the number of {category}.",
        "Count the number of {plural}.",
        "Count the {plural} in the image.",
        "Count all {plural} in this image.",
        "What is the total count of {category}?",
        "What is the total count of {plural}?",
        "How many {plural} can you see?",
        "How many {plural} are there in the image?",
    ]
    for img_info, cat_name, boxes in candidates:
        plural_name = pluralize(cat_name)
        question = random.choice(templates).format(category=cat_name, plural=plural_name)
        thinking = generate_counting_thinking(cat_name, boxes, len(boxes))
        records.append({
            "image": str(Path("images") / img_info["file_name"]),
            "question": question,
            "thinking": thinking,
            "count": len(boxes),
            "boxes": boxes,
        })

    with open(output_path, "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    print(f"Counting 数据: {len(records)} 条 -> {output_path}")


# ---------------------------------------------------------------------------
# 4. Spatial Reasoning 数据（CLEVR 风格，程序生成）
# ---------------------------------------------------------------------------

def generate_clevr_image(size: int = 400) -> Image.Image:
    """生成一张 CLEVR 风格的简单几何体图片。"""
    img = Image.new("RGB", (size, size), "lightgray")
    draw = ImageDraw.Draw(img)
    colors = ["red", "blue", "green", "yellow", "purple", "cyan", "brown", "gray"]
    shapes = ["circle", "rectangle", "triangle"]
    materials = ["metal", "rubber"]
    objects = []

    num_objs = random.randint(3, 6)
    for _ in range(num_objs):
        obj_w = random.randint(30, 80)
        obj_h = random.randint(30, 80)
        x = random.randint(10, size - obj_w - 10)
        y = random.randint(10, size - obj_h - 10)
        color = random.choice(colors)
        shape = random.choice(shapes)
        material = random.choice(materials)

        if shape == "circle":
            draw.ellipse([x, y, x + obj_w, y + obj_h], fill=color, outline="black")
        elif shape == "rectangle":
            draw.rectangle([x, y, x + obj_w, y + obj_h], fill=color, outline="black")
        else:
            # triangle
            draw.polygon([(x + obj_w // 2, y), (x, y + obj_h), (x + obj_w, y + obj_h)], fill=color, outline="black")

        # normalized bbox
        nx1 = normalize_coordinate(x, size)
        ny1 = normalize_coordinate(y, size)
        nx2 = normalize_coordinate(x + obj_w, size)
        ny2 = normalize_coordinate(y + obj_h, size)
        objects.append({
            "shape": shape,
            "color": color,
            "material": material,
            "bbox": [nx1, ny1, nx2, ny2],
        })
    return img, objects


def generate_spatial_question(objects: List[dict], img_path: Path) -> dict:
    """基于生成物体生成空间推理问题和答案。"""
    if len(objects) < 2:
        return None

    # 简化: 只使用 attribute 问题类型
    q_type = "attribute"

    # 选一个目标物体
    target = random.choice(objects)
    target_color = target["color"]
    target_shape = target["shape"]
    target_mat = target["material"]

    question = f"Is there a {target_color} {target_mat} {target_shape}?"
    answer = "Yes"

    # 构建 thinking
    lines = []
    lines.append("1. **Analyzing the request**")
    lines.append(f"The user asks if there is a {target_color} {target_mat} {target_shape}.")
    lines.append("2. **Object grounding**")
    for obj in objects:
        c = obj["color"]
        s = obj["shape"]
        m = obj["material"]
        b = obj["bbox"]
        lines.append(f"I see a <|ref|>{c} {m} {s}<|/ref|><|box|>[[{b[0]},{b[1]},{b[2]},{b[3]}]]<|/box|>.")
    lines.append("3. **Conclusion**")
    lines.append(f"Since there is a {target_color} {target_mat} {target_shape}, the answer is Yes.")
    thinking = "\n".join(lines)

    return {
        "image": str(img_path),
        "question": question,
        "thinking": thinking,
        "answer": answer,
        "boxes": [target["bbox"]],
        "points": [],
    }


def generate_spatial_data(output_dir: Path, num_samples: int):
    output_dir.mkdir(parents=True, exist_ok=True)
    img_dir = output_dir / "images"
    img_dir.mkdir(exist_ok=True)

    records = []
    for i in range(num_samples):
        img, objects = generate_clevr_image(size=400)
        img_path = img_dir / f"spatial_{i:06d}.png"
        img.save(img_path)

        rec = generate_spatial_question(objects, img_path.relative_to(output_dir))
        if rec:
            records.append(rec)

    with open(output_dir / "spatial_data.jsonl", "w", encoding="utf-8") as f:
        for rec in records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
    print(f"Spatial 数据: {len(records)} 条 -> {output_dir}")


# ---------------------------------------------------------------------------
# 5. 调用 maze / path 生成
# ---------------------------------------------------------------------------

def call_maze_generation(output_dir: Path, num_samples: int):
    import subprocess
    cmd = [
        sys.executable, str(PROJECT_ROOT / "scripts" / "generate_maze_data.py"),
        "--output_dir", str(output_dir),
        "--num_samples", str(num_samples),
    ]
    print(f"运行: {' '.join(cmd)}")
    subprocess.run(cmd, check=True)


def call_path_generation(output_dir: Path, num_samples: int):
    import subprocess
    cmd = [
        sys.executable, str(PROJECT_ROOT / "scripts" / "generate_path_data.py"),
        "--output_dir", str(output_dir),
        "--num_samples", str(num_samples),
    ]
    print(f"运行: {' '.join(cmd)}")
    subprocess.run(cmd, check=True)


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main():
    args = parse_args()
    random.seed(args.seed)

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    # 1. COCO
    coco_img_dir, coco_ann_path, annotations = download_coco(
        output_dir / "coco" / args.coco_split,
        split=args.coco_split,
        max_images=args.coco_subset,
    )

    # 2. 预训练 grounding
    generate_pretrain_data(
        annotations,
        output_dir / "pretrain" / "grounding.jsonl",
    )
    # 创建符号链接或复制 images
    pretrain_img_dir = output_dir / "pretrain" / "images"
    pretrain_img_dir.mkdir(parents=True, exist_ok=True)
    # 这里直接写入相对路径，训练时 image_root 指向 coco/val/images

    # 3. Counting
    generate_counting_data(
        annotations,
        output_dir / "sft" / "counting" / "counting_data.jsonl",
        num_samples=args.num_counting,
    )

    # 4. Spatial
    generate_spatial_data(
        output_dir / "sft" / "spatial",
        num_samples=args.num_spatial,
    )

    # 5. Maze
    call_maze_generation(output_dir / "sft" / "maze", args.num_maze)

    # 6. Path
    call_path_generation(output_dir / "sft" / "path", args.num_path)

    print("\n========================================")
    print("所有数据准备完成！")
    print(f"预训练数据: {output_dir / 'pretrain' / 'grounding.jsonl'}")
    print(f"Counting:   {output_dir / 'sft' / 'counting'}")
    print(f"Spatial:    {output_dir / 'sft' / 'spatial'}")
    print(f"Maze:       {output_dir / 'sft' / 'maze'}")
    print(f"Path:       {output_dir / 'sft' / 'path'}")
    print("========================================")


if __name__ == "__main__":
    main()