from manim import *

class NeuralNetworkAnimation(Scene):
    def construct(self):
        # 创建三层神经网络
        layer1 = VGroup(*[Circle(radius=0.3) for _ in range(3)])
        layer2 = VGroup(*[Circle(radius=0.3) for _ in range(4)])
        layer3 = VGroup(*[Circle(radius=0.3) for _ in range(2)])
        
        # 排列
        layer1.arrange(DOWN, buff=0.5)
        layer2.arrange(DOWN, buff=0.5).shift(RIGHT * 3)
        layer3.arrange(DOWN, buff=0.5).shift(RIGHT * 6)
        
        # 动画
        self.play(Create(layer1), Create(layer2), Create(layer3))
        # ... 绘制连接线、激活函数等

import { makeScene2D, Circle, Rect } from '@motion-canvas/2d';
import { all, sequence } from '@motion-canvas/core';

export default makeScene2D(function* (view) {
  const circle = new Circle({
    size: 100,
    fill: '#FF0000',
  });
  
  const rect = new Rect({
    width: 200,
    height: 100,
    fill: '#00FF00',
    x: 300,
  });
  
  view.add(circle, rect);
  
  yield* sequence(
    circle.scale(2, 1),
    all(
      circle.position.x(300, 1),
      rect.opacity(0.5, 1),
    ),
  );
});

import React from 'react';
import { Composition } from 'remotion';

const MyVideo: React.FC<{ data: number[] }> = ({ data }) => (
  <div style={{ width: '100%', height: '100%', background: '#fff' }}>
    {data.map((value, i) => (
      <div
        key={i}
        style={{
          height: `${value * 10}px`,
          width: `${100 / data.length}%`,
          background: '#0066cc',
        }}
      />
    ))}
  </div>
);

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyComposition"
      component={MyVideo}
      durationInFrames={300}
      fps={30}
      width={1920}
      height={1080}
      defaultProps={{ data: [10, 20, 15, 30, 25] }}
    />
  );
};

写脚本 → 关键帧设计 → 用文生视频生成 B-roll 
→ 在剪映/Premiere 中组合 → 配音和字幕

"diagram showing neural network architecture, 
minimalist style, educational illustration, 
network nodes connected by lines, clean lines, 
no text, scientific diagram, scientific illustration style"

准备脚本 (纯文本) 
→ 选择虚拟讲师和语言 
→ AI 自动生成唇形同步视频 
→ 导出用于编辑

粘贴文章或脚本 
→ AI 自动识别场景和匹配素材 
→ 自动加字幕和配音 
→ 调整后导出

import { Text, slideInLeft, fadeIn } from '@motion-canvas/2d';

const keyword = new Text('Neural Network', {
  fontSize: 48,
  fill: '#FF0000',
});

view.add(keyword);

yield* sequence(
  keyword.opacity(0, 0),
  slideInLeft(keyword, 0.5),
  keyword.fontSize(36, 0.3),
);

录制屏幕操作 
→ 自动追踪或手工关键帧缩放 
→ 添加光标强调和转场 
→ 导出为视频

导入图片或元素 
→ 设置画笔顺序 
→ 自动生成手绘动画 
→ 配置速度和样式 
→ 导出

手工在 Grease Pencil 中画或导入 SVG 
→ 设置描边顺序 → 录制

const StaticImagePan: React.FC = () => {
  const frame = useCurrentFrame();
  const fps = useVideoConfig().fps;
  const duration = 5 * fps; // 5 秒运镜
  
  const zoomLevel = interpolate(frame, [0, duration], [1, 1.5], {
    extrapolateRight: 'clamp',
  });
  
  const panX = interpolate(frame, [0, duration], [0, -100], {
    extrapolateRight: 'clamp',
  });
  
  return (
    <img
      src="landscape.jpg"
      style={{
        transform: `scale(${zoomLevel}) translateX(${panX}px)`,
        width: '100%',
      }}
    />
  );
};

# 录制
asciinema rec demo.cast

# 导出为 SVG 动画
asciinema-player export demo.cast demo.svg

# 或转 GIF（需要 ffmpeg）
asciinema convert demo.cast demo.gif

const codeLines = [
  'function fibonacci(n) {',
  '  if (n <= 1) return n;',
  '  return fibonacci(n-1) + fibonacci(n-2);',
  '}',
];

const texts = codeLines.map(
  (line, i) =>
    new Text(line, {
      fontSize: 24,
      y: i * 40,
      opacity: 0,
    }),
);

for (const text of texts) {
  view.add(text);
  yield* text.opacity(1, 0.5);
}

from manim import *

class NeuralNetworkVisualization(Scene):
    def construct(self):
        layers = VGroup()
        
        # 输入层 (784 个神经元，但只显示部分)
        input_neurons = VGroup(
            *[Circle(radius=0.1) for _ in range(10)]
        ).arrange(DOWN, buff=0.1)
        
        # 隐藏层 1 (128 个)
        hidden1 = VGroup(
            *[Circle(radius=0.08) for _ in range(8)]
        ).arrange(DOWN, buff=0.08).shift(RIGHT * 2)
        
        # 输出层 (10 个)
        output = VGroup(
            *[Circle(radius=0.08) for _ in range(10)]
        ).arrange(DOWN, buff=0.1).shift(RIGHT * 4)
        
        layers.add(input_neurons, hidden1, output)
        
        # 绘制连接（采样）
        connections = VGroup()
        for neuron_in in input_neurons[:5]:
            for neuron_hidden in hidden1[:3]:
                line = Line(neuron_in, neuron_hidden, stroke_width=0.5)
                connections.add(line)
        
        self.add(layers, connections)
        
        # 激活动画
        self.play(LaggedStart(
            *[Circle(radius=0.15, color=YELLOW).move_to(n.get_center())
              for n in input_neurons],
            lag_ratio=0.1
        ))

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.animation import FuncAnimation

# 模拟注意力权重（seq_len x seq_len）
attention_weights = np.random.rand(12, 12)  # 12 个 token

fig, ax = plt.subplots(figsize=(8, 8))
sns.heatmap(attention_weights, cmap='YlOrRd', ax=ax, 
            cbar_kws={'label': 'Attention Weight'})
ax.set_title('Transformer Attention Weights (Head 1)')
ax.set_xlabel('Key Token Position')
ax.set_ylabel('Query Token Position')

plt.savefig('attention.png', dpi=150, bbox_inches='tight')
plt.close()

# 然后用 p5.capture 或 Screen Studio 录制为视频

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# 模拟 loss 数据
epochs = 100
losses = np.exp(-np.arange(epochs) / 20) + np.random.normal(0, 0.05, epochs)

fig, ax = plt.subplots(figsize=(10, 6))
line, = ax.plot([], [], lw=2, color='#FF6B6B')

ax.set_xlim(0, epochs)
ax.set_ylim(0, max(losses) * 1.1)
ax.set_xlabel('Epoch')
ax.set_ylabel('Loss')
ax.set_title('Training Loss Curve')
ax.grid(True, alpha=0.3)

def animate(frame):
    x_data = np.arange(frame + 1)
    y_data = losses[:frame + 1]
    line.set_data(x_data, y_data)
    return line,

ani = animation.FuncAnimation(fig, animate, frames=epochs, 
                               blit=True, interval=50)
ani.save('loss_curve.mp4', fps=20)
plt.close()

import { makeScene2D, Text, Circle, Line } from '@motion-canvas/2d';
import { all, sequence } from '@motion-canvas/core';

export default makeScene2D(function* (view) {
  const tokens = ['The', 'quick', 'brown', 'fox'];
  
  // 创建 token 节点
  const tokenNodes = tokens.map((text, i) => {
    const circle = new Circle({
      size: 60,
      fill: '#4A90E2',
      x: i * 150 - 200,
    });
    const label = new Text(text, {
      fontSize: 20,
      fill: 'white',
      y: i * 150 - 200,
    });
    view.add(circle, label);
    return { circle, label };
  });
  
  // Token 流动动画
  for (let i = 0; i < tokenNodes.length; i++) {
    yield* tokenNodes[i].circle.fill('#FF6B6B', 0.3);
    yield* tokenNodes[i].circle.scale(1.2, 0.2);
    yield* tokenNodes[i].circle.scale(1, 0.2);
  }
});

from transformers import AutoTokenizer, AutoModel
from bertviz import head_view
import torch

model_name = "bert-base-uncased"
model = AutoModel.from_pretrained(model_name, output_attentions=True)
tokenizer = AutoTokenizer.from_pretrained(model_name)

text = "The model generated a very detailed explanation"
inputs = tokenizer.encode(text, return_tensors='pt')
outputs = model(inputs)
attention = outputs[-1]  # 所有头的注意力

# 可视化
head_view(attention, tokenizer.convert_ids_to_tokens(inputs[0]))

from PIL import Image, ImageDraw, ImageFont

# 加载截图
img = Image.open('paper_page.png')
draw = ImageDraw.Draw(img)

# 绘制高亮框（黄色透明矩形）
highlight_box = (100, 200, 400, 250)  # (x1, y1, x2, y2)
draw.rectangle(highlight_box, outline='yellow', width=3)

# 添加箭头指向关键部分
arrow_start = (450, 225)
arrow_end = (500, 225)
draw.line([arrow_start, arrow_end], fill='red', width=4)

# 添加文字注释
font = ImageFont.load_default()
draw.text((510, 210), "Key Finding", fill='red', font=font)

img.save('annotated_paper.png')

(1) 用 Manim 生成核心动画 → 输出视频片段
(2) Python 脚本生成热力图动画 → 导入 Premiere
(3) 屏幕录制代码示例 → 编辑缩放关键帧
(4) 收集论文截图 → After Effects 标注 → 输出
(5) 所有素材在 Premiere 中组合
(6) 加字幕（Descript 自动生成）
(7) 导出最终视频

┌─ 预算充足(>$500/年)
│  ├─ 需要传统 UI 编辑 → After Effects + Premiere Pro
│  └─ 需要 3D 科学图 → Blender + After Effects
│
├─ 有编程基础(Python/JS/TS)
│  ├─ 数学/算法科普 → Manim
│  ├─ 实时交互演示 → Motion Canvas
│  ├─ 数据驱动视频 → Remotion
│  └─ 创意可视化 → p5.js
│
├─ 快速出稿(+24 小时)
│  ├─ 中文用户 → 剪映/CapCut
│  ├─ 脚本→视频 → Fliki/Pictory
│  └─ 屏幕录制 → Screen Studio
│
└─ 完全开源/免费
   ├─ 剪辑主体 → DaVinci Resolve
   ├─ 代码动画 → Manim + Motion Canvas
   ├─ 3D 示意图 → Blender
   └─ 字幕生成 → Descript (付费) 或手工

# SRT 格式字幕直接烧制
ffmpeg -i input.mp4 -vf subtitles=subs.srt output.mp4

# 支持样式：字体、大小、颜色、位置（但有限）

# ASS 格式支持高级样式：字体、颜色、边框、阴影、缩放、倾斜、对齐
ffmpeg -i input.mp4 -vf ass=subs.ass output.mp4

# 格式转换：SRT → ASS
ffmpeg -i subs.srt subs.ass

# 使用 Subtitle Edit CLI 批量转换
# SRT 支持的是最基础的时间码格式：HH:MM:SS,ms

# 高级样式示例（ASS 格式）：
# [Script Info]
# Title: My Subtitles
# 
# [V4+ Styles]
# Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, ...
# Style: Default,Arial,20,&H00FFFFFF,&H000000FF,0,0,0,100,100,0,0,0,0,0,0
#
# [Events]
# Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
# Dialogue: 0,0:00:00.00,0:00:05.00,Default,,0,0,0,,字幕内容

# libass 自动渲染 ASS/SSA 格式，支持所有高级特性
ffmpeg -vf "ass=subs.ass" input.mp4 output.mp4

# Batch 烧字幕脚本
for file in *.mp4; do
  ffmpeg -i "$file" -vf "ass=subs.ass" -c:v libx264 -crf 23 "burned_$file"
done

# 创建 concat.txt
# file 'segment1.mp4'
# file 'segment2.mp4'
# file 'segment3.mp4'

ffmpeg -f concat -safe 0 -i concat.txt -c copy output.mp4

# 使用 xfade 实现 1 秒交叉淡化
# 支持 30+ 转场类型：fade, wipeleft, slidedown, dissolve, pixelize 等

ffmpeg -i segment1.mp4 -i segment2.mp4 \
  -filter_complex "[0:v][1:v]xfade=transition=fade:duration=1:offset=4[v]; [0:a][1:a]acrossfade=d=1[a]" \
  -map "[v]:v" -map "[a]:a" output.mp4

# 转场类型列表（可选替换 fade）：
# fade, wipeleft, wiperight, wipeup, wipedown
# slideleft, slideright, slideup, slidedown
# circlecrop, rectcrop, distance
# fadeblack, fadewhite, radial
# smoothleft, smoothright, smoothup, smoothdown
# circleopen, circleclose
# vertopen, vertclose, horzopen, horzclose
# dissolve, pixelize
# diagtl, diagtr, diagbl, diagbr（对角线）

# 单文件归一化到 -16 LUFS
ffmpeg -i input.mp4 -af "loudnorm=I=-16:TP=-1.5:LRA=11" output.mp4

# 参数说明：
# I=-16       目标集成响度（Integrated Loudness）
# TP=-1.5     真峰值上限（True Peak Ceiling），防止削波
# LRA=11      响度范围（Loudness Range），音量动态范围

# 批量归一化脚本
for file in *.mp4; do
  ffmpeg -i "$file" -af "loudnorm=I=-16:TP=-1.5:LRA=11" "normalized_$file"
done

# 使用专用工具（更精细）
pip install ffmpeg-normalize
ffmpeg-normalize *.mp3 --target-level -16 --loudness-range-target 11

# 1080p60 最高质量
ffmpeg -i input.mov \
  -c:v libx264 \
  -preset slow \
  -crf 18 \
  -c:a aac -b:a 128k \
  -pix_fmt yuv420p \
  output_1080p60.mp4

# 参数说明：
# preset slow   编码速度（fast/medium/slow，影响时间）
# crf 18        质量等级（0-51，低=高质量，18-23 是理想范围）
# aac -b:a 128k 音频编码 AAC 128kbps
# pix_fmt yuv420p 色彩空间（广泛兼容）

# 4K 30fps H.264（B 站可接受）
ffmpeg -i input.mov \
  -c:v libx264 \
  -preset slow \
  -crf 20 \
  -s 3840x2160 \
  -r 30 \
  -b:v 15M \
  -c:a aac -b:a 192k \
  output_4k.mp4

# 4K 编码码率建议：
# 1080p60: 6-8 Mbps
# 1440p60: 10-15 Mbps  
# 4K30: 15-25 Mbps
# 4K60: 40-60 Mbps（YouTube）

# AV1 比 H.264 节省 50% 带宽，比 VP9 节省 30%
ffmpeg -i input.mov \
  -c:v libaom-av1 \
  -cpu-used 4 \
  -crf 24 \
  -b:v 0 \
  output_av1.mkv

# 参数说明：
# cpu-used 4   编码速度（0-8，值越低越慢但更小）
# crf 24      质量（AV1 的 CRF 18-24 相当于 H.264 的 22-28）
# -b:v 0      自适应码率（AV1 特有，不需要手动指定）

# 注意：AV1 编码时间长，不适合实时应用，但最终体积小

#!/bin/bash
# 完整科普视频制作脚本

INPUT="raw_video.mp4"
SUBS="captions.ass"
OUTPUT_NAME="science_video_final"

# Step 1: 字幕烧制 + 分辨率标准化
ffmpeg -i "$INPUT" \
  -vf "ass=$SUBS,scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 -preset medium -crf 22 \
  temp_subtitled.mp4

# Step 2: 音频响度归一化
ffmpeg -i temp_subtitled.mp4 \
  -af "loudnorm=I=-16:TP=-1.5:LRA=11" \
  -c:v copy \
  temp_normalized.mp4

# Step 3: 最终编码 (1080p)
ffmpeg -i temp_normalized.mp4 \
  -c:v libx264 -preset slow -crf 20 \
  -c:a aac -b:a 128k \
  -pix_fmt yuv420p \
  "$OUTPUT_NAME.mp4"

# 清理临时文件
rm temp_subtitled.mp4 temp_normalized.mp4

echo "✓ 生产完成: $OUTPUT_NAME.mp4"

# 批量烧字幕 + 编码 100 个视频
mkdir -p output

for video in input/*.mp4; do
  name=$(basename "$video" .mp4)
  
  echo "处理: $name"
  
  ffmpeg -i "$video" \
    -vf "ass=subtitles/$name.ass" \
    -af "loudnorm=I=-16:TP=-1.5:LRA=11" \
    -c:v libx264 -preset slow -crf 22 \
    -c:a aac -b:a 128k \
    -y \
    "output/$name.mp4"
done

echo "✓ 批处理完成"

论文 PDF → Claude 提炼关键概念 → Claude 生成 Manim Python
  → 本地渲染视频 → video-audio-mcp 字幕烧制/规范化
  → FFmpeg 编码输出

概念 → Claude Code 生成 React/Manim 组件 
  → 本地浏览器预览
  → CLI 渲染 MP4 
  → video-audio-mcp 编辑微调
  → ffmpeg 最终编码

# 安装 MoneyPrinterTurbo
git clone https://github.com/harry0703/MoneyPrinterTurbo
cd MoneyPrinterTurbo
pip install -r requirements.txt

# 生成第一个视频
python main.py --topic "量子纠缠原理" --duration 60