Animated Math Skill

Tạo đồ thị toán học động chất lượng cao với Manim, xuất video chuẩn YouTube và Shorts.

Quick Start

1. Cài đặt Manim

# Recommended: using uv
uv pip install manim

# Or pip
pip install manim

# Verify installation
manim --version

Yêu cầu: Python 3.8+, FFmpeg, LaTeX (optional)

2. Tạo animation đầu tiên

from manim import *

class SineCurve(Scene):
    def construct(self):
        # Tạo hệ trục tọa độ
        axes = Axes(
            x_range=[-3, 3, 1],
            y_range=[-2, 2, 1],
            axis_config={"include_tip": True}
        )

        # Vẽ đồ thị sin(x)
        graph = axes.plot(lambda x: np.sin(x), color=BLUE)
        label = axes.get_graph_label(graph, label="\\sin(x)")

        # Animation
        self.play(Create(axes))
        self.play(Create(graph), Write(label))
        self.wait(2)

3. Render video

# YouTube 1080p (Full HD)
manim -qh -p scene.py SineCurve

# YouTube 4K
manim -qk -p scene.py SineCurve

# YouTube Shorts (vertical 9:16)
manim -qh -r 1080,1920 -p scene.py SineCurve

---

Video Quality Presets

YouTube Standard (16:9 Landscape)

Preset	Flag	Resolution	FPS	Use Case
Preview	-ql	854×480	15	Quick preview
Medium	-qm	1280×720	30	Draft
1080p	-qh	1920×1080	60	YouTube standard
2K	-qp	2560×1440	60	High quality
4K	-qk	3840×2160	60	YouTube premium

YouTube Shorts (9:16 Vertical)

# Shorts 1080p (recommended)
manim -qh -r 1080,1920 scene.py SceneName

# Shorts 4K
manim -qk -r 2160,3840 scene.py SceneName

Shorts specs:

• Aspect ratio: 9:16 (vertical)
• Max duration: 60 seconds
• Resolution: 1080×1920 (recommended)

---

Animation Templates

1. Function Graph Animation

from manim import *

class FunctionGraph(Scene):
    """Template: Vẽ đồ thị hàm số với animation"""

    def construct(self):
        # Config
        axes = Axes(
            x_range=[-4, 4, 1],
            y_range=[-2, 2, 0.5],
            x_length=10,
            y_length=6,
            axis_config={"include_numbers": True}
        )

        # Function
        func = lambda x: np.sin(x)
        graph = axes.plot(func, color=BLUE)
        label = MathTex(r"f(x) = \sin(x)").to_corner(UL)

        # Animate
        self.play(Create(axes), run_time=2)
        self.play(Create(graph), Write(label), run_time=3)
        self.wait(2)

2. Derivative Visualization

from manim import *

class DerivativeVisualization(Scene):
    """Template: Minh họa đạo hàm với tiếp tuyến di chuyển"""

    def construct(self):
        axes = Axes(x_range=[-3, 3], y_range=[-1, 9])

        # f(x) = x²
        func = axes.plot(lambda x: x**2, color=BLUE)
        func_label = MathTex(r"f(x) = x^2").to_corner(UL)

        # Điểm di chuyển trên đồ thị
        dot = Dot(color=YELLOW)
        dot.move_to(axes.c2p(-2, 4))

        # Đường tiếp tuyến
        tangent = always_redraw(
            lambda: axes.get_secant_slope_group(
                x=axes.p2c(dot.get_center())[0],
                graph=func,
                dx=0.01,
                secant_line_length=4,
                secant_line_color=RED
            )
        )

        self.play(Create(axes), Create(func), Write(func_label))
        self.add(dot, tangent)
        self.play(dot.animate.move_to(axes.c2p(2, 4)), run_time=5)
        self.wait()

3. Integral Animation

from manim import *

class IntegralVisualization(Scene):
    """Template: Minh họa tích phân với diện tích dưới đồ thị"""

    def construct(self):
        axes = Axes(x_range=[0, 5], y_range=[0, 6])

        func = axes.plot(lambda x: 0.5 * x**2, color=BLUE)

        # Diện tích dưới đồ thị
        area = axes.get_area(func, x_range=[1, 4], color=GREEN, opacity=0.5)

        # Labels
        integral_label = MathTex(
            r"\int_1^4 \frac{x^2}{2} dx"
        ).to_corner(UL)

        self.play(Create(axes), Create(func))
        self.play(FadeIn(area), Write(integral_label))
        self.wait(2)

4. 3D Surface Plot

from manim import *

class Surface3D(ThreeDScene):
    """Template: Đồ thị 3D cho hàm 2 biến"""

    def construct(self):
        axes = ThreeDAxes()

        # z = sin(x) * cos(y)
        surface = Surface(
            lambda u, v: axes.c2p(u, v, np.sin(u) * np.cos(v)),
            u_range=[-3, 3],
            v_range=[-3, 3],
            resolution=(30, 30)
        )
        surface.set_fill_by_value(axes=axes, colorscale=[BLUE, GREEN, YELLOW])

        self.set_camera_orientation(phi=60 * DEGREES, theta=-45 * DEGREES)
        self.play(Create(axes), Create(surface))
        self.begin_ambient_camera_rotation(rate=0.2)
        self.wait(5)

5. YouTube Shorts Template

from manim import *

# Config cho Shorts (9:16)
config.frame_width = 9
config.frame_height = 16
config.pixel_width = 1080
config.pixel_height = 1920

class MathShort(Scene):
    """Template: Math animation cho YouTube Shorts"""

    def construct(self):
        # Title lớn ở trên
        title = Text("Đạo hàm là gì?", font_size=72).to_edge(UP, buff=1)

        # Đồ thị ở giữa
        axes = Axes(
            x_range=[-2, 2],
            y_range=[-1, 4],
            x_length=7,
            y_length=8
        ).shift(DOWN * 1)

        func = axes.plot(lambda x: x**2, color=BLUE)

        # Công thức ở dưới
        formula = MathTex(r"f'(x) = 2x", font_size=60).to_edge(DOWN, buff=1)

        # Fast animations cho Shorts
        self.play(Write(title), run_time=0.5)
        self.play(Create(axes), Create(func), run_time=1)
        self.play(Write(formula), run_time=0.5)
        self.wait(1)

---

Common Mobjects

Mathematical Objects

# Công thức toán
MathTex(r"\frac{d}{dx}[x^n] = nx^{n-1}")

# Hệ trục tọa độ
Axes(x_range=[-5, 5], y_range=[-3, 3])

# Hệ trục 3D
ThreeDAxes()

# Đồ thị hàm số
axes.plot(lambda x: x**2, color=BLUE)

# Vector
Arrow(start=ORIGIN, end=[2, 1, 0], color=RED)
Vector([2, 1])

# Ma trận
Matrix([[1, 2], [3, 4]])

Shapes

Circle(radius=1, color=BLUE)
Square(side_length=2)
Triangle()
Polygon([[-1, 0, 0], [1, 0, 0], [0, 2, 0]])
Line(start=[-2, 0, 0], end=[2, 0, 0])
Dot(point=[1, 1, 0], color=RED)

---

Animation Methods

Basic Animations

self.play(Create(obj))       # Vẽ từ từ
self.play(Write(text))       # Viết chữ/công thức
self.play(FadeIn(obj))       # Hiện dần
self.play(FadeOut(obj))      # Ẩn dần
self.play(GrowFromCenter(obj))  # Phóng to từ tâm

Transform

self.play(Transform(obj1, obj2))      # Biến đổi
self.play(ReplacementTransform(a, b)) # Thay thế
self.play(obj.animate.shift(RIGHT))   # Di chuyển
self.play(obj.animate.scale(2))       # Scale
self.play(obj.animate.rotate(PI/2))   # Xoay

Camera (3D)

self.set_camera_orientation(phi=60*DEGREES, theta=-45*DEGREES)
self.begin_ambient_camera_rotation(rate=0.2)
self.move_camera(phi=75*DEGREES)

---

Render Commands

YouTube Standard

# Preview nhanh
manim -ql scene.py SceneName

# 1080p 60fps (YouTube recommended)
manim -qh scene.py SceneName

# 4K 60fps (YouTube premium)
manim -qk scene.py SceneName

# Mở file sau khi render
manim -qh -p scene.py SceneName

YouTube Shorts

# Shorts 1080x1920 (vertical)
manim -qh -r 1080,1920 scene.py SceneName

# Shorts 4K vertical
manim -qk -r 2160,3840 scene.py SceneName

Other Formats

# GIF (cho preview/thumbnail)
manim -qm --format gif scene.py SceneName

# WebM
manim -qh --format webm scene.py SceneName

# PNG frames
manim -qh --format png scene.py SceneName

Output Directory

media/
├── videos/
│   └── scene/
│       ├── 480p15/          # -ql
│       ├── 720p30/          # -qm
│       ├── 1080p60/         # -qh (YouTube)
│       ├── 1440p60/         # -qp
│       └── 2160p60/         # -qk (4K)
├── images/
└── Tex/

---

Configuration

manim.cfg file

[CLI]
quality = high_quality
preview = True

[output]
media_dir = ./output
video_dir = {media_dir}/videos
images_dir = {media_dir}/images

[video]
frame_rate = 60
pixel_width = 1920
pixel_height = 1080

Programmatic Config

from manim import *

# YouTube 1080p
config.frame_rate = 60
config.pixel_width = 1920
config.pixel_height = 1080

# YouTube Shorts
config.frame_width = 9
config.frame_height = 16
config.pixel_width = 1080
config.pixel_height = 1920

---

YouTube Specifications

Standard Videos (16:9)

Quality	Resolution	Bitrate (SDR)	Bitrate (HDR)
1080p 30fps	1920×1080	8 Mbps	10 Mbps
1080p 60fps	1920×1080	12 Mbps	15 Mbps
4K 30fps	3840×2160	35-45 Mbps	44-56 Mbps
4K 60fps	3840×2160	53-68 Mbps	66-85 Mbps

Shorts (9:16)

• Resolution: 1080×1920 (recommended)
• Max duration: 60 seconds
• Aspect ratio: 9:16
• Format: MP4 (H.264)

Best Practices

1. Frame rate: Dùng 60fps cho animation mượt
2. Duration: Shorts tối đa 60s, thường 15-30s hiệu quả nhất
3. Text size: Font lớn hơn cho Shorts (mobile-first)
4. Colors: Contrast cao, tránh màu quá nhạt

---

Tips & Best Practices

Performance

• Dùng -ql để preview nhanh
• Chỉ render -qk (4K) khi cần final output
• Cache LaTeX với --flush_cache khi cần

Animation Quality

# Smooth animations
self.play(Create(obj), run_time=2)  # Chậm hơn = mượt hơn

# Easing functions
self.play(obj.animate.shift(RIGHT), rate_func=smooth)
self.play(obj.animate.scale(2), rate_func=there_and_back)

Shorts Optimization

# Font lớn cho mobile
Text("Title", font_size=72)
MathTex(r"formula", font_size=60)

# Animation nhanh
self.play(Write(text), run_time=0.5)

# Vertical layout
obj.to_edge(UP, buff=1)
obj.to_edge(DOWN, buff=1)

---

References

• references/manim-patterns.md - Common animation patterns
• references/youtube-specs.md - YouTube video specifications
• templates/ - Ready-to-use scene templates
• examples/ - Complete working examples

---

External Resources

• Manim Community Docs
• 3Blue1Brown Manim
• YouTube Upload Specs

---

Animated Math Skill v1.0 - Part of MicroAI Document Skills