실습: LaTex Typing Animation

Markdown/LaTeX 개념 정리
→ Manim Scene 스크립트
→ MP4 렌더

Markdown
→ Reveal.js 슬라이드
→ 브라우저 렌더
→ 화면 녹화 or Puppeteer 캡처

## Def: Convexity
Convex function is defined as:

$$
f(\lambda x + (1-\lambda)y) \le \lambda f(x) + (1-\lambda)f(y)
$$

Steps:
1. Fix $x,y$
2. Choose $\lambda\in[0,1]$
3. Compare chord and graph

```chalk
Write the inequality slowly.
Pause after the LHS appears.

from manim import *

class ChalkStyle:
    def __init__(self):
        self.text_font = "STIX Two Text"
        self.math_font = "STIX Two Math"
        self.line_spacing = 0.9
        self.scale = 0.9
        self.write_time = 1.0
        self.step_time = 0.6

def mk_paragraph(s: str, style: ChalkStyle):
    return Paragraph(
        *s.split("\n"),
        font=style.text_font,
        line_spacing=style.line_spacing
    ).scale(style.scale)

def mk_math(latex: str, style: ChalkStyle):
    # latex는 $$ $$ 제거 후 들어온다고 가정
    return MathTex(latex, font_size=42)

def anim_write(mobj, style: ChalkStyle):
    return Write(mobj, run_time=style.write_time)

import re
from dataclasses import dataclass

@dataclass
class Scene: title: str; blocks: list
@dataclass
class Paragraph: text: str
@dataclass
class DisplayMath: latex: str
@dataclass
class Steps: items: list
@dataclass
class ChalkNote: text: str

def parse(md: str) -> list[Scene]:
    scenes = []
    cur = None
    buf = []

    def flush_paragraph():
        nonlocal buf, cur
        if not buf: return
        text = "\n".join(buf).strip()
        if text:
            cur.blocks.append(Paragraph(text))
        buf = []

    lines = md.splitlines()
    i = 0
    while i < len(lines):
        line = lines[i]

        m = re.match(r"^##\s+(.*)$", line)
        if m:
            if cur:
                flush_paragraph()
                scenes.append(cur)
            cur = Scene(title=m.group(1).strip(), blocks=[])
            i += 1
            continue

        if line.strip().startswith("```chalk"):
            flush_paragraph()
            i += 1
            note_lines = []
            while i < len(lines) and not lines[i].strip().startswith("```"):
                note_lines.append(lines[i])
                i += 1
            cur.blocks.append(ChalkNote("\n".join(note_lines).strip()))
            i += 1
            continue

        if line.strip() == "$$":
            flush_paragraph()
            i += 1
            math_lines = []
            while i < len(lines) and lines[i].strip() != "$$":
                math_lines.append(lines[i])
                i += 1
            cur.blocks.append(DisplayMath("\n".join(math_lines).strip()))
            i += 1
            continue

        if re.match(r"^\d+\.\s+", line):
            flush_paragraph()
            items = []
            while i < len(lines) and re.match(r"^\d+\.\s+", lines[i]):
                items.append(re.sub(r"^\d+\.\s+", "", lines[i]).strip())
                i += 1
            cur.blocks.append(Steps(items))
            continue

        buf.append(line)
        i += 1

    if cur:
        flush_paragraph()
        scenes.append(cur)
    return scenes

import json
from manim import *

class Video(Scene):
    def construct(self):
        data = json.load(open("out/scenes.json", "r", encoding="utf-8"))
        style = ChalkStyle()

        for sc in data:
            self.render_scene(sc, style)
            self.clear()

    def render_scene(self, sc, style):
        title = Text(sc["title"], font=style.text_font).scale(0.8).to_edge(UP)
        self.play(FadeIn(title, shift=DOWN), run_time=0.4)

        y = 2.6
        for blk in sc["blocks"]:
            t = blk["type"]
            if t == "Paragraph":
                m = mk_paragraph(blk["text"], style).to_corner(UL).shift(DOWN*0.6)
                self.play(FadeIn(m, shift=UP*0.1), run_time=0.35)
            elif t == "DisplayMath":
                m = mk_math(blk["latex"], style).next_to(title, DOWN, buff=0.6)
                self.play(anim_write(m, style))
            elif t == "Steps":
                self.render_steps(blk["items"], title, style)
            elif t == "ChalkNote":
                # 렌더 없음: 타이밍 힌트로만 사용
                pass

    def render_steps(self, items, anchor, style):
        group = VGroup()
        for k, it in enumerate(items):
            line = Tex(rf"{k+1}.\;\; {it}")
            group.add(line)
        group.arrange(DOWN, aligned_edge=LEFT, buff=0.25).next_to(anchor, DOWN, buff=0.8).to_edge(LEFT)

        for k, line in enumerate(group):
            self.play(Write(line), run_time=style.step_time)
            if k >= 1:
                group[k-1].set_opacity(0.55)

default:
  write_time: 1.0
  step_time: 0.6
scenes:
  - title: "Def: Convexity"
    write_time: 1.2
    pause_after_math: 0.5

python build.py notes.md meta.yml
manim -pql manim_project/video.py Video
# 최종
manim -pqh manim_project/video.py Video