Tutor Math Geometry

#!/usr/bin/env python3
"""
Tutor 技能项目初始化脚本

功能：
1. 检查依赖环境（uv, manim, edge-tts等）
2. 创建项目目录结构
3. 拷贝脚手架模板
4. 生成示例CSV文件

使用：
    python init.py [项目目录]

默认在当前目录创建项目结构。
"""

import os
import sys
import shutil
import subprocess
from pathlib import Path


# ========== 配置 ==========
SKILL_DIR = Path(__file__).parent.resolve()
TEMPLATES_DIR = SKILL_DIR / "templates"
SCRIPTS_DIR = SKILL_DIR / "scripts"

# 依赖检查配置
DEPENDENCIES = {
    "uv": {
        "check": ["uv", "--version"],
        "install_hint": "curl -LsSf https://astral.sh/uv/install.sh | sh",
        "required": True,
    },
    "manim": {
        "check": ["manim", "--version"],
        "install_hint": "uv pip install manim",
        "required": True,
    },
    "edge-tts": {
        "check": ["edge-tts", "--version"],
        "install_hint": "uv pip install edge-tts",
        "required": True,
    },
    "ffmpeg": {
        "check": ["ffmpeg", "-version"],
        "install_hint": "brew install ffmpeg (macOS) 或 apt install ffmpeg (Linux)",
        "required": False,  # 可选但推荐
    },
}

# 项目目录结构
PROJECT_STRUCTURE = {
    "audio": "音频文件目录",
    "media": "Manim渲染输出",
    "assets": "静态资源",
}


# ========== 颜色输出 ==========
class Colors:
    GREEN = "\033[92m"
    YELLOW = "\033[93m"
    RED = "\033[91m"
    BLUE = "\033[94m"
    RESET = "\033[0m"


def ok(msg):
    print(f"{Colors.GREEN}✓{Colors.RESET} {msg}")


def warn(msg):
    print(f"{Colors.YELLOW}⚠{Colors.RESET} {msg}")


def error(msg):
    print(f"{Colors.RED}✗{Colors.RESET} {msg}")


def info(msg):
    print(f"{Colors.BLUE}ℹ{Colors.RESET} {msg}")


# ========== 依赖检查 ==========
def check_dependency(name, config):
    """检查单个依赖"""
    try:
        result = subprocess.run(
            config["check"],
            capture_output=True,
            check=False,
        )
        if result.returncode == 0:
            version = result.stdout.decode().strip().split('\n')[0][:50]
            ok(f"{name}: {version}")
            return True
    except FileNotFoundError:
        pass

    if config["required"]:
        error(f"{name}: 未安装 (必需)")
        info(f"  安装: {config['install_hint']}")
    else:
        warn(f"{name}: 未安装 (可选)")
        info(f"  安装: {config['install_hint']}")

    return not config["required"]


def check_all_dependencies():
    """检查所有依赖"""
    print("=" * 50)
    print("检查依赖环境")
    print("=" * 50)

    all_ok = True
    for name, config in DEPENDENCIES.items():
        if not check_dependency(name, config):
            all_ok = False

    print()
    return all_ok


# ========== 项目初始化 ==========
def create_directory_structure(project_dir):
    """创建项目目录结构"""
    print("=" * 50)
    print("创建项目目录")
    print("=" * 50)

    project_path = Path(project_dir)
    project_path.mkdir(parents=True, exist_ok=True)

    for dirname, description in PROJECT_STRUCTURE.items():
        dirpath = project_path / dirname
        dirpath.mkdir(exist_ok=True)
        ok(f"{dirname}/ - {description}")

    print()


def copy_templates(project_dir):
    """拷贝脚手架模板"""
    print("=" * 50)
    print("拷贝模板文件")
    print("=" * 50)

    project_path = Path(project_dir)

    # 拷贝 script_scaffold.py
    scaffold_src = TEMPLATES_DIR / "script_scaffold.py"
    scaffold_dst = project_path / "script.py"

    if scaffold_src.exists():
        shutil.copy2(scaffold_src, scaffold_dst)
        ok(f"script.py - 脚手架模板 (从 script_scaffold.py)")
        info("  提示: 根据分镜实现 TODO 部分")
    else:
        error(f"模板不存在: {scaffold_src}")

    # 拷贝 script_example.py 作为参考
    example_src = TEMPLATES_DIR / "script_example.py"
    example_dst = project_path / "script_example.py"

    if example_src.exists():
        shutil.copy2(example_src, example_dst)
        ok(f"script_example.py - 完整示例 (参考用)")
    else:
        warn("script_example.py 模板不存在")

    print()


def generate_csv_template(project_dir):
    """生成示例CSV文件"""
    print("=" * 50)
    print("生成音频列表模板")
    print("=" * 50)

    project_path = Path(project_dir)
    csv_path = project_path / "audio_list.csv"

    csv_content = """filename,text
audio_001_开场.wav,"大家好！今天我们来学习三角形内角和定理。"
audio_002_画三角形.wav,"首先，让我们画一个任意三角形。"
audio_003_标角度.wav,"标记三角形的三个内角。"
audio_004_画平行线.wav,"过顶点作底边的平行线。"
audio_005_证明.wav,"利用平行线性质进行证明。"
audio_006_总结.wav,"总结：三角形内角和等于180度。"
"""

    if not csv_path.exists():
        csv_path.write_text(csv_content, encoding='utf-8')
        ok(f"audio_list.csv - 音频列表模板")
        info("  使用: python {}/scripts/generate_tts.py audio_list.csv ./audio".format(SKILL_DIR))
    else:
        warn("audio_list.csv 已存在，跳过")

    print()


def generate_gitignore(project_dir):
    """生成 .gitignore 文件"""
    project_path = Path(project_dir)
    gitignore_path = project_path / ".gitignore"

    if not gitignore_path.exists():
        content = """# Manim
media/
__pycache__/
*.pyc

# Audio
audio/*.wav
audio/*.mp3
!audio/audio_info.json

# Video
*.mp4
*.mov

# Temp
.DS_Store
*.log
"""
        gitignore_path.write_text(content)
        ok(".gitignore")


# ========== 主流程 ==========
def main():
    # 解析参数
    project_dir = sys.argv[1] if len(sys.argv) > 1 else "."

    print("\n" + "=" * 50)
    print("Tutor 技能 - 项目初始化")
    print("=" * 50)
    print(f"项目目录: {Path(project_dir).resolve()}")
    print(f"技能目录: {SKILL_DIR}")
    print()

    # 1. 检查依赖
    if not check_all_dependencies():
        print("=" * 50)
        error("依赖检查失败，请先安装必需依赖")
        print()
        print("快速安装:")
        print("  uv pip install manim edge-tts mutagen")
        sys.exit(1)

    # 2. 创建目录结构
    create_directory_structure(project_dir)

    # 3. 拷贝模板
    copy_templates(project_dir)

    # 4. 生成CSV
    generate_csv_template(project_dir)

    # 5. 生成gitignore
    generate_gitignore(project_dir)

    # 完成
    print("=" * 50)
    ok("项目初始化完成！")
    print("=" * 50)
    print()
    print("下一步:")
    print("  1. 编辑 audio_list.csv 填写对白")
    print("  2. 生成音频: python {}/scripts/generate_tts.py audio_list.csv ./audio".format(SKILL_DIR))
    print("  3. 编辑 script.py 实现动画")
    print("  4. 渲染视频: manim -pqh script.py MathScene")
    print()


if __name__ == "__main__":
    main()

# Tutor 技能依赖
# 使用 uv 管理依赖: uv pip install -r requirements.txt

# 核心依赖
manim>=0.18.0
numpy>=1.24.0

# TTS 依赖
edge-tts>=6.1.0

# 音频处理
mutagen>=1.47.0

# 工具库
pillow>=10.0.0

file '../audio/audio_001_开场.mp3'
file '../audio/audio_002_展示完整图形.mp3'
file '../audio/audio_003_切线长定理.mp3'
file '../audio/audio_004_双曲线性质推导.mp3'
file '../audio/audio_005_蒙日定理应用.mp3'
file '../audio/audio_006_总结.mp3'

#!/usr/bin/env python3
"""
使用 Edge TTS 从分镜脚本生成配音文件

用法:
    python generate_edge_tts.py <分镜脚本.md> [输出目录] [--voice VOICE]

示例:
    python generate_edge_tts.py 几何_20260128_正方形面积问题_分镜.md ./audio
    python generate_edge_tts.py 分镜.md ./audio --voice zh-CN-YunjianNeural
"""

import asyncio
import edge_tts
import re
import os
import sys
import argparse
import json
from pathlib import Path
from typing import List, Dict, Optional

try:
    import miniaudio
    HAS_MINIAUDIO = True
except ImportError:
    HAS_MINIAUDIO = False

# Edge TTS 支持的中文语音
VOICES = {
    'xiaoxiao': 'zh-CN-XiaoxiaoNeural',      # 女声，温暖（默认）
    'xiaoyi': 'zh-CN-XiaoyiNeural',          # 女声，清脆
    'yunjian': 'zh-CN-YunjianNeural',        # 男声，沉稳
    'yunxi': 'zh-CN-YunxiNeural',            # 男声，温和
    'yunxia': 'zh-CN-YunxiaNeural',          # 男声，活力
    'yunyang': 'zh-CN-YunyangNeural',        # 男声，专业
}

DEFAULT_VOICE = 'zh-CN-XiaoxiaoNeural'


def get_audio_duration(audio_path: str) -> float:
    """
    获取音频文件的时长（秒）

    参数:
        audio_path: 音频文件路径

    返回:
        时长（秒）
    """
    try:
        if HAS_MINIAUDIO:
            info = miniaudio.get_file_info(audio_path)
            return info.duration
        else:
            # 使用 ffprobe 或 fallback
            import subprocess
            result = subprocess.run(
                ['ffprobe', '-v', 'error', '-show_entries', 'format=duration',
                 '-of', 'default=noprint_wrappers=1:nokey=1', audio_path],
                capture_output=True, text=True
            )
            if result.returncode == 0:
                return float(result.stdout.strip())
    except Exception as e:
        print(f"  警告: 无法获取音频时长: {e}")
    return 0.0


def parse_storyboard(md_content: str):
    """解析分镜脚本，提取读白"""
    scenes = []
    num_map = {'一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10}

    lines = md_content.split('\n')
    current_scene = None
    in_voiceover = False
    voiceover_lines = []

    for line in lines:
        if line.startswith('###') and '第' in line and '幕' in line and '（' in line and '秒）' in line:
            if current_scene and current_scene.get('voiceover'):
                scenes.append(current_scene)

            num_char = ''
            for c in line:
                if c in num_map:
                    num_char = c
                    break

            idx_mu = line.find('幕')
            idx_bracket = line.find('（')
            if idx_mu > 0 and idx_bracket > idx_mu:
                title = line[idx_mu+1:idx_bracket].strip()
                if ':' in title:
                    title = title[1:]
                if '：' in title:
                    title = title[1:]

                idx_end = line.find('秒）')
                duration = line[idx_bracket+1:idx_end] if idx_end > 0 else '0'

                current_scene = {
                    "scene_num": num_map.get(num_char, len(scenes) + 1),
                    "title": title.strip(),
                    "duration": f"{duration}秒",
                    "voiceover": ""
                }
                in_voiceover = False
                voiceover_lines = []
                continue

        if current_scene and '**读白**' in line:
            in_voiceover = True
            if ':' in line or '：' in line:
                content_part = line.split(':', 1)[-1].split('：', 1)[-1].strip()
                if content_part and content_part.startswith('"') and content_part.endswith('"'):
                    content_part = content_part[1:-1]
                if content_part and not content_part.startswith('-') and not content_part.startswith('示例'):
                    voiceover_lines = [content_part]
            continue

        if in_voiceover and current_scene:
            if line.startswith('**') and '读白' not in line:
                in_voiceover = False
                if voiceover_lines:
                    current_scene['voiceover'] = ' '.join(voiceover_lines).strip()
                continue

            if line.strip() and not line.strip().startswith('示例') and not line.strip().startswith('-'):
                voiceover_lines.append(line.strip())

        if current_scene and '**情感**' in line:
            if ':' in line or '：' in line:
                content_part = line.split(':', 1)[-1].split('：', 1)[-1].strip()
                if content_part and not content_part.startswith('-'):
                    current_scene['emotion'] = content_part.split('/')[0].strip()

    if current_scene and current_scene.get('voiceover'):
        scenes.append(current_scene)

    return scenes


async def generate_audio(text: str, output_file: str, voice: str = DEFAULT_VOICE):
    """使用 Edge TTS 生成音频"""
    communicate = edge_tts.Communicate(text, voice)
    await communicate.save(output_file)
    return output_file


async def main():
    parser = argparse.ArgumentParser(
        description='从分镜脚本生成 Edge TTS 配音音频',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  # 使用默认语音（Xiaoxiao 女声）
  python generate_edge_tts.py 分镜.md ./audio

  # 使用 Yunjian 男声
  python generate_edge_tts.py 分镜.md ./audio --voice yunjian

可用语音:
  xiaoxiao  - 女声，温暖（默认）
  xiaoyi    - 女声，清脆
  yunjian   - 男声，沉稳
  yunxi     - 男声，温和
  yunxia    - 男声，活力
  yunyang   - 男声，专业
        """
    )

    parser.add_argument('storyboard', help='分镜脚本 Markdown 文件路径')
    parser.add_argument('output_dir', nargs='?', default='./audio', help='音频输出目录（默认：./audio）')
    parser.add_argument('--voice', default='xiaoxiao', choices=list(VOICES.keys()),
                       help='语音选择（默认：xiaoxiao）')
    parser.add_argument('--yes', action='store_true', help='跳过确认直接生成')

    args = parser.parse_args()

    # 检查分镜文件
    storyboard_path = Path(args.storyboard)
    if not storyboard_path.exists():
        print(f"错误: 分镜文件不存在: {storyboard_path}")
        sys.exit(1)

    # 读取分镜内容
    print(f"读取分镜脚本: {storyboard_path}")
    with open(storyboard_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # 解析分镜
    print("解析分镜脚本...")
    scenes = parse_storyboard(content)
    print(f"找到 {len(scenes)} 个场景\n")

    if not scenes:
        print("错误: 未找到任何场景（请检查分镜脚本格式）")
        sys.exit(1)

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

    # 获取语音
    voice = VOICES.get(args.voice, DEFAULT_VOICE)

    # 显示场景列表
    print("场景列表:")
    for scene in scenes:
        print(f"  场景 {scene['scene_num']}: {scene['title']}")
        print(f"    读白: {scene['voiceover'][:50]}...")
        print()

    # 确认
    if not args.yes:
        response = input(f"是否继续生成音频? (使用语音: {args.voice}) (y/n): ").strip().lower()
        if response != 'y':
            print("已取消")
            sys.exit(0)

    # 生成所有场景的音频
    print(f"\n开始生成音频 (使用 Edge TTS - {voice})...\n")

    generated_files = []
    scenes_with_duration = []

    for scene in scenes:
        num = scene['scene_num']
        title = scene['title']
        voiceover = scene['voiceover']

        if not voiceover:
            print(f"跳过场景 {num}: 无读白内容")
            continue

        filename = f"audio_{num:03d}_{title}.mp3"
        output_path = output_dir / filename

        print(f"生成场景 {num}: {title}")
        try:
            await generate_audio(voiceover, str(output_path), voice)
            file_size = output_path.stat().st_size / 1024

            # 获取音频时长
            duration = get_audio_duration(str(output_path))
            scene['duration'] = duration
            scenes_with_duration.append(scene)

            print(f"  ✓ 已生成: {filename} ({file_size:.1f} KB, {duration:.2f}秒)")
            generated_files.append(output_path)
        except Exception as e:
            print(f"  ✗ 错误: {e}")

    # 生成清单文件（包含时长）
    manifest_path = output_dir / "audio_manifest.json"
    manifest = {
        "total_scenes": len(scenes_with_duration),
        "voice": voice,
        "scenes": [
            {
                "scene_num": s['scene_num'],
                "title": s['title'],
                "voiceover": s['voiceover'],
                "duration": s.get('duration', 0),
                "audio_file": f"audio_{s['scene_num']:03d}_{s['title']}.mp3"
            }
            for s in scenes_with_duration
        ]
    }
    with open(manifest_path, 'w', encoding='utf-8') as f:
        json.dump(manifest, f, ensure_ascii=False, indent=2)

    # 生成时间轴文件（用于Manim生成）
    timeline_path = output_dir / "timeline.json"
    timeline = {
        "total_duration": sum(s.get('duration', 0) for s in scenes_with_duration),
        "scenes": [
            {
                "index": i + 1,
                "scene_num": s['scene_num'],
                "title": s['title'],
                "duration": s.get('duration', 0),
                "audio_file": f"audio_{s['scene_num']:03d}_{s['title']}.mp3",
                "voiceover": s['voiceover'][:100] + "..." if len(s['voiceover']) > 100 else s['voiceover']
            }
            for i, s in enumerate(scenes_with_duration)
        ]
    }
    with open(timeline_path, 'w', encoding='utf-8') as f:
        json.dump(timeline, f, ensure_ascii=False, indent=2)

    print(f"\n{'='*60}")
    print(f"音频生成完成！")
    print(f"生成文件数: {len(generated_files)}/{len(scenes)}")
    print(f"总时长: {timeline['total_duration']:.2f}秒")
    print(f"输出目录: {output_dir}")
    print(f"语音: {voice}")
    print(f"\n生成的文件:")
    for f in sorted(generated_files):
        size_kb = f.stat().st_size / 1024
        print(f"  - {f.name} ({size_kb:.1f} KB)")
    print(f"\n音频清单: {manifest_path}")
    print(f"时间轴文件: {timeline_path}")
    print(f"{'='*60}")
    print("\n✅ 音频时长已自动记录，可直接用于生成Manim代码")


if __name__ == "__main__":
    asyncio.run(main())

#!/bin/bash
# 一键渲染脚本 - 音频驱动画面同步
# 流程: 生成音频 → 记录时长 → 渲染视频(根据时长) → 合并音视频

set -e

echo "=========================================="
echo "  Manim 视频渲染 - 音频驱动版"
echo "=========================================="
echo ""
echo "🎬 本脚本将根据实际音频时长自动同步画面"
echo ""

# 检查参数
if [ "$1" == "--help" ] || [ "$1" == "-h" ]; then
    echo "用法: ./render.sh [选项]"
    echo ""
    echo "选项:"
    echo "  --audio       重新生成音频并渲染（默认）"
    echo "  --skip-audio  使用现有音频，仅重新渲染视频"
    echo "  --clean       清理环境并重新创建"
    echo "  --help        显示此帮助"
    echo ""
    echo "流程:"
    echo "  1. 生成 TTS 音频"
    echo "  2. 记录每段音频实际时长 → audio/timeline.json"
    echo "  3. 渲染视频（画面自动等待对应音频时长）"
    echo "  4. 合并音视频 → final_video.mp4"
    exit 0
fi

# 检查 uv
if ! command -v uv &> /dev/null; then
    echo "❌ 错误: 未找到 uv"
    echo ""
    echo "请安装 uv:"
    echo "  macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh"
    echo "  或访问: https://github.com/astral-sh/uv"
    exit 1
fi

# 检查 ffmpeg
if ! command -v ffmpeg &> /dev/null; then
    echo "❌ 错误: 未找到 ffmpeg"
    echo "请安装: brew install ffmpeg (macOS) 或 apt install ffmpeg (Linux)"
    exit 1
fi

# 设置环境
VENV_DIR=".venv"

# 清理环境
if [ "$1" == "--clean" ]; then
    echo "🧹 清理环境..."
    rm -rf "$VENV_DIR" media/ final_video.mp4
    echo "✅ 环境已清理"
    echo ""
fi

# 创建虚拟环境
if [ ! -d "$VENV_DIR" ]; then
    echo "📦 创建虚拟环境..."
    uv venv "$VENV_DIR"
    echo "✅ 虚拟环境已创建"
    echo ""
fi

# 安装依赖
echo "📦 安装依赖..."
if [ -f "requirements.txt" ]; then
    echo "   使用 requirements.txt"
    uv pip install --python "$VENV_DIR/bin/python" -r requirements.txt -q
else
    echo "   使用默认依赖"
    uv pip install --python "$VENV_DIR/bin/python" manim edge-tts -q
fi
echo "✅ 依赖安装完成"
echo ""

PYTHON="$VENV_DIR/bin/python"
MANIM="$VENV_DIR/bin/manim"

# 步骤 1: 生成音频
generate_audio() {
    echo "📢 步骤 1: 生成 TTS 音频"
    echo "----------------------------------------"

    # 查找分镜文件
    STORYBOARD=$(ls *.md 2>/dev/null | grep -E "(分镜|storyboard)" | head -1)
    if [ -z "$STORYBOARD" ]; then
        STORYBOARD=$(ls *.md 2>/dev/null | head -1)
    fi

    if [ -z "$STORYBOARD" ]; then
        echo "❌ 错误: 未找到分镜脚本 (.md 文件)"
        exit 1
    fi

    echo "使用分镜: $STORYBOARD"
    echo ""

    # 生成音频（会自动创建 audio/timeline.json）
    "$PYTHON" generate_edge_tts.py "$STORYBOARD" ./audio --yes

    if [ ! -f "audio/timeline.json" ]; then
        echo "❌ 错误: timeline.json 未生成"
        exit 1
    fi

    echo ""
    echo "✅ 音频生成完成，时长已记录"
    echo ""
}

# 步骤 2: 渲染视频
render_video() {
    echo "🎬 步骤 2: 渲染视频（音频驱动）"
    echo "----------------------------------------"

    # 确定场景文件
    SCENE_NAME="GeometryProof"
    if [ -f "scene.py" ]; then
        SCENE_FILE="scene.py"
    else
        echo "❌ 错误: 未找到 scene.py"
        exit 1
    fi

    echo "场景: $SCENE_FILE - $SCENE_NAME"
    echo "分辨率: 1080x1920 (竖屏)"
    echo ""

    # 检查 timeline.json
    if [ -f "audio/timeline.json" ]; then
        TOTAL_DURATION=$(cat audio/timeline.json | grep -o '"total_duration": [0-9.]*' | cut -d' ' -f2)
        echo "📊 音频总时长: ${TOTAL_DURATION}秒"
        echo "   (视频将自动同步各场景时长)"
        echo ""
    fi

    # 渲染高质量 MP4
    "$MANIM" -pqh --format=mp4 "$SCENE_FILE" "$SCENE_NAME"

    echo ""
    echo "✅ 视频渲染完成"
    echo ""
}

# 步骤 3: 合并音视频
merge_audio_video() {
    echo "🔧 步骤 3: 合并音视频"
    echo "----------------------------------------"

    # 查找生成的视频
    VIDEO_FILE="media/videos/scene/1920p30/GeometryProof.mp4"

    if [ ! -f "$VIDEO_FILE" ]; then
        echo "❌ 错误: 未找到视频文件"
        exit 1
    fi

    VIDEO_DURATION=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$VIDEO_FILE" 2>/dev/null | cut -d. -f1)
    echo "视频时长: ${VIDEO_DURATION}秒"

    # 合并音频
    if [ -d "audio" ] && [ "$(ls audio/audio_*.mp3 2>/dev/null | wc -l)" -gt 0 ]; then
        echo "合并音频..."

        # 创建音频列表
        AUDIO_LIST="audio_list.txt"
        echo "" > "$AUDIO_LIST"
        for f in audio/audio_*.mp3; do
            [ -f "$f" ] && echo "file '../$f'" >> "$AUDIO_LIST"
        done

        # 合并音频
        ffmpeg -f concat -safe 0 -i "$AUDIO_LIST" -c copy /tmp/combined_audio.mp3 -y 2>/dev/null || true

        if [ -f "/tmp/combined_audio.mp3" ]; then
            AUDIO_DURATION=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 /tmp/combined_audio.mp3 2>/dev/null | cut -d. -f1)
            echo "音频时长: ${AUDIO_DURATION}秒"
            echo ""

            # 合并视频和音频（取较长者）
            ffmpeg -i "$VIDEO_FILE" -i /tmp/combined_audio.mp3 -c:v copy -c:a aac \
                   -shortest final_video.mp4 -y 2>&1 | grep -E "(Duration|Output|Stream)" || true

            echo ""
            echo "✅ 已生成: final_video.mp4"

            # 验证时长
            if [ -f "final_video.mp4" ]; then
                FINAL_DURATION=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 final_video.mp4 2>/dev/null | cut -d. -f1)
                echo "   最终时长: ${FINAL_DURATION}秒"
            fi
        else
            cp "$VIDEO_FILE" final_video.mp4
            echo "⚠️  未找到音频，仅复制视频"
        fi
    else
        cp "$VIDEO_FILE" final_video.mp4
        echo "⚠️  未找到音频，仅复制视频"
    fi
}

# 执行流程
if [ "$1" != "--skip-audio" ]; then
    generate_audio
else
    echo "📢 步骤 1: 跳过音频生成"
    echo "   (使用现有 audio/timeline.json)"
    echo ""

    if [ ! -f "audio/timeline.json" ]; then
        echo "❌ 错误: audio/timeline.json 不存在"
        echo "   请先运行: ./render.sh (不带 --skip-audio)"
        exit 1
    fi
    echo ""
fi

render_video
merge_audio_video

echo ""
echo "=========================================="
echo "✅ 全部完成！"
echo "=========================================="
echo ""
echo "输出文件:"
echo "  📹 final_video.mp4     - 最终视频（含音频）"
echo "  📁 media/videos/        - 原始视频文件"
echo "  🎵 audio/               - 音频文件和时长数据"
echo "  📊 audio/timeline.json  - 音频时长记录"
echo ""
echo "💡 提示:"
echo "   - 修改分镜后重新运行 ./render.sh 即可"
echo "   - 画面会自动根据 audio/timeline.json 中的时长同步"
echo ""

# 视频生成依赖
manim>=0.20.0

# TTS 语音生成
edge-tts>=7.0.0

# 可选：音频处理（用于获取音频时长）
# miniaudio>=1.5.0

"""
第九十九题：证明四点共圆 - Manim 动画 (音频驱动版本)
根据 timeline.json 中的实际音频时长自动同步画面
"""

from manim import *
import numpy as np
import json
import os

# 配置 - 竖屏 9:16
config.background_color = "#1a1a2e"
config.frame_rate = 30
config.pixel_height = 1920
config.pixel_width = 1080
config.frame_height = 16
config.frame_width = 9

# 加载实际音频时长
def load_audio_timings():
    """从 timeline.json 加载音频时长，如果不存在则使用默认值"""
    timeline_path = "audio/timeline.json"
    if os.path.exists(timeline_path):
        with open(timeline_path, 'r', encoding='utf-8') as f:
            timeline = json.load(f)
            # 转换为秒数
            timings = {}
            for scene in timeline.get('scenes', []):
                idx = scene.get('index', 0)
                duration = scene.get('duration', 5)
                # 根据索引映射到场景名称
                scene_names = ['opening', 'show_figure', 'tangent', 'hyperbola', 'monge', 'summary']
                if idx <= len(scene_names):
                    timings[scene_names[idx-1]] = duration
            print(f"✅ 已加载音频时长: {timings}")
            return timings
    # 默认时长（当 timeline.json 不存在时使用）
    print("⚠️  未找到 timeline.json，使用默认时长")
    return {
        "opening": 11.66,
        "show_figure": 17.18,
        "tangent": 18.46,
        "hyperbola": 25.25,
        "monge": 25.22,
        "summary": 16.66
    }

AUDIO_TIMINGS = load_audio_timings()

# 颜色定义
CIRCLE_I_COLOR = "#3498db"   # 蓝色 - 内切圆 I (虚线)
CIRCLE_J_COLOR = "#e74c3c"   # 红色 - 内切圆 J (虚线)
TRIANGLE_COLOR = "#2c3e50"   # 深蓝灰 - 三角形 ABC
TRIANGLE_INNER_COLOR = "#7f8c8d"  # 灰色 - 三角形 KBC
HIGHLIGHT_COLOR = "#ffc107"  # 黄色 - 高亮
HYPERBOLA_COLOR = "#9c27b0"  # 紫色 - 双曲线
AUX_CIRCLE_COLOR = "#00bcd4" # 青色 - 辅助圆（四点共圆）
POINT_COLOR = "#000000"      # 黑色 - 点
I_POINT_COLOR = "#3498db"    # 蓝色 - 内心 I
J_POINT_COLOR = "#e74c3c"    # 红色 - 内心 J


def calculate_geometry():
    """根据 6.html 的数学模型计算所有点和圆"""

    # 缩放因子（适配竖屏 9:16）
    SCALE = 0.7

    # 1. 定义 B、C 在 x 轴上
    B = np.array([-5.0, 0.0, 0.0]) * SCALE
    C = np.array([5.0, 0.0, 0.0]) * SCALE

    # 2. 定义 A 点 (AB > AC，所以 A 在右侧)
    A = np.array([1.5, 9.0, 0.0]) * SCALE

    # 3. 计算边长
    def dist(p1, p2):
        return np.linalg.norm(p1 - p2)

    AB = dist(A, B)
    AC = dist(A, C)
    BC = dist(B, C)

    # 4. 计算 D 点（内切圆 I 在 BC 上的切点）
    # BD = (AB + BC - AC) / 2
    BD = (AB + BC - AC) / 2
    CD = BC - BD

    # D 在 BC 上，从 B 向 C 移动 BD 距离
    D = B + (BD / BC) * (C - B)

    # 5. 计算双曲线参数（K 点在双曲线上）
    # 双曲线焦点：B(-5,0), C(5,0), 中心在原点
    # 2a = |AB - AC|
    diff_ABC = abs(AB - AC)
    a_hyp = diff_ABC / 2
    c_hyp = 5.0  # 焦点到中心的距离
    b_hyp = np.sqrt(c_hyp**2 - a_hyp**2)

    # 6. 定义 K 点（在双曲线上，y < y_A，在三角形内部）
    yK = 4.5
    # x^2 = a^2 * (1 + y^2/b^2)
    xK = a_hyp * np.sqrt(1 + (yK**2) / (b_hyp**2))
    K = np.array([xK, yK, 0.0])

    # 7. 计算切点 F（在 AB 上，BF = BD）
    vec_BA = (A - B) / AB
    F = B + BD * vec_BA

    # 8. 计算切点 E（在 AC 上，CE = CD）
    vec_CA = (A - C) / AC
    E = C + CD * vec_CA

    # 9. 计算切点 M（在 KB 上，BM = BD）
    KB = dist(K, B)
    vec_BK = (K - B) / KB
    M = B + BD * vec_BK

    # 10. 计算切点 N（在 KC 上，CN = CD）
    KC = dist(K, C)
    vec_CK = (K - C) / KC
    N = C + CD * vec_CK

    # 11. 计算内心 I 和 J
    # 因为 BC 是水平的，切点在 D，所以 I 和 J 都在 x = D.x 的垂直线上
    # I.y = r_I, J.y = r_J

    # 三角形 ABC 的面积和半周长
    area_ABC = 0.5 * BC * A[1]
    s_ABC = (AB + AC + BC) / 2
    r_I = area_ABC / s_ABC

    I = np.array([D[0], r_I, 0.0])

    # 三角形 KBC 的面积和半周长
    area_KBC = 0.5 * BC * K[1]
    s_KBC = (KB + KC + BC) / 2
    r_J = area_KBC / s_KBC

    J = np.array([D[0], r_J, 0.0])

    return {
        'A': A, 'B': B, 'C': C, 'D': D, 'E': E, 'F': F,
        'K': K, 'M': M, 'N': N, 'I': I, 'J': J,
        'r_I': r_I, 'r_J': r_J,
        'AB': AB, 'AC': AC, 'BC': BC,
        'BD': BD, 'CD': CD,
        'KB': KB, 'KC': KC
    }


class GeometryProof(Scene):
    """几何证明动画 - 音频驱动，画面自动同步语音时长"""

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.scene_start_time = 0
        self.current_scene_name = ""

    def start_scene(self, scene_name):
        """开始一个场景，记录开始时间"""
        self.current_scene_name = scene_name
        self.scene_start_time = self.time
        print(f"\n▶️  场景: {scene_name} (音频时长: {AUDIO_TIMINGS.get(scene_name, 5):.2f}秒)")

    def wait_for_audio(self, animation_time=0):
        """等待直到音频播放完成

        参数:
            animation_time: 已经用于动画的时间（秒）
        """
        total_time = AUDIO_TIMINGS.get(self.current_scene_name, 5)
        remaining = total_time - animation_time
        if remaining > 0:
            print(f"   ⏱️  动画用时 {animation_time:.2f}秒, 等待 {remaining:.2f}秒")
            self.wait(remaining)
        else:
            print(f"   ⚠️  动画用时 {animation_time:.2f}秒 已超过音频时长!")

    def construct(self):
        # 计算所有几何元素
        geo = calculate_geometry()

        # ========== 第一幕：开场 ==========
        self.start_scene("opening")
        # 标题动画
        title = Text("第九十九题：证明四点共圆", font_size=52, color=WHITE)
        subtitle = Text("三角形内切圆与双曲线性质的综合运用", font_size=32, color=GRAY_B)
        subtitle.next_to(title, DOWN, buff=0.5)

        # 题目描述
        problem_text = VGroup(
            Text("已知：", font_size=28, color=GRAY_B),
            Text("△ABC 内切圆⊙I 切 BC、CA、AB 于 D、E、F", font_size=24),
            Text("K 为△ABC 内一点，△KBC 内切圆⊙J 切 BC 于 D", font_size=24),
            Text("求证：E、F、M、N 四点共圆", font_size=28, color=HIGHLIGHT_COLOR)
        ).arrange(DOWN, aligned_edge=LEFT, buff=0.4)
        problem_text.to_edge(DOWN, buff=1.5)

        self.play(Write(title), run_time=3)
        self.play(FadeIn(subtitle), run_time=2)
        self.wait(2)
        self.play(
            FadeOut(title),
            FadeOut(subtitle),
            Write(problem_text),
            run_time=4
        )
        # 等待音频完成
        self.wait_for_audio(animation_time=10)

        # 淡出问题描述
        self.play(FadeOut(problem_text), run_time=1)

        # ========== 第二幕：展示完整图形 ==========
        self.start_scene("show_figure")
        # 1. 先画三角形 ABC
        triangle = Polygon(geo['A'], geo['B'], geo['C'],
                          color=TRIANGLE_COLOR, stroke_width=2.5, fill_opacity=0.05)

        self.play(Create(triangle), run_time=2)
        self.wait(0.5)

        # 2. 显示顶点和标签
        labels_ABC = VGroup(
            Text("A", font_size=32).next_to(geo['A'], UP, buff=0.15),
            Text("B", font_size=32).next_to(geo['B'], LEFT, buff=0.15),
            Text("C", font_size=32).next_to(geo['C'], RIGHT, buff=0.15)
        )

        dots_ABC = VGroup(
            Dot(geo['A'], color=POINT_COLOR, radius=0.08),
            Dot(geo['B'], color=POINT_COLOR, radius=0.08),
            Dot(geo['C'], color=POINT_COLOR, radius=0.08)
        )

        self.play(
            FadeIn(dots_ABC),
            FadeIn(labels_ABC),
            run_time=2
        )

        # 3. 计算并显示 D 点
        D_dot = Dot(geo['D'], color=POINT_COLOR, radius=0.08)
        D_label = Text("D", font_size=32).next_to(geo['D'], DOWN, buff=0.15)

        # BD 和 CD 的长度标注
        BD_mid = (geo['B'] + geo['D']) / 2
        BD_text = Text(f"BD = {geo['BD']:.2f}", font_size=24, color=GRAY_B)
        BD_text.next_to(BD_mid, DOWN, buff=0.3)

        self.play(
            FadeIn(D_dot),
            FadeIn(D_label),
            Write(BD_text),
            run_time=2
        )
        self.wait(0.5)
        self.play(FadeOut(BD_text), run_time=0.5)

        # 4. 画内切圆 I (蓝色虚线)
        circle_I = DashedVMobject(
            Circle(radius=geo['r_I'], color=CIRCLE_I_COLOR, stroke_width=3),
            num_dashes=30,
            dashed_ratio=0.5
        )
        circle_I.set_stroke(opacity=0.9)
        circle_I.move_to(geo['I'])

        I_dot = Dot(geo['I'], color=I_POINT_COLOR, radius=0.08)
        I_label = Text("I", font_size=28, color=CIRCLE_I_COLOR).next_to(geo['I'], RIGHT, buff=0.1)

        self.play(
            Create(circle_I),
            FadeIn(I_dot),
            FadeIn(I_label),
            run_time=3
        )

        # 5. 显示切点 E、F
        E_dot = Dot(geo['E'], color=POINT_COLOR, radius=0.08)
        E_label = Text("E", font_size=28).next_to(geo['E'], RIGHT, buff=0.1)
        F_dot = Dot(geo['F'], color=POINT_COLOR, radius=0.08)
        F_label = Text("F", font_size=28).next_to(geo['F'], LEFT, buff=0.1)

        self.play(
            FadeIn(E_dot), FadeIn(E_label),
            FadeIn(F_dot), FadeIn(F_label),
            run_time=2
        )
        self.wait(0.5)

        # 6. 显示点 K
        K_dot = Dot(geo['K'], color=POINT_COLOR, radius=0.08)
        K_label = Text("K", font_size=28).next_to(geo['K'], UP, buff=0.15)

        self.play(
            FadeIn(K_dot), FadeIn(K_label),
            run_time=2
        )

        # 7. 画三角形 KBC
        triangle_KBC = Polygon(geo['K'], geo['B'], geo['C'],
                               color=TRIANGLE_INNER_COLOR, stroke_width=1.5, fill_opacity=0)

        self.play(Create(triangle_KBC), run_time=1.5)

        # 8. 画内切圆 J (红色虚线)
        circle_J = DashedVMobject(
            Circle(radius=geo['r_J'], color=CIRCLE_J_COLOR, stroke_width=3),
            num_dashes=25,
            dashed_ratio=0.5
        )
        circle_J.move_to(geo['J'])
        circle_J.set_stroke(opacity=0.9)

        J_dot = Dot(geo['J'], color=J_POINT_COLOR, radius=0.08)
        J_label = Text("J", font_size=28, color=CIRCLE_J_COLOR).next_to(geo['J'], RIGHT, buff=0.1)

        self.play(
            Create(circle_J),
            FadeIn(J_dot),
            FadeIn(J_label),
            run_time=2.5
        )

        # 9. 显示切点 M、N
        M_dot = Dot(geo['M'], color=POINT_COLOR, radius=0.08)
        M_label = Text("M", font_size=28).next_to(geo['M'], LEFT, buff=0.1)
        N_dot = Dot(geo['N'], color=POINT_COLOR, radius=0.08)
        N_label = Text("N", font_size=28).next_to(geo['N'], RIGHT, buff=0.1)

        self.play(
            FadeIn(M_dot), FadeIn(M_label),
            FadeIn(N_dot), FadeIn(N_label),
            run_time=2
        )

        # 显示字幕：已知条件
        subtitle1 = Text("已知：两内切圆共切点 D", font_size=32, color=WHITE)
        subtitle1.to_edge(DOWN, buff=0.8)
        self.play(Write(subtitle1), run_time=2)
        self.wait(1)
        self.play(FadeOut(subtitle1), run_time=0.5)

        # 等待音频完成 (2+0.5+2+2+0.5+3+2+0.5+2+1.5+2.5+2+2+1+0.5 = 大约16秒)
        self.wait_for_audio(animation_time=16)

        # ========== 第三幕：切线长定理 ==========
        self.start_scene("tangent")
        # 简化图形，突出切线长
        self.play(
            triangle.animate.set_stroke(width=0.8).set_fill(opacity=0.3),
            triangle_KBC.animate.set_stroke(width=0.5).set_fill(opacity=0.3),
            circle_I.animate.set_stroke(width=0.8, opacity=0.3),
            circle_J.animate.set_stroke(width=0.8, opacity=0.3),
            run_time=0.5
        )

        # 标题
        tangent_title = Text("切线长定理", font_size=40, color=HIGHLIGHT_COLOR)
        tangent_title.to_edge(UP, buff=0.5)
        self.play(Write(tangent_title), run_time=1)

        # 1. BF = BD
        BF_line = Line(geo['B'], geo['F'], color=HIGHLIGHT_COLOR, stroke_width=6)
        BD_line_1 = Line(geo['B'], geo['D'], color=HIGHLIGHT_COLOR, stroke_width=6)
        eq1 = Text("BF = BD", font_size=36, color=HIGHLIGHT_COLOR).to_edge(RIGHT, buff=0.5).shift(UP * 2.5)

        self.play(
            Create(BF_line),
            Create(BD_line_1),
            Write(eq1),
            run_time=2
        )
        self.wait(1)
        self.play(FadeOut(BF_line), FadeOut(BD_line_1), FadeOut(eq1), run_time=0.5)

        # 2. CE = CD
        CE_line = Line(geo['C'], geo['E'], color=HIGHLIGHT_COLOR, stroke_width=6)
        CD_line_1 = Line(geo['C'], geo['D'], color=HIGHLIGHT_COLOR, stroke_width=6)
        eq2 = Text("CE = CD", font_size=36, color=HIGHLIGHT_COLOR).to_edge(RIGHT, buff=0.5).shift(UP * 1.8)

        self.play(
            Create(CE_line),
            Create(CD_line_1),
            Write(eq2),
            run_time=2
        )
        self.wait(1)
        self.play(FadeOut(CE_line), FadeOut(CD_line_1), FadeOut(eq2), run_time=0.5)

        # 3. BM = BD
        BM_line = Line(geo['B'], geo['M'], color=HIGHLIGHT_COLOR, stroke_width=6)
        BD_line_2 = Line(geo['B'], geo['D'], color=HIGHLIGHT_COLOR, stroke_width=6)
        eq3 = Text("BM = BD", font_size=36, color=HIGHLIGHT_COLOR).to_edge(RIGHT, buff=0.5).shift(UP * 1.1)

        self.play(
            Create(BM_line),
            Create(BD_line_2),
            Write(eq3),
            run_time=2
        )
        self.wait(1)
        self.play(FadeOut(BM_line), FadeOut(BD_line_2), FadeOut(eq3), run_time=0.5)

        # 4. CN = CD
        CN_line = Line(geo['C'], geo['N'], color=HIGHLIGHT_COLOR, stroke_width=6)
        CD_line_2 = Line(geo['C'], geo['D'], color=HIGHLIGHT_COLOR, stroke_width=6)
        eq4 = Text("CN = CD", font_size=36, color=HIGHLIGHT_COLOR).to_edge(RIGHT, buff=0.5).shift(UP * 0.4)

        self.play(
            Create(CN_line),
            Create(CD_line_2),
            Write(eq4),
            run_time=2
        )
        self.wait(1.5)
        self.play(
            FadeOut(CN_line), FadeOut(CD_line_2), FadeOut(eq4),
            FadeOut(tangent_title),
            run_time=0.5
        )

        # 恢复图形
        self.play(
            triangle.animate.set_stroke(width=2.5, opacity=1),
            triangle_KBC.animate.set_stroke(width=1.5, opacity=1),
            circle_I.animate.set_stroke(width=2, opacity=1),
            circle_J.animate.set_stroke(width=2, opacity=1),
            run_time=1
        )

        # 等待音频完成
        self.wait_for_audio(animation_time=17)

        # ========== 第四幕：双曲线性质推导 ==========
        self.start_scene("hyperbola")
        hyperbola_title = Text("双曲线性质", font_size=40, color=HYPERBOLA_COLOR)
        hyperbola_title.to_edge(UP, buff=0.5)
        self.play(Write(hyperbola_title), run_time=1.5)

        # 公式推导（分步显示）
        # 步骤 1: AB - AC 的计算
        formula1 = Text("AB - AC = (BD + AF) - (CD + AE)", font_size=30, color=WHITE)
        formula1.to_edge(UP, buff=1.2)

        # 高亮 AB 和 AC
        AB_highlight = Line(geo['A'], geo['B'], color=BLUE, stroke_width=8)
        AB_highlight.set_stroke(opacity=0.5)
        AC_highlight = Line(geo['A'], geo['C'], color=BLUE, stroke_width=8)
        AC_highlight.set_stroke(opacity=0.5)

        self.play(
            Write(formula1),
            Create(AB_highlight),
            Create(AC_highlight),
            run_time=2.5
        )
        self.wait(1)
        self.play(FadeOut(AB_highlight), FadeOut(AC_highlight), run_time=0.5)

        # 步骤 2: 化简
        formula2 = Text("= BD - CD    (∵ AF = AE)", font_size=30, color=WHITE)
        formula2.next_to(formula1, DOWN, buff=0.3, aligned_edge=LEFT)

        self.play(Write(formula2), run_time=2)
        self.wait(1)

        # 步骤 3: KB - KC 的计算
        formula3 = Text("KB - KC = (BM + MK) - (CN + NK)", font_size=30, color=WHITE)
        formula3.next_to(formula2, DOWN, buff=0.5)

        KB_highlight = Line(geo['K'], geo['B'], color=GREEN, stroke_width=8)
        KB_highlight.set_stroke(opacity=0.5)
        KC_highlight = Line(geo['K'], geo['C'], color=GREEN, stroke_width=8)
        KC_highlight.set_stroke(opacity=0.5)

        self.play(
            Write(formula3),
            Create(KB_highlight),
            Create(KC_highlight),
            run_time=2.5
        )
        self.wait(1)
        self.play(FadeOut(KB_highlight), FadeOut(KC_highlight), run_time=0.5)

        # 步骤 4: 化简
        formula4 = Text("= BM - CN = BD - CD", font_size=30, color=WHITE)
        formula4.next_to(formula3, DOWN, buff=0.3, aligned_edge=LEFT)

        self.play(Write(formula4), run_time=2)
        self.wait(1)

        # 结论
        conclusion_hyperbola = Text("∴ AB - AC = KB - KC", font_size=38, color=HIGHLIGHT_COLOR)
        conclusion_hyperbola.next_to(formula4, DOWN, buff=0.5)

        self.play(Write(conclusion_hyperbola), run_time=1.5)
        self.wait(2)

        # 清除公式
        self.play(
            FadeOut(formula1), FadeOut(formula2), FadeOut(formula3),
            FadeOut(formula4), FadeOut(conclusion_hyperbola),
            run_time=1
        )

        # 绘制双曲线
        hyperbola = self._create_hyperbola(geo['B'], geo['C'], abs(geo['AB'] - geo['AC']) / 2)
        hyperbola.set_stroke(HYPERBOLA_COLOR, width=2.5)
        hyperbola.set_stroke(opacity=0.7)

        self.play(Create(hyperbola), run_time=3)

        # 显示 A 和 K 在双曲线上
        A_on_curve = Text("A 在双曲线上", font_size=28, color=WHITE).next_to(geo['A'], UR, buff=0.2)
        K_on_curve = Text("K 在双曲线上", font_size=28, color=WHITE).next_to(geo['K'], UR, buff=0.2)

        # 创建 A 和 K 的高亮点
        A_highlight = Dot(geo['A'], color=HIGHLIGHT_COLOR, radius=0.15)
        K_highlight = Dot(geo['K'], color=HIGHLIGHT_COLOR, radius=0.15)

        self.play(
            Write(A_on_curve),
            Create(A_highlight),
            run_time=1.5
        )
        self.wait(0.5)
        self.play(
            Write(K_on_curve),
            Create(K_highlight),
            run_time=1.5
        )
        self.wait(2)

        # 清除双曲线相关
        self.play(
            FadeOut(hyperbola), FadeOut(A_on_curve), FadeOut(K_on_curve),
            FadeOut(A_highlight), FadeOut(K_highlight),
            run_time=1
        )

        # 等待音频完成
        self.wait_for_audio(animation_time=24)

        # ========== 第五幕：蒙日定理应用 ==========
        monge_title = Text("蒙日定理推论", font_size=40, color=AUX_CIRCLE_COLOR)
        monge_title.to_edge(UP, buff=0.5)
        self.play(Write(monge_title), run_time=1.5)

        # 显示定理内容
        monge_text = VGroup(
            Text("从双曲线上的点向有公共切点的两圆作切线，", font_size=28),
            Text("四个切点共圆", font_size=28, color=HIGHLIGHT_COLOR)
        ).arrange(DOWN, buff=0.3)
        monge_text.next_to(monge_title, DOWN, buff=0.5)

        self.play(Write(monge_text), run_time=3)
        self.wait(1)

        # 绘制辅助圆（E、F、M、N 的外接圆）
        aux_circle = self._create_circumcircle(geo['E'], geo['F'], geo['M'])
        aux_circle.set_stroke(AUX_CIRCLE_COLOR, width=3.5)

        self.play(Create(aux_circle), run_time=3)

        # 高亮 E、F、M、N 四点
        EFMN_dots = VGroup(
            Dot(geo['E'], color=AUX_CIRCLE_COLOR, radius=0.12),
            Dot(geo['F'], color=AUX_CIRCLE_COLOR, radius=0.12),
            Dot(geo['M'], color=AUX_CIRCLE_COLOR, radius=0.12),
            Dot(geo['N'], color=AUX_CIRCLE_COLOR, radius=0.12)
        )

        # 连接四点形成四边形
        quad = Polygon(geo['E'], geo['F'], geo['M'], geo['N'],
                       color=AUX_CIRCLE_COLOR, stroke_width=1.5)
        quad.set_fill(opacity=0.1)

        self.play(
            Create(quad),
            FadeIn(EFMN_dots),
            run_time=2.5
        )

        # 显示结论
        conclusion_final = Text("∴ E、F、M、N 四点共圆", font_size=44, color=HIGHLIGHT_COLOR)
        conclusion_final.to_edge(DOWN, buff=1.5)

        self.play(Write(conclusion_final), run_time=2)
        self.wait(3)

        # 清除
        self.play(
            FadeOut(monge_title), FadeOut(monge_text),
            FadeOut(conclusion_final),
            FadeOut(quad), FadeOut(EFMN_dots),
            run_time=1
        )

        # 等待音频完成
        self.wait_for_audio(animation_time=24)

        # ========== 第六幕：总结 ==========
        summary_title = Text("证明步骤总结", font_size=44, color=WHITE)
        summary_title.to_edge(UP, buff=0.5)

        step1 = Text("1. 切线长定理 → 相等线段", font_size=34, color=WHITE)
        step2 = Text("2. 双曲线识别 → AB - AC = KB - KC", font_size=34, color=WHITE)
        step3 = Text("3. 蒙日定理 → 四点共圆", font_size=34, color=HIGHLIGHT_COLOR)

        steps = VGroup(step1, step2, step3).arrange(DOWN, aligned_edge=LEFT, buff=0.5)
        steps.next_to(summary_title, DOWN, buff=0.8)

        # 逐步显示步骤
        self.play(Write(summary_title), run_time=1.5)
        self.wait(0.5)

        self.play(Write(step1), run_time=2)
        self.wait(1)

        self.play(Write(step2), run_time=2)
        self.wait(1)

        self.play(Write(step3), run_time=2)
        self.wait(2)

        # 证明完成
        done_text = Text("证明完成！", font_size=64, color=HIGHLIGHT_COLOR)
        done_text.next_to(steps, DOWN, buff=1)

        self.play(Write(done_text), run_time=2)

        # 等待音频完成
        self.wait_for_audio(animation_time=15)

        # 结束
        self.play(
            *[FadeOut(mob) for mob in self.mobjects],
            run_time=1.5
        )

    def _create_hyperbola(self, F1, F2, a, num_points=200):
        """创建双曲线"""
        c = np.linalg.norm(F1 - F2) / 2
        center = (F1 + F2) / 2

        if c > a:
            b = np.sqrt(c**2 - a**2)
        else:
            b = 0.5

        # 生成双曲线点（两支）
        t = np.linspace(-1.5, 1.5, num_points)
        points = []

        for ti in t:
            # 右支
            x_r = a * np.cosh(ti)
            y_r = b * np.sinh(ti)
            points.append([center[0] + x_r, center[1] + y_r, 0])
            # 左支
            x_l = -a * np.cosh(ti)
            y_l = b * np.sinh(ti)
            points.append([center[0] + x_l, center[1] + y_l, 0])

        # 创建曲线
        hyperbola = VGroup()
        for p in points:
            if -6 < p[1] < 10:  # 限制显示范围
                dot = Dot(p, radius=0.025, color=HYPERBOLA_COLOR)
                hyperbola.add(dot)

        return hyperbola

    def _create_circumcircle(self, A, B, C):
        """创建外接圆"""
        # 计算外心
        D = 2 * (A[0] * (B[1] - C[1]) + B[0] * (C[1] - A[1]) + C[0] * (A[1] - B[1]))
        if abs(D) < 1e-10:
            # 三点共线，返回一个大圆
            return Circle(radius=10, color=AUX_CIRCLE_COLOR)

        Ux = ((A[0]**2 + A[1]**2) * (B[1] - C[1]) +
              (B[0]**2 + B[1]**2) * (C[1] - A[1]) +
              (C[0]**2 + C[1]**2) * (A[1] - B[1])) / D
        Uy = ((A[0]**2 + A[1]**2) * (C[0] - B[0]) +
              (B[0]**2 + B[1]**2) * (A[0] - C[0]) +
              (C[0]**2 + C[1]**2) * (B[0] - A[0])) / D

        center = np.array([Ux, Uy, 0])
        radius = np.linalg.norm(A - center)

        return Circle(radius=radius, color=AUX_CIRCLE_COLOR).move_to(center)


if __name__ == "__main__":
    # 使用命令行渲染：python -m manim -qh geometry_proof_audio.py GeometryProof
    pass