AIとCapCutでつくる15秒縦型動画──企画から書き出し検証まで、迷わない実務設計

import argparse
import json
from pathlib import Path


def main():
    parser = argparse.ArgumentParser(description="縦型動画の制作ブリーフをJSONで作成")
    parser.add_argument("--output", default="production-brief.json")
    parser.add_argument("--title", default="15秒で伝える新サービス紹介")
    parser.add_argument("--audience", default="サービスを初めて知る人")
    parser.add_argument("--goal", default="プロフィール訪問")
    parser.add_argument("--kpi", default="視聴完了率")
    parser.add_argument("--force", action="store_true", help="既存の出力を上書き")
    args = parser.parse_args()

    output = Path(args.output)
    if output.exists() and not args.force:
        raise SystemExit(f"出力済みです: {output}（上書きは --force）")
    brief = {
        "title": args.title,
        "audience": args.audience,
        "goal": args.goal,
        "primary_kpi": args.kpi,
        "duration_seconds": 15,
        "aspect_ratio": "9:16",
        "pipeline": ["企画", "絵コンテ", "素材生成・撮影", "編集", "QC", "投稿", "振り返り"],
        "approval_checks": ["人物・ロゴの利用許諾", "音源ライセンス", "事実と表記", "納品仕様"],
        "note": "数値目標は案件の実績を見て別途設定する",
    }
    output.write_text(json.dumps(brief, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(f"created: {output.resolve()}")


if __name__ == "__main__":
    main()

import argparse
import json
import math
from pathlib import Path


DEMO = [
    {"name": "hook", "start": 0.0, "end": 3.0},
    {"name": "problem", "start": 3.0, "end": 6.0},
    {"name": "solution", "start": 6.0, "end": 12.0},
    {"name": "action", "start": 12.0, "end": 15.0},
]


def validate(shots, target, tolerance):
    errors = []
    ordered = sorted(shots, key=lambda x: x["start"])
    if not ordered:
        return ["ショットが空です"], 0
    if abs(ordered[0]["start"]) > tolerance:
        errors.append(f"先頭が0秒ではありません: {ordered[0]['start']:.3f} 秒")
    for index, shot in enumerate(ordered):
        if not all(math.isfinite(float(shot[key])) for key in ("start", "end")):
            errors.append(f"有限でない時刻: {shot['name']}")
            continue
        if shot["start"] < 0 or shot["end"] <= shot["start"]:
            errors.append(f"不正な区間: {shot['name']}")
        if index and abs(shot["start"] - ordered[index - 1]["end"]) > tolerance:
            errors.append(f"隙間または重複: {ordered[index - 1]['name']} → {shot['name']}")
    end = max((shot["end"] for shot in ordered), default=0)
    if abs(end - target) > tolerance:
        errors.append(f"終了時刻 {end:.3f} 秒（目標 {target:.3f} 秒）")
    return errors, end


def main():
    parser = argparse.ArgumentParser(description="絵コンテの時間軸を検証")
    parser.add_argument("--input", help="shot配列を持つJSON。省略時はデモ")
    parser.add_argument("--target", type=float, default=15.0)
    parser.add_argument("--tolerance", type=float, default=0.001)
    args = parser.parse_args()
    if not math.isfinite(args.target) or args.target < 0:
        raise SystemExit("targetは有限の0以上にしてください")
    if not math.isfinite(args.tolerance) or args.tolerance < 0:
        raise SystemExit("toleranceは有限の0以上にしてください")
    shots = json.loads(Path(args.input).read_text(encoding="utf-8")) if args.input else DEMO
    errors, end = validate(shots, args.target, args.tolerance)
    print(json.dumps({"valid": not errors, "end_seconds": end, "errors": errors}, ensure_ascii=False, indent=2))
    raise SystemExit(1 if errors else 0)


if __name__ == "__main__":
    main()

import argparse
from pathlib import Path


def main():
    parser = argparse.ArgumentParser(description="縦型動画用セーフゾーンSVGを生成")
    parser.add_argument("--output", default="vertical-safe-zone.svg")
    parser.add_argument("--width", type=int, default=1080)
    parser.add_argument("--height", type=int, default=1920)
    parser.add_argument("--top", type=int, default=180, help="例示マージン(px)")
    parser.add_argument("--right", type=int, default=180, help="例示マージン(px)")
    parser.add_argument("--bottom", type=int, default=320, help="例示マージン(px)")
    parser.add_argument("--left", type=int, default=100, help="例示マージン(px)")
    args = parser.parse_args()
    if min(args.width, args.height, args.top, args.right, args.bottom, args.left) < 0:
        raise SystemExit("寸法は0以上にしてください")
    safe_w = args.width - args.left - args.right
    safe_h = args.height - args.top - args.bottom
    if safe_w <= 0 or safe_h <= 0:
        raise SystemExit("マージンがキャンバスを超えています")
    svg = f'''<svg xmlns="http://www.w3.org/2000/svg" width="{args.width}" height="{args.height}" viewBox="0 0 {args.width} {args.height}">
  <rect width="100%" height="100%" fill="#161922"/>
  <rect x="{args.left}" y="{args.top}" width="{safe_w}" height="{safe_h}" fill="#42d392" fill-opacity=".14" stroke="#42d392" stroke-width="6" stroke-dasharray="20 12"/>
  <text x="{args.width / 2}" y="{args.top + 70}" text-anchor="middle" fill="white" font-family="sans-serif" font-size="40">SAFE ZONE（例）</text>
  <text x="{args.width / 2}" y="{args.height - 80}" text-anchor="middle" fill="#aab2c8" font-family="sans-serif" font-size="28">投稿画面で実機確認してください</text>
</svg>'''
    output = Path(args.output)
    if output.exists():
        raise SystemExit(f"出力済みです: {output}")
    output.write_text(svg, encoding="utf-8")
    print(f"created: {output.resolve()} ({safe_w}x{safe_h} safe area)")


if __name__ == "__main__":
    main()

import argparse
import json
from pathlib import Path


DEMO = {
    "subject": "白い机で試作品を手に取る人物",
    "action": "試作品をカメラへゆっくり近づける",
    "camera": "胸元から上、カメラ固定",
    "lighting": "柔らかい窓光、自然な肌色",
    "duration_seconds": 5,
    "constraints": ["縦9:16", "文字を生成しない", "指や製品形状を崩さない"],
}


def compose(data):
    required = ["subject", "action", "camera", "lighting", "duration_seconds"]
    missing = [key for key in required if key not in data]
    if missing:
        raise ValueError("不足項目: " + ", ".join(missing))
    constraints = "、".join(data.get("constraints", [])) or "なし"
    return (
        f"被写体: {data['subject']}\n動作: {data['action']}\n"
        f"カメラ: {data['camera']}\n照明: {data['lighting']}\n"
        f"尺: {data['duration_seconds']}秒\n制約: {constraints}\n"
        "一貫した被写体と自然な時間変化を保ち、1カットの動画として生成する。"
    )


def main():
    parser = argparse.ArgumentParser(description="ショット設計JSONから生成用プロンプトを組み立てる")
    parser.add_argument("--input", help="ショットJSON。省略時はデモ")
    parser.add_argument("--output", help="指定時のみテキスト保存")
    args = parser.parse_args()
    data = json.loads(Path(args.input).read_text(encoding="utf-8")) if args.input else DEMO
    prompt = compose(data)
    if args.output:
        output = Path(args.output)
        if output.exists():
            raise SystemExit(f"出力済みです: {output}")
        output.write_text(prompt + "\n", encoding="utf-8")
        print(f"created: {output.resolve()}")
    else:
        print(prompt)


if __name__ == "__main__":
    main()

import argparse
import csv
import io
import json
from pathlib import Path


DEMO = "layer,start_frame,end_frame\nbackground_blur,0,449\nsubject_cutout,0,449\n"


def read_rows(path):
    text = Path(path).read_text(encoding="utf-8-sig") if path else DEMO
    return list(csv.DictReader(io.StringIO(text)))


def main():
    parser = argparse.ArgumentParser(description="背景ぼかし層と前景層の同期を検査")
    parser.add_argument("--input", help="layer,start_frame,end_frame のCSV")
    parser.add_argument("--tolerance", type=int, default=0, help="許容フレーム差")
    args = parser.parse_args()
    if args.tolerance < 0:
        raise SystemExit("許容差は0以上にしてください")
    rows = read_rows(args.input)
    if len(rows) < 2:
        raise SystemExit("比較には2レイヤー以上必要です")
    parsed = []
    for row in rows:
        start, end = int(row["start_frame"]), int(row["end_frame"])
        if start < 0 or end < start:
            raise SystemExit(f"不正なフレーム範囲: {row['layer']}")
        parsed.append({"layer": row["layer"], "start": start, "end": end})
    base = parsed[0]
    mismatches = [
        item["layer"] for item in parsed[1:]
        if abs(item["start"] - base["start"]) > args.tolerance
        or abs(item["end"] - base["end"]) > args.tolerance
    ]
    print(json.dumps({"synced": not mismatches, "reference": base["layer"], "mismatches": mismatches}, ensure_ascii=False, indent=2))
    raise SystemExit(1 if mismatches else 0)


if __name__ == "__main__":
    main()

import argparse
import json
import math
from pathlib import Path


def main():
    parser = argparse.ArgumentParser(description="文字を人物の背後へ置くための編集設計書を生成")
    parser.add_argument("--output", default="text-behind-layer-plan.json")
    parser.add_argument("--media", default="source.mp4", help="参照名。メディアは変更しません")
    parser.add_argument("--text", default="新しい視点")
    parser.add_argument("--start", type=float, default=1.0)
    parser.add_argument("--end", type=float, default=4.0)
    args = parser.parse_args()
    if not math.isfinite(args.start) or not math.isfinite(args.end):
        raise SystemExit("startとendは有限値にしてください")
    if args.start < 0 or args.end <= args.start:
        raise SystemExit("start >= 0 かつ end > start にしてください")
    output = Path(args.output)
    if output.exists():
        raise SystemExit(f"出力済みです: {output}")
    plan = {
        "format": "local-editing-plan-v1",
        "warning": "CapCutへ直接読み込む形式ではありません。手作業の配置確認用です。",
        "source_media_reference": args.media,
        "time_range_seconds": {"start": args.start, "end": args.end},
        "layers_bottom_to_top": [
            {"track": 1, "role": "background", "content": args.media},
            {"track": 2, "role": "title", "content": args.text},
            {"track": 3, "role": "subject_cutout", "content": args.media},
        ],
        "checks": ["上下クリップの同期", "輪郭の欠け", "文字の可読性", "第三者素材の権利"],
    }
    output.write_text(json.dumps(plan, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(f"created: {output.resolve()}")


if __name__ == "__main__":
    main()

import argparse
import csv
import io
from pathlib import Path


DEMO = "frame,x,y,width,height\n0,0.30,0.20,0.25,0.30\n10,0.40,0.25,0.25,0.30\n"
FIELDS = ["frame", "x", "y", "width", "height"]


def load(path):
    text = Path(path).read_text(encoding="utf-8-sig") if path else DEMO
    rows = [{"frame": int(r["frame"]), **{k: float(r[k]) for k in FIELDS[1:]}} for r in csv.DictReader(io.StringIO(text))]
    if len(rows) < 2 or any(row["frame"] < 0 for row in rows) or any(rows[i]["frame"] >= rows[i + 1]["frame"] for i in range(len(rows) - 1)):
        raise ValueError("フレーム昇順のキーフレームを2件以上指定してください")
    for row in rows:
        if row["width"] <= 0 or row["height"] <= 0:
            raise ValueError(f"widthとheightは0より大きくしてください: frame {row['frame']}")
        if any(not 0 <= row[k] <= 1 for k in FIELDS[1:]) or row["x"] + row["width"] > 1 or row["y"] + row["height"] > 1:
            raise ValueError(f"0〜1の画面範囲を超えています: frame {row['frame']}")
    return rows


def interpolate(a, b, frame):
    ratio = (frame - a["frame"]) / (b["frame"] - a["frame"])
    return {"frame": frame, **{k: a[k] + (b[k] - a[k]) * ratio for k in FIELDS[1:]}}


def main():
    parser = argparse.ArgumentParser(description="矩形マスクのキーフレーム間を線形補間")
    parser.add_argument("--input", help="frame,x,y,width,height CSV")
    parser.add_argument("--output", default="mask-frames.csv")
    args = parser.parse_args()
    try:
        keys = load(args.input)
    except (ValueError, KeyError) as error:
        raise SystemExit(str(error)) from error
    output = Path(args.output)
    if output.exists():
        raise SystemExit(f"出力済みです: {output}")
    frames = []
    for index in range(len(keys) - 1):
        frames.extend(interpolate(keys[index], keys[index + 1], f) for f in range(keys[index]["frame"], keys[index + 1]["frame"]))
    frames.append(keys[-1])
    with output.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=FIELDS)
        writer.writeheader(); writer.writerows(frames)
    print(f"created: {output.resolve()} ({len(frames)} frames)")


if __name__ == "__main__":
    main()

import argparse
import json
import shutil
import subprocess


def tool_status():
    return {name: shutil.which(name) for name in ("ffprobe", "ffmpeg")}


def probe(path):
    command = [
        "ffprobe", "-v", "error", "-show_entries",
        "format=duration,format_name:stream=index,codec_type,codec_name,width,height,r_frame_rate",
        "-of", "json", path,
    ]
    return json.loads(subprocess.run(command, check=True, capture_output=True, text=True, encoding="utf-8").stdout)


PROFILES = {
    "master": {"width": 1080, "height": 1920, "fps": "30/1", "label": "制作マスターの内部QC例"},
    "post-720": {"width": 720, "height": 1280, "fps": "30/1", "label": "投稿用軽量版の内部QC例"},
}


def summarize(data, profile_name):
    video = next((s for s in data.get("streams", []) if s.get("codec_type") == "video"), None)
    audio = next((s for s in data.get("streams", []) if s.get("codec_type") == "audio"), None)
    profile = PROFILES[profile_name]
    duration = float(data.get("format", {}).get("duration", 0))
    format_names = data.get("format", {}).get("format_name", "").split(",")
    return {
        "qc_scope": profile["label"],
        "duration_seconds": duration,
        "container_reported": format_names,
        "video": video,
        "audio": audio,
        "checks": {
            "video_size": bool(video and video.get("width") == profile["width"] and video.get("height") == profile["height"]),
            "video_fps": bool(video and video.get("r_frame_rate") == profile["fps"]),
            "video_codec_h264": bool(video and video.get("codec_name") == "h264"),
            "audio_codec_aac": bool(audio and audio.get("codec_name") == "aac"),
            "duration_15s_example": abs(duration - 15.0) <= 0.05,
            "container_includes_mp4": "mp4" in format_names,
        },
        "caution": "内部制作基準との比較です。X公式仕様への適合や投稿成功を保証しません。",
    }


def main():
    parser = argparse.ArgumentParser(description="ffprobeで動画情報を読み取り、内部制作プロファイルと比較")
    parser.add_argument("input", nargs="?", help="検査する動画。省略時はツール確認だけ")
    parser.add_argument("--profile", choices=PROFILES, default="master")
    parser.add_argument("--print-convert-command", action="store_true")
    args = parser.parse_args()
    tools = tool_status()
    if not args.input:
        print(json.dumps({"tools": tools, "profiles": PROFILES, "note": "内部QC例であり、X公式合格・投稿保証ではありません"}, ensure_ascii=False, indent=2)); return
    if not tools["ffprobe"]:
        raise SystemExit("ffprobeが見つかりません。FFmpegをインストールしてPATHを通してください")
    print(json.dumps(summarize(probe(args.input), args.profile), ensure_ascii=False, indent=2))
    if args.print_convert_command:
        size = "1080:1920" if args.profile == "master" else "720:1280"
        print(f'ffmpeg -n -i INPUT -vf "scale={size}:force_original_aspect_ratio=decrease,pad={size}:-1:-1" -r 30 -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart OUTPUT.mp4')
        print("INPUTとOUTPUT.mp4を実際のパスへ置換してください。-nは既存出力を上書きしません。")


if __name__ == "__main__":
    main()

import argparse
import csv
import io
import json
from pathlib import Path


DEMO = "variant,impressions,views,completed,engagements\nA,1000,420,180,35\nB,800,400,220,42\n"


def divide(numerator, denominator):
    return None if denominator == 0 else numerator / denominator


def main():
    parser = argparse.ArgumentParser(description="動画案ごとの指標を同じ分母で比較")
    parser.add_argument("--input", help="variant,impressions,views,completed,engagements CSV")
    args = parser.parse_args()
    text = Path(args.input).read_text(encoding="utf-8-sig") if args.input else DEMO
    results = []
    for row in csv.DictReader(io.StringIO(text)):
        values = {key: int(row[key]) for key in ("impressions", "views", "completed", "engagements")}
        if any(value < 0 for value in values.values()):
            raise SystemExit(f"負数は扱えません: {row['variant']}")
        if values["completed"] > values["views"]:
            raise SystemExit(f"完了数が再生開始イベント数を超えています: {row['variant']}")
        results.append({
            "variant": row["variant"],
            "view_rate": divide(values["views"], values["impressions"]),
            "completion_rate": divide(values["completed"], values["views"]),
            "engagement_rate": divide(values["engagements"], values["impressions"]),
            "raw": values,
        })
    print(json.dumps({"definitions": {
        "views": "このCSVで定義・収集した再生開始イベント数。プラットフォームの公開view数と同一とは限らない",
        "view_rate": "再生開始イベント数 / impressions",
        "completion_rate": "completed / views",
        "engagement_rate": "engagements / impressions",
        "zero_denominator": "null",
    }, "results": results, "caution": "差は因果関係や推薦アルゴリズムを保証しません"}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

import argparse
import json
import math


def nonnegative(value):
    number = float(value)
    if not math.isfinite(number) or number < 0:
        raise argparse.ArgumentTypeError("有限の0以上を指定してください")
    return number


def main():
    parser = argparse.ArgumentParser(description="動画制作費の例示試算")
    parser.add_argument("--planning-hours", type=nonnegative, default=1.5)
    parser.add_argument("--production-hours", type=nonnegative, default=3.0)
    parser.add_argument("--review-hours", type=nonnegative, default=1.0)
    parser.add_argument("--hourly-rate", type=nonnegative, default=5000)
    parser.add_argument("--tool-expenses", type=nonnegative, default=1200)
    parser.add_argument("--other-expenses", type=nonnegative, default=0)
    parser.add_argument("--contingency-percent", type=nonnegative, default=10)
    args = parser.parse_args()
    hours = args.planning_hours + args.production_hours + args.review_hours
    labor = hours * args.hourly_rate
    direct = args.tool_expenses + args.other_expenses
    subtotal = labor + direct
    contingency = subtotal * args.contingency_percent / 100
    if not all(math.isfinite(value) for value in (hours, labor, direct, subtotal, contingency, subtotal + contingency)):
        raise SystemExit("計算結果が有限範囲を超えました。入力値を小さくしてください")
    result = {
        "currency": "JPY",
        "inputs_are_illustrative": True,
        "hours": hours,
        "labor": round(labor),
        "direct_expenses": round(direct),
        "contingency": round(contingency),
        "estimated_total": round(subtotal + contingency),
        "note": "見積判断の補助例です。税務・会計・法務上の助言ではありません。権利許諾費は案件ごとに確認してください。",
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()