思考机器2

这个屌丝很懒，什么也没留下！

热门标签

利用Python中的Manim进行数学绘画和创作_manim教程线性代数

作者：思考机器2 | 2024-01-02 15:36:35

踩

manim教程线性代数

在这里插入图片描述

相信很多同学就算没听过3Blue1Brown，也一定曾看过他们出品的视频，其从独特的视觉角度解说各种数学概念，内容包括线性代数、微积分、神经网络、傅里叶变换以及四元数等晦涩难懂的知识点。例如最火的《线性代数本质》系列视频。

那么这些视频是如何制作的呢？

这里需要引入的是Python的Manim视频支持引擎——专门用于支持数学可视化的媒体引擎，通过Manim并结合Python编程就可以实现3Blue1Brown的视频效果。
在这里插入图片描述

什么是Python

在当今备受推崇的大数据技术和人工智能技术领域，Python一直是一门备受瞩目的编程语言。它长期占据着TIOBE公布的编程语言排行榜的榜首位置。业界也一直流传着一句话：“人生苦短，我用Python”。Python作为一门计算机编程语言具有独特的优势，可以总结为以下三个特点：简洁性、易读性和可扩展性。

简洁性：
Python是一门非常简洁的脚本语言。很多时候，只需一行代码就能实现复杂的功能。比如，下面这行代码就能打印出一个九九乘法表。这种简洁性使得你能够将注意力集中在解决问题上，而不必花费过多时间去理解语言本身。
在这里插入图片描述

易读性：
Python的语法风格清晰简约，易于阅读。有时候，它就像人类说话一样自然简单，没有过多的修饰。

可扩展性：
Python最初的设计就注重可扩展性，它并没有将所有的特性和功能集成到核心语言中。Python提供了丰富的API和工具，以及众多第三方库，让你可以灵活扩展其功能。你可以根据需要选择合适的库来解决问题，这使得Python非常适合各种不同的应用场景。

什么是manim

manim视频

manim是一个Python第三方库，全称是mathematical animation engine（数学动画引擎）。它是由斯坦福大学数学系学生Grant Sanderson在其YouTube频道3Blue1Brown上创建的。manim用于解说线性代数、微积分、神经网络、黎曼猜想、傅里叶变换以及四元数等数学概念。

manim因其精美的动画制作和独特的解释角度而广受关注，并吸引了越来越多的读者参与其中，共同贡献内容。manim经历了两个版本的迭代。第一代是ManimCairo，这是较早的版本，Grant Sanderson早期的项目都是在此版本中编译的。它使用cairo库作为渲染引擎。第二代是ManimGL，由Grant Sanderson等人开发的最新版本。该版本的最大改进是采用更强大的OpenGL库进行渲染。

此外，还有ManimCE（manim社区版），也使用OpenGL进行渲染。

manim使你能够以编程的方式创建精确的数学图形、动画和场景。与传统的几何画板等绘图软件不同，manim提供了一种全新的思路：“所思即可得”。它能够实现非常精准的绘制。在manim的世界中，你可以体验到一切皆可设置的感觉。颜色、粗细、长度、角度、时长、播放方式等均可通过设置来完成，这使你能够制作出具有个性化的数学动画。

版本	渲染引擎	库
ManimCairo	Cairo	manimlib
ManimGL	OpenGL	manimgl
ManimCE	OpenGL	manim

在这里插入图片描述

如何来运行Manim

安装 Manim：
首先，您需要安装 Python 和一些依赖项。然后，您可以通过以下命令使用 pip 安装 Manim：
```
pip install manim
1
```
创建动画：
创建一个 Python 脚本，并使用 Manim 中的类来定义您的动画场景和对象。
运行 Manim：
在命令行中，转到包含您的 Python 脚本的目录，并使用以下命令来运行 Manim：
```
manim your_script.py YourSceneName -p -ql
1
```
其中，your_script.py 是您的 Python 脚本的文件名，YourSceneName 是您定义的场景名称。

这样，Manim 就会开始渲染动画。请注意，Manim 的运行可能需要一定的时间，具体取决于动画内容和计算机性能。

用 Manim 绘制图形

首先需要引入 Manim 库，然后将需要绘制的内容封装到一个类(class)里面。

from manim import *
1

对于编辑好的程序文件（例如christmas-intro.py文件），需要在同一个文件夹下运行命令来运行程序，命令格式如下：

manim -pql christmas-intro.py DemoSquare
1

上面的命令行中：

manim 是运行程序的主要标志用语；
p 表示程序运行后会进行预览（图片或视频）；
ql 表示低质量（quality low）, 其他的选项有 -ql, -qm, -qh, -qk, 分别表示低质量、正常质量、高质量、4K质量；
christmas-intro.py 是py代码文件；
DemoSquare 是 py代码文件中的一个类；

命令行中，还有其他许多参数可以设置，可以通过社区版的支持文档来进一步了解。

几个常见方程的示例

在这里插入图片描述

from manim import *

class QuadraticSurface(ThreeDScene):
    def construct(self):
        resolution_fa = 24 #曲面样本数
        axes = ThreeDAxes() #3维度笛卡尔直角坐标系
        self.set_camera_orientation(phi = 75*DEGREES, theta = 45*DEGREES) #phi是竖直方向岔开的角度，theta是水平面岔开的角度
    
        def paramsFunc(u, v): #参数方程
            
            x = u
            y = 1/2*u**2
            z = v
            return np.array([x, y, z])

        quadratic_surface = Surface(
            paramsFunc,
            resolution = (resolution_fa, resolution_fa), #分辨率
            u_range=[-2.5, +2.5], #参数u的范围
            v_range=[-1, +1], #参数v的范围
            fill_opacity = 0.5 #透明度

        ) #二次曲面

        self.add(axes) #添加坐标轴
        self.wait() #停留一秒
        self.play(Write(quadratic_surface), run_time = 10) #绘制二次曲面
        self.begin_3dillusion_camera_rotation(rate = 2) #摇晃rotation illusion
        self.wait(PI) #摇晃时长
        self.stop_3dillusion_camera_rotation() #停止摇晃

with tempconfig({'quality':'medium_quality', 'preview':True}):
    scene = QuadraticSurface()
    scene.render()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

在这里插入图片描述

from manim import *

class QuadraticSurface(ThreeDScene):
    def construct(self):
        resolution_fa = 24 #曲面样本数
        axes = ThreeDAxes() #3维度笛卡尔直角坐标系
        self.set_camera_orientation(phi = 75*DEGREES, theta = 45*DEGREES) #phi是竖直方向岔开的角度，theta是水平面岔开的角度
    
        def paramsFunc(u, v): #参数方程
            
            x = np.sqrt(2)* np.cos(TAU*u)*v
            y = np.sqrt(2)* np.sin(TAU*u)*v
            z = v
            return np.array([x, y, z])

        quadratic_surface = Surface(
            paramsFunc,
            resolution = (resolution_fa, resolution_fa), #分辨率
            u_range=[-2, +2], #参数u的范围
            v_range=[-2, +2], #参数v的范围
            fill_opacity = 0.5 #透明度

        ) #二次曲面

        self.add(axes) #添加坐标轴
        self.wait() #停留一秒
        self.play(Write(quadratic_surface), run_time = 10) #绘制二次曲面
        self.begin_3dillusion_camera_rotation(rate = 2) #摇晃rotation illusion
        self.wait(PI) #摇晃时长
        self.stop_3dillusion_camera_rotation() #停止摇晃

with tempconfig({'quality':'medium_quality', 'preview':True}):
    scene = QuadraticSurface()
    scene.render()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

manin安装教程

https://docs.manim.community/en/stable/installation.html（社区版）
在这里插入图片描述
Manim教程合集
https://www.bilibili.com/video/BV1W4411Z7Zt/?vd_source=3ef6540f8473c7367625a53b7b77fd66

Manim官方文档
https://docs.manim.org.cn/cairo-backend/getting_started/index.html
在这里插入图片描述

from manim import *

class QuadraticSurface(ThreeDScene):
    def construct(self):
        resolution_fa = 24 #曲面样本数
        axes = ThreeDAxes() #3维度笛卡尔直角坐标系
        self.set_camera_orientation(phi = 75*DEGREES, theta = 45*DEGREES) #phi是竖直方向岔开的角度，theta是水平面岔开的角度
    
        def paramsFunc(u, v): #参数方程

            x =  np.sinh(u)*np.cos(v)
            y =  np.sinh(u)*np.sin(v)
            z =  np.cosh(u)
            return np.array([x, y, z])

        quadratic_surface = Surface(
            paramsFunc,
            resolution = (resolution_fa, resolution_fa), #分辨率
            u_range=[-1.5, +1.5], #参数u的范围
            v_range=[-PI, +PI], #参数v的范围
            fill_opacity = 0.5 #透明度

        ) #二次曲面


        def paramsFunc1(u, v): #参数方程

            x =  np.sinh(u)*np.cos(v)
            y =  np.sinh(u)*np.sin(v)
            z =  np.cosh(u)
            return np.array([x, y, -z])
        
        quadratic_surface1 = Surface(
                paramsFunc1,
                resolution = (resolution_fa, resolution_fa), #分辨率
                u_range=[-1.5, +1.5], #参数u的范围
                v_range=[-PI, +PI], #参数v的范围
                fill_opacity = 0.5 #透明度

            ) #二次曲面


        self.add(axes) #添加坐标轴
        self.wait() #停留一秒
        self.play(Write(quadratic_surface), run_time = 10) #绘制二次曲面
        self.play(Write(quadratic_surface1), run_time = 10) #绘制二次曲面
        self.begin_3dillusion_camera_rotation(rate = 2) #摇晃rotation illusion
        self.wait(PI) #摇晃时长
        self.stop_3dillusion_camera_rotation() #停止摇晃

with tempconfig({'quality':'medium_quality', 'preview':True}):
    scene = QuadraticSurface()
    scene.render()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

版本说明

对于 Manim 的初学者，使用 Manim 时，对于其版本的选择还是有些需要注意的地方。

不同版本的代码、教程等，还是有稍许差异的。

目前 Manim 主要有三个版本：

3b1b 旧版：3blue1brown 自己维护的版本，使用 Cairo 作为后端；

3b1b 新版：3blue1brown 自己维护的版本，使用 OpenGL 和 moderngl 来进行 GPU 渲染，优点是速度快；

Manim 社区版：社区版是2020年下半年才出来的版本，目前主要是 Manim 旧版的衍生，更新更活跃，有很好的文档和社区支持。当然，随着社区版的迭代更新，目前 3b1b 新版的某些特性也在逐步容纳进来。

关于这几个版本如何选择的建议：

如果你是新接触这个工具的，建议可以从社区版开始，主要是社区版的文档教程比较齐全，其迭代的频率更快。
如果你是 Python 或者其他编程领域的资深人士，想体自己动手深入理解并优化这个工具，可以使用 3b1b 新版

Manim 的安装

在 Manim 3b1b 版本和社区版均提供了如何安装的文档：

3b1b 新版的安装文档：https://github.com/3b1b/manim
社区版的安装文档：https://docs.manim.community/en/stable/installation.html

安装ffmpeg

FFmpeg是一个开源的跨平台音视频处理工具，可以用来录制、转换和流式传输音视频内容。它包括一组库和程序，可以处理多种不同格式的音频、视频和图片文件。FFmpeg支持几乎所有主流的音视频格式，因此被广泛应用于多媒体处理领域。

FFmpeg提供了丰富的功能，包括但不限于：

音视频编解码：可以对音频和视频进行编码（压缩）和解码（解压），支持众多编解码器。
格式转换：可以将音视频文件从一个格式转换为另一个格式，例如从MP4转换为AVI。
剪辑和编辑：可以对音视频文件进行剪辑、合并、分离等操作。
流媒体处理：支持流式传输音视频内容，适用于网络直播、视频会议等场景。
屏幕录制：可以用来录制屏幕内容并保存为视频文件。

由于其强大的功能和灵活性，FFmpeg被广泛用于视频处理、视频转码、音频处理等各种多媒体应用中。同时，FFmpeg也是许多视频播放器、编辑软件以及流媒体平台的重要组件之一。

安装FFmpeg可以通过命令行或者图形界面进行操作，以下是在Windows和MacOS上安装FFmpeg的基本步骤：

在Windows上安装FFmpeg

下载FFmpeg：
- 访问FFmpeg官方网站或Windows Builds by BtbN下载最新版本的静态链接的可执行文件。
解压文件：
- 将下载的压缩包解压到你想要安装的位置。
设置环境变量（可选）：
- 将FFmpeg的bin目录添加到系统的PATH环境变量中，这样就可以在命令行中直接访问FFmpeg。
测试安装：
- 打开命令提示符（Win + R，输入cmd，回车），输入以下命令来检查FFmpeg是否成功安装：
```
ffmpeg -version
1
```

在MacOS上安装FFmpeg

使用Homebrew安装（推荐）：
- 打开终端，运行以下命令安装Homebrew：
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
1
```
- 然后运行以下命令来安装FFmpeg：
```
brew install ffmpeg
1
```
测试安装：
- 在终端中输入以下命令来检查FFmpeg是否成功安装：
```
ffmpeg -version
1
```

在Linux上安装FFmpeg

使用包管理器安装：
- 对于大多数Linux发行版，可以使用其包管理器来安装FFmpeg。例如，在Ubuntu上可以使用以下命令：
```
sudo apt-get update
sudo apt-get install ffmpeg
1
2
```
测试安装：
- 在终端中输入以下命令来检查FFmpeg是否成功安装：
```
ffmpeg -version
1
```

验证安装

无论在哪个操作系统上安装，验证安装步骤都是一样的。只需要在命令行或终端中输入以下命令：

ffmpeg -version
1

如果安装成功，会显示FFmpeg的版本信息。这样就可以确认FFmpeg已经成功安装并且可以在系统中正常运行了。

在这里插入图片描述

安装Latex

LaTeX是一种专业的排版系统，常用于撰写学术论文、书籍、报告和演示文稿。与常见的文字处理软件（如Microsoft Word）不同，LaTeX使用的是一种“标记语言”，用户需要通过输入特定的命令和标记来控制文档的格式、结构和样式。

LaTeX最初是由著名计算机科学家Leslie Lamport开发的，它建立在TeX排版系统之上，并提供了一系列功能强大的工具和环境，使用户能够轻松地创建高质量的文档。

使用LaTeX编写文档的优势包括：

专业的排版效果：LaTeX能够生成高质量、专业水准的文档排版，特别适合于学术论文、书籍等内容丰富的文档。
具有强大的数学公式排版能力：LaTeX在排版数学公式和符号方面非常出色，被广泛应用于数学、物理等领域的文档撰写。
跨平台性：LaTeX在不同操作系统上都可以运行，并且生成的文档格式稳定、可靠。

虽然学习曲线较陡，但一旦熟悉了LaTeX的基本语法和命令，就能够享受到其带来的排版便利和效果。

安装LaTeX可以通过以下步骤进行操作：

在Windows上安装LaTeX

在这里插入图片描述

下载安装包：
- 访问TeX Users Group或MiKTeX网站，下载LaTeX发行版的安装程序。
运行安装程序：
- 双击下载的安装程序，按照提示进行安装。
配置编辑器（可选）：
- 如果你希望使用图形化的编辑器来编写LaTeX文档，可以安装一些流行的LaTeX编辑器，如TeXstudio、TeXworks等，这些编辑器通常会自动检测已安装的LaTeX发行版。
测试安装：
- 打开命令提示符或者你喜欢的LaTeX编辑器，新建一个简单的.tex文件，输入以下内容并保存：
```
\documentclass{article}
\begin{document}
Hello, LaTeX!
\end{document}
1
2
3
4
```
- 编译这个文件，如果能够生成对应的.pdf文件并且内容显示正常，那么LaTeX安装成功了。

在MacOS上安装LaTeX

使用MacTeX安装：
- 下载并安装MacTeX，这是专为MacOS准备的LaTeX发行版。你可以在MacTeX官方网站下载最新版本的安装程序。
配置编辑器（可选）：
- 安装一些流行的LaTeX编辑器，如TeXShop、TeXstudio等，这些编辑器通常会自动检测已安装的LaTeX发行版。
测试安装：
- 使用编辑器创建一个简单的.tex文件，输入上述示例中的内容，并进行编译。

在Linux上安装LaTeX

使用包管理器安装：
- 对于大多数Linux发行版，可以使用其包管理器来安装LaTeX。例如，在Ubuntu上可以使用以下命令：
```
sudo apt-get update
sudo apt-get install texlive-full
1
2
```
测试安装：
- 使用编辑器创建一个简单的.tex文件，输入上述示例中的内容，并进行编译。

安装dvisvgm

安装 dvisvgm 可以通过以下步骤进行：

Windows 用户

使用 Chocolatey 进行安装：
打开命令提示符（CMD）或 PowerShell，并执行以下命令：
```
choco install dvisvgm
1
```

macOS 用户

使用 Homebrew 进行安装：
打开终端，并执行以下命令：
```
brew install dvisvgm
1
```

Linux 用户

对于基于 Debian 的系统（如 Ubuntu）：
打开终端，并执行以下命令：
```
sudo apt-get install dvisvgm
1
```
对于基于 Red Hat 的系统（如 Fedora）：
打开终端，并执行以下命令：
```
sudo dnf install dvisvgm
1
```

一旦安装完成，您可以在命令行中运行 dvisvgm --version 来验证 dvisvgm 是否成功安装。

在这里插入图片描述

利用Manim绘制苹果logo

from manimlib.imports import *
from my_projects.my_utils.boolean_operation import VGroup_

get_angle = lambda c: np.angle(-c) + PI if not c/abs(c) == 1 else 0
convert_angle = lambda a: a if a>=0 else a + TAU

class Apple_logo(VGroup):

    CONFIG = {
        'scale': 0.25,
        'logo_color': RED_D,
        'logo_stroke': 8,
        'coord_center': DOWN * 1.25,
        'assistent_lines_config': {
            'stroke_width': 2,
            'stroke_color': GREY,
        },
        'key_lines_config': {
            'stroke_width': 2.5,
            'stroke_color': GREY_E,
        },
        'step_size': 0.02,
        'create_shape': True,

    }

    def __init__(self, **kwargs):

        VGroup.__init__(self, **kwargs)
        self.set_key_lines()
        self.set_outline()
        if self.create_shape:
            self.set_logo_shape()

    def set_key_lines(self):

        s = self.scale
        center = self.coord_center
        self.c1 = Circle(arc_center=center+ORIGIN, radius=1/2*s, **self.key_lines_config)
        self.c5_r = Circle(arc_center=center+3*s*RIGHT, radius=5/2*s, **self.key_lines_config)
        self.c5_l = Circle(arc_center=center+3*s*LEFT,  radius=5/2*s, **self.key_lines_config)
        # self.c5_l = self.c5_r.copy().flip()
        self.c8_d = Circle(arc_center=center + s * 5.77 * DOWN, radius=8/2*s, **self.key_lines_config)
        self.c13  = Circle(arc_center=center + s * 4.73 * UP, radius=13/2*s, **self.key_lines_config)
        self.c8_r = Circle(arc_center=center + s * ( 3.48 * RIGHT + 7.69 * UP),
                           radius=8/2*s, **self.key_lines_config)
        self.c8_l = Circle(arc_center=center + s * (-3.48 * RIGHT + 7.69 * UP),
                           radius=8/2*s, **self.key_lines_config)
        self.c3_r = Circle(arc_center=center + s * ( 5.9 * RIGHT + 2.75 * UP),
                           radius=3/2*s, **self.key_lines_config)
        self.c3_l = Circle(arc_center=center + s * (-5.9 * RIGHT + 2.75 * UP),
                           radius=3/2*s, **self.key_lines_config)
        self.c24_r = Circle(arc_center=center + s * ( 3.89 * RIGHT + 6.54 * UP),
                           radius=24/2*s, **self.key_lines_config)
        self.c24_l = Circle(arc_center=center + s * (-3.89 * RIGHT + 6.54 * UP),
                           radius=24/2*s, **self.key_lines_config)


        self.c12_r = Circle(arc_center=center + s * ( 2.11 * RIGHT + 6.23 * UP),
                           radius=12/2*s, **self.key_lines_config)
        self.c12_l = Circle(arc_center=center + s * (-2.11 * RIGHT + 6.23 * UP),
                           radius=12/2*s, **self.key_lines_config)
        self.c8_u = Circle(arc_center=center + s * 14.89 * UP, radius=8/2*s, **self.key_lines_config)
        self.c8_01 = Circle(arc_center=center + s * (8.82 * RIGHT + 6.23 * UP),
                            radius=8/2*s, **self.key_lines_config)
        self.c8_02 = Circle(arc_center=center + s * (3.61 * RIGHT + 12.23 * UP),
                            radius=8/2*s, **self.key_lines_config)
        self.c8_03 = Circle(arc_center=center + s * (-0.46 * RIGHT + 15.69 * UP),
                            radius=8/2*s, **self.key_lines_config)

        self.key_lines = VGroup(self.c1, self.c5_r, self.c5_l,
                                self.c8_d, self.c13,
                                self.c8_r, self.c8_l,
                                self.c3_r, self.c3_l,
                                self.c24_r, self.c24_l,
                                self.c12_r, self.c12_l,
                                self.c8_u,
                                self.c8_01,
                                self.c8_02, self.c8_03,
                                )
        self.key_lines_center = VGroup(* [Dot(c.get_center(), stroke_color=self.key_lines_config['stroke_color'],
                                              radius=self.key_lines_config['stroke_width']/100) for c in self.key_lines])
        return self

    def set_outline(self):
        s = self.scale
        center = self.coord_center
        # kp_list = [[7.41, 2.49, 0], [4.81, -1.72, 0], [1.85, -2.22, 0], [-1.85, -2.22, 0], [-4.81, 1.72, 0], [-8.1, 5.91, 0],
        #            [-6.22, 10.6, 0], [-1.74, 11.29, 0], [1.74, 11.29, 0], [6.22, 10.6, 0], [6.95, 9.77, 0], [-0.37, 11.87, 0], [3.42, 16.22, 0]]
        kp_list = [[6.95, 9.77, 0], [6.22, 10.6, 0], [1.74, 11.29, 0], [-1.74, 11.29, 0], [-6.22, 10.6, 0], [-8.1, 5.91, 0],
                   [-4.81, -1.72, 0], [-1.85, -2.22, 0], [1.85, -2.22, 0], [4.81, -1.72, 0], [7.41, 2.49, 0], [-0.35, 11.69, 0], [3.5, 16.23, 0]]

        self.key_angles = np.array([10.62, 69, -51.5, 69, 49.77, 40.52, 73.94, -54.97, 73.94, 23.77, -131.51, 96.09, -96.09]) * DEGREES
        self.key_radius = np.array([12/2, 8/2, 8/2, 8/2, 12/2, 24/2, 5/2, 8/2, 5/2, 24/2, 8/2]) * s
        self.key_points = np.array(kp_list) * s + center
        n = len(kp_list)
        self.outline_by_arcs = VGroup_(step_size=self.step_size)
        for i in range(n-2):
            p1, p2 = self.key_points[i], self.key_points[(i+1) % (n-2)]
            arc_i = ArcBetweenPoints(p1, p2, angle=self.key_angles[i], radius=self.key_radius[i], stroke_color=self.logo_color, stroke_width=self.logo_stroke)
            self.outline_by_arcs.add(arc_i)
        arc_1 = ArcBetweenPoints(self.key_points[-2], self.key_points[-1], angle=self.key_angles[-2], radius=self.key_radius[-2], stroke_color=self.logo_color, stroke_width=self.logo_stroke)
        arc_2 = ArcBetweenPoints(self.key_points[-2], self.key_points[-1], angle=self.key_angles[-1], radius=self.key_radius[-1], stroke_color=self.logo_color, stroke_width=self.logo_stroke)

        self.outline_by_arcs.add(arc_1, arc_2)
        return self

    def set_logo_shape(self):
        s = self.scale
        center = self.coord_center
        self.outline_by_arcs.get_all_outline_points()
        self.shape_1 = self.outline_by_arcs.get_shape(center=center + s * (-3.89 * RIGHT + 6.54 * UP), fill_color=self.logo_color, fill_opacity=1, stroke_color=self.logo_color, stroke_width=self.logo_stroke)
        self.shape_2 = self.outline_by_arcs.get_shape(center=center + s * (1.52 * RIGHT + 14.05 * UP), fill_color=self.logo_color, fill_opacity=1, stroke_color=self.logo_color, stroke_width=self.logo_stroke)
        # shape_1.set_fill(self.logo_color, 1).set_stroke(self.logo_color, self.logo_stroke, 1)
        # shape_2.set_fill(self.logo_color, 1).set_stroke(self.logo_color, self.logo_stroke, 1)
        self.add(self.shape_1, self.shape_2)
        return self

# from my_projects.others.BooleanOperationsOnPolygons import PolygonIntersection, PolygonUnion, PolygonSubtraction
#
# class PolygonBooleanTest(Scene):
#     def construct(self):
#         pol1 = RegularPolygon(9).scale(2).shift(LEFT)
#         pol2 = RegularPolygon(9).scale(2).shift(RIGHT)
#         start = time.perf_counter()
#         boolpol = PolygonSubtraction(
#             PolygonUnion(pol1, pol2), PolygonIntersection(pol1, pol2)
#         ).set_stroke(color=YELLOW, width=0).set_fill(color=YELLOW, opacity=0.5)
#         end = time.perf_counter()
#         print(end - start)
#         self.add(pol1, pol2, boolpol)
#
#         '''
#         pol1 = RegularPolygon(16).scale(2)
#         pol2 = Circle().stretch(1.2, 1).stretch(0.8, 0)
#         pol3 = RegularPolygon(5).scale(2).shift(LEFT*0.9)
#         pol4 = RegularPolygon(3).stretch(3, 1).shift(LEFT)
#         pol5 = Ellipse().scale(0.6).shift(LEFT).stretch(2, 0)
#         #start = time.perf_counter()
#         boolpol = PolygonSubtraction(
#             PolygonUnion(
#                 PolygonIntersection(
#                     PolygonSubtraction(
#                         pol1, pol2), pol3), pol4), pol5) \
#             .set_stroke(color=YELLOW, width=0).set_fill(color=YELLOW, opacity=0.5)
#         #end = time.perf_counter()
#         #print(end - start)#0.49910769999999993
#         self.add(pol1, pol2, pol3, pol4, pol5, boolpol)
#         '''
#

class Compass(VGroup):

    CONFIG = {
        'stroke_color': GREY_E,
        'fill_color': WHITE,
        'stroke_width': 2,
        'leg_length': 3,
        'leg_width': 0.12,
        'r': 0.2,
        'depth_test': True,
    }

    def __init__(self, span=2.5,  **kwargs):

        VGroup.__init__(self, **kwargs)
        self.span = span
        self.create_compass()


    # def create_compass_old(self):
    #
    #     s, l, r = self.span, self.leg_length, self.r
    #     theta = np.arcsin(s/2/l)
    #     arc = Arc(start_angle=-PI/2 + theta, angle=TAU-theta*2, radius=r, stroke_color=self.stroke_color, stroke_width=self.stroke_width*4)
    #     dot = Dot(color=self.stroke_color).set_height(self.stroke_width*8/100)
    #     leg_01 = Line(arc.get_center(), arc.get_center() + complex_to_R3(l * np.exp(1j * (-PI/2-theta))), stroke_color=self.stroke_color, stroke_width=self.stroke_width)
    #     leg_02 = Line(arc.get_center(), arc.get_center() + complex_to_R3(l * np.exp(1j * (-PI/2+theta))), stroke_color=self.stroke_color, stroke_width=self.stroke_width * 1)
    #     leg_11 = Line(arc.get_center(), arc.get_center() + complex_to_R3((l - r * 0.8) * np.exp(1j * (-PI/2-theta))), stroke_color=self.stroke_color, stroke_width=self.stroke_width * 4)
    #     leg_12 = Line(arc.get_center(), arc.get_center() + complex_to_R3((l - r * 0.8) * np.exp(1j * (-PI/2+theta))), stroke_color=self.stroke_color, stroke_width=self.stroke_width * 4)
    #     pen_point = Dot(color=self.stroke_color).set_height(self.stroke_width * 1/125).move_to(leg_02.get_end())
    #     leg_1, leg_2 = VGroup(leg_01, leg_11),  VGroup(leg_02, leg_12, pen_point)
    #     head = Line(UP * r, UP * (r + r * 1), stroke_color=self.stroke_color, stroke_width=self.stroke_width * 4)
    #
    #     self.add(arc, dot, head, leg_1, leg_2)
    #     self.move_to(ORIGIN)
    #
    #     return self

    def create_compass(self):

        s, l, r, w = self.span, self.leg_length, self.r, self.leg_width
        self.theta = np.arcsin(s/2/l)

        self.c = Circle(radius=r, fill_color=self.fill_color, fill_opacity=1, stroke_color=self.stroke_color, stroke_width=self.stroke_width*5)
        c2 = Circle(radius=r+self.stroke_width*5/100/2, fill_opacity=0, stroke_color=self.fill_color, stroke_width=self.stroke_width)

        self.leg_1 = Polygon(ORIGIN, l * RIGHT, (l-w*np.sqrt(3)) * RIGHT + w * DOWN, w * DOWN,
                             stroke_width=0, stroke_color=self.fill_color, fill_color=self.stroke_color,
                             fill_opacity=1).rotate(-PI/2-self.theta, about_point=self.c.get_center())
        self.leg_2 = Polygon(ORIGIN, l * RIGHT, (l-w*np.sqrt(3)) * RIGHT + w * UP, w * UP,
                             stroke_width=0, stroke_color=self.fill_color, fill_color=self.stroke_color,
                             fill_opacity=1).rotate(-PI/2+self.theta, about_point=self.c.get_center())


        # self.leg_1, self.leg_2 = VGroup(leg_01, leg_11),  VGroup(leg_02, leg_12, pen_point)
        h = Line(UP * r, UP * (r + r * 1.8), stroke_color=self.stroke_color, stroke_width=self.stroke_width*6)

        self.head = VGroup(h, self.c, c2)
        self.add(self.leg_1, self.leg_2, self.head)
        self.move_to(ORIGIN)

        return self

    def get_niddle_tip(self):
        return self.leg_1.get_vertices()[1]

    def get_pen_tip(self):
        return self.leg_2.get_vertices()[1]

    def move_niddle_tip_to(self, pos):
        self.shift(pos-self.get_niddle_tip())
        return self

    def rotate_about_niddle_tip(self, angle=PI/2):
        self.rotate(angle=angle, about_point=self.get_niddle_tip())

    def get_span(self):
        # return self.span 如果进行了缩放而self.span没变会有问题
        return get_norm(self.get_pen_tip() - self.get_niddle_tip())

    def set_span(self, s):
        self.span = s
        l, r, w = self.leg_length, self.r, self.leg_width
        theta_new, theta_old = np.arcsin(s/2/l), self.theta
        sign = np.sign(get_angle(R3_to_complex(self.leg_2.get_vertices()[1] - self.leg_2.get_vertices()[0])) - get_angle(R3_to_complex(self.leg_1.get_vertices()[1] - self.leg_1.get_vertices()[0])))
        rotate_angle = 2 * (theta_new - theta_old) * sign
        self.leg_2.rotate(rotate_angle, about_point=self.c.get_center())
        self.theta=theta_new
        self.head.rotate(rotate_angle/2, about_point=self.c.get_center())
        self.rotate_about_niddle_tip(-rotate_angle/2)
        return self

    def set_compass(self, center, pen_tip):
        self.move_niddle_tip_to(center)
        self.set_span(get_norm(pen_tip - center))
        self.rotate_about_niddle_tip(np.angle(R3_to_complex(pen_tip - center)) - np.angle(R3_to_complex(self.get_pen_tip() - center)))
        return self

    def set_compass_to_draw_arc(self, arc):
        return self.set_compass(arc.arc_center, arc.get_start())

    def reverse_tip(self):
        return self.flip(axis=self.head[0].get_end() - self.head[0].get_start(), about_point=self.c.get_center())

class DrawingScene(Scene):

    CONFIG = {
        'compass_config':{
            'stroke_color': GREY_E,
            'fill_color': WHITE,
            'stroke_width': 2,
            'leg_length': 3,
            'leg_width': 0.12,
            'r': 0.2,
            'depth_test': True,
        },
        'ruler_config':{
            'width': 10,
            'height': 0.8,
            'stroke_width': 8,
            'stroke_color': GREY_E,
            'stroke_opacity': 0.4,
            'fill_color': WHITE,
            'fill_opacity': 0.5,
        },
        'dot_config':{
            'radius': 0.06,
            'color': GREY_E,
        },
        'line_config':{
            'stroke_color': GREY_E,
            'stroke_width': 2.5,
        },
        'brace_config':{
            'fill_color': GREY_E,
            'buff':0.025,
        },
        'text_config':{
            'size': 0.6 * 5, # 5 times than the actual size and the sacle down
            'font': 'Cambria Math',
            'color': GREY_E,
        },
        'add_ruler': False,
    }

    def setup(self):
        self.cp = Compass(**self.compass_config)
        self.ruler = VGroup(Rectangle(**self.ruler_config).set_height(self.ruler_config['height'] - self.ruler_config['stroke_width']/2/100, stretch=True)\
                            .round_corners(self.ruler_config['height']/8),
                            Rectangle(**self.ruler_config).set_opacity(0))
        self.dot = Dot(**self.dot_config)

        self.cp.move_to(UP * 10)
        if self.add_ruler:
            self.ruler.move_to(DOWN * 10)
            self.add(self.ruler)
        self.add(self.cp)

        self.temp_points = []

    def construct(self):

        self.add(self.cp)
        self.play(self.cp.move_niddle_tip_to, ORIGIN, run_time=1)
        self.wait(0.3)
        self.set_span(3.6, run_time=1, rate_func=smooth)
        self.wait(0.5)
        self.set_compass(DL * 0.5, UR * 0.5, run_time=1, rate_func=there_and_back)
        arc = Arc(color=GREY_E)
        self.set_compass_to_draw_arc(arc)
        self.draw_arc_by_compass(arc)

        self.wait()

    def set_span(self, s, run_time=1, rate_func=smooth):

        s_old = self.cp.get_span()
        n = int(run_time * self.camera.frame_rate)
        dt = 1/self.camera.frame_rate
        t_series = np.linspace(1, n, n)/n
        # s_series = s_old + rate_func(t_series) * (s - s_old)
        s_series = [s_old + rate_func(t_series[i]) * (s - s_old) for i in range(n)]
        for i in range(n):
            self.cp.set_span(s_series[i])
            self.wait(dt)

    def set_compass_direction(self, start, end, run_time=1, rate_func=smooth):
        vect = end - start
        a = np.angle(R3_to_complex(vect))
        c_old, p_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip()
        a_old = np.angle(R3_to_complex(p_old - c_old))
        n = int(run_time * self.camera.frame_rate)
        dt = 1/self.camera.frame_rate
        t_series = np.linspace(1, n, n)/n
        c_series = [c_old + rate_func(t_series[i]) * (start - c_old) for i in range(n)]
        delta_a = (a - a_old)/n
        for i in range(n):
            self.bring_to_front(self.cp)
            self.cp.move_niddle_tip_to(c_series[i])
            self.cp.rotate_about_niddle_tip(delta_a)
            self.wait(dt)

    def set_compass(self, center, pen_tip, run_time=1, rate_func=smooth, emphasize_dot=False):
        if emphasize_dot:
            run_time -= 0.15
        c_old, p_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip()
        n = int(run_time * self.camera.frame_rate)
        dt = 1/self.camera.frame_rate
        t_series = np.linspace(1, n, n)/n
        # s_series = s_old + rate_func(t_series) * (s - s_old)
        c_series = [c_old + rate_func(t_series[i]) * (center - c_old) for i in range(n)]
        p_series = [p_old + rate_func(t_series[i]) * (pen_tip - p_old) for i in range(n)]

        for i in range(n):
            self.bring_to_front(self.cp)
            self.cp.set_compass(c_series[i], p_series[i])
            self.wait(dt)
        if emphasize_dot:
            self.emphasize_dot([center, pen_tip], run_time=0.15)

    def set_compass_(self, center, pen_tip, adjust_angle=0, run_time=1, rate_func=smooth, emphasize_dot=False):

        vect = center - pen_tip
        a = np.angle(R3_to_complex(vect)) + adjust_angle
        s = get_norm(vect)
        c_old, p_old, s_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip(), self.cp.get_span()
        a_old = np.angle(R3_to_complex(p_old - c_old))
        if emphasize_dot:
            run_time -= 0.15
        n = int(run_time * self.camera.frame_rate)
        dt = 1/self.camera.frame_rate
        t_series = np.linspace(1, n, n)/n
        c_series = [c_old + rate_func(t_series[i]) * (center - c_old) for i in range(n)]
        delta_a = (a - a_old)/n
        s_series = [s_old + rate_func(t_series[i]) * (s - s_old) for i in range(n)]

        for i in range(n):
            self.bring_to_front(self.cp)
            self.cp.move_niddle_tip_to(c_series[i])
            self.cp.rotate_about_niddle_tip(delta_a)
            self.cp.set_span(s_series[i])
            self.wait(dt)
        if emphasize_dot:
            self.emphasize_dot([center, pen_tip], run_time=0.15)

    def set_compass_to_draw_arc(self, arc, **kwargs):
        self.set_compass(arc.arc_center, arc.get_start(), **kwargs)

    def set_compass_to_draw_arc_(self, arc, **kwargs):
        self.set_compass_(arc.arc_center, arc.get_start(), **kwargs)

    def draw_arc_by_compass(self, arc, is_prepared=True, run_time=1, rate_func=smooth, reverse=False, add_center=False, **kwargs):
        self.bring_to_front(self.cp)
        if not is_prepared: self.set_compass_to_draw_arc(arc, run_time=0.5)
        theta = arc.angle if not reverse else -1 * arc.angle
        self.play(Rotating(self.cp, angle=theta, about_point=self.cp.get_niddle_tip()), ShowCreation(arc), rate_func=rate_func, run_time=run_time)
        if add_center:
            d = Dot(self.cp.get_niddle_tip(), **self.dot_config).scale(0.5)
            self.temp_points.append(d)
            self.add(d)

    def emphasize_dot(self, pos, add_dot=False, size=1.2, run_time=0.2, **kwargs):
        if type(pos) == list:
            d = VGroup(*[Dot(pos[i], radius=size/2, color=GREY_C, fill_opacity=0.25).scale(0.25) for i in range(len(pos))])
        else:
            d = Dot(pos, radius=size/2, color=GREY_C, fill_opacity=0.25).scale(0.25)
        self.add(d)
        if type(pos) == list:
            self.play(d[0].scale, 4, d[1].scale, 4, rate_func=linear, run_time=run_time)
            
        else:
            self.play(d.scale, 4, rate_func=linear, run_time=run_time)

        self.remove(d)
        if add_dot:
            if type(pos) == list:
                dot = VGroup(*[Dot(pos[i],**kwargs) for i in range(len(pos))])
            else:
                dot = Dot(pos, **kwargs)
            self.add(dot)
            return dot

    def set_ruler(self, pos1, pos2, run_time=1, rate_func=smooth):
        p1, p2 = self.ruler[-1].get_vertices()[1], self.ruler[-1].get_vertices()[0]
        c12 = (p1 + p2) / 2
        center = (pos1 + pos2)/2
        self.bring_to_front(self.ruler)
        self.play(self.ruler.shift, center - c12, run_time=run_time/2, rate_func=rate_func)
        self.play(Rotating(self.ruler, angle=np.angle(R3_to_complex(pos2 - pos1)) - np.angle(R3_to_complex(p2 - p1)), about_point=center), run_time=run_time/2, rate_func=rate_func)

    def draw_line(self, pos1, pos2, is_prepared=True, run_time=1.2, rate_func=smooth, pre_time=0.8):
        if not is_prepared: self.set_ruler(pos1, pos2, run_time=pre_time)
        self.dot.move_to(pos1)
        self.emphasize_dot(pos1, run_time=0.15)
        self.add(self.dot)
        l = Line(pos1, pos2, **self.line_config)
        self.play(ShowCreation(l), self.dot.move_to, pos2, run_time=run_time-0.3, rate_func=rate_func)
        self.emphasize_dot(pos2, run_time=0.15)
        self.remove(self.dot)
        return l

    def draw_line_(self, l, is_prepared=True, run_time=1.2, rate_func=smooth):
        pos1, pos2 = l.get_start(), l.get_end()
        if not is_prepared: self.set_ruler(pos1, pos2, run_time=0.5)
        self.dot.move_to(pos1)
        self.emphasize_dot(pos1, run_time=0.15)
        self.add(self.dot)
        # l = Line(pos1, pos2, **self.line_config)
        self.play(ShowCreation(l), self.dot.move_to, pos2, run_time=run_time-0.3, rate_func=rate_func)
        self.emphasize_dot(pos2, run_time=0.15)
        self.remove(self.dot)
        return l

    def put_aside_ruler(self, direction=DOWN, run_time=0.5):
        self.bring_to_front(self.ruler)
        self.play(self.ruler.move_to, direction * 15, run_time=run_time)

    def put_aside_compass(self, direction=DOWN, run_time=0.5):
        self.bring_to_front(self.cp)
        self.play(self.cp.move_to, direction * 15, run_time=run_time)

    def get_length_label(self, p1, p2, text='', reverse_label=False, add_bg=False, bg_color=WHITE):
        l = Line(p1, p2)
        b = Brace(l, direction=complex_to_R3(np.exp(1j * (l.get_angle()+PI/2 * (1 -2 * float(reverse_label))))), **self.brace_config)
        t = Text(text, **self.text_config).scale(0.2)
        if add_bg:
            bg = SurroundingRectangle(t, fill_color=bg_color, fill_opacity=0.6, stroke_opacity=0).set_height(t.get_height() + 0.05, stretch=True).set_width(t.get_width() + 0.05, stretch=True)
            b.put_at_tip(bg, buff=0.0)
            b.put_at_tip(t, buff=0.05)
            return b, bg, t
        else:
            b.put_at_tip(t, buff=0.05)
            return b, t

    def set_compass_and_show_span(self, p1, p2, run_time=1, show_span_time=[0.4, 0.3, 0.9, 0.4], text='', reverse_label=False, add_bg=True, **kwargs):
        self.set_compass(p1, p2, run_time=run_time, **kwargs)
        bt = self.get_length_label(p1, p2, text=text, reverse_label=reverse_label, add_bg=add_bg)
        b, t = bt[0], bt[-1]
        st = show_span_time
        self.play(ShowCreation(b), run_time=st[0])
        if add_bg:
            self.add(bt[1])
            self.play(FadeIn(t), run_time=st[1])
        else:
            self.play(FadeIn(t), run_time=st[1])
        self.wait(st[2])
        self.play(FadeOut(VGroup(*bt)), run_time=st[3])
        return bt

    def set_compass_and_show_span_(self, p1, p2, run_time=1, show_span_time=[0.4, 0.3, 0.9, 0.4], text='', reverse_label=False, add_bg=True, **kwargs):
        self.set_compass_(p1, p2, run_time=run_time, **kwargs)
        bt = self.get_length_label(p1, p2, text=text, reverse_label=reverse_label)
        b, t = bt[0], bt[-1]
        st = show_span_time
        self.play(ShowCreation(b), run_time=st[0])
        if add_bg:
            self.add(bt[1])
            self.play(FadeIn(t), run_time=st[1])
        else:
            self.play(FadeIn(t), run_time=st[1])
        self.wait(st[2])
        self.play(FadeOut(VGroup(*bt)), run_time=st[3])
        return bt

    def highlight_on(self, *mobjects, to_front=True, stroke_config={'color': '#66CCFF', 'width': 4}, run_time=1, **kwargs):
        self.highlight = VGroup(*mobjects)
        self.play(self.highlight.set_stroke, stroke_config, run_time=run_time, **kwargs)
        if to_front:
            self.bring_to_front(self.highlight)
            self.bring_to_front(self.cp, self.ruler)

    def highlight_off(self, *mobjects):

        pass

    def show_arc_info(self, arc, time_list=[0.5, 0.2, 0.3]):

        c, r, s, a, ps, pe = arc.arc_center, arc.radius, arc.start_angle, arc.angle, arc.get_start(), arc.get_end()
        d_center = Dot(c, radius=0.08, color=PINK)
        r1, r2 = DashedLine(c, ps, stroke_width=3.5, stroke_color=PINK), DashedLine(c, pe , stroke_width=3.5, stroke_color=PINK)
        arc_new = Arc(arc_center=c, radius=r, start_angle=s, angle=a, stroke_width=8, stroke_color=RED)
        self.play(ShowCreation(arc_new), run_time=time_list[0])
        self.play(FadeIn(arc_new), run_time=time_list[1])
        self.play(ShowCreation(r1), ShowCreation(r2), run_time=time_list[2])

class Test_01(Scene):

    def construct(self):

        logo = Apple_logo()
        kl = logo.key_lines
        ol = logo.outline_by_arcs
        self.play(ShowCreation(kl), run_time=6)
        self.wait(0.25)
        # self.play(ShowCreation(ol), run_time=4)
        # self.wait(0.8)

        self.play(DrawBorderThenFill(logo.shape_1, stroke_width=logo.logo_stroke), run_time=3)
        self.play(DrawBorderThenFill(logo.shape_2, stroke_width=logo.logo_stroke), run_time=1.6)
        self.wait(0.2)
        self.play(Uncreate(kl), run_time=1.5)

        self.wait(2)

class Test_compass(Scene):

    def construct(self):
        coord = NumberPlane(axis_config={"stroke_color": GREY_D}, background_line_style={"stroke_color": BLUE_C},)
        self.add(coord)
        cp = Compass(stroke_color=PINK)
        c = Circle(radius=cp.get_span())
        self.add(cp)
        self.wait()
        self.play(cp.move_niddle_tip_to, ORIGIN, run_time=1)
        self.wait()

        self.bring_to_front(cp)
        self.play(Rotating(cp, about_point=cp.get_niddle_tip()), ShowCreation(c), rate_func=smooth, run_time=1.5)
        self.bring_to_front(cp)
        c1 = Circle(stroke_color=GREY_E)
        # self.play(cp.set_span, 1, run_time=1)
        # cp.set_span(1)
        # self.wait()
        # self.play(Rotating(cp, about_point=cp.get_niddle_tip()), ShowCreation(c1), rate_func=smooth, run_time=1.5)
        self.bring_to_front(cp)
        # self.play(cp.set_compass, DL * 2, UR * 2, run_time=1.5)
        cp.set_compass(DL * 2, UR * 2)

        self.wait(2)

class Test_1(DrawingScene):

    def construct(self):

        s = 0.5
        # axis = Axes(x_range=[-30, 30, 1], y_range=[-20, 20, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s)
        # logo = Apple_logo(create_shape=False, coord_center=ORIGIN, scale=s*2)
        # self.add(axis, logo.c1)
        c = Circle(color=BLACK)
        c1 = Circle(color=BLACK)
        c2 = Circle(color=BLACK)
        self.add(c, c1, c2)
        self.wait()
        self.play(ApplyMethod(c.shift, RIGHT * 4, run_time=1),
                  ApplyMethod(c1.shift, RIGHT * 4, run_time=2),
                  ApplyMethod(c2.shift, RIGHT * 4, run_time=4)
        )

class Step_0(DrawingScene):

    '''
    画出基本的直角坐标系作为辅助
    '''

    def construct(self):
        s = 0.5
        # coord = NumberPlane(x_range=[-15, 15, 1], y_range=[-15, 15, 1], axis_config={"stroke_color": GREY_D}, background_line_style={"stroke_color": BLUE_C},).scale(s)
        # logo = Apple_logo(create_shape=False, coord_center=ORIGIN, scale=s)
        self.cp.move_to(UP * 10)
        # self.add(coord)
        self.wait()
        self.play(FadeIn(self.ruler))

        l1 = self.draw_line(LEFT * 4.5, RIGHT * 4.5, is_prepared=False)
        self.put_aside_ruler()
        self.wait()

        arc_1 = Arc(arc_center=LEFT * 2, radius=3, start_angle=-PI/3, angle=2*PI/3, **self.line_config)
        arc_2 = Arc(arc_center=RIGHT * 2, radius=3, start_angle=2 * PI/3, angle=2*PI/3, **self.line_config)

        self.play(self.cp.move_to, ORIGIN)
        self.wait(0.2)
        self.set_compass_to_draw_arc(arc_1, emphasize_dot=True)
        self.draw_arc_by_compass(arc_1)
        self.wait(0.1)
        self.set_compass_to_draw_arc_(arc_2, adjust_angle=PI, emphasize_dot=True)
        self.draw_arc_by_compass(arc_2)
        self.wait(0.2)
        self.put_aside_compass()
        self.set_ruler(UP, DOWN)
        l2 = self.draw_line(UP * 3, DOWN * 3)
        self.put_aside_ruler(direction=LEFT)

        self.wait(0.6)
        self.play(FadeOut(arc_1), FadeOut(arc_2), l1.scale, 2, l2.scale, 2, run_time=1.2)
        self.wait(0.8)

        c1 = Circle(radius=1*s, **self.line_config)
        # c2_l = Circle(arc_center=6*s*LEFT, radius=5*s, **self.line_config)
        # c2_r = Arc(arc_center=6*s*RIGHT, radius=5*s, start_angle=PI, angle=-TAU, **self.line_config)
        self.set_compass_to_draw_arc(c1, run_time=1.2)
        self.wait(0.12)
        self.draw_arc_by_compass(c1)
        self.wait(0.2)
        arcs = VGroup(*[Arc(arc_center=i*s*RIGHT, radius=1*s, start_angle=-PI/6, angle=PI/3, **self.line_config) for i in range(1, 7)])
        for i in range(6):
            self.set_compass_to_draw_arc(arcs[i], run_time=0.32, emphasize_dot=False)
            self.draw_arc_by_compass(arcs[i], run_time=0.5)
        self.wait(0.6)
        axis = Axes(x_range=[-15, 15, 1], y_range=[-10, 10, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5}, ).scale(s)
        dot = Dot(color=GREY_E, radius=0.06)
        self.play(FadeIn(axis), FadeIn(dot), FadeOut(l1), FadeOut(l2), FadeOut(self.cp), FadeOut(arcs))
        self.wait(2)

class Step_1(DrawingScene):
    '''
    画出...
    '''
    def construct(self):

        s = 0.5
        axis = Axes(x_range=[-30, 30, 1], y_range=[-20, 20, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s)
        logo = Apple_logo(create_shape=False, coord_center=ORIGIN, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.06}
        d1 = Dot(**dot_config)
        self.add(axis, logo.c1, d1)
        self.wait()

        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)
        # self.set_compass_to_draw_arc(logo.c5_l, emphasize_dot=True)
        self.set_compass_and_show_span(logo.c5_l.get_center(), logo.c5_l.get_start(), reverse_label=True, text='r=5')
        self.wait(0.1)
        self.draw_arc_by_compass(logo.c5_l)
        self.cp.reverse_tip()
        logo.c5_r.flip()
        self.wait(0.15)

        self.add(d5_l)
        self.set_compass_to_draw_arc(logo.c5_r, emphasize_dot=True)
        # self.set_compass_to_draw_arc_(logo.c5_r, emphasize_dot=True)
        self.draw_arc_by_compass(logo.c5_r, reverse=True)

        self.wait(0.1)
        self.add(d5_r)
        self.put_aside_compass(direction=UP)
        self.wait(0.4)
        self.play(VGroup(*self.mobjects).scale, 0.6, {'about_point': ORIGIN}, run_time=1.2)
        self.play(VGroup(*self.mobjects).shift, UP * 2, run_time=1.2)

        # s_vg = VGroup(axis, logo.c5_l, logo.c5_r, logo.c1)
        # s_vg2 = logo.key_lines.remove(logo.c5_l, logo.c5_r, logo.c1)
        # self.play(s_vg.scale, 0.5, {'about_point': ORIGIN}, run_time=1.2)
        # s_vg2.scale(0.5, about_point=ORIGIN)
        # self.wait(0.4)
        # self.set_compass_(logo.c8_d.get_center(), logo.c8_d.get_start(), emphasize_dot=True)
        # # self.set_compass_to_draw_arc(logo.c8_d, emphasize_dot=True)
        # self.draw_arc_by_compass(logo.c8_d)

        self.wait(2)

class Step_11(DrawingScene):

    CONFIG = {
        'compass_config':{
            'stroke_color': GREY_E,
            'fill_color': WHITE,
            'stroke_width': 2,
            'leg_length': 4,
            'leg_width': 0.12,
            'r': 0.2,
            'depth_test': True,
        },
        'add_ruler': True,
    }

    def construct(self):

        s = 0.5 * 0.6
        axis = Axes(x_range=[-30, 30, 1], y_range=[-25, 25, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s).shift(UP * 2)
        logo = Apple_logo(create_shape=False, coord_center=UP * 2, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.03}
        d1 = Dot(logo.c1.get_center(), **dot_config)
        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)

        self.add(axis, logo.c1, logo.c5_l, logo.c5_r, d1, d5_l, d5_r)

        self.wait()
        self.cp.move_to(DOWN * 10)
        self.cp.rotate_about_niddle_tip(PI)

        arc_13_l = Arc(arc_center=logo.c5_l.get_center(), radius=13 * s, start_angle=3*PI/2, angle=PI/4, **self.line_config)
        arc_13_r = Arc(arc_center=logo.c5_r.get_center(), radius=13 * s, start_angle=3*PI/2-PI/4, angle=PI/4 + PI/2, **self.line_config)
        self.highlight_on(logo.c5_l, logo.c5_r)
        self.wait(0.15)
        self.set_compass_and_show_span(logo.c5_l.get_center(), logo.c5_l.get_center() + (5 + 8) * s * LEFT, reverse_label=True, text='r=5+8=13', run_time=1.4)
        self.wait(0.4)
        self.set_compass_to_draw_arc_(arc_13_l, adjust_angle=PI, rate_func=linear, run_time=0.6)
        self.draw_arc_by_compass(arc_13_l, rate_func=linear, run_time=0.3)
        self.wait(0.12)
        self.set_compass_(logo.c5_r.get_center(), logo.c5_r.get_center() + (5 + 8) * s * LEFT, adjust_angle=PI, emphasize_dot=True, run_time=1.4)
        self.wait(0.2)
        self.set_compass_to_draw_arc_(arc_13_r, adjust_angle=-PI, rate_func=linear, run_time=0.6)
        self.draw_arc_by_compass(arc_13_r, rate_func=linear, run_time=0.9)
        self.wait(0.6)

        self.set_compass_and_show_span(axis.c2p(11, 0), axis.c2p(19, 0), reverse_label=True, text='r=8', run_time=1.2)
        self.wait(0.15)
        self.set_compass_to_draw_arc_(logo.c8_d.scale(0.995), adjust_angle=-PI, run_time=1.)
        self.draw_arc_by_compass(logo.c8_d, run_time=1.2)
        d8_d = Dot(logo.c8_d.get_center(), **dot_config)
        self.add(d8_d)
        self.wait(0.2)
        self.put_aside_compass(UP * 0.5, run_time=1.)
        self.play(FadeOut(arc_13_l), FadeOut(arc_13_r))
        self.remove(self.cp)
        self.wait(0.4)
        self.play(logo.c5_r.set_stroke, {'color': GREY_E, 'width': 2.5}, logo.c5_l.set_stroke, {'color': GREY_E, 'width': 2.5}, run_time=0.6)
        self.wait(0.2)
        self.play(VGroup(*self.mobjects).shift, DOWN * 4, run_time=1.25)

        self.wait(2)

class Step_12(DrawingScene):

    def construct(self):

        s = 0.5 * 0.6
        axis = Axes(x_range=[-30, 30, 1], y_range=[-30, 30, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s).shift(DOWN * 2)
        logo = Apple_logo(create_shape=False, coord_center=DOWN * 2, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.03}
        d1 = Dot(logo.c1.get_center(), **dot_config)
        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)

        self.add(axis, logo.c1, logo.c5_l, logo.c5_r, logo.c8_d.scale(0.995), d1, d5_l, d5_r)
        self.set_compass_and_show_span(axis.c2p(0, 13), axis.c2p(0,0), emphasize_dot=True, reverse_label=True, text='r=13', run_time=2)
        self.wait(0.6)
        logo.c13.rotate(-PI/2)
        self.set_compass_to_draw_arc(logo.c13, emphasize_dot=True)
        self.wait(0.2)
        d13 = Dot(logo.c13.get_center(), **dot_config)
        a_13 = Arc(arc_center=logo.c8_d.get_center() + UP * 8 * s, start_angle=PI/2 + PI/20, radius=13 * s, angle=-PI/10, **self.line_config)

        self.cp.reverse_tip()
        self.set_compass_to_draw_arc(a_13, run_time=0.25)
        self.draw_arc_by_compass(a_13, run_time=0.5)
        self.add(d13)
        self.wait(0.25)
        self.put_aside_compass(RIGHT * 0.8, run_time=1.2)
        self.wait(0.6)
        self.play(VGroup(*self.mobjects).scale, 0.8, {'about_point': axis.c2p(0,0)}, run_time=1.2)

        self.wait(2)

class Step_2(DrawingScene):

    """
    画出辅助正方形
    """

    CONFIG = {
        'compass_config':{
            'stroke_color': GREY_E,
            'fill_color': WHITE,
            'stroke_width': 2,
            'leg_length': 4,
            'leg_width': 0.12,
            'r': 0.2,
            'depth_test': True,
        },
    }

    def construct(self):

        s = 0.5 * 0.6 * 0.8
        axis = Axes(x_range=[-40, 40, 1], y_range=[-36, 36, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s).shift(DOWN * 2)
        logo = Apple_logo(create_shape=False, coord_center=DOWN * 2, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.03}
        d1 = Dot(logo.c1.get_center(), **dot_config)
        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)
        a_13 = Arc(arc_center=logo.c8_d.get_center() + UP * 8 * s, start_angle=PI/2 + PI/30, radius=13 * s, angle=-PI/15, **self.line_config)
        d13 = Dot(logo.c13.get_center(), **dot_config)

        self.add(axis, logo.c1, logo.c5_l, logo.c5_r, logo.c8_d.scale(0.995), a_13, d1, d5_l, d5_r, d13)
        self.wait()

        self.play(FadeIn(self.ruler))
        self.wait(0.2)
        dl, dr = logo.c5_l.get_center() * 8/13 + logo.c8_d.get_center() * 5/13, logo.c5_r.get_center() * 8/13 + logo.c8_d.get_center() * 5/13
        self.set_ruler(dl, dr)
        self.emphasize_dot([dl, dr], run_time=0.2)
        # l = Line(dl + LEFT * 4.5, dr + RIGHT *4.5, **self.line_config)
        self.wait(0.5)
        l = self.draw_line(dl + LEFT * 3.6, dr + RIGHT * 3.6, run_time=1.25)
        self.put_aside_ruler(DOWN * 0.4)
        self.wait(0.1)
        dm = (dl+dr)/2
        self.set_compass(d13.get_center(), dm, emphasize_dot=True, run_time=1.5)
        self.wait(0.2)
        a_13_r = Arc(arc_center=dm, radius=self.cp.get_span(), start_angle=10 * DEGREES, angle=-20 * DEGREES, **self.line_config)
        a_13_l = Arc(arc_center=dm, radius=self.cp.get_span(), start_angle=190 * DEGREES, angle=-20 * DEGREES, **self.line_config)
        # a_13_u = Arc(arc_center=d13.get_center(), radius=self.cp.get_span(), start_angle=100 * DEGREES, angle=20 * DEGREES, **self.line_config)
        l_square = get_norm(d13.get_center()-dm)
        circle = Circle(arc_center=d13.get_center(), radius=l_square * np.sqrt(2), **self.line_config).rotate(-PI/4)

        self.cp.reverse_tip()
        self.set_compass_to_draw_arc_(a_13_l, adjust_angle=PI, run_time=0.64)
        self.draw_arc_by_compass(a_13_l, run_time=0.12, rate_func=linear)
        self.set_compass_to_draw_arc_(a_13_r, adjust_angle=PI, run_time=0.96, rate_func=linear)
        self.draw_arc_by_compass(a_13_r, run_time=0.12, rate_func=linear)
        self.wait(0.25)
        self.cp.reverse_tip()
        self.set_compass_to_draw_arc(circle, run_time=1.2, emphasize_dot=True)
        self.wait(0.15)
        self.draw_arc_by_compass(circle, run_time=1.6)
        self.wait(0.5)
        self.set_compass(dm + l_square * LEFT, dm + l_square * RIGHT, emphasize_dot=True)
        self.wait(0.2)
        self.cp.reverse_tip()
        arc_r = Arc(arc_center=dm + l_square * RIGHT, radius=l_square * 2, start_angle=100 * DEGREES, angle=-20 * DEGREES, **self.line_config)
        arc_l = Arc(arc_center=dm + l_square * LEFT, radius=l_square * 2, start_angle=80 * DEGREES, angle=20 * DEGREES, **self.line_config)

        # self.set_compass_to_draw_arc_(arc_r, adjust_angle=PI, run_time=0.6, rate_func=linear)
        self.play(Rotating(self.cp, angle=-80 * DEGREES, about_point=self.cp.get_niddle_tip(), rate_func=linear), run_time=0.6)
        self.draw_arc_by_compass(arc_r, run_time=0.15, rate_func=linear)
        self.wait(0.2)
        # self.set_compass_(dm + l_square * RIGHT, dm + l_square * LEFT, emphasize_dot=True)
        self.play(Rotating(self.cp, angle=100 * DEGREES, about_point=self.cp.get_niddle_tip()), run_time=0.8)
        self.emphasize_dot([self.cp.get_niddle_tip(), self.cp.get_pen_tip()], run_time=0.15)
        self.wait(0.2)
        self.cp.reverse_tip()
        self.set_compass_to_draw_arc_(arc_l, adjust_angle=PI, run_time=0.6, rate_func=linear)
        self.draw_arc_by_compass(arc_l, run_time=0.15, rate_func=linear)
        self.wait(0.2)
        self.put_aside_compass(LEFT)
        self.wait(0.6)

        dots = [dm + l_square * RIGHT, dm + l_square * (RIGHT + 2 * UP), dm + l_square * (LEFT + 2 * UP), dm + l_square * LEFT]
        # self.set_ruler(dots[0], dots[1])
        l_r = self.draw_line(dots[0], dots[1], is_prepared=False, pre_time=0.75)
        self.wait(0.2)
        l_u = self.draw_line(dots[1], dots[2], is_prepared=False, pre_time=0.75)
        self.wait(0.2)
        l_l = self.draw_line(dots[3], dots[2], is_prepared=False, pre_time=0.75)
        l_d = Line(dots[3], dots[0],**self.line_config)
        self.wait(0.18)
        self.put_aside_ruler(LEFT * 0.7)
        self.wait(0.9)
        self.play(Transform(l, l_d, run_time=0.9),
                  FadeOut(a_13_r, run_time=0.6),
                  # FadeOut(a_13, run_time=0.8),
                  FadeOut(a_13_l, run_time=0.8),
                  FadeOut(arc_r, run_time=1.),
                  FadeOut(arc_l, run_time=1.2),
                  FadeOut(circle, run_time=1.4)
                  )
        self.wait(0.75)
        self.play(VGroup(*self.mobjects).scale, 0.8, {'about_point': axis.c2p(0,0)})
        self.wait(2)

class Step_3(DrawingScene):

    CONFIG = {
        'add_ruler': True,
    }

    def construct(self):

        s = 0.5 * 0.6 * 0.8 * 0.8
        axis = Axes(x_range=[-40, 40, 1], y_range=[-36, 36, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s).shift(DOWN * 2)
        logo = Apple_logo(create_shape=False, coord_center=DOWN * 2, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.03}
        d1 = Dot(logo.c1.get_center(), **dot_config)
        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)
        a_13 = Arc(arc_center=logo.c8_d.get_center() + UP * 8 * s, start_angle=PI/2 + PI/30, radius=13 * s, angle=-PI/15, **self.line_config)
        d13 = Dot(logo.c13.get_center(), **dot_config)

        dl, dr = logo.c5_l.get_center() * 8/13 + logo.c8_d.get_center() * 5/13, logo.c5_r.get_center() * 8/13 + logo.c8_d.get_center() * 5/13
        dm = (dl+dr)/2
        l_square = get_norm(d13.get_center()-dm)
        dots = [dm + l_square * RIGHT, dm + l_square * (RIGHT + 2 * UP), dm + l_square * (LEFT + 2 * UP), dm + l_square * LEFT]
        square = Polygon(*dots, **self.line_config)
        before = VGroup(axis, logo.c1, logo.c5_l, logo.c5_r, logo.c8_d.scale(0.995), a_13, d1, d5_l, d5_r, d13, square)
        self.add(before)
        self.wait()

        dots = square.get_vertices()
        r1 = l_square * 0.7

        ### left part ###
        a_1 = Arc(arc_center=dots[2], radius=r1, start_angle=PI/3,  angle=-2 * PI/3, **self.line_config)
        a_2 = Arc(arc_center=(dots[1] +dots[2])/2, radius=r1, start_angle=2 * PI/3, angle=2 * PI/3, **self.line_config)
        self.cp.flip(axis=RIGHT)
        self.set_compass_to_draw_arc(a_1)
        self.draw_arc_by_compass(a_1)
        self.wait(0.15)
        self.cp.reverse_tip()
        self.set_compass_to_draw_arc_(a_2, adjust_angle=PI)
        self.draw_arc_by_compass(a_2)
        self.put_aside_compass(RIGHT * 0.8, run_time=0.64)

        pm = (dots[2] + (dots[1] +dots[2])/2)/2
        pu, pd = pm + 10 * s * UP, pm + 10 * s * DOWN

        l = self.draw_line(pu, pd, is_prepared=False, pre_time=0.72)
        self.wait(0.18)
        self.put_aside_ruler(LEFT * 0.65)
        logo.c8_l.rotate(PI/2)
        self.set_compass_and_show_span_(axis.c2p(0,0), axis.c2p(0,8), run_time=1.4, emphasize_dot=True, adjust_angle=PI, text='r=8', reverse_label=True, add_bg=True)
        self.wait(0.5)

        self.set_compass_to_draw_arc_(logo.c8_l, adjust_angle=PI, emphasize_dot=True)
        self.wait(0.2)
        self.draw_arc_by_compass(logo.c8_l, run_time=1.25, add_center=True)
        self.wait(0.2)
        self.put_aside_compass(LEFT * 0.64)
        self.wait(0.6)

        ### right part ### 同理直接copy吧
        a_3 = Arc(arc_center=(dots[1] + dots[2])/2, radius=r1, start_angle=PI/3,  angle=-2 * PI/3, **self.line_config)
        a_4 = Arc(arc_center=dots[1], radius=r1, start_angle=2 * PI/3, angle=2 * PI/3, **self.line_config)
        d8_r = Dot(logo.c8_r.get_center(), **dot_config)
        pm_r = (dots[1] + (dots[1] +dots[2])/2)/2
        pu_r, pd_r = pm_r + 10 * s * UP, pm_r + 10 * s * DOWN
        logo.c8_r.rotate(PI/2)
        l02 = Line(pu_r, pd_r, **self.line_config)
        right_part = VGroup(a_3, a_4, l02, logo.c8_r)
        right_part_ = right_part.copy().set_stroke(opacity=0.32).shift(l_square * LEFT)
        self.add(right_part_)
        self.play(right_part_.shift, l_square * RIGHT)
        self.wait(0.2)
        self.play(ShowCreation(a_3), run_time=0.8)
        self.play(ShowCreation(a_4), run_time=0.8)
        self.play(ShowCreation(l02), run_time=0.8)
        self.play(ShowCreation(logo.c8_r), FadeIn(d8_r))
        self.remove(right_part_)
        self.wait()

        self.play(FadeOut(a_4, run_time=0.6), FadeOut(l02, run_time=0.7), FadeOut(a_3, run_time=0.8),
                  FadeOut(a_2, run_time=0.9), FadeOut(l, run_time=1.), FadeOut(a_1, run_time=1.1),
                  )
        self.wait(0.8)
        self.play(VGroup(*self.mobjects).scale, 1.25, {'about_point': axis.c2p(0,0)})

        self.wait(2)

class Step_4(DrawingScene):

    CONFIG = {
            'add_ruler': True,
        }

    def construct(self):

        s = 0.5 * 0.6 * 0.8
        axis = Axes(x_range=[-45, 45, 1], y_range=[-36, 36, 1], axis_config={"stroke_color": GREY_D, "stroke_width": 2.5, "stroke_opacity": 1},).scale(s).shift(DOWN * 2)
        logo = Apple_logo(create_shape=False, coord_center=DOWN * 2, scale=s*2)
        dot_config = {'color': GREY_E, 'radius': 0.03}
        d1 = Dot(logo.c1.get_center(), **dot_config)
        d5_l, d5_r = Dot(logo.c5_l.get_center(), **dot_config), Dot(logo.c5_r.get_center(), **dot_config)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000

参考文献

1.https://www.tiobe.com/tiobe-index
2.https://baike.baidu.com/item/Python/407313?fr=aladdin
3.https://docs.manim.community/en/stable/installation.html
4.https://docs.manim.org.cn/

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/37593

利用Python中的Manim进行数学绘画和创作_manim教程 线性代数

什么是Python

什么是manim

如何来运行Manim

几个常见方程的示例

manin安装教程

版本说明

Manim 的安装

安装ffmpeg

在Windows上安装FFmpeg

在MacOS上安装FFmpeg

在Linux上安装FFmpeg

验证安装

安装Latex

在Windows上安装LaTeX

在MacOS上安装LaTeX

在Linux上安装LaTeX

安装dvisvgm

Windows 用户

macOS 用户

Linux 用户

利用Manim绘制苹果logo

利用Python中的Manim进行数学绘画和创作_manim教程线性代数