用manim实现三维向量和平面的结合

于 2024-10-06 15:56:13 发布
阅读量194 收藏 6
点赞数 5
分类专栏： python画图 python建模 Manim数学建模 文章标签： python 机器学习 算法 manim动画 manim 人工智能 数学建模
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45449625/article/details/142727938
版权

矩阵在线性代数中无处不在。矩阵的列描述了相应的基向量相对于初始基的位置。所有变换后的向量都是变换后的基向量的线性组合它们是矩阵的列，这也被称为线性。对矩阵进行操作的算法本质上只是改变了向量变换的方式，保留了一些性质。

from manim import *  # 导入 Manim 库  

class LinearTransformation3D02(ThreeDScene):  # 定义一个名为 LinearTransformation3D02 的类，继承 ThreeDScene  

    def create_matrix(self, np_matrix):  # 定义一个方法，用于创建矩阵对象  
        m = Matrix(np_matrix)  # 创建一个矩阵 m  
        m.scale(0.5)  # 将矩阵缩放到原来的一半大小  
        m.set_column_colors(GREEN, RED, GOLD)  # 设置矩阵列的颜色  
        m.to_corner(UP + LEFT)  # 将矩阵移动到屏幕的左上角  
        return m  # 返回创建的矩阵对象  

    def construct(self):  # 定义构建场景的方法  
        basis_i_color = GREEN  # 设置 i 向量的颜色为绿色  
        basis_j_color = RED  # 设置 j 向量的颜色为红色  
        basis_k_color = GOLD  # 设置 k 向量的颜色为金色  

        M = np.array([  # 创建一个变换矩阵 M  
            [2, 2, -1],  
            [-2, 1, 2],  
            [3, 1, 0]  
        ])  

        axes = ThreeDAxes()  # 创建三维坐标轴对象  
        axes.set_color(GRAY)  # 设置坐标轴的颜色为灰色  
        axes.add(axes.get_axis_labels())  # 为坐标轴添加轴标签  

        self.set_camera_orientation(phi=75 * DEGREES, theta=-45 * DEGREES)  # 设置相机的旋转角度  

        basis_vector_helper = Tex("$i$" , "," , "$j$" , "," , "$k$")  # 创建基础向量标签  
        basis_vector_helper[0].set_color(basis_i_color)  # 设置 i 向量标签的颜色  
        basis_vector_helper[2].set_color(basis_j_color)  # 设置 j 向量标签的颜色  
        basis_vector_helper[4].set_color(basis_k_color)  # 设置 k 向量标签的颜色  
        basis_vector_helper.to_corner(UP + RIGHT)  # 将标签移动到右上角  

        self.add_fixed_in_frame_mobjects(basis_vector_helper)  # 将基础向量标签固定在屏幕上  
        matrix = self.create_matrix(M)  # 创建矩阵对象  
        self.add_fixed_in_frame_mobjects(matrix)  # 将矩阵固定在屏幕上  

        self.add(axes)  # 添加坐标轴到场景  

        self.begin_ambient_camera_rotation(rate=0.2)  # 开始相机的环绕旋转  

        cube = Cube(side_length=1, fill_color=BLUE, stroke_width=2, fill_opacity=0.1)  # 创建透明的蓝色正方体  
        cube.set_stroke(BLUE_E)  # 设置正方体的边框颜色  

        i_vec = Vector(np.array([1, 0, 0]), color=basis_i_color)  # 创建 i 向量  
        j_vec = Vector(np.array([0, 1, 0]), color=basis_j_color)  # 创建 j 向量  
        k_vec = Vector(np.array([0, 0, 1]), color=basis_k_color)  # 创建 k 向量  

        i_vec_new = Vector(M @ np.array([1, 0, 0]), color=basis_i_color)  # 计算变换后的 i 向量  
        j_vec_new = Vector(M @ np.array([0, 1, 0]), color=basis_j_color)  # 计算变换后的 j 向量  
        k_vec_new = Vector(M @ np.array([0, 0, 1]), color=basis_k_color)  # 计算变换后的 k 向量  

        self.play(  # 播放初始动画  
            Create(cube),  # 创建正方体动画  
            GrowArrow(i_vec),  # 显示 i 向量动画  
            GrowArrow(j_vec),  # 显示 j 向量动画  
            GrowArrow(k_vec),  # 显示 k 向量动画  
            Write(basis_vector_helper)  # 显示基础向量标签动画  
        )  

        self.wait(2)  # 等待 2 秒以展示初始状态  

        # 变换 i 向量  
        matrix_anim_i = ApplyMatrix(M, cube)  # 创建应用矩阵 M 的动画  
        self.play(  
            matrix_anim_i,  # 应用矩阵的动画  
            Transform(i_vec, i_vec_new)  # 变换 i 向量到新的位置  
        )  
        self.wait(2)  # 等待 2 秒  

        # 变换 j 向量  
        matrix_anim_j = ApplyMatrix(M, cube)  # 创建应用矩阵 M 的动画  
        self.play(  
            matrix_anim_j,  # 应用矩阵的动画  
            Transform(j_vec, j_vec_new)  # 变换 j 向量到新的位置  
        )  
        self.wait(2)  # 等待 2 秒  

        # 变换 k 向量  
        matrix_anim_k = ApplyMatrix(M, cube)  # 创建应用矩阵 M 的动画  
        self.play(  
            matrix_anim_k,  # 应用矩阵的动画  
            Transform(k_vec, k_vec_new)  #
                        Transform(k_vec, k_vec_new)  # 变换 k 向量到新的位置  
        )  
        self.wait(2)  # 等待 2 秒  

        # 将正方体移动到新的 i、j 和 k 向量方向对应的位置  
        new_position = (i_vec_new.get_end() + j_vec_new.get_end() + k_vec_new.get_end()) / 3  # 计算正方体的新位置  
        self.play(cube.animate.move_to(new_position))  # 移动正方体到新位置  

        # 最后等待几秒钟以展示最终效果  
        self.wait(7)  # 等待 7 秒以展示最终状态

 

 

 

 

 

代码解释

  1. 向量变换:

    • 在每次动画中，ApplyMatrix(M, cube) 将变换矩阵 M 应用于立方体 cube，展示了基于矩阵变换后的三维形状变化。
    • Transform(i_vec, i_vec_new) 类似地将旧的向量变换为新的向量。这个过程重复了三次，分别对应了 i、j 和 k 向量的变化。

  2. 新位置计算:

    • 在所有的向量都完成变换后，代码计算了正方体的新位置，这个新位置是所有三维向量的终点的平均值。这意味着正方体会中心对齐到建立的新基座。

  3. 节奏控制:

    • self.wait(2) 和 self.wait(7) 用于控制每个动画阶段之间的间隔以及展示效果。这样使得观众有足够的时间来理解每个变换过程。

示例代码2：

在animm中，有一个特殊的ApplyMatrix动画，允许我们原生地将矩阵应用到对象的每个3D顶点。

from manimlib.imports import *

class LinearTransformation3D(ThreeDScene):

    CONFIG = {
        "x_axis_label": "$x$",
        "y_axis_label": "$y$",
        "basis_i_color": GREEN,
        "basis_j_color": RED,
        "basis_k_color": GOLD
    }

    def create_matrix(self, np_matrix):

        m = Matrix(np_matrix)

        m.scale(0.5)
        m.set_column_colors(self.basis_i_color, self.basis_j_color, self.basis_k_color)

        m.to_corner(UP + LEFT)

        return m

    def construct(self):

        M = np.array([
            [2, 2, -1],
            [-2, 1, 2],
            [3, 1, -0]
        ])

        axes = ThreeDAxes()
        axes.set_color(GRAY)
        axes.add(axes.get_axis_labels())

        self.set_camera_orientation(phi=75 * DEGREES, theta=-45 * DEGREES)

        # basis vectors i,j,k
        basis_vector_helper = TextMobject("$i$", ",", "$j$", ",", "$k$")
        basis_vector_helper[0].set_color(self.basis_i_color)
        basis_vector_helper[2].set_color(self.basis_j_color)
        basis_vector_helper[4].set_color(self.basis_k_color)

        basis_vector_helper.to_corner(UP + RIGHT)

        self.add_fixed_in_frame_mobjects(basis_vector_helper)

        # matrix
        matrix = self.create_matrix(M)

        self.add_fixed_in_frame_mobjects(matrix)

        # axes & camera
        self.add(axes)

        self.begin_ambient_camera_rotation(rate=0.2)

        cube = Cube(side_length=1, fill_color=BLUE, stroke_width=2, fill_opacity=0.1)
        cube.set_stroke(BLUE_E)

        i_vec = Vector(np.array([1, 0, 0]), color=self.basis_i_color)
        j_vec = Vector(np.array([0, 1, 0]), color=self.basis_j_color)
        k_vec = Vector(np.array([0, 0, 1]), color=self.basis_k_color)

        i_vec_new = Vector(M @ np.array([1, 0, 0]), color=self.basis_i_color)
        j_vec_new = Vector(M @ np.array([0, 1, 0]), color=self.basis_j_color)
        k_vec_new = Vector(M @ np.array([0, 0, 1]), color=self.basis_k_color)

        self.play(
            ShowCreation(cube),
            GrowArrow(i_vec),
            GrowArrow(j_vec),
            GrowArrow(k_vec),
            Write(basis_vector_helper)
        )

        self.wait()

        matrix_anim = ApplyMatrix(M, cube)

        self.play(
            matrix_anim,
            Transform(i_vec, i_vec_new, rate_func=matrix_anim.get_rate_func(),
                      run_time=matrix_anim.get_run_time()),
            Transform(j_vec, j_vec_new, rate_func=matrix_anim.get_rate_func(),
                      run_time=matrix_anim.get_run_time()),
            Transform(k_vec, k_vec_new, rate_func=matrix_anim.get_rate_func(),
                      run_time=matrix_anim.get_run_time())
        )

        self.wait()

        self.wait(7)

示例代码3： 

在上一篇文章中，我们实现了一个高级版本的高斯消去算法(PA = LU分解)。我们可以用下面的方法类似地实现纯高斯消去算法:

def gauss(a):
    m = a.shape[0]

    for x in range(m):
        pivotRow = x

        # search for the best pivot
        for y in range(x + 1, m, 1):
            if abs(a[y][x]) > abs(a[pivotRow][x]):
                pivotRow = y

        if a[pivotRow][x] == 0:
            # we didn't find any row with a non-zero leading coefficient
            # that means that the matrix has all zeroes in this column
            # so we don't need to search for pivots after all for the current column x
            continue

        # did we just use a pivot that is not on the diagonal?
        if pivotRow != x:
            # swap the pivot row with the current row in both A and L matrices
            a[[x, pivotRow]] = a[[pivotRow, x]]
            yield a

        # now the pivot row is x
        # search for rows where the leading coefficient must be eliminated
        for y in range(x + 1, m, 1):
            currentValue = a[y][x]
            if currentValue == 0:
                # variable already eliminated, nothing to do
                continue

            pivot = a[x][x]
            assert pivot != 0  # just in case, we already made sure the pivot is not zero

            pivotFactor = currentValue / pivot

            # subtract the pivot row from the current row

            a[y][x] = 0

            for i in range(x + 1, m, 1):
                a[y][i] -= pivotFactor * a[x][i]

            yield a

 注意，在我们想要可视化的每个矩阵运算之后，我都添加了一个yield语句。Python中的生成器非常适合可视化算法，因为它们允许我们保存当前状态，生成值，然后在调用者处理接收到的值时继续执行。在这种情况下，我们在算法运行时生成矩阵的每个版本。
现在我们可以调整和扩展用于呈现线性变换的代码，以便在高斯消去的每一步都这样做:

class Gauss3D(ThreeDScene):

    CONFIG = {
        "x_axis_label": "$x$",
        "y_axis_label": "$y$",
        "basis_i_color": GREEN,
        "basis_j_color": RED,
        "basis_k_color": GOLD
    }

    def create_matrix(self, np_matrix):

        m = Matrix(np_matrix)

        m.scale(0.5)
        m.set_column_colors(self.basis_i_color, self.basis_j_color, self.basis_k_color)

        m.to_corner(UP + LEFT)

        return m

    def construct(self):

        M = np.array([
            [-1.0, 1.0, -2.0],
            [-4.0, -2.0, 1.0],
            [-2.0, 2.0, 3.0]
        ])

        # axes
        axes = ThreeDAxes()
        axes.set_color(GRAY)
        axes.add(axes.get_axis_labels())

        self.set_camera_orientation(phi=55 * DEGREES, theta=-45 * DEGREES)

        # basis vectors i,j,k
        basis_vector_helper = TextMobject("$i$", ",", "$j$", ",", "$k$")
        basis_vector_helper[0].set_color(self.basis_i_color)
        basis_vector_helper[2].set_color(self.basis_j_color)
        basis_vector_helper[4].set_color(self.basis_k_color)

        basis_vector_helper.to_corner(UP + RIGHT)

        self.add_fixed_in_frame_mobjects(basis_vector_helper)

        # matrix
        matrix = self.create_matrix(M)

        self.add_fixed_in_frame_mobjects(matrix)

        # axes & camera
        self.add(axes)

        self.begin_ambient_camera_rotation(rate=0.15)

        cube = Cube(side_length=1, fill_color=BLUE, stroke_width=2, fill_opacity=0.1)
        cube.set_stroke(BLUE_E)  # cube.set_stroke(TEAL_E)

        i_vec = Vector(np.array([1, 0, 0]), color=self.basis_i_color)
        j_vec = Vector(np.array([0, 1, 0]), color=self.basis_j_color)
        k_vec = Vector(np.array([0, 0, 1]), color=self.basis_k_color)

        i_vec_new = Vector(M @ np.array([1, 0, 0]), color=self.basis_i_color)
        j_vec_new = Vector(M @ np.array([0, 1, 0]), color=self.basis_j_color)
        k_vec_new = Vector(M @ np.array([0, 0, 1]), color=self.basis_k_color)

        self.play(
            ShowCreation(cube),
            GrowArrow(i_vec),
            GrowArrow(j_vec),
            GrowArrow(k_vec),
            Write(basis_vector_helper)
        )

        self.wait()

        matrix_anim = ApplyMatrix(M, cube)

        self.play(
            matrix_anim,
            ReplacementTransform(i_vec, i_vec_new, rate_func=matrix_anim.get_rate_func(),
                                 run_time=matrix_anim.get_run_time()),
            ReplacementTransform(j_vec, j_vec_new, rate_func=matrix_anim.get_rate_func(),
                                 run_time=matrix_anim.get_run_time()),
            ReplacementTransform(k_vec, k_vec_new, rate_func=matrix_anim.get_rate_func(),
                                 run_time=matrix_anim.get_run_time())
        )

        self.wait()

        i_vec, j_vec, k_vec = i_vec_new, j_vec_new, k_vec_new

        self.wait(2)

        for a in gauss(M):

            a_rounded = np.round(a.copy(), 2)

            self.remove(matrix)

            matrix = self.create_matrix(a_rounded)

            self.add_fixed_in_frame_mobjects(matrix)

            # transformed cube
            new_cube = Cube(side_length=1, fill_color=BLUE, stroke_width=2, fill_opacity=0.1)
            new_cube.set_stroke(BLUE_E)

            new_cube.apply_matrix(a)

            # vectors
            i_vec_new = Vector(a @ np.array([1, 0, 0]), color=self.basis_i_color)
            j_vec_new = Vector(a @ np.array([0, 1, 0]), color=self.basis_j_color)
            k_vec_new = Vector(a @ np.array([0, 0, 1]), color=self.basis_k_color)

            # prepare and run animation
            cube_anim = ReplacementTransform(cube, new_cube)

            self.play(
                cube_anim,
                ReplacementTransform(i_vec, i_vec_new, rate_func=cube_anim.get_rate_func(),
                                     run_time=cube_anim.get_run_time()),
                ReplacementTransform(j_vec, j_vec_new, rate_func=cube_anim.get_rate_func(),
                                     run_time=cube_anim.get_run_time()),
                ReplacementTransform(k_vec, k_vec_new, rate_func=cube_anim.get_rate_func(),
                                     run_time=cube_anim.get_run_time())
            )

            self.wait()

            cube = new_cube
            i_vec, j_vec, k_vec = i_vec_new, j_vec_new, k_vec_new

            self.wait(1)

        self.wait(1)

Yasen.M
关注
专栏目录
3D建模作品
一只小翊的博客
01-09 1272
匕首 车 复古房屋 Coffee机 辣椒房 魔法书
几种主流的3D建模软件对比.pdf
11-19
几种主流的3D建模软件对比.pdf
Rhino 3D建模的世界
新缸中之脑
07-19 2135
由于 NURBS 在 Rhino 的开发中扮演了如此重要的角色，我们需要解释一下它们是什么。这个首字母缩略词代表非均匀有理 B 样条线，简单地说，它是曲线或曲面的数学表示。这些曲线由一组控制点、权重和节点向量定义。控制点决定曲线或曲面的一般形状，而权重则影响每个控制点的影响。这些因素使我们能够完全精确地控制曲线/曲面，这就是汽车设计、工业设计、建筑等行业使用 Rhino 的原因。NURBS 数据是交互式的，我们可以实时修改几何图形，而且它非常灵活，允许我们使用各种形状，从简单的圆弧到高度复杂的双曲面。
面向开发人员的3D建模基础知识
新缸中之脑
04-29 1009
如果你想深入了解 3D 建模世界，这个快速概述可以帮助你入门。3D 建模是一项强大的技能，允许开发人员创建逼真的视觉效果、设计产品和探索虚拟空间。无论你对游戏开发、动画还是产品设计感兴趣，了解 3D 建模的基础知识都是至关重要的。通过耐心和练习，你可以自学 3D 建模并将创意变为现实。
开发人员必备3D建模基础
老子云3D可视化与模型优化服务平台的博客
05-31 1070
3D 建模是一项强大的技能，允许开发人员创建逼真的视觉效果、设计产品和探索虚拟空间。无论你对游戏开发、动画还是产品设计感兴趣，了解 3D 建模的基础知识都是至关重要的。
10大主流3D建模技术
新缸中之脑
07-31 5341
在决定使用哪种类型的建模时，我们需要考虑我们的最终目标是什么。但在大多数情况下，这将是一个组合。特别是如果我们正在创建一个场景。在这些情况下，我们可能有一些对象需要一些技术，而其他对象则需要其他技术。如果你是初学者，我建议你从盒子建模和多边形建模开始，因为它们使用的工具相同，并且这些技术是所有建模的基础。但是，例如，如果想在3D打印领域占据一席之地，那么你应该从nurbs建模开始。10种3D建模技术—BimAnt。...
浅谈3D建模
weixin_52002180的博客
04-15 6776
一、3D建模是什么 将所见所想用立体三维的方式通过计算机技术表现出来，这就是3D建模，比如你看到了一个可爱呆萌的卡通人物又或是华丽酷炫的变形金刚，总之就是你认为美好的立体实物 你想将它用计算机技术完美的呈现出来，就要必须用到3D建模，小到喝水用的水杯、大到影视剧里面的怪兽，3D模型技术的身影随处可见，它是一切虚拟模型的基础你想将它用计算机技术完美的呈现出来，就要必须用到3D建模，小到喝水用的水杯、大到影视剧里面的怪兽，3D模型技术的身影随处可见，它是一切虚拟模型的基础。 对于专业人士来说，画三维图的目
3D 建模或扫描建模工具和技术
易之阴阳，量子纠缠，道之一体，缘起性空
04-24 819
综上所述，3D建模和扫描建模分别依赖于专业的建模软件（如Maya、Blender等）和扫描设备（如激光扫描仪、深度相机等），结合相应的建模技术（如多边形建模、雕刻建模等）或扫描后处理技术（如摄影测量法、点云处理等），用于创建和优化三维数字模型。用户应根据项目需求、预算、精度要求和操作熟练度选择合适的工具和技术。3D建模和扫描建模是创建数字三维模型的两种主要方式，各自采用不同的工具和技术。3D 扫描建模工具和技术。3D 建模工具和技术。
chatgpt 与传统3D建模对比分析
ygtu2018的博客
07-07 2215
随着人工智能技术的发展，越来越多的领域正逐渐被AI模型所取代。ChatGPT作为一种自然语言处理技术，越来越为人们所熟悉。最近，一些3D建模领域的专家想知道ChatGPT是否可以取代传统的手动3D建模。本文的目的是分析用ChatGPT取代传统手动3D建模的可行性。本文探讨了 ChatGPT 以及传统手动 3D 建模过程的优缺点。我们将得出结论，尽管ChatGPT在速度和易用性方面具有优势，但由于无法生成高分辨率的3D模型且缺乏创造力，它还无法取代传统的手动3D建模。
3D问界—关于3D建模流程的汇总与思考
FifthDesign的博客
07-26 2126
2024 都已经过去大半年了，3D领域的圈子翻来覆去，我发现客户的需求始终围绕着那几款3D软件，下边是2024年热门3D建模软件排行榜
3D建模概念
顺其自然~专栏
03-23 1320
3D是的缩写，就是三维图形。在平面里显示三维图形，不像现实世界里，真实的三维空间，有真实的距离空间。计算机里只是看起来很像真实世界，因此在计算机显示的3d图形，就是让人眼看上就像真的一样。人眼有一个特性就是近大远小，就会形成立体感。计算机屏幕是平面二维的，我们之所以能欣赏到真如实物般的三维图像，是因为显示在计算机屏幕上时色彩灰度的不同而使人眼产生视觉上的错觉，而将二维的计算机屏幕感知为三维图像。基于色彩学的有关知识，三维物体边缘的凸出部分一般显高亮度色，而凹下去的部分由于受光线的遮挡而显暗色。
Blender，一个神奇的3D建模软件
01-27
事情是这样的······ 上学期，在选择学校开的几门选修课的时候，本来打算选戏剧的我突然被冯·诺依曼先生附体，莫名其妙往最不擅长的 ...但在接下来的三个月，我们的任务变成了学习3D建模，也就是如何
基于三维CAD中望3D建模设计电感线圈.pdf
08-04
基于三维CAD中望3D建模设计电感线圈.pdf
3D建模理论与实战 - 使用Ruby进行SketchUp(草图大师)插件开发
06-13
SketchUp作为设计学院三剑客之一，在国内外广受欢迎，其拥有成熟的插件生态环境(插件商店...Ruby语言的应用不仅仅是Rails, 本课程将带你探索3D建模的领域。 本课程不是：3D模型设计课程，OpenGL课程，Ruby编程技巧课程
计算机图形学-基于MFC的3D建模技术.rar
07-03
计算机图形学-基于MFC的3D建模技术.rar
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
最新发布
haidizym的博客
10-02 471
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1192
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
酷炫音乐盒: 使用Python和Tkinter配合Pygame打造自己的音乐播放器
宇宙第一小趴菜的博客
09-29 1230
Tkinter是一个功能强大且简单易用的库，适合构建轻量级的GUI应用程序。它在不同的操作系统上具有相同的外观和行为，因此可以实现跨平台的应用程序。当然，Tkinter还有更多的功能和细节，通过阅读官方文档和教程，你可以更深入地了解和学习如何运用Tkinter来创建各种GUI应用程序。
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 408
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yasen.M

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值