l jFaNUdZddlmZddlmZddlmZmZddlm Z ddl m Z ddl m Z m Z dd lmZdd lmZmZgd Zdd lmZmZmZdd lmZddlmZddlmZmZmZerddl m!Z!dZ"de#d<dZ$de#d<GddZ%d%dZ&Gdde%Z'Gdde%Z(d&d#Z)d$S)'zAnimate mobjects.) annotations) OpenGLMobject)configlogger) RendererTypemobject)GroupMobject)opengl_mobject)linearsmooth) AnimationWaitAddoverride_animation)CallableIterableSequencedeepcopy) partialmethod) TYPE_CHECKINGAnySelf)Sceneg?floatDEFAULT_ANIMATION_RUN_TIMEDEFAULT_ANIMATION_LAG_RATIOceZdZdZ dJdddKfdZeeedddddfd dd dLdZe dMdZ e j dNd Z dOd"Z dPd#Z dPd$ZdQd%ZdQd&ZdRd)ZdRd*ZdSd,ZdTd.ZdUd0ZdVd2ZdWd4ZdXd5ZdYd7ZdYd8ZdZd<Zd[d@Zd\dAZdMdBZd]dCZd^dDZ d_dEZ!d`dFZ"d`dGZ#e$dQfdH Z%eZ&e$dQdIZ'xZ(S)araD An animation. Animations have a fixed time span. Parameters ---------- mobject The mobject to be animated. This is not required for all types of animations. lag_ratio Defines the delay after which the animation is applied to submobjects. This lag is relative to the duration of the animation. This does not influence the total runtime of the animation. Instead the runtime of individual animations is adjusted so that the complete animation has the defined run time. run_time The duration of the animation in seconds. rate_func The function defining the animation progress based on the relative runtime (see :mod:`~.rate_functions`) . For example ``rate_func(0.5)`` is the proportion of the animation that is done after half of the animations run time. reverse_rate_function Reverses the rate function of the animation. Setting ``reverse_rate_function`` does not have any effect on ``remover`` or ``introducer``. These need to be set explicitly if an introducer-animation should be turned into a remover one and vice versa. name The name of the animation. This gets displayed while rendering the animation. Defaults to (). remover Whether the given mobject should be removed from the scene after this animation. suspend_mobject_updating Whether updaters of the mobject should be suspended during the animation. .. NOTE:: In the current implementation of this class, the specified rate function is applied within :meth:`.Animation.interpolate_mobject` call as part of the call to :meth:`.Animation.interpolate_submobject`. For subclasses of :class:`.Animation` that are implemented by overriding :meth:`interpolate_mobject`, the rate function has to be applied manually (e.g., by passing ``self.rate_func(alpha)`` instead of just ``alpha``). Examples -------- .. manim:: LagRatios class LagRatios(Scene): def construct(self): ratios = [0, 0.1, 0.5, 1, 2] # demonstrated lag_ratios # Create dot groups group = VGroup(*[Dot() for _ in range(4)]).arrange_submobjects() groups = VGroup(*[group.copy() for _ in ratios]).arrange_submobjects(buff=1) self.add(groups) # Label groups self.add(Text("lag_ratio = ", font_size=36).next_to(groups, UP, buff=1.5)) for group, ratio in zip(groups, ratios): self.add(Text(str(ratio), font_size=36).next_to(group, UP)) #Animate groups with different lag_ratios self.play(AnimationGroup(*[ group.animate(lag_ratio=ratio, run_time=1.5).shift(DOWN * 2) for group, ratio in zip(groups, ratios) ])) # lag_ratio also works recursively on nested submobjects: self.play(groups.animate(run_time=1, lag_ratio=0.1).shift(UP * 2)) NT) use_overridereturnrct|trT|rR|j|}|@||g|Ri|}tjd|jdt |jd|St|S)NzThe z# animation has been overridden for za mobjects. use_override = False can be used as keyword argument to prevent animation overriding.) isinstancer animation_override_forrdebug__name__typesuper__new__)clsr r#argskwargsfuncanim __class__s T/home/agentuser/manim-venv/lib/python3.11/site-packages/manim/animation/animation.pyr,zAnimation.__new__ms gw ' ' L 171#66DtG5d555f55 U3<UUG}}-UUU  wws###FcdSN)_s r3zAnimation.s4r4) _on_finishr#r Mobject | OpenGLMobject | None lag_ratiorrun_time rate_funcCallable[[float], float]reverse_rate_functionboolnamestrremoversuspend_mobject_updating introducerr:Callable[[], None]r#Nonec ||||_||_||_||_||_| |_||_||_| |_ tdtj kr+t|_||n t|_n*t!|_||n t!|_t#|drt%jddSdS)NrendererCONFIG)z,CONFIG has been removed from ManimCommunity.z%Please use keyword arguments instead.)_typecheck_inputr=r>r@rBrDrFrEr<r:rrOPENGLrstarting_mobjectr r hasattrrerror) selfr r<r=r>r@rBrDrErFr:r#s r3__init__zAnimation.__init__s g&&&' 3<+@" $ $ *.F% )3= * !4 4 43@??D !".MOO LL.5YYD !/6/BGG DL 4 " "  L       r4c|jSr6) _run_timerQs r3r=zAnimation.run_times ~r4valuec`|dkr td|jjd|d||_dS)NrzThe run_time of z) cannot be negative. The given value was .) ValueErrorr2r)rT)rQrVs r3r=zAnimation.run_timesR 199:4>#:::16::: r4Mobject | Nonec|tjddSt|ttfst ddS)NzAnimation with empty mobjectz Animation only works on Mobjects)rr(r&r r TypeError)rQr s r3rLzAnimation._typecheck_inputsQ ? L7 8 8 8 8 8Gg}%=>> @>?? ? @ @r4cf|jr|jS|jjdt|jdS)N())rBr2r)rCr rUs r3__str__zAnimation.__str__s: 9 9 .)@@C ,=,=@@@@r4c t|Sr6)rCrUs r3__repr__zAnimation.__repr__s4yyr4c||_|jr|j|ddS)zBegin the animation. This method is called right as an animation is being played. As much initialization as possible, especially any mobject copying, should live in this method. rN)create_starting_mobjectrNrEr suspend_updating interpolaterUs r3beginzAnimation.beginsS!% < < > >  ( , L ) ) + + + r4c|d|jr"|j|jdSdSdS)z\Finish the animation. This method gets called when the animation is over. N)rfrEr resume_updatingrUs r3finishzAnimation.finishsT   ( +T\-E L ( ( * * * * * + +-E-Er4scenerc|||r||jdSdS)a4Clean up the :class:`~.Scene` after finishing the animation. This includes to :meth:`~.Scene.remove` the Animation's :class:`~.Mobject` if the animation is a remover. Parameters ---------- scene The scene the animation should be cleaned up from. N)r: is_removerremover rQrls r3clean_up_from_scenezAnimation.clean_up_from_scenesL  ??   ' LL & & & & & ' 'r4c|dS|r7|j|vr||jdSdSdS)a5Setup up the :class:`~.Scene` before starting the animation. This includes to :meth:`~.Scene.add` the Animation's :class:`~.Mobject` if the animation is an introducer. Parameters ---------- scene The scene the animation should be cleaned up from. N) is_introducerr get_mobject_family_membersaddrps r3 _setup_scenezAnimation._setup_scenese = F     $ E$D$D$F$FFF IIdl # # # # #  $ $FFr4Mobject | OpenGLMobjectc4|jSr6)r copyrUs r3rdz!Animation.create_starting_mobjects|  """r4!Sequence[Mobject | OpenGLMobject]c|j|jfS)zGet all mobjects involved in the animation. Ordering must match the ordering of arguments to interpolate_submobject Returns ------- Sequence[Mobject] The sequence of mobjects. )r rNrUs r3get_all_mobjectszAnimation.get_all_mobjects s|T222r4Iterable[tuple]ctdtjkr(td|DddiStd|DddiS)NrJc3>K|]}|VdSr6) get_family.0mobs r3 z4Animation.get_all_families_zipped..s,FFs#..""FFFFFFr4strictFc3>K|]}|VdSr6)family_members_with_pointsrs r3rz4Animation.get_all_families_zipped..s. R R3c,,.. R R R R R Rr4)rrrMzipr|rUs r3get_all_families_zippedz!Animation.get_all_families_zippeds * !4 4 4FFd.C.C.E.EFFFOT  R R$:O:O:Q:Q R R R    r4dtc^|D]}||dS)a Updates things like starting_mobject, and (for Transforms) target_mobject. Note, since typically (always?) self.mobject will have its updating suspended during the animation, this will do nothing to self.mobject. N)get_all_mobjects_to_updateupdate)rQrrs r3update_mobjectszAnimation.update_mobjects!s:2244  C JJrNNNN  r4 list[Mobject]chttfdS)zGet all mobjects to be updated during the animation. Returns ------- List[Mobject] The list of mobjects to be updated during the animation. c|juSr6r )mrQs r3r9z6Animation.get_all_mobjects_to_update..7sQdl%:r4)listfilterr|rUs`r3rz$Animation.get_all_mobjects_to_update,s3F::::D)rQrrrr< full_lengthrVlowers r3rzAnimation.get_sub_alphalso(N &*i7!;  # !  % 1>>!uu}"566 6>>%%-00 0r4c||_|S)afSet the run time of the animation. Parameters ---------- run_time The new time the animation should take in seconds. .. note:: The run_time of an animation should not be changed while it is already running. Returns ------- Animation ``self`` r=)rQr=s r3 set_run_timezAnimation.set_run_times$!  r4c|jS)zGet the run time of the animation. Returns ------- float The time the animation takes in seconds. rrUs r3 get_run_timezAnimation.get_run_times }r4c||_|S)a7Set the rate function of the animation. Parameters ---------- rate_func The new function defining the animation progress based on the relative runtime (see :mod:`~.rate_functions`). Returns ------- Animation ``self`` r>)rQr>s r3 set_rate_funczAnimation.set_rate_funcs"# r4c|jS)zGet the rate function of the animation. Returns ------- Callable[[float], float] The rate function of the animation. rrUs r3 get_rate_funczAnimation.get_rate_funcs ~r4c||_|S)zSet the name of the animation. Parameters ---------- name The new name of the animation. Returns ------- Animation ``self`` )rB)rQrBs r3set_namezAnimation.set_names  r4c|jS)zTest if the animation is a remover. Returns ------- bool ``True`` if the animation is a remover, ``False`` otherwise. )rDrUs r3rnzAnimation.is_removers |r4c|jS)zTest if the animation is an introducer. Returns ------- bool ``True`` if the animation is an introducer, ``False`` otherwise. )rFrUs r3rszAnimation.is_introducers r4c Rtjdi||j|_dS)Nr7)r+__init_subclass__rR_original__init__)r-r/r2s r3rzAnimation.__init_subclass__s0!!++F+++ # r4c T|rt|jfi||_dS|j|_dS)aSets the default values of keyword arguments. If this method is called without any additional keyword arguments, the original default values of the initialization method of this class are restored. Parameters ---------- kwargs Passing any keyword argument will update the default values of the keyword arguments of the initialization function of this class. Examples -------- .. manim:: ChangeDefaultAnimation class ChangeDefaultAnimation(Scene): def construct(self): Rotate.set_default(run_time=2, rate_func=rate_functions.linear) Indicate.set_default(color=None) S = Square(color=BLUE, fill_color=BLUE, fill_opacity=0.25) self.add(S) self.play(Rotate(S, PI)) self.play(Indicate(S)) Rotate.set_default() Indicate.set_default() N)rrRr)r-r/s r3 set_defaultzAnimation.set_defaults8F  1(@@@@CLLL0CLLLr4r6)r$r)r r;r<rr=rr>r?r@rArBrCrDrArErArFrAr:rGr#rAr$rH)r$r)rVrr$rH)r rZr$rH)r$rCr$rHrlrr$rH)r$rw)r$rz)r$r}rrr$rH)r$r)r$rrrr$rH)rr rr rrr$r)rrrrrrr$r)r=rr$r)r>r?r$r)r$r?)rBrCr$r)r$rA))r) __module__ __qualname____doc__r,r!rrrRpropertyr=setterrLr`rbrgrkrqrvrdr|rrrryrfrrrrrrrrrnrs classmethodrrr __classcell__r2s@r3rrs)LL`$ $$$$$$$$,74.4&+)- (*8!((((((TX__@@@@ AAAA & + + + + ' ' ' '$$$$&#### 3 3 3 3         V V V V ( ( ( ( : : : :    1111<,(     -----[- !%1%1%1[%1%1%1%1%1r4rr1HAnimation | mobject._AnimationBuilder | opengl_mobject._AnimationBuilderr$ct|tjr|St|tjr|St|t r|St d|d)aReturns either an unchanged animation, or the animation built from a passed animation factory. Examples -------- :: >>> from manim import Square, FadeIn >>> s = Square() >>> prepare_animation(FadeIn(s)) FadeIn(Square) :: >>> prepare_animation(s.animate.scale(2).rotate(42)) _MethodAnimation(Square) :: >>> prepare_animation(42) Traceback (most recent call last): ... TypeError: Object 42 cannot be converted to an animation zObject z$ cannot be converted to an animation)r&r _AnimationBuilderbuildr rr\)r1s r3prepare_animationrs{:$122zz||$899zz||$ "" HdHHH I IIr4cVeZdZdZdddefdfd ZddZddZddZddZ ddZ xZ S)raA "no operation" animation. Parameters ---------- run_time The amount of time that should pass. stop_condition A function without positional arguments that evaluates to a boolean. The function is evaluated after every new frame has been rendered. Playing the animation stops after the return value is truthy, or after the specified ``run_time`` has passed. frozen_frame Controls whether or not the wait animation is static, i.e., corresponds to a frozen frame. If ``False`` is passed, the render loop still progresses through the animation as usual and (among other things) continues to call updater functions. If ``None`` (the default value), the :meth:`.Scene.play` call tries to determine whether the Wait call can be static or not itself via :meth:`.Scene.should_mobjects_update`. kwargs Keyword arguments to be passed to the parent class, :class:`.Animation`. riNr=rstop_conditionCallable[[], bool] | None frozen_frame bool | Noner>r?c |r|rtd||_||_||_t jd||d|g|j_dS)Nz5A static Wait animation cannot have a stop condition.)r=r>r6)rYdurationris_static_waitr+rRr shader_wrapper_list)rQr=rrr>r/r2s r3rRz Wait.__init___sp  Vl VTUU U' ,$0PIPPPPP+- (((r4r$rHcdSr6r7rUs r3rgz Wait.beginq r4cdSr6r7rUs r3rkz Wait.finishtrr4rlrcdSr6r7rps r3rqzWait.clean_up_from_scenewrr4rcdSr6r7rQrs r3rzWait.update_mobjectszrr4rcdSr6r7rs r3rfzWait.interpolate}rr4)r=rrrrrr>r?rrrr) r)rrrrrRrgrkrqrrfrrs@r3rrHs048$(.4 .......$                        r4rcReZdZdZdddfd Zdd ZddZddZddZddZ xZ S)rakAdd Mobjects to a scene, without animating them in any other way. This is similar to the :meth:`.Scene.add` method, but :class:`Add` is an animation which can be grouped into other animations. Parameters ---------- mobjects One :class:`~.Mobject` or more to add to a scene. run_time The duration of the animation after adding the ``mobjects``. Defaults to 0, which means this is an instant animation without extra wait time after adding them. **kwargs Additional arguments to pass to the parent :class:`Animation` class. Examples -------- .. manim:: DefaultAddScene class DefaultAddScene(Scene): def construct(self): text_1 = Text("I was added with Add!") text_2 = Text("Me too!") text_3 = Text("And me!") texts = VGroup(text_1, text_2, text_3).arrange(DOWN) rect = SurroundingRectangle(texts, buff=0.5) self.play( Create(rect, run_time=3.0), Succession( Wait(1.0), # You can Add a Mobject in the middle of an animation... Add(text_1), Wait(1.0), # ...or multiple Mobjects at once! Add(text_2, text_3), ), ) self.wait() .. manim:: AddWithRunTimeScene class AddWithRunTimeScene(Scene): def construct(self): # A 5x5 grid of circles circles = VGroup( *[Circle(radius=0.5) for _ in range(25)] ).arrange_in_grid(5, 5) self.play( Succession( # Add a run_time of 0.2 to wait for 0.2 seconds after # adding the circle, instead of using Wait(0.2) after Add! *[Add(circle, run_time=0.2) for circle in circles], rate_func=smooth, ) ) self.wait() r rmobjectsr r=rr/rr$rHct|dkr|dnt|}tj|f|dd|dS)NrirT)r=rF)rr r+rR)rQr=rr/r r2s r3rRz Add.__init__sS"%X!!3!3(1++9IO8OOOOOOOr4cdSr6r7rUs r3rgz Add.beginrr4cdSr6r7rUs r3rkz Add.finishrr4rlrcdSr6r7rps r3rqzAdd.clean_up_from_scenerr4rcdSr6r7rs r3rzAdd.update_mobjectsrr4rcdSr6r7rs r3rfzAdd.interpolaterr4)rr r=rr/rr$rHrrrr) r)rrrrRrgrkrqrrfrrs@r3rrs;;|58PPPPPPPP                         r4ranimation_classtype[Animation]Callable[[Callable], Callable]cfd}|S)aDecorator used to mark methods as overrides for specific :class:`~.Animation` types. Should only be used to decorate methods of classes derived from :class:`~.Mobject`. ``Animation`` overrides get inherited to subclasses of the ``Mobject`` who defined them. They don't override subclasses of the ``Animation`` they override. See Also -------- :meth:`~.Mobject.add_animation_override` Parameters ---------- animation_class The animation to be overridden. Returns ------- Callable[[Callable], Callable] The actual decorator. This marks the method as overriding an animation. Examples -------- .. manim:: OverrideAnimationExample class MySquare(Square): @override_animation(FadeIn) def _fade_in_override(self, **kwargs): return Create(self, **kwargs) class OverrideAnimationExample(Scene): def construct(self): self.play(FadeIn(MySquare())) c|_|Sr6)_override_animation)r0rs r3 decoratorz%override_animation..decorators#2  r4r7)rrs` r3rrs%N r4N)r1rr$r)rrr$r)*r __future__r#manim.mobject.opengl.opengl_mobjectrrr constantsrr mobject.mobjectr r mobject.openglr utils.rate_functionsrr__all__collections.abcrrrryr functoolsrtypingrrrmanim.scene.scenerr__annotations__r!rrrrrr7r4r3rs#""""""======$$$$$$,,,,,,,,++++++11111111 < < <9888888888######++++++++++(''''''%(''''%(((((~1~1~1~1~1~1~1~1B&J&J&J&JR6 6 6 6 6 96 6 6 rQ Q Q Q Q )Q Q Q h++++++r4