标签：play set color self square circle manim

from manim import *
#导入manim命名空间

#这是一个最基本的manim结构，类名叫做BaseFrame，传入一个场景Scene，并且包含一个construct方法，传入self
class BaseFrame(Scene):
    def construct(self):
        self.wait()


class CreateCircle(Scene):
    def construct(self):
        circle = Circle()  # 创建了一个Circle对象：circle
        circle.set_fill(PINK, opacity=0.5)  # set the color and transparency
        self.play(Create(circle))  # show the circle on screen



class SquareToCircle(Scene):
    def construct(self):
        circle = Circle()  # create a circle
        circle.set_fill(PINK, opacity=0.5)  # set color and transparency

        square = Square()  # create a square
        square.rotate(PI / 4)  # rotate a certain amount

        self.play(Create(square))  # animate the creation of the square
        self.play(Transform(square, circle))  # interpolate the square into the circle
        self.play(FadeOut(square))  # fade out animation

class SquareAndCircle(Scene):
    def construct(self):
        circle = Circle()  # create a circle
        circle.set_fill(PINK, opacity=0.5)  # set the color and transparency

        square = Square()  # create a square
        square.set_fill(BLUE, opacity=0.5)  # set the color and transparency

        square.next_to(circle, RIGHT, buff=0.5)  # set the position
        self.play(Create(circle), Create(square))  # show the shapes on screen

class ThreePar(Scene):
    def construct(self):
        circle = Circle()
        circle.set_fill(RED, opacity=0.6)

        star = Star()
        star.set_fill(BLUE, opacity=0.4)
        
        square = Square()
        square.set_fill(BLUE, opacity=0.5)

        circle.next_to(star, LEFT, buff=0.5)
        square.next_to(star, RIGHT, buff=0.5)

        #占用1秒的时长，
        #如果你的Create方法是在play里面的，他就会占用一秒钟的时间去展示创建对象的过程
        self.add(star)
        self.add(circle)#无意义的，后面的Create(circle)会创建，系统会删除次代码
        self.play(Create(circle),Create(square))
        self.wait(1)
        self.remove(star)
        self.wait(1)

class AnimatedSquareToCircle(Scene):
    def construct(self):
        circle = Circle()  # create a circle
        square = Square()  # create a square

#Play_Scripts_Start
        self.play(Create(square))  # show the square on screen
        self.play(square.animate.rotate(PI / 4))  # 旋转图形，参数是弧度制
        self.play(
            ReplacementTransform(square, circle)
        )  # transform the square into a circle
        self.play(
            circle.animate.set_fill(PINK, opacity=0.5)
        )  # color the circle on screen
#Play_Scripts_End

class DifferentRotations(Scene):
    def construct(self):
        left_square = Square(color=BLUE, fill_opacity=0.7).shift(2 * LEFT)
        right_square = Square(color=GREEN, fill_opacity=0.7).shift(2 * RIGHT)
        self.play(
            left_square.animate.rotate(PI), Rotate(right_square, angle=PI), run_time=2
        )
        self.wait()



#默认情况下，对象会生成在屏幕中心点
class Learn01_move(Scene):
    def construct(self):
        circle = Circle()
        triangle = Triangle()

        self.add(circle,triangle)
        print ("移动")
        self.wait(1)

        circle.shift(LEFT*3 + UP*2)
            #瞬间移动,LEFT,UP是单位方向向量
            #以自身为参考
        self.wait(1)

        triangle.next_to(circle,RIGHT)
            #瞬间移动
            #以传入对象为参考
        self.wait(1)

        circle.move_to(DOWN)
            #瞬间移动
            #以屏幕中心为参考
        self.wait(1)

        triangle.align_to(circle,DOWN)
            #瞬间移动
            #以传入对象的假想边界作为调整
            #传入DOWN(0,-1)，那么物体的纵坐标就会"对其"对象的下边界
                #这个假想的边界一般以物体以中心为原点的第二象限区域
        self.wait(1)

class Learn02_beauty(Scene):
    def construct(self):

        circle = Circle().shift(LEFT*2)
        star = Star().shift(RIGHT*2)
        self.play(Create(circle), Create(star))
        self.wait(1)

        #set_fill()  改变图形的内部
        #set_stroke()改变图形的边框
        star.set_stroke(color=YELLOW, width=20)
        circle.set_stroke(color=BLUE, width=20)
        star.set_fill(YELLOW, opacity=0.7)
        circle.set_fill(YELLOW, opacity=0.7)

        
        self.wait(1)
        
class Learn03_animations(Scene):
    def construct(self):
        star = Star()
        self.play(FadeIn(star))#渐入特效
        #self.play(FadeIn(star),run_time = 5)可以设置时间
        self.wait(1)
        self.play(Rotate(star, 2*PI))#旋转特效
        self.wait(1)
        self.play(FadeOut(star))#渐出特效

#animate方法
    #这样就可以
class Learn04_animateMethod(Scene):
    def construct(self):
        star = Star()
        self.play(star.animate.set_fill(YELLOW, opacity=0.4))
        self.wait(1)
        self.play(star.animate.set_fill(WHITE))
        self.wait(1)

        #也可以同时进行animate方法
        self.play(
            star.animate
            .shift(UP+LEFT)
            .rotate(2/3*PI)
            .set_fill(RED)
        )
        self.wait(1)

        #也可以在play中添加run_time参数，修改动画持续时间
        self.play(
            star.animate
            .shift(-UP-LEFT)
            .rotate(2/3*PI)
            .set_fill(BLUE)
            ,run_time = 5
        )
        self.wait(1)


#创建自定义动画
#重写interpolate_mobject()方法
class Countqq(Animation):
    #kwargs是可变参数，此处暂时用不上
    def __init__(self, number: DecimalNumber, start: float, end: float, **kwargs):
        # Pass number as the mobject of the animation
        #这个是构造方法，使用到我们这个Countqq这个类的时候就会自动把参数传入此方法中
        #self在构造的时候不需要传递
        super().__init__(number, **kwargs)
        # Set start and end
        self.start = start
        self.end = end

    def interpolate_mobject(self, alpha: float):
        # Set value of DecimalNumber according to alpha
        #这一行是增长的 这个是manim系统内部调用的，我们就不管他了。
        value = self.start + (alpha * (self.end - self.start)) 
        self.mobject.set_value(value)
class Learn05_CountingScene(Scene):
    def construct(self):
        #创建一个Decimal数字，设置颜色，缩放比
        number = DecimalNumber().set_color(BLUE).scale(5).move_to(LEFT)
        #添加一个定时更新器,ORIGIN相当于[0,0,0],移动到屏幕中心点
        #匿名函数lambda构建方法 lambda XXX:___
        number.add_updater(lambda number: number)

        self.add(number)

        self.wait(1)

        # Play the Count Animation to count from 0 to 314 in 4 seconds
        #Count传入数字范围从0到100，设置持续时间4秒，线性增长
        #play可以传递一个Animation类型的参数，用于动画的播放，参数可设置：run_time,rate_func there_and_back
        self.play(Countqq(number, 0, 100), run_time=4, rate_func=linear)
        
        self.wait(1)

class Learn06_MobjectExample(Scene):
    def construct(self):
        p1= [-1,-1,0]
        p2= [1,-1,0]
        p3= [1,1,0]
        p4= [-1,1,0]
        #append_points()方法是增加节点，连成折线。
            #方法中传入起点与终点的Line的points
        a = Line(p1,p2).append_points(Line(p2,p3).points).append_points(Line(p3,p4).points)
        #寻找线的开头&结尾&重心 get_start get_end get_center
        point_start= a.get_start()
        point_end  = a.get_end()
        point_center = a.get_center()
        #这个self.mobjects[-1]是指上一个add的对象
        #np是numpy的意思，manim中，numpy as np，即数学库
            #UR指的是UP+RIGHT，在边界的右上角
        self.add(Text(f"a.get_start() = {np.round(point_start,2).tolist()}", font_size=24).to_edge(UR).set_color(YELLOW))
        self.add(Text(f"a.get_end() = {np.round(point_end,2).tolist()}", font_size=24).next_to(self.mobjects[-1],DOWN).set_color(RED))
        self.add(Text(f"a.get_center() = {np.round(point_center,2).tolist()}", font_size=24).next_to(self.mobjects[-1],DOWN).set_color(BLUE))
        #还可以get各种位置 get_bottom get_center point_from_proportion是线的中点
        self.add(Dot(a.get_start()).set_color(YELLOW).scale(2))
        self.add(Dot(a.get_end()).set_color(RED).scale(2))
        self.add(Dot(a.get_top()).set_color(GREEN_A).scale(2))
        self.add(Dot(a.get_bottom()).set_color(GREEN_D).scale(2))
        self.add(Dot(a.get_center()).set_color(BLUE).scale(2))
        self.add(Dot(a.point_from_proportion(0.5)).set_color(ORANGE).scale(2))
        self.add(*[Dot(x) for x in a.points])
        self.add(a)

#测试，不用管这里
class Learn07_MobjectTest(Scene):
    def construct(self):
        p1=[-1,-1,0]
        p2=[1,1,0]
        p3=[-1,1,0]

        a =Line(p1,p2).append_points(Line(p2,p3).points)
        self.add(Dot(a.point_from_proportion(0.5)).set_color(ORANGE).scale(2))
        self.add(*[Dot(x) for x in a.points])
        self.add(a)


class Learn08_Transform(Scene):
    def construct(self):
        #设置摄像机的背景颜色，即屏幕背景
        self.camera.background_color = GREEN_A
        #创建一个正方形
        m1 = Circle().set_color(RED)
        #创建一个矩形，旋转一定角度
        m2 = Rectangle().set_color(RED).rotate(PI/6)
        #转变图形
        self.play(Transform(m1,m2))
        #会直接把m1变成m2的外观，m2不会显示


class Test_Transform(Scene):
    def construct(self):
        #渐变色
        mobj1 = Text(f"早上好，我是？", font_size=93,t2g={'[1:-1]': (RED,GREEN),}).shift(UP*2)
        self.play(FadeIn(mobj1),run_time=1)
        mobj2 = Text(f"傻逼！", font_size=256).next_to(self.mobjects[-1],DOWN).set_color(BLUE)
        self.play(Transform(mobj1,mobj2),run_time=2)

class Learn09_roll(Scene):
    def construct(self):
        self.camera.background_color = WHITE
        m1a = Square().set_color(RED).shift(LEFT)
        m1b = Circle().set_color(RED).shift(LEFT)
        m2a= Square().set_color(BLUE).shift(RIGHT)
        m2b= Circle().set_color(BLUE).shift(RIGHT)

        points = m2a.points
        points = np.roll(points, int(len(points)/4), axis=0)
        m2a.points = points

        self.play(Transform(m1a,m1b),Transform(m2a,m2b), run_time=1)



class Learn10_HelloLaTeX(Scene):
    def construct(self):
        tex = MathTex(
            r"\sum_{i=1}^{n}{X_i}"
        )
        tex2 = MathTex(
            r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots"
            ,substrings_to_isolate="x"#隔离x作为字串，后面就可以单独渲染它的颜色了
        ).next_to(tex,DOWN)
        tex2.set_color_by_tex("x", YELLOW)
        self.add(tex,tex2)

标签：play,set,color,self,square,circle,manim
来源： https://www.cnblogs.com/remyuu/p/16411992.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。