【Python】AI画像でCOCOデータセットを自動生成する方法【Ollama+Stable Diffusion+BiRefNet】

{
    "id": 1,
    "image_id": 1,
    "category_id": 1,
    "bbox": [120, 200, 150, 180],
    "area": 27000,
    "segmentation": [
        [...]
    ],
    "iscrowd": 0
}

import random
import re
import time
import ollama

MODEL_NAME = "qwen3:8b"

DOG_BREEDS = [
    "Golden Retriever",
    "Labrador Retriever",
    "Shiba Inu",
    "German Shepherd",
    "Beagle",
    "Border Collie",
    "French Bulldog",
    "Siberian Husky",
    "Toy Poodle",
    "Dachshund",
    "Chihuahua",
    "Dalmatian",
    "Pembroke Welsh Corgi",
    "Australian Shepherd",
    "mixed-breed dog",
]

CAT_BREEDS = [
    "British Shorthair cat",
    "American Shorthair cat",
    "Scottish Fold cat",
    "Maine Coon cat",
    "Siamese cat",
    "Bengal cat",
    "Persian cat",
    "Russian Blue cat",
    "Ragdoll cat",
    "Norwegian Forest cat",
    "Calico cat",
    "Tuxedo cat",
    "Tabby cat",
    "white domestic cat",
    "black domestic cat",
]

DOG_POSES = [
    "standing and facing the camera",
    "sitting and facing the camera",
    "standing in side profile",
    "walking naturally",
    "running",
    "lying down",
    "looking slightly upward",
    "looking to the left",
    "looking to the right",
    "playfully raising one front paw",
    "stretching",
]

CAT_POSES = [
    "standing and facing the camera",
    "sitting and facing the camera",
    "standing in side profile",
    "walking naturally",
    "running",
    "lying down",
    "crouching",
    "looking slightly upward",
    "looking to the left",
    "looking to the right",
    "playfully raising one front paw",
    "stretching",
]

VIEWPOINTS = [
    "eye-level view",
    "slightly elevated view",
    "slightly low-angle view",
    "three-quarter front view",
    "side view",
]

OBJECT_SIZES = [
    {
        "name": "small",
        "description": (
            "the entire animal occupies approximately 25 to 35 percent "
            "of the image height"
        ),
    },
    {
        "name": "medium",
        "description": (
            "the entire animal occupies approximately 40 to 55 percent "
            "of the image height"
        ),
    },
    {
        "name": "large",
        "description": (
            "the entire animal occupies approximately 60 to 75 percent "
            "of the image height"
        ),
    },
]

APPEARANCES = [
    "realistic natural fur",
    "highly detailed fur",
    "soft natural fur texture",
    "photorealistic appearance",
]

LIGHTING = [
    "soft uniform studio lighting",
    "diffused frontal studio lighting",
    "balanced shadowless studio lighting",
]

# 背景除去しやすいよう、単色・無地・高コントラストを指定。
# 背景色そのものは生成AI側に選ばせる。
BACKGROUND_CONDITION = (
    "a perfectly uniform solid-color studio background with no texture, "
    "gradient, floor, horizon, scenery, shadows, or background objects; "
    "choose a background color that strongly contrasts with the animal's fur "
    "and makes the animal boundary easy to separate during background removal"
)

NEGATIVE_PROMPT = (
    "multiple animals, extra animal, duplicate animal, "
    "close-up, portrait, "
    "cropped body, cropped head, cropped legs, cropped paws, cropped tail, "
    "body outside frame, out of frame, "
    "missing legs, extra legs, malformed paws, "
    "deformed anatomy, distorted face, two heads, "
    "accessories, collar, leash, clothes, toy, furniture, "
    "floor, horizon, scenery, grass, "
    "uneven background, gradient background, textured background, "
    "background objects, shadows on background, "
    "text, watermark, logo, border, frame, blur, low quality"
)


def remove_thinking_text(text: str) -> str:
    """Qwen系モデルが出力する可能性があるthinkタグなどを除去する。"""
    text = re.sub(
        r"<think>.*?</think>",
        "",
        text,
        flags=re.DOTALL | re.IGNORECASE,
    )
    return text.strip().strip('"').strip("'")


def select_conditions(animal: str) -> dict:
    """指定された動物について、種類・ポーズ・サイズなどをPython側で抽選する。"""
    if animal == "dog":
        breed = random.choice(DOG_BREEDS)
        pose = random.choice(DOG_POSES)
    elif animal == "cat":
        breed = random.choice(CAT_BREEDS)
        pose = random.choice(CAT_POSES)
    else:
        raise ValueError("animal must be 'dog' or 'cat'")

    object_size = random.choice(OBJECT_SIZES)

    return {
        "animal": animal,
        "breed": breed,
        "pose": pose,
        "viewpoint": random.choice(VIEWPOINTS),
        "size_name": object_size["name"],
        "size_description": object_size["description"],
        "appearance": random.choice(APPEARANCES),
        "lighting": random.choice(LIGHTING),
    }


def build_instruction(conditions: dict) -> str:
    """Ollamaに渡す指示文を作成する。"""
    return f"""
Create one concise English positive prompt for Stable Diffusion.

The generated image will be used as synthetic training data for object detection.

Required conditions:
- Canvas size: 512 x 512 pixels
- Exactly one animal
- Animal category: {conditions["animal"]}
- Breed or appearance: {conditions["breed"]}
- Pose: {conditions["pose"]}
- Viewpoint: {conditions["viewpoint"]}
- Object size: {conditions["size_description"]}
- Place the complete animal at the exact center of the image
- Full-body composition
- The entire animal must be visible from head to tail
- Show all four legs and all paws completely
- Show both ears and the entire tail completely
- No part of the animal may extend outside the image frame
- Leave a clear empty margin around the entire animal
- Background: {BACKGROUND_CONDITION}
- No other animal or object
- {conditions["appearance"]}
- {conditions["lighting"]}
- Preserve a clear margin between the animal and all image edges
- Make the animal boundary clear and easy to separate from the background

Output only the finished English Stable Diffusion prompt.
Do not output explanations, headings, quotation marks, JSON or Markdown.
""".strip()


def generate_prompt(conditions: dict) -> str:
    """OllamaでStable Diffusion用プロンプトを1件生成する。"""
    instruction = build_instruction(conditions)

    response = ollama.generate(
        model=MODEL_NAME,
        prompt=instruction,
        think=False,
        stream=False,
        options={
            "temperature": 0.8,
            "top_p": 0.9,
            "num_predict": 256,
        },
    )

    response_text = response.get("response", "")
    thinking_text = response.get("thinking", "")

    prompt = remove_thinking_text(
        response_text or thinking_text or ""
    )

    if not prompt:
        raise RuntimeError("Ollamaから空の応答が返されました。")

    return " ".join(prompt.split())


def generate_animal_prompts(
    dog_count: int,
    cat_count: int,
    retry_until_complete: bool = True,
) -> list[str]:
    """
    犬と猫のStable Diffusion用プロンプトを指定数生成して返す。

    例:
        prompts = generate_animal_prompts(1000, 1000)
        # len(prompts) == 2000

    戻り値:
        犬のプロンプト dog_count 件 +
        猫のプロンプト cat_count 件を格納したlist[str]

    retry_until_complete=True の場合、
    Ollamaで一時的なエラーが発生しても指定件数に達するまで再試行する。
    """
    if dog_count < 0 or cat_count < 0:
        raise ValueError("dog_count and cat_count must be 0 or greater")

    prompts: list[str] = []

    targets = [
        ("dog", dog_count),
        ("cat", cat_count),
    ]

    total_count = dog_count + cat_count
    completed = 0
    total_start = time.perf_counter()

    for animal, count in targets:
        generated = 0

        while generated < count:
            conditions = select_conditions(animal)
            start = time.perf_counter()

            try:
                positive_prompt = generate_prompt(conditions)

            except ollama.ResponseError as error:
                print(
                    f"[{completed + 1}/{total_count}] "
                    f"Ollama error ({animal}): {error.error}"
                )
                if not retry_until_complete:
                    generated += 1
                    completed += 1
                time.sleep(0.1)
                continue

            except Exception as error:
                print(
                    f"[{completed + 1}/{total_count}] "
                    f"Error ({animal}): {error}"
                )
                if not retry_until_complete:
                    generated += 1
                    completed += 1
                time.sleep(0.1)
                continue

            elapsed = time.perf_counter() - start

            prompts.append(positive_prompt)
            generated += 1
            completed += 1

            print(
                f"[{completed:04d}/{total_count}] "
                f"{animal} / {conditions['breed']} / "
                f"{conditions['pose']} / "
                f"{conditions['size_name']} "
                f"({elapsed:.2f} sec)"
            )

            time.sleep(0.1)

    total_elapsed = time.perf_counter() - total_start

    print()
    print(f"Completed : {len(prompts)} prompts")
    print(f"Dog       : {dog_count}")
    print(f"Cat       : {cat_count}")
    print(f"Total Time: {total_elapsed:.2f} sec")

    if prompts:
        print(f"Average   : {total_elapsed / len(prompts):.2f} sec/prompt")

    return prompts

import random
import re
import time

import ollama


MODEL_NAME = "qwen3:8b"


BACKGROUND_TYPES = [
    "modern city street",
    "quiet residential street",
    "urban sidewalk",
    "public park",
    "forest path",
    "grassy field",
    "sandy beach",
    "mountain landscape",
    "riverside",
    "lakeside",
    "garden",
    "backyard",
    "indoor living room",
    "wooden floor room",
    "modern office",
    "warehouse interior",
    "concrete industrial area",
    "parking lot",
    "train station platform",
    "shopping street",
    "country road",
    "suburban road",
    "school playground",
    "open plaza",
    "stone pavement",
    "wooden deck",
    "farm field",
    "hill landscape",
    "forest clearing",
    "indoor hallway",
]


WEATHER = [
    "clear weather",
    "slightly cloudy weather",
    "overcast weather",
    "soft cloudy weather",
]


TIME_OF_DAY = [
    "morning",
    "daytime",
    "late afternoon",
    "early evening",
]


LIGHTING = [
    "soft natural lighting",
    "diffused natural lighting",
    "realistic ambient lighting",
    "balanced natural lighting",
]


SEASON = [
    "spring",
    "summer",
    "autumn",
    "winter",
]


CAMERA_VIEW = [
    "eye-level view",
    "slightly low-angle view",
    "slightly elevated view",
    "natural human eye perspective",
    "wide-angle environmental view",
]


def remove_thinking_text(text: str) -> str:
    """
    Qwen系モデルが返す可能性がある
    <think>...</think> を除去する。
    """

    text = re.sub(
        r"<think>.*?</think>",
        "",
        text,
        flags=re.DOTALL | re.IGNORECASE,
    )

    return text.strip().strip('"').strip("'")


def select_background_conditions(
    include_person: bool = False,
) -> dict:
    """
    背景画像の条件をランダムに選択する。
    include_person=True の場合は人物を含む背景にする。
    """

    return {
        "background_type": random.choice(BACKGROUND_TYPES),
        "weather": random.choice(WEATHER),
        "time_of_day": random.choice(TIME_OF_DAY),
        "lighting": random.choice(LIGHTING),
        "season": random.choice(SEASON),
        "camera_view": random.choice(CAMERA_VIEW),
        "include_person": include_person,
    }


def build_background_instruction(
    conditions: dict,
) -> str:
    """
    Ollamaに渡す背景生成用の指示文を作成する。
    """

    if conditions["include_person"]:
        person_requirement = """
- Include one or more realistic people naturally present in the scene
- People should be part of the environment, not the dominant subject
- People may be standing, walking, sitting, or doing a natural everyday activity
"""
    else:
        person_requirement = """
- The scene must contain no people
"""

    return f"""
Create one concise English positive prompt for Stable Diffusion.

The generated image will be used as a background image for synthetic
object-detection training data.

Required conditions:

- Scene: {conditions["background_type"]}
- Weather: {conditions["weather"]}
- Time of day: {conditions["time_of_day"]}
- Season: {conditions["season"]}
- Lighting: {conditions["lighting"]}
- Camera viewpoint: {conditions["camera_view"]}

Image requirements:

- Photorealistic appearance
- Natural perspective
- Realistic textures
- Realistic environmental lighting
- The scene must contain no dogs
- The scene must contain no cats
- The scene must contain no animals
{person_requirement}
- Do not make any single object the dominant subject
- Do not place a large object in the exact center of the image
- Keep the central area reasonably open for a separately composited animal
- The image should work naturally as a background behind a dog or cat
- Avoid unusual or surreal elements
- Avoid text, logos and watermarks

Output only the finished English Stable Diffusion prompt.

Do not output:
- explanations
- headings
- quotation marks
- JSON
- Markdown
""".strip()


def generate_background_prompt(
    conditions: dict,
) -> str:
    """
    OllamaでStable Diffusion用の
    背景プロンプトを1件生成する。
    """

    instruction = build_background_instruction(
        conditions
    )

    response = ollama.generate(
        model=MODEL_NAME,
        prompt=instruction,
        think=False,
        stream=False,
        options={
            "temperature": 0.9,
            "top_p": 0.95,
            "num_predict": 256,
        },
    )

    response_text = response.get(
        "response",
        "",
    )

    thinking_text = response.get(
        "thinking",
        "",
    )

    prompt = remove_thinking_text(
        response_text
        or thinking_text
        or ""
    )

    if not prompt:
        raise RuntimeError(
            "Ollamaから空の応答が返されました。"
        )

    # 改行や連続スペースを1つのスペースへ統一
    return " ".join(
        prompt.split()
    )


def generate_background_prompts(
    count: int,
    person_ratio: float = 0.10,
) -> list[str]:
    """
    背景画像生成用プロンプトを
    指定数生成してlistで返す。

    Parameters
    ----------
    count : int
        生成するプロンプト数。

    Returns
    -------
    list[str]
        Stable Diffusion用の
        背景生成プロンプト一覧。

    Example
    -------
    prompts = generate_background_prompts(
        10000
    )

    print(len(prompts))
    # 10000
    """

    if count < 0:
        raise ValueError(
            "count must be 0 or greater"
        )

    if not 0.0 <= person_ratio <= 1.0:
        raise ValueError(
            "person_ratio must be between 0.0 and 1.0"
        )

    prompts: list[str] = []

    # 指定割合のプロンプトだけ人物ありにする。
    person_count = round(count * person_ratio)
    person_flags = (
        [True] * person_count
        + [False] * (count - person_count)
    )
    random.shuffle(person_flags)

    total_start = time.perf_counter()

    while len(prompts) < count:

        index = len(prompts) + 1
        include_person = person_flags[len(prompts)]

        conditions = (
            select_background_conditions(
                include_person=include_person,
            )
        )

        start = time.perf_counter()

        try:

            prompt = (
                generate_background_prompt(
                    conditions
                )
            )

        except ollama.ResponseError as error:

            print(
                f"[{index:05d}/{count}] "
                f"Ollama error: "
                f"{error.error}"
            )

            time.sleep(0.1)

            continue

        except Exception as error:

            print(
                f"[{index:05d}/{count}] "
                f"Error: {error}"
            )

            time.sleep(0.1)

            continue

        elapsed = (
            time.perf_counter()
            - start
        )

        prompts.append(
            prompt
        )

        print(
            f"[{index:05d}/{count}] "
            f"{conditions['background_type']} / "
            f"{conditions['season']} / "
            f"{conditions['time_of_day']} / "
            f"person={'yes' if conditions['include_person'] else 'no'} "
            f"({elapsed:.2f} sec)"
        )

        print(
            f"  {prompt}"
        )

        # CPU負荷を少し抑える
        time.sleep(0.1)

    total_elapsed = (
        time.perf_counter()
        - total_start
    )

    print()

    print(
        f"Completed : "
        f"{len(prompts)} prompts"
    )

    print(
        f"Total Time: "
        f"{total_elapsed:.2f} sec"
    )

    if prompts:

        print(
            f"Average   : "
            f"{total_elapsed / len(prompts):.2f} "
            f"sec/prompt"
        )

    return prompts

def generate_source_images(
    target_prompts: list[str],
    background_prompts: list[str],
    dog_count: int,
    base_seed: int | None = None,
    skip_existing: bool = True,
) -> list[dict]:
    """
    target/backgroundプロンプトから元画像を生成する。

    target_promptsは、先頭dog_count件が犬、残りが猫である前提。

    Returns
    -------
    list[dict]
        target画像のファイルパスとカテゴリ情報。
    """
    if dog_count < 0 or dog_count > len(target_prompts):
        raise ValueError("dog_count が target_prompts の範囲外です。")

    pipe = load_sd_pipeline()
    target_entries: list[dict] = []

    try:
        total = len(target_prompts) + len(background_prompts)
        current = 0

        # ---------- target ----------
        for index, prompt in enumerate(target_prompts):
            current += 1
            category_id, category_name = get_target_category(index, dog_count)

            output_path = TARGET_RAW_DIR / f"target_{index:06d}_{category_name}.png"
            seed = (
                base_seed + index
                if base_seed is not None
                else random.randint(0, 2**31 - 1)
            )

            if not (skip_existing and output_path.exists()):
                print(
                    f"[{current:06d}/{total:06d}] "
                    f"Generate target: {category_name}"
                )
                image = generate_sd_image(
                    pipe=pipe,
                    prompt=prompt,
                    negative_prompt=TARGET_NEGATIVE_PROMPT,
                    seed=seed,
                )
                image.save(output_path)
            else:
                print(f"[{current:06d}/{total:06d}] SKIP target: {output_path}")

            target_entries.append(
                {
                    "path": output_path,
                    "category_id": category_id,
                    "category_name": category_name,
                }
            )

        # ---------- background ----------
        seed_offset = len(target_prompts)

        for index, prompt in enumerate(background_prompts):
            current += 1
            output_path = BACKGROUND_RAW_DIR / f"background_{index:06d}.png"
            seed = (
                base_seed + seed_offset + index
                if base_seed is not None
                else random.randint(0, 2**31 - 1)
            )

            if skip_existing and output_path.exists():
                print(f"[{current:06d}/{total:06d}] SKIP background: {output_path}")
                continue

            print(f"[{current:06d}/{total:06d}] Generate background")
            image = generate_sd_image(
                pipe=pipe,
                prompt=prompt,
                negative_prompt=BACKGROUND_NEGATIVE_PROMPT,
                seed=seed,
            )
            image.save(output_path)

    finally:
        del pipe
        release_cuda()

    return target_entries

def create_target_cutouts(
    target_entries: list[dict],
    skip_existing: bool = True,
) -> list[dict]:
    """全targetをBiRefNetで1回だけ背景除去してキャッシュする。"""
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = load_birefnet_model(device)
    transform = create_birefnet_transform()

    cutout_entries: list[dict] = []

    try:
        for index, entry in enumerate(target_entries):
            cutout_path = TARGET_CUTOUT_DIR / f"target_{index:06d}.png"

            if not (skip_existing and cutout_path.exists()):
                print(
                    f"[{index + 1:06d}/{len(target_entries):06d}] "
                    f"BiRefNet: {entry['category_name']}"
                )

                image = Image.open(entry["path"]).convert("RGB")
                transparent, _ = remove_background(
                    image=image,
                    model=model,
                    device=device,
                    transform=transform,
                )
                transparent.save(cutout_path)
            else:
                print(
                    f"[{index + 1:06d}/{len(target_entries):06d}] "
                    f"SKIP cutout: {cutout_path}"
                )

            cutout_entries.append(
                {
                    **entry,
                    "cutout_path": cutout_path,
                }
            )

    finally:
        del model
        release_cuda()

    return cutout_entries

def prepare_random_target(
    cutout_image: Image.Image,
) -> tuple[Image.Image, np.ndarray]:
    """
    targetをランダム左右反転し、元サイズの20～50%へ縮小する。

    Returns
    -------
    resized_rgba : PIL.Image.Image
    binary_mask : np.ndarray
        uint8、前景=1、背景=0
    """
    image = cutout_image.convert("RGBA")

    if random.random() < HORIZONTAL_FLIP_PROBABILITY:
        image = ImageOps.mirror(image)

    scale = random.uniform(
        MIN_TARGET_SCALE,
        MAX_TARGET_SCALE,
    )

    new_width = max(1, int(image.width * scale))
    new_height = max(1, int(image.height * scale))

    image = image.resize(
        (new_width, new_height),
        resample=Image.Resampling.LANCZOS,
    )

    alpha = np.asarray(image.getchannel("A"), dtype=np.uint8)
    binary_mask = (alpha >= MASK_THRESHOLD).astype(np.uint8)

    return image, binary_mask

def place_target(
    canvas: Image.Image,
    target_image: Image.Image,
    target_mask: np.ndarray,
) -> tuple[np.ndarray, int, int]:
    """targetを背景のランダム位置へ配置し、全画面サイズのマスクを返す。"""
    max_x = canvas.width - target_image.width
    max_y = canvas.height - target_image.height

    if max_x < 0 or max_y < 0:
        raise RuntimeError("縮小後targetが背景画像より大きくなっています。")

    x = random.randint(0, max_x)
    y = random.randint(0, max_y)

    canvas.alpha_composite(target_image, dest=(x, y))

    full_mask = np.zeros(
        (canvas.height, canvas.width),
        dtype=np.uint8,
    )

    full_mask[
        y : y + target_image.height,
        x : x + target_image.width,
    ] = target_mask

    return full_mask, x, y

def calculate_visible_masks(
    instance_masks: list[np.ndarray],
) -> list[np.ndarray]:
    """
    後から描画したtargetが手前にあるものとして、
    各インスタンスの最終的な可視マスクを計算する。
    """
    if not instance_masks:
        return []

    visible_masks = [np.zeros_like(instance_masks[0]) for _ in instance_masks]
    occupied = np.zeros_like(instance_masks[0], dtype=np.uint8)

    # 後から置いたものほど手前
    for index in range(len(instance_masks) - 1, -1, -1):
        current = instance_masks[index].astype(bool)
        visible = current & ~occupied.astype(bool)
        visible_masks[index] = visible.astype(np.uint8)
        occupied = np.logical_or(occupied, current).astype(np.uint8)

    return visible_masks

def mask_to_bbox(mask: np.ndarray) -> list[float] | None:
    """二値マスクからCOCO形式[x, y, width, height]のBBoxを作る。"""
    ys, xs = np.where(mask > 0)

    if len(xs) == 0 or len(ys) == 0:
        return None

    x_min = int(xs.min())
    y_min = int(ys.min())
    x_max = int(xs.max())
    y_max = int(ys.max())

    width = x_max - x_min + 1
    height = y_max - y_min + 1

    return [float(x_min), float(y_min), float(width), float(height)]

def mask_to_polygons(mask: np.ndarray) -> list[list[float]]:
    """二値マスクをCOCO polygon segmentationへ変換する。"""
    mask_u8 = (mask > 0).astype(np.uint8) * 255

    contours, _ = cv2.findContours(
        mask_u8,
        cv2.RETR_EXTERNAL,
        cv2.CHAIN_APPROX_SIMPLE,
    )

    segmentation: list[list[float]] = []

    for contour in contours:
        if contour.shape[0] < 3:
            continue

        polygon = contour.reshape(-1, 2).astype(float).flatten().tolist()

        # x,yが3点以上 = 6要素以上
        if len(polygon) >= 6:
            segmentation.append(polygon)

    return segmentation

def make_annotation(
    annotation_id: int,
    image_id: int,
    category_id: int,
    mask: np.ndarray,
) -> dict | None:
    """可視マスクから1件のCOCO annotationを生成する。"""
    area = int(mask.sum())

    if area < MIN_VISIBLE_AREA:
        return None

    bbox = mask_to_bbox(mask)
    if bbox is None:
        return None

    segmentation = mask_to_polygons(mask)
    if not segmentation:
        return None

    return {
        "id": annotation_id,
        "image_id": image_id,
        "category_id": category_id,
        "segmentation": segmentation,
        "area": float(area),
        "bbox": bbox,
        "iscrowd": 0,
    }

def compose_coco_dataset(
    cutout_entries: list[dict],
    background_count: int,
    train_ratio: float = 0.8,
) -> dict:
    """
    各backgroundに1～5匹を配置し、train/valへ分割して
    COCO画像とJSONを作成する。

    Parameters
    ----------
    train_ratio : float
        trainへ割り当てる割合。0.0より大きく1.0未満。
        例: 0.8 -> train 80%, val 20%
    """
    if not cutout_entries:
        raise RuntimeError("利用できるtarget画像がありません。")

    if not 0.0 < train_ratio < 1.0:
        raise ValueError("train_ratio は 0.0 より大きく 1.0 未満にしてください。")

    # 背景indexを先にシャッフルしてtrain/valを決定する。
    background_indices = list(range(background_count))
    random.shuffle(background_indices)

    train_count = int(background_count * train_ratio)
    train_indices = set(background_indices[:train_count])

    categories = [
        {
            "id": CATEGORY_DOG,
            "name": "dog",
            "supercategory": "animal",
        },
        {
            "id": CATEGORY_CAT,
            "name": "cat",
            "supercategory": "animal",
        },
    ]

    def create_coco_dict(description: str) -> dict:
        return {
            "info": {
                "description": description,
                "version": "1.0",
            },
            "licenses": [],
            "images": [],
            "annotations": [],
            "categories": categories,
        }

    train_coco = create_coco_dict("Synthetic dog/cat dataset - train")
    val_coco = create_coco_dict("Synthetic dog/cat dataset - val")

    train_annotation_id = 1
    val_annotation_id = 1
    train_image_id = 1
    val_image_id = 1

    for bg_index in range(background_count):
        background_path = BACKGROUND_RAW_DIR / f"background_{bg_index:06d}.png"

        if not background_path.exists():
            raise FileNotFoundError(
                f"background画像が見つかりません: {background_path}"
            )

        is_train = bg_index in train_indices

        if is_train:
            split_name = "train"
            output_dir = TRAIN_IMAGE_DIR
            coco = train_coco
            image_id = train_image_id
            annotation_id = train_annotation_id
        else:
            split_name = "val"
            output_dir = VAL_IMAGE_DIR
            coco = val_coco
            image_id = val_image_id
            annotation_id = val_annotation_id

        background = Image.open(background_path).convert("RGBA")
        canvas = background.copy()

        animal_count = random.randint(
            MIN_ANIMALS_PER_IMAGE,
            MAX_ANIMALS_PER_IMAGE,
        )

        placed_instances: list[dict] = []

        for _ in range(animal_count):
            entry = random.choice(cutout_entries)
            cutout = Image.open(entry["cutout_path"]).convert("RGBA")

            target_image, local_mask = prepare_random_target(cutout)

            if int(local_mask.sum()) < MIN_VISIBLE_AREA:
                continue

            full_mask, _, _ = place_target(
                canvas=canvas,
                target_image=target_image,
                target_mask=local_mask,
            )

            placed_instances.append(
                {
                    "category_id": entry["category_id"],
                    "mask": full_mask,
                }
            )

        # 最低1匹は配置する
        if not placed_instances:
            entry = random.choice(cutout_entries)
            cutout = Image.open(entry["cutout_path"]).convert("RGBA")
            target_image, local_mask = prepare_random_target(cutout)

            full_mask, _, _ = place_target(
                canvas=canvas,
                target_image=target_image,
                target_mask=local_mask,
            )

            placed_instances.append(
                {
                    "category_id": entry["category_id"],
                    "mask": full_mask,
                }
            )

        visible_masks = calculate_visible_masks(
            [instance["mask"] for instance in placed_instances]
        )

        filename = f"synthetic_{bg_index:06d}.png"
        output_path = output_dir / filename
        canvas.convert("RGB").save(output_path)

        coco["images"].append(
            {
                "id": image_id,
                "file_name": filename,
                "width": canvas.width,
                "height": canvas.height,
            }
        )

        valid_annotations = 0

        for instance, visible_mask in zip(
            placed_instances,
            visible_masks,
        ):
            annotation = make_annotation(
                annotation_id=annotation_id,
                image_id=image_id,
                category_id=instance["category_id"],
                mask=visible_mask,
            )

            if annotation is None:
                continue

            coco["annotations"].append(annotation)
            annotation_id += 1
            valid_annotations += 1

        if is_train:
            train_annotation_id = annotation_id
            train_image_id += 1
        else:
            val_annotation_id = annotation_id
            val_image_id += 1

        print(
            f"[{bg_index + 1:06d}/{background_count:06d}] "
            f"{split_name}: {filename} / instances={valid_annotations}"
        )

    with TRAIN_COCO_JSON_PATH.open("w", encoding="utf-8") as file:
        json.dump(train_coco, file, ensure_ascii=False, indent=2)

    with VAL_COCO_JSON_PATH.open("w", encoding="utf-8") as file:
        json.dump(val_coco, file, ensure_ascii=False, indent=2)

    print()
    print(f"Train images : {len(train_coco['images'])}")
    print(f"Val images   : {len(val_coco['images'])}")
    print(f"Train JSON   : {TRAIN_COCO_JSON_PATH.resolve()}")
    print(f"Val JSON     : {VAL_COCO_JSON_PATH.resolve()}")

    return {
        "train": train_coco,
        "val": val_coco,
    }