l jXUdZddlmZgdZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddlZddlmZmZddlmZmZddlmZddlmZmZddlZdd lmZdd lmZd d l m!Z!m"Z"d d l#Td dl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+d dl,m-Z-d dl.m/Z/m0Z0d dl1m2Z2d dl3m4Z4m5Z5m6Z6erQddlm7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCd dlDmEZEedeFgeGfZHdeId<edgeGfZJdeId<eJeHzZKdeId<GddZLGddeLeZMGdd ZNGd!d"ZOd&d%ZPdS)'z/Base classes for objects that can be displayed.) annotations)MobjectGroupoverride_animateN)CallableIterable) partialmethodreduce)Path) TYPE_CHECKINGAny)MethodWithArgs)ConvertToOpenGL)configlogger)*)BLACK PURE_YELLOWWHITE ManimColorParsableManimColorcolor_gradientinterpolate_color)MultiAnimationOverrideException) list_updateremove_list_redundancies) straight_path)angle_between_vectors normalizerotation_matrix)Self TypeAlias) FunctionOverrideMappingFunctionMatrixMNMultiMappingFunction PathFuncType PixelArrayPoint3D Point3DLikePoint3DLike_Array Vector3DLike) Animationrr#TimeBasedUpdaterNonTimeBasedUpdaterUpdaterc & eZdZdZiZedRfd ZeddddfdSdZdTdZ dUdZ edVdZ edRdZ edWd Z edRd!ZedXd#ZedYd$ZdYd%ZdZd'ZdYd(Zd[d*Zd[d+Zd\d-Zd]d0Zd^d1Zd^d2Zd\d3Zd\d4Zd5Zd6ZdYd7Zd_d:Z ed`d;Z!e!j"dad=Z!ed`d>Z#e#j"dad?Z#ed`d@Z$e$j"dadAZ$dbdCZ%dcdFZ&dddedHZ'dddRdIZ(dddfdJZ)dYdKZ*dgdhdOZ+didjdSZ,dkdUZ-dldVZ.dmdXZ/dmdYZ0 dndod^Z1dpd_Z2dqdrd`Z3dsdaZ4dqdrdbZ5dqdrdcZ6dtdeZ7dudhZ8dddidvdoZ9e:fdwdrZ;e:fdddidxdsZdddidzdvZ?dddid{dyZ@d|dzZAd|d{ZBdddid}d~ZCdddid~dZDdYdZEddZF dddZGdZHdYdZIeJfddZKeLeJfddZMeNeJfddZOePeQeRddeSjTgdfddZUdYdZVdZWddZX dgddZYddZZddZ[ddZ\ddZ]ddZ^ddZ_eRfddZ`eRfddZaeRfddZbeRfddZcdddZdeReSjTgdfddZe dddZfddLegfddZhddZi dddZjdYdZkdYdZlemdPfdd„ZnddĄZoddeepfddʄZqdd̄Zrddeepfdd̈́ZsdYd΄Zt dqddЄZudddӄZvddՄZwdYdքZxdYdׄZyddڄZzdd܄Z{dd߄Z|ddZ}ddZ~ddZ dddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZeRfddZeRfddZeRfddZeRfddZddZddZddZddZddZddZddZdldZdldZdsdZddZdsd Zdsd Zdsd ZeRfdd ZeRfdsd ZeRfdsdZeRfdsdZeRfddZdZdZddZddZeddZddZdqddZddZePeQdPfddZddegeRdddddf dd'Zd(dfdd-Zdgdd.Zdgdd/ZdYd0ZdYd1ZdRd2Zdgdd4Zddd5Zdsd6Zdd8Zdsd9Zd^d:ZdYd;Zdd>Zdd@ZefddEZddFZ dddKZÐdqddMZĐdRdNZ dqdÐdPZƐdYdQZLjxZS(raMathematical Object: base class for objects that can be displayed on screen. There is a compatibility layer that allows for getting and setting generic attributes with ``get_*`` and ``set_*`` methods. See :meth:`set` for more details. Attributes ---------- submobjects : List[:class:`Mobject`] The contained objects. points : :class:`numpy.ndarray` The points of the objects. .. seealso:: :class:`~.VMobject` returnNonec tjdi|i|_||j|_dSN)super__init_subclass__animation_overrides"_add_intrinsic_animation_overrides__init___original__init__)clskwargs __class__s P/home/agentuser/manim-venv/lib/python3.11/site-packages/manim/mobject/mobject.pyr9zMobject.__init_subclass__XsQ!!++F+++   ..000 # Nrcolor-ParsableManimColor | list[ParsableManimColor]name str | Nonedimintz_indexfloatc<| |jjn||_||_||_||_d|_g|_g|_d|_ tj ||_ | ||dSNF)r@__name__rFrHtargetrJ point_hash submobjectsupdatersupdating_suspendedrparserD reset_pointsgenerate_points init_colors)selfrDrFrHrOrJs rAr<zMobject.__init__cs04|DN++   ') "'%e,,    rBrQIterable[Mobject]r"c8||tS)aCheck that all submobjects are actually instances of :class:`Mobject`, and that none of them is ``self`` (a :class:`Mobject` cannot contain itself). This is an auxiliary function called when adding Mobjects to the :attr:`submobjects` list. This function is intended to be overridden by subclasses such as :class:`VMobject`, which should assert that only other VMobjects may be added into it. Parameters ---------- submobjects The list containing values to validate. Returns ------- :class:`Mobject` The Mobject itself. Raises ------ TypeError If any of the values in `submobjects` is not a :class:`Mobject`. ValueError If there was an attempt to add a :class:`Mobject` as its own submobject. )"_assert_valid_submobjects_internalr)rXrQs rA_assert_valid_submobjectsz!Mobject._assert_valid_submobjectsys<66{GLLLrB list[Mobject] mob_class type[Mobject]c pt|D]\}}t||sdd|jdt|jd|d|dt|jd }t|tr|dz }t |||ur(t dt|jd |d |S) NzOnly values of type z can be added as submobjects of z, but the value z (at index z ) is of type .z4 You can try adding this value into a Group instead.z Cannot add z% as a submobject of itself (at index z).) enumerate isinstancerNtyper TypeError ValueError)rXrQr^isubmob error_messages rAr[z*Mobject._assert_valid_submobjects_internals#;//  IAvfi00 /09+=00)-d)<0000*+00F||,000fg..!NM ...~~ .$t**"5..()...  rBanimation_classtype[Animation]FunctionOverride | Nonec2||jvr |j|SdS)aReturns the function defining a specific animation override for this class. Parameters ---------- animation_class The animation class for which the override function should be returned. Returns ------- Optional[Callable[[Mobject, ...], Animation]] The function returning the override animation or ``None`` if no such animation override is defined. N)r:)r>rjs rAanimation_override_forzMobject.animation_override_fors%$ c5 5 5*?; ;trBct|D]U}|drt||}t|dr|j}|||VdS)zhInitializes animation overrides marked with the :func:`~.override_animation` decorator. ___override_animationN)dir startswithgetattrhasattrrqadd_animation_override)r> method_namemethodrjs rAr;z*Mobject._add_intrinsic_animation_overridess s88 D DK%%d++ S+..Fv455 D"("<**?FCCC D DrB override_funcr$c ||jvr ||j|<dStd|jd|jd|j|jd|jd )aAdd an animation override. This does not apply to subclasses. Parameters ---------- animation_class The animation type to be overridden override_func The function returning an animation replacing the default animation. It gets passed the parameters given to the animation constructor. Raises ------ MultiAnimationOverrideException If the overridden animation was already overridden. zThe animation z for z( is overridden by more than one method: z and raN)r:rrN __qualname__)r>rjrys rArvzMobject.add_animation_overrides. #"9 9 97DC #O 4 4 411!911<11*?;H11!-111 rBc T|rt|jfi||_dS|j|_dS)a%Sets 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 -------- :: >>> from manim import Square, GREEN >>> Square.set_default(color=GREEN, fill_opacity=0.25) >>> s = Square(); s.color, s.fill_opacity (ManimColor('#83C167'), 0.25) >>> Square.set_default() >>> s = Square(); s.color, s.fill_opacity (ManimColor('#FFFFFF'), 0.0) .. manim:: ChangedDefaultTextcolor :save_last_frame: config.background_color = WHITE class ChangedDefaultTextcolor(Scene): def construct(self): Text.set_default(color=BLACK) self.add(Text("Changing default values is easy!")) # we revert the colour back to the default to prevent a bug in the docs. Text.set_default(color=WHITE) N)r r<r=)r>r?s rA set_defaultzMobject.set_defaults8V  1(@@@@CLLL0CLLLrB_AnimationBuilder | Selfc t|S)a Used to animate the application of any method of :code:`self`. Any method called on :code:`animate` is converted to an animation of applying that method on the mobject itself. For example, :code:`square.set_fill(WHITE)` sets the fill color of a square, while :code:`square.animate.set_fill(WHITE)` animates this action. Multiple methods can be put in a single animation once via chaining: :: self.play(my_mobject.animate.shift(RIGHT).rotate(PI)) .. warning:: Passing multiple animations for the same :class:`Mobject` in one call to :meth:`~.Scene.play` is discouraged and will most likely not work properly. Instead of writing an animation like :: self.play( my_mobject.animate.shift(RIGHT), my_mobject.animate.rotate(PI) ) make use of method chaining. Keyword arguments that can be passed to :meth:`.Scene.play` can be passed directly after accessing ``.animate``, like so:: self.play(my_mobject.animate(rate_func=linear).shift(RIGHT)) This is especially useful when animating simultaneous ``.animate`` calls that you want to behave differently:: self.play( mobject1.animate(run_time=2).rotate(PI), mobject2.animate(rate_func=there_and_back).shift(RIGHT), ) .. seealso:: :func:`override_animate` Examples -------- .. manim:: AnimateExample class AnimateExample(Scene): def construct(self): s = Square() self.play(Create(s)) self.play(s.animate.shift(RIGHT)) self.play(s.animate.scale(2)) self.play(s.animate.rotate(PI / 2)) self.play(Uncreate(s)) .. manim:: AnimateChainExample class AnimateChainExample(Scene): def construct(self): s = Square() self.play(Create(s)) self.play(s.animate.shift(RIGHT).scale(2).rotate(PI / 2)) self.play(Uncreate(s)) .. manim:: AnimateWithArgsExample class AnimateWithArgsExample(Scene): def construct(self): s = Square() c = Circle() VGroup(s, c).arrange(RIGHT, buff=2) self.add(s, c) self.play( s.animate(run_time=2).rotate(PI / 2), c.animate(rate_func=there_and_back).shift(RIGHT), ) .. warning:: ``.animate`` will interpolate the :class:`~.Mobject` between its points prior to ``.animate`` and its points after applying ``.animate`` to it. This may result in unexpected behavior when attempting to interpolate along paths, or rotations (see :meth:`.rotate`). If you want animations to consider the points between, consider using :class:`~.ValueTracker` with updaters instead (see :meth:`.add_updater`). )_AnimationBuilderrXs rAanimatezMobject.animate)sD!&&&rBc t|S)aCall a method on a mobject every frame. This is syntactic sugar for ``mob.add_updater(lambda m: m.method(*args, **kwargs), call_updater=True)``. Note that this will call the method immediately. If this behavior is not desired, you should use :meth:`add_updater` directly. .. warning:: Chaining of methods is allowed, but each method will be added as its own updater. If you are chaining methods, make sure they do not interfere with each other or you may get unexpected results. .. warning:: :attr:`always` is not compatible with :meth:`.ValueTracker.get_value`, because the value will be computed once and then never updated again. Use :meth:`add_updater` if you would like to use a :class:`~.ValueTracker` to update the value. Example ------- .. manim:: AlwaysExample class AlwaysExample(Scene): def construct(self): sq = Square().to_edge(LEFT) t = Text("Hello World!") t.always.next_to(sq, UP) self.add(sq, t) self.play(sq.animate.to_edge(RIGHT)) )_UpdaterBuilderrs rAalwayszMobject.alwayssDt$$$rBc *|j}||}||t|<|jD])\}}t ||t j||*tt||_ |SN) r@__new__id__dict__itemssetattrcopydeepcopystr original_id)rX clone_from_idr>resultkvs rA __deepcopy__zMobject.__deepcopy__snS!!"( bhhM'')) @ @DAq FAt}Q >> ? ? ? ? D]] rBrc*t|jSr)rrFrs rA__repr__zMobject.__repr__s49~~rBcFtjd|jf|_|S)z)Sets :attr:`points` to be an empty array.r)npzerosrHpointsrs rArUzMobject.reset_pointssh48}--  rBobjectcdS)zInitializes the colors. Gets called upon creation. This is an empty method that can be implemented by subclasses. Nr7rs rArWzMobject.init_colorsrBcdS)zInitializes :attr:`points` and therefore the shape. Gets called upon creation. This is an empty method that can be implemented by subclasses. Nr7rs rArVzMobject.generate_pointsrrBmobjectsc||t|}t|t|krtjdt |j||_|S)a Add mobjects as submobjects. The mobjects are added to :attr:`submobjects`. Subclasses of mobject may implement ``+`` and ``+=`` dunder methods. Parameters ---------- mobjects The mobjects to add. Returns ------- :class:`Mobject` ``self`` Raises ------ :class:`ValueError` When a mobject tries to add itself. :class:`TypeError` When trying to add an object that is not an instance of :class:`Mobject`. Notes ----- A mobject cannot contain itself, and it cannot contain a submobject more than once. If the parent mobject is displayed, the newly-added submobjects will also be displayed (i.e. they are automatically added to the parent Scene). See Also -------- :meth:`remove` :meth:`add_to_back` Examples -------- :: >>> outer = Mobject() >>> inner = Mobject() >>> outer = outer.add(inner) Duplicates are not added again:: >>> outer = outer.add(inner) >>> len(outer.submobjects) 1 Only Mobjects can be added:: >>> outer.add(3) Traceback (most recent call last): ... TypeError: Only values of type Mobject can be added as submobjects of Mobject, but the value 3 (at index 0) is of type int. Adding an object to itself raises an error:: >>> outer.add(outer) Traceback (most recent call last): ... ValueError: Cannot add Mobject as a submobject of itself (at index 0). A given mobject cannot be added as a submobject twice to some parent:: >>> parent = Mobject(name="parent") >>> child = Mobject(name="child") >>> parent.add(child, child) [...] WARNING ... parent >>> parent.submobjects [child] zgAttempted adding some Mobject as a child more than once, this is not possible. Repetitions are ignored.)r\rlenrwarningrrQ)rXrunique_mobjectss rAaddz Mobject.addsuZ &&x00028<< x==C00 0 0 NA    't'7II rBindexmobjectch||g|j||dS)a}Inserts a mobject at a specific position into self.submobjects Effectively just calls ``self.submobjects.insert(index, mobject)``, where ``self.submobjects`` is a list. Highly adapted from ``Mobject.add``. Parameters ---------- index The index at which mobject The mobject to be inserted. N)r\rQinsert)rXrrs rArzMobject.insert(s9 &&y111 w/////rBctrNotImplementedErrorrXrs rA__add__zMobject.__add__:!!rBctrrrs rA__iadd__zMobject.__iadd__=rrBc|||j|tt||jz|_|S)aAdd all passed mobjects to the back of the submobjects. If :attr:`submobjects` already contains the given mobjects, they just get moved to the back instead. Parameters ---------- mobjects The mobjects to add. Returns ------- :class:`Mobject` ``self`` .. note:: Technically, this is done by adding (or moving) the mobjects to the head of :attr:`submobjects`. The head of this list is rendered first, which places the corresponding mobjects behind the subsequent list members. Raises ------ :class:`ValueError` When a mobject tries to add itself. :class:`TypeError` When trying to add an object that is not an instance of :class:`Mobject`. Notes ----- A mobject cannot contain itself, and it cannot contain a submobject more than once. If the parent mobject is displayed, the newly-added submobjects will also be displayed (i.e. they are automatically added to the parent Scene). See Also -------- :meth:`remove` :meth:`add` )r\removelistdictfromkeysrQ)rXrs rA add_to_backzMobject.add_to_back@sQX &&x000 X h 7 7884;KK rBcV|D]%}||jvr|j|&|S)aRemove :attr:`submobjects`. The mobjects are removed from :attr:`submobjects`, if they exist. Subclasses of mobject may implement ``-`` and ``-=`` dunder methods. Parameters ---------- mobjects The mobjects to remove. Returns ------- :class:`Mobject` ``self`` See Also -------- :meth:`add` )rQr)rXrrs rArzMobject.removers>,  1 1G$*** ''000 rBctrrrXothers rA__sub__zMobject.__sub__rrBctrrrs rA__isub__zMobject.__isub__rrBc \|D]\}}t||||S)a#Sets attributes. I.e. ``my_mobject.set(foo=1)`` applies ``my_mobject.foo = 1``. This is a convenience to be used along with :attr:`animate` to animate setting attributes. In addition to this method, there is a compatibility layer that allows ``get_*`` and ``set_*`` methods to get and set generic attributes. For instance:: >>> mob = Mobject() >>> mob.set_foo(0) Mobject >>> mob.get_foo() 0 >>> mob.foo 0 This compatibility layer does not interfere with any ``get_*`` or ``set_*`` methods that are explicitly defined. .. warning:: This compatibility layer is for backwards compatibility and is not guaranteed to stay around. Where applicable, please prefer getting/setting attributes normally or with the :meth:`set` method. Parameters ---------- **kwargs The attributes and corresponding values to set. Returns ------- :class:`Mobject` ``self`` Examples -------- :: >>> mob = Mobject() >>> mob.set(foo=0) Mobject >>> mob.foo 0 )rr)rXr?attrvalues rAsetz Mobject.sets:f"<<>> ' 'KD% D$ & & & & rBrtypes.MethodTypec8|dr$|ddfd}tj||S|dr$|ddfd}tj||Stt |jd|d)Nget_c\tjdtdt|S)Nz[This method is not guaranteed to stay around. Please prefer getting the attribute normally.r stacklevel)warningswarnDeprecationWarningrt)rXto_gets rAgetterz#Mobject.__getattr__..getters9 6& tV,,,rBset_cbtjdtdt|||S)NzqThis method is not guaranteed to stay around. Please prefer setting the attribute normally or with Mobject.set().rr)rrrr)rXrto_sets rAsetterz#Mobject.__getattr__..settersA L& fe,,, rBz object has no attribute '')rstypes MethodTypeAttributeErrorrdrN)rXrrrrrs @@rA __getattr__zMobject.__getattr__s ??6 " " 2!""XF - - - - -#FD11 1 ??6 " " 2!""XF     #FD11 1T 3VVtVVVWWWrBc,|dS)aThe width of the mobject. Returns ------- :class:`float` Examples -------- .. manim:: WidthExample class WidthExample(Scene): def construct(self): decimal = DecimalNumber().to_edge(UP) rect = Rectangle(color=BLUE) rect_copy = rect.copy().set_stroke(GRAY, opacity=0.5) decimal.add_updater(lambda d: d.set_value(rect.width)) self.add(rect_copy, rect, decimal) self.play(rect.animate.set(width=7)) self.wait() See also -------- :meth:`length_over_dim` rlength_over_dimrs rAwidthz Mobject.width<##A&&&rBrc0||dSr)scale_to_fit_widthrXrs rArz Mobject.width &&&&&rBc,|dS)aThe height of the mobject. Returns ------- :class:`float` Examples -------- .. manim:: HeightExample class HeightExample(Scene): def construct(self): decimal = DecimalNumber().to_edge(UP) rect = Rectangle(color=BLUE) rect_copy = rect.copy().set_stroke(GRAY, opacity=0.5) decimal.add_updater(lambda d: d.set_value(rect.height)) self.add(rect_copy, rect, decimal) self.play(rect.animate.set(height=5)) self.wait() See also -------- :meth:`length_over_dim` rrs rAheightzMobject.heightrrBc0||dSr)scale_to_fit_heightrs rArzMobject.height>s   '''''rBc,|dS)zThe depth of the mobject. Returns ------- :class:`float` See also -------- :meth:`length_over_dim` rrrs rAdepthz Mobject.depthBs##A&&&rBc0||dSr)scale_to_fit_depthrs rArz Mobject.depthRrrB list[str]cdgS)Nrr7rs rAget_array_attrszMobject.get_array_attrsWs zrBfuncr'c |D]*}t|||t||+|Sr)rrrt)rXrrs rAapply_over_attr_arrayszMobject.apply_over_attr_arraysZsK((** ; ;D D$WT4%8%8 9 9 : : : : rBr)cx|ddlm}|}|||S)Nr)Camera) camera.camerarcapture_mobject get_image)rXcamerars rArzMobject.get_imageasJ > . . . . . .VXXFt$$$!!!rBcV||dS)N)r)rshow)rXrs rArz Mobject.showis( f%%**,,,,,rBc|ttjd|pt |dzdS)z\Saves an image of only this :class:`Mobject` at its position to a png file. video_dirz.pngN)rsaver rget_dirjoinpathr)rXrFs rA save_imagezMobject.save_imagelsc   ,, - - 6 68ID V7S T T     rBc*tj|S)a-Create and return an identical copy of the :class:`Mobject` including all :attr:`submobjects`. Returns ------- :class:`Mobject` The copy. Note ---- The clone is initially not visible in the Scene, even if the original was. )rrrs rArz Mobject.copyts}T"""rBF use_deepcopyboolcd|_|rtj||_n||_|jSr)rOrr)rXrs rAgenerate_targetzMobject.generate_targets;  &---DKK))++DK{rBTdt recursivec|js=|jD]5}dtj|jvr |||*||6|r!|jD]}||||S)a Apply all updaters. Does nothing if updating is suspended. Parameters ---------- dt The parameter ``dt`` to pass to the update functions. Usually this is the time in seconds since the last call of ``update``. recursive Whether to recursively update all submobjects. Returns ------- :class:`Mobject` ``self`` See Also -------- :meth:`add_updater` :meth:`get_updaters` rr)rSrRinspect signature parametersrQupdate)rXrrupdaterrhs rAr zMobject.updates0& "= " "7,W55@@@GD"%%%%GDMMMM  7* 7 7 bI 6666 rBlist[TimeBasedUpdater]c$d|jDS)a\Return all updaters using the ``dt`` parameter. The updaters use this parameter as the input for difference in time. Returns ------- List[:class:`Callable`] The list of time based updaters. See Also -------- :meth:`get_updaters` :meth:`has_time_based_updater` cHg|]}dtj|jv| S)rrrr .0r s rA z3Mobject.get_time_based_updaters..s;   w(11<<< <<td|jDS)aTest if ``self`` has a time based updater. Returns ------- :class:`bool` ``True`` if at least one updater uses the ``dt`` parameter, ``False`` otherwise. See Also -------- :meth:`get_time_based_updaters` c3LK|]}dtj|jvV dS)rNrrs rA z1Mobject.has_time_based_updater..sF  >EDG%g..9 9      rB)anyrRrs rAhas_time_based_updaterzMobject.has_time_based_updaters4  IM      rB list[Updater]c|jS)zReturn all updaters. Returns ------- List[:class:`Callable`] The list of updaters. See Also -------- :meth:`add_updater` :meth:`get_time_based_updaters` rrs rA get_updaterszMobject.get_updaterss }rBcpttjd|DS)Nc3>K|]}|VdSr)r)rsms rArz.Mobject.get_family_updaters..s,MMRr00MMMMMMrB)ritchain get_familyrs rAget_family_updaterszMobject.get_family_updaterss0BHMM4??;L;LMMMNOOOrBupdate_functionr1 int | None call_updaterc||j|n|j|||r5tj|j}d|vr ||dn |||S)uAdd an update function to this mobject. Update functions, or updaters in short, are functions that are applied to the Mobject in every frame. Parameters ---------- update_function The update function to be added. Whenever :meth:`update` is called, this update function gets called using ``self`` as the first parameter. The updater can have a second parameter ``dt``. If it uses this parameter, it gets called using a second value ``dt``, usually representing the time in seconds since the last call of :meth:`update`. index The index at which the new updater should be added in ``self.updaters``. In case ``index`` is ``None`` the updater will be added at the end. call_updater Whether or not to call the updater initially. If ``True``, the updater will be called using ``dt=0``. Returns ------- :class:`Mobject` ``self`` Examples -------- .. manim:: NextToUpdater class NextToUpdater(Scene): def construct(self): def update_label(mobject): mobject.set_value(dot.get_center()[0]) mobject.next_to(dot) dot = Dot(RIGHT*3) label = DecimalNumber() label.add_updater(update_label) self.add(dot, label) self.play(Rotating(dot, angle=TAU, about_point=ORIGIN, run_time=TAU, rate_func=linear)) .. manim:: DtUpdater class DtUpdater(Scene): def construct(self): square = Square() #Let the square rotate 90° per second square.add_updater(lambda mobject, dt: mobject.rotate(dt*90*DEGREES)) self.add(square) self.wait(2) See also -------- :meth:`get_updaters` :meth:`remove_updater` :class:`~.UpdateFromFunc` :class:`~.Rotating` :meth:`rotate` :attr:`~.Mobject.animate` Nrr)rRappendrrrr )rXr$rr&r s rA add_updaterzMobject.add_updatersJ = M  1 1 1 1 M  8 8 8  & *?;;FJz!!a((((%%% rBc^||jvr#|j|||jv#|S)aRemove an updater. If the same updater is applied multiple times, every instance gets removed. Parameters ---------- update_function The update function to be removed. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`clear_updaters` :meth:`add_updater` :meth:`get_updaters` )rRr)rXr$s rAremove_updaterzMobject.remove_updater<s;... M  1 1 1.. rBcTg|_|r|jD]}||S)aqRemove every updater. Parameters ---------- recursive Whether to recursively call ``clear_updaters`` on all submobjects. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`remove_updater` :meth:`add_updater` :meth:`get_updaters` )rRrQclear_updatersrXrrhs rAr-zMobject.clear_updatersWs?(  (* ( (%%'''' rBc||D]}|||S)aMatch the updaters of the given mobject. Parameters ---------- mobject The mobject whose updaters get matched. Returns ------- :class:`Mobject` ``self`` Note ---- All updaters from submobjects are removed, but only updaters of the given mobject are matched, not those of it's submobjects. See also -------- :meth:`add_updater` :meth:`clear_updaters` )r-rr))rXrr s rAmatch_updaterszMobject.match_updatersqsM0 ++-- & &G   W % % % % rBcVd|_|r|jD]}|||S)ahDisable updating from updaters and animations. Parameters ---------- recursive Whether to recursively suspend updating on all submobjects. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`resume_updating` :meth:`add_updater` T)rSrQsuspend_updatingr.s rAr2zMobject.suspend_updatingsB(#'  3* 3 3'' 2222 rBcd|_|r|jD]}|||d||S)afEnable updating from updaters and animations. Parameters ---------- recursive Whether to recursively enable updating on all submobjects. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`suspend_updating` :meth:`add_updater` Fr)rr)rSrQresume_updatingr r.s rAr4zMobject.resume_updatingsX&#(  2* 2 2&&y1111 qI ... rBCallable[[Mobject], None]cJ|D] }||dS)aApply a function to ``self`` and every submobject with points recursively. Parameters ---------- func The function to apply to each mobject. ``func`` gets passed the respective (sub)mobject as parameter. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`family_members_with_points` N)family_members_with_points)rXrmobs rAapply_to_familyzMobject.apply_to_familys8&2244  C DIIII  rBvectorsr-cttj|}|D]1}|jd|_|xj|z c_2|S)aJShift by the given vectors. Parameters ---------- vectors Vectors to shift by. If multiple vectors are given, they are added together. Returns ------- :class:`Mobject` ``self`` See also -------- :meth:`move_to` rK)r oprr7rastype)rXr: total_vectorr8s rAshiftz Mobject.shifts^$bfg.. 2244 ' 'C**733CJ JJ, &JJJ rB about_point about_edge scale_factorrAPoint3DLike | NonerBVector3DLike | Nonec<|fd|||S)uScale the size by a factor. Default behavior is to scale about the center of the mobject. Parameters ---------- scale_factor The scaling factor :math:`\alpha`. If :math:`0 < |\alpha| < 1`, the mobject will shrink, and for :math:`|\alpha| > 1` it will grow. Furthermore, if :math:`\alpha < 0`, the mobject is also flipped. about_point The point about which to apply the scaling. about_edge The edge about which to apply the scaling. Returns ------- :class:`Mobject` ``self`` Examples -------- .. manim:: MobjectScaleExample :save_last_frame: class MobjectScaleExample(Scene): def construct(self): f1 = Text("F") f2 = Text("F").scale(2) f3 = Text("F").scale(0.5) f4 = Text("F").scale(-1) vgroup = VGroup(f1, f2, f3, f4).arrange(6 * RIGHT) self.add(vgroup) See also -------- :meth:`move_to` c|zSrr7)rrCs rAzMobject.scale..$s <&0rB!apply_points_function_about_point)rXrCrArBs ` rAscalez Mobject.scales5` .. 0 0 0 0+z    rBangleaxisc<|||tS)zERotates the :class:`~.Mobject` about the ORIGIN, which is at [0,0,0].rA)rotateORIGIN)rXrLrMs rArotate_about_originzMobject.rotate_about_origin(s{{5$F{;;;rBc\t|||fd|||S)aWRotates the :class:`~.Mobject` around a specified axis and point. Parameters ---------- angle The angle of rotation in radians. Predefined constants such as ``DEGREES`` can also be used to specify the angle in degrees. axis The rotation axis (see :class:`~.Rotating` for more). about_point The point about which the mobject rotates. If ``None``, rotation occurs around the center of the mobject. about_edge The edge about which to apply the scaling. Returns ------- :class:`Mobject` ``self`` (for method chaining) .. note:: To animate a rotation, use :class:`~.Rotating` or :class:`~.Rotate` instead of ``.animate.rotate(...)``. The ``.animate.rotate(...)`` syntax only applies a transformation from the initial state to the final rotated state (interpolation between the two states), without showing proper rotational motion based on the angle (from 0 to the given angle). Examples -------- .. manim:: RotateMethodExample :save_last_frame: class RotateMethodExample(Scene): def construct(self): circle = Circle(radius=1, color=BLUE) line = Line(start=ORIGIN, end=RIGHT) arrow1 = Arrow(start=ORIGIN, end=RIGHT, buff=0, color=GOLD) group1 = VGroup(circle, line, arrow1) group2 = group1.copy() arrow2 = group2[2] arrow2.rotate(angle=PI / 4, about_point=arrow2.get_start()) group3 = group1.copy() arrow3 = group3[2] arrow3.rotate(angle=120 * DEGREES, about_point=arrow3.get_start()) self.add(VGroup(group1, group2, group3).arrange(RIGHT, buff=1)) See also -------- :class:`~.Rotating`, :class:`~.Rotate`, :attr:`~.Mobject.animate`, :meth:`apply_points_function_about_point` c8tj|jSrrdotT)r rot_matrixs rArHz Mobject.rotate..os26&*,77rB)r!rJ)rXrLrMrArBrXs @rArPzMobject.rotate,sDB%UD11  .. 7 7 7 7j    rBcD|tdz |||S)aFlips/Mirrors an mobject about its center. Examples -------- .. manim:: FlipExample :save_last_frame: class FlipExample(Scene): def construct(self): s= Line(LEFT, RIGHT+UP).shift(4*LEFT) self.add(s) s2= s.copy().flip() self.add(s2) rr@)rPTAU)rXrMrArBs rAflipz Mobject.flipss,.{{ !GT{z   rBfactorcFdfd }|||||S)Nr Point3D_Arrayr3c0|ddfxxzcc<|Srr7)rrHr\s rArzMobject.stretch..funcs& 111c6NNNf $NNNMrBrr^r3r^rI)rXr\rHrArBrs `` rAstretchzMobject.stretchsF        ..t[*MMM rBfunctionr%cX| |t}dfd }|||||S)Nrr^r3c4tjd|}|SNr)rapply_along_axis)rrrbs rAmulti_mapping_functionz6Mobject.apply_function..multi_mapping_functions$&$7!V$L$LFMrBr`)rQrJ)rXrbrArBrgs ` rAapply_functionzMobject.apply_functions]  :#5 K       .. "      rBcf||||Sr)move_to get_center)rXrbs rAapply_function_to_positionz"Mobject.apply_function_to_positions- XXdoo//00111 rBcD|jD]}|||Sr)rQrl)rXrbrhs rA&apply_function_to_submobject_positionsz.Mobject.apply_function_to_submobject_positionss0& 8 8F  - -h 7 7 7 7 rBmatrixr&c| |t}tj|jtj|}|d|jdd|jdf<|fd|||S)Nrrc8tj|jSrrU)r full_matrixs rArHz&Mobject.apply_matrix..s26&+-88rB)rQridentityrHarrayshaperJ)rXrorArBrrs @rA apply_matrixzMobject.apply_matrixs  :#5 Kk$(++ &!!fd}||||S)aApplies a complex function to a :class:`Mobject`. The x and y Point3Ds correspond to the real and imaginary parts respectively. Example ------- .. manim:: ApplyFuncExample class ApplyFuncExample(Scene): def construct(self): circ = Circle().scale(1.5) circ_ref = circ.copy() circ.apply_complex_function( lambda x: np.exp(x*1j) ) t = ValueTracker(0) circ.add_updater( lambda x: x.become(circ_ref.copy().apply_complex_function( lambda x: np.exp(x+t.get_value()*1j) )).set_color(BLUE) ) self.add(circ_ref) self.play(TransformFromCopy(circ_ref, circ)) self.play(t.animate.set_value(TAU), run_time=3) c`|\}}}t||}|j|j|gSr)complexrealimag)pointxyz xy_complexrbs rAR3_funcz/Mobject.apply_complex_function..R3_funcs6GAq!!'!Q--00JOZ_a8 8rBr@)rh)rXrbrArBrs ` rAapply_complex_functionzMobject.apply_complex_functionsCB 9 9 9 9 9 "" #   rBc`|D]}|d|S)Nc^tjtt|Sr)rrtrreversed)arrs rArHz(Mobject.reverse_points..s28D#.repeat_array..s2r)B)B)BrB)r )rtrs rA repeat_arrayz$Mobject.repeat..repeat_arraysBBUGeOTT TrBr)rXrrr8s ` rArepeatzMobject.repeatsZ U U U U U2244 5 5C  & &| 4 4 4 4 rBc ||t}||}tj|d}|D]7}|xj|zc_||j|_|xj|z c_8|S)NTr)rQget_critical_pointrrtr7r)rXrrArBr8s rArJz)Mobject.apply_points_function_about_point s  !# 11*==Kh{666 2244 & &C JJ+ %JJcj))CJ JJ+ %JJJ rBc N|jtdz ttzfi||S)N)rPrZRIGHTUPrXr?s rA pose_at_anglezMobject.pose_at_angles+ C"Hebj33F333 rBcV|| |S)zMoves the center of the mobject to the center of the scene. Returns ------- :class:`.Mobject` The centered mobject. )r?rkrs rAcenterzMobject.center$s( DOO%%%&&& rB directionbuffc<tj|tdtddfz}||}||z |tj|zz }|t tj|z}|||S)zeDirection just needs to be a vector pointing towards side or corner in the 2d plane. frame_x_radiusframe_y_radiusr)rsignrrrtabsr?)rXrr target_pointpoint_to_align shift_vals rAalign_on_borderzMobject.align_on_border/s wy)) # $ # $ -  00;; >1D28I;N;N4NN BGI$6$6 7 77  9 rBcornerc.|||S)aMoves this :class:`~.Mobject` to the given corner of the screen. Returns ------- :class:`.Mobject` The newly positioned mobject. Examples -------- .. manim:: ToCornerExample :save_last_frame: class ToCornerExample(Scene): def construct(self): c = Circle() c.to_corner(UR) t = Tex("To the corner!") t2 = MathTex("x^3").shift(DOWN) self.add(c,t,t2) t.to_corner(DL, buff=0) t2.to_corner(UL, buff=1.5) r)rXrrs rA to_cornerzMobject.to_corner@s4##FD111rBedgec.|||S)aMoves this :class:`~.Mobject` to the given edge of the screen, without affecting its position in the other dimension. Returns ------- :class:`.Mobject` The newly positioned mobject. Examples -------- .. manim:: ToEdgeExample :save_last_frame: class ToEdgeExample(Scene): def construct(self): tex_top = Tex("I am at the top!") tex_top.to_edge(UP) tex_side = Tex("I am moving to the side!") c = Circle().shift(2*DOWN) self.add(tex_top, tex_side, c) tex_side.to_edge(LEFT) c.to_edge(RIGHT, buff=0) r)rXrrs rAto_edgezMobject.to_edge\s8##D$///rB)rrrmobject_or_pointMobject | Point3DLike aligned_edgesubmobject_to_alignMobject | Noneindex_of_submobject_to_align coor_maskcjtj|}tj|} t|tr(|} | | |} n| } | | |z} n|} ||} n | ||} n|} | | |z }|| |z ||zz|z|S)a.Move this :class:`~.Mobject` next to another's :class:`~.Mobject` or Point3D. Examples -------- .. manim:: GeometricShapes :save_last_frame: class GeometricShapes(Scene): def construct(self): d = Dot() c = Circle() s = Square() t = Triangle() d.next_to(c, RIGHT) s.next_to(c, LEFT) t.next_to(c, DOWN) self.add(d, c, s, t) )rasarrayrcrrr?)rXrrrrrrr np_directionnp_aligned_edger8target_alignerralignerrs rAnext_tozMobject.next_tozs<z),, *\22 & 0 0 ,"C+7!$%A!B!$)<<,.LL,L  *)GG ) 578GGG 33Ol4RSS L>1D<4GG9TUUU rBc tdtdg}ttttfD]}t jt j|}|dt}|||z }| |}t j |||kr|j |fi||S)Nrrr) rrDOWNLEFTrrargmaxrgetDEFAULT_MOBJECT_TO_EDGE_BUFFERget_edge_centerrVr)rXr? space_lengthsvectrHrmax_val edge_centers rAshift_onto_screenzMobject.shift_onto_screens 016:J3KL dE) - -D)BF4LL))C::f&DEED#C(4/G..t44Kvk4((722 T,,V,,, rBcZ|dtdkrdS|dtd krdS|dtdkrdS|dtd kS)NrrTrr)get_leftr get_right get_bottomget_toprs rA is_off_screenzMobject.is_off_screens ==??1 '7 8 8 84 >>  A &)9":!: : :4 ??  Q &)9": : :4||~~a F+;$<#<<>> from manim import * >>> sq = Square() >>> sq.height np.float64(2.0) >>> sq.scale_to_fit_width(5) Square >>> sq.width np.float64(5.0) >>> sq.height np.float64(5.0) rraFrrXrr?s rArzMobject.scale_to_fit_widths&.#t"5!EEUEfEEErBc $|j|dfddi|S)aStretches the :class:`~.Mobject` to fit a width, not keeping height/depth proportional. Returns ------- :class:`Mobject` ``self`` Examples -------- :: >>> from manim import * >>> sq = Square() >>> sq.height np.float64(2.0) >>> sq.stretch_to_fit_width(5) Square >>> sq.width np.float64(5.0) >>> sq.height np.float64(2.0) rraTrrs rAstretch_to_fit_widthzMobject.stretch_to_fit_widths&.#t"5!DDTDVDDDrBrc $|j|dfddi|S)aScales the :class:`~.Mobject` to fit a height while keeping width/depth proportional. Returns ------- :class:`Mobject` ``self`` Examples -------- :: >>> from manim import * >>> sq = Square() >>> sq.width np.float64(2.0) >>> sq.scale_to_fit_height(5) Square >>> sq.height np.float64(5.0) >>> sq.width np.float64(5.0) rraFrrXrr?s rArzMobject.scale_to_fit_heights&.#t"61FFeFvFFFrBc $|j|dfddi|S)aStretches the :class:`~.Mobject` to fit a height, not keeping width/depth proportional. Returns ------- :class:`Mobject` ``self`` Examples -------- :: >>> from manim import * >>> sq = Square() >>> sq.width np.float64(2.0) >>> sq.stretch_to_fit_height(5) Square >>> sq.height np.float64(5.0) >>> sq.width np.float64(2.0) rraTrrs rAstretch_to_fit_heightzMobject.stretch_to_fit_heights&.#t"61EEdEfEEErBrc $|j|dfddi|S)zUScales the :class:`~.Mobject` to fit a depth while keeping width/height proportional.rraFrrXrr?s rArzMobject.scale_to_fit_depth7s$"t"5!EEUEfEEErBc $|j|dfddi|S)zWStretches the :class:`~.Mobject` to fit a depth, not keeping width/height proportional.rraTrrs rAstretch_to_fit_depthzMobject.stretch_to_fit_depth;s$"t"5!DDTDVDDDrBc|||}tj|j}||z ||<|||Sr) get_coordrrrHr?)rXrrHrcurr shift_vects rA set_coordzMobject.set_coord?sJ~~c9--Xdh'' $, 3 : rBr~c0||d|S)zJSet x value of the center of the :class:`~.Mobject` (``int`` or ``float``)rr)rXr~rs rAset_xz Mobject.set_xF~~aI...rBrc0||d|S)zJSet y value of the center of the :class:`~.Mobject` (``int`` or ``float``)rr)rXrrs rAset_yz Mobject.set_yJrrBrc0||d|S)zJSet z value of the center of the :class:`~.Mobject` (``int`` or ``float``)rr)rXrrs rAset_zz Mobject.set_zNrrB?c f|j|fi||jD]}|d|z |S)Ng?)rKrQ)rXr\r?rhs rAspace_out_submobjectszMobject.space_out_submobjectsRsL 6$$V$$$& ' 'F LLv & & & & rBpoint_or_mobjectPoint3DLike | Mobjectct|tr||}n|}||}|||z |z|S)z9Move center of the :class:`~.Mobject` to certain Point3D.)rcrrr?)rXrrrrOrs rArjzMobject.move_toXse & 0 0 &%88FFFF%F00>> F^+y8999 rB dim_to_matchc|s|jstd|r5||j||jn+||||d| | | z |S)Nz,Attempting to replace mobject with no pointsFr) get_num_pointsrQWarningrrrrrrr?rk)rXrrras rAreplacezMobject.replacegs%%'' J0C JHII I    % %gm 4 4 4  & &w~ 6 6 6 6   '' 55     7%%''$//*;*;;<<< rBc||||||}|||z|z |Sr)rrrK)rXrrrarrs rAsurroundzMobject.surroundxsM WlG444((66 FTMV+,,, rBstartendc|\}}||z }tj|dkrtj||_|Stj|tj|z }tjtj||dkr"ttj||nt}| tj|tj|z || t|||||||z |S)NrrO)rArM)get_start_and_endrallrtrrlinalgnormcrossr OUTrKrPrr?)rXrr curr_startcurr_end curr_vect target_vectrMs rAput_start_and_end_onzMobject.put_start_and_end_onsG#5577 Hz) 6)q. ! ! (5//DKKjoo 5(9(99 y~~bhy+>>??1DD bhy+66 7 7 7 INN; ' '")..*C*C C"     !)[ 9 9"    5:%&&& rB?ParsableManimColor | Noneopacityc hddlm}||f||d||_||j|S)aAdd a BackgroundRectangle as submobject. The BackgroundRectangle is added behind other submobjects. This can be used to increase the mobjects visibility in front of a noisy background. Parameters ---------- color The color of the BackgroundRectangle opacity The opacity of the BackgroundRectangle kwargs Additional keyword arguments passed to the BackgroundRectangle constructor Returns ------- :class:`Mobject` ``self`` See Also -------- :meth:`add_to_back` :class:`~.BackgroundRectangle` r)BackgroundRectangle)rD fill_opacity)%manim.mobject.geometry.shape_matchersrbackground_rectangler)rXrDrr?rs rAadd_background_rectanglez Mobject.add_background_rectanglese@ NMMMMM$7$7 % G% % 7=% % ! 2333 rBc 4|jD]}|jdi||Sr6)rQr)rXr? submobjects rA'add_background_rectangle_to_submobjectsz/Mobject.add_background_rectangle_to_submobjectss5* : :J /J / 9 9& 9 9 9 9 rBc N|D]}|jdi||Sr6)r7r)rXr?r8s rA6add_background_rectangle_to_family_members_with_pointsz>Mobject.add_background_rectangle_to_family_members_with_pointss>2244 3 3C (C ( 2 26 2 2 2 2 rBrfamilyc~|r!|jD]}|||tj||_|S)zCondition is function which takes in one arguments, (x, y, z). Here it just recurses to submobjects, but in subclasses this should be further implemented based on the the inner workings of color r)rQ set_colorrrTrD)rXrDrrhs rArzMobject.set_colorsQ  7* 7 7  v 6666%e,,  rBcolorsc|j||S)z Parameters ---------- colors The colors to use for the gradient. Use like `set_color_by_gradient(RED, BLUE, GREEN)`. self.color = ManimColor.parse(color) return self )!set_submobject_colors_by_gradient)rXrs rAset_color_by_gradientzMobject.set_color_by_gradients /.77 rBrrradius inner_color outer_colorc6||||||Sr)(set_submobject_colors_by_radial_gradient)rXrr#r$r%s rAset_colors_by_radial_gradientz%Mobject.set_colors_by_radial_gradients/ 55         rBIterable[ParsableManimColor]cDt|dkrtdt|dkr |j|S|}t |t|}t ||dD]\}}||d|S)NrzNeed at least one colorrTstrictFr)rrfrr7rzip)rXrmobs new_colorsr8rDs rAr!z)Mobject.set_submobject_colors_by_gradients v;;!  677 7 [[A  !4>6* *..00#FCII66 dJt<<< / /JC MM%M . . . . rBc>||}|D]q}tj||z |z }t |d}t |||}||dr|S)NrFr)rkr7rrrminrr)rXrr#r$r%r8t mob_colors rAr'z0Mobject.set_submobject_colors_by_radial_gradient s >__&&F2244 3 3C s~~//&899FBAAq A)+{AFFI MM)EM 2 2 2 2 rBc:||j|Sr)rrDrs rAto_original_colorzMobject.to_original_colors tz""" rBalphac|dkr:t|||}||d|r |jD]}||||S)NrFr)rr get_colorrrQfade_to)rXrDr6r new_colorrhs rAr9zMobject.fade_to"s    1 $ $)$..*:*:E5III NN9UN 3 3 3  -* - -ue,,,, rB?darknesscJ|r |jD]}||||Sr)rQfade)rXr<rrhs rAr>z Mobject.fade-s8  .* . . Hf---- rBrc|jS)zReturns the color of the :class:`~.Mobject` Examples -------- :: >>> from manim import Square, RED >>> Square(color=RED).get_color() == RED True )rDrs rAr8zMobject.get_color3s zrBcft|drd|_||_|S)z`Save the current state (position, color & size). Can be restored with :meth:`~.Mobject.restore`. saved_stateN)rurArrs rA save_statezMobject.save_stateCs1 4 ' ' $#D 99;; rBct|dr|jtd||j|S)zORestores the state that was previously saved with :meth:`~.Mobject.save_state`.rANz&Trying to restore without having saved)rurB ExceptionbecomerArs rArestorezMobject.restoreLsEt]++ Ft/FDEE E D$%%% rB reduce_funcrcV|dksJ|dksJt|jdkrt|jdkrdSt|jdkrd}n||jdd|f}|jD])}|||}||n |||g}*|S)zUFind the min or max value from a dimension across all points in this and submobjects.rrN)rrQrreduce_across_dimension)rXrGrHrvmobjrs rArIzMobject.reduce_across_dimensionSsaxxxxaxxxx t A % %#dk*:*:a*?*?1 t{  q BBT[C011B$ C CD00cBBE*++ubk*B*BBB rB list[Self]c$d|jDS)Ncrg|]4}t|jdkst|jdk2|5Sr)rrQr)rrhs rArz0Mobject.nonempty_submobjects..jsL   6%&&!++s6=/A/AQ/F/F /F/F/FrB)rQrs rAnonempty_submobjectszMobject.nonempty_submobjectsis&  *    rB array_attr np.ndarrayct||}|jD],}tj|||d}-|S)zReturn all of a given attribute from this mobject and all submobjects. May contain duplicates; the order is in a depth-first (pre-order) traversal of the submobjects. rr)rtrQrr(get_merged_array)rXrQrrhs rArTzMobject.get_merged_arraypsS z**& T TFYvv'>'>z'J'JQRSSSFF rBr^c,|dS)zReturn all points from this mobject and all submobjects. May contain duplicates; the order is in a depth-first (pre-order) traversal of the submobjects. r)rTrs rAget_all_pointszMobject.get_all_points{s $$X...rBc*|Sr)rVrs rAget_points_defining_boundaryz$Mobject.get_points_defining_boundarys""$$$rBc*t|jSrrrrs rArzMobject.get_num_pointss4;rBrPoint3DLike_Array | Nonekeyc.||ntj|}|dd|f}|dkrtj|S|dkr,tj|tj|zdz Stj|S)Nrr)rXrrr1max)rXrrHr\ np_pointsvaluess rAget_extremum_along_dimzMobject.get_extremum_along_dims ~  - - / / /F##  111c6" 776&>> ! AXXF6NNRVF^^3q8 86&>> !rBr*ctj|j}|}t |dkr|St |jD]#}|||||||<$|S)aPicture a box bounding the :class:`~.Mobject`. Such a box has 9 'critical points': 4 corners, 4 edge center, the center. This returns one of them, along the given direction. :: sample = Arc(start_angle=PI / 7, angle=PI / 5) # These are all equivalent max_y_1 = sample.get_top()[1] max_y_2 = sample.get_critical_point(UP)[1] max_y_3 = sample.get_extremum_along_dim(dim=1, key=1) rrHr\)rrrHrXrrangera)rXrr all_pointsrHs rArzMobject.get_critical_points$(##6688 z??a  M??  C55cN6F3KK  rBc,||S)z(Get edge Point3Ds for certain direction.rrXrs rArzMobject.get_edge_center&&y111rBc,||S)z*Get corner Point3Ds for certain direction.rgrhs rA get_cornerzMobject.get_cornerrirBcZ|tj|jS)zGet center Point3Ds)rrrrHrs rArkzMobject.get_centers"&&rx'9'9:::rBcftjtjd|Sr)rrfmeanrVrs rAget_center_of_masszMobject.get_center_of_masss%"27At/B/B/D/DEEErBc|}tjtj||}||Sr)rXrrrV)rXrrers rAget_boundary_pointzMobject.get_boundary_points96688  "&Y7788%  rBc,|dS)adGet Point3Ds of the middle of the path that forms the :class:`~.Mobject`. Examples -------- .. manim:: AngleMidPoint :save_last_frame: class AngleMidPoint(Scene): def construct(self): line1 = Line(ORIGIN, 2*RIGHT) line2 = Line(ORIGIN, 2*RIGHT).rotate_about_origin(80*DEGREES) a = Angle(line1, line2, radius=1.5, other_angle=False) d = Dot(a.get_midpoint()).set_color(RED) self.add(line1, line2, a, d) self.wait() r;)point_from_proportionrs rA get_midpointzMobject.get_midpoints*))#...rBc6|tS)z9Get top Point3Ds of a box bounding the :class:`~.Mobject`)rrrs rArzMobject.get_top##B'''rBc6|tS)zGet zenith Point3Ds of a box bounding a 3D :class:`~.Mobject`.)rrrs rA get_zenithzMobject.get_zeniths##C(((rBc6|tS)zSGet nadir (opposite the zenith) Point3Ds of a box bounding a 3D :class:`~.Mobject`.)rINrs rA get_nadirzMobject.get_nadirrvrBcp|t||t|z S)zCMeasure the length of an :class:`~.Mobject` in a certain direction.)rIr^r1)rXrHs rArzMobject.length_over_dims:++      ( (c 2 23 3rBc<||||S)z6Meant to generalize ``get_x``, ``get_y`` and ``get_z``rc)ra)rXrHrs rArzMobject.get_coord s**s #*GGGrBc.|d|S)zFReturns x Point3D of the center of the :class:`~.Mobject` as ``float``rrrhs rAget_xz Mobject.get_x ~~a+++rBc.|d|S)zFReturns y Point3D of the center of the :class:`~.Mobject` as ``float``rrrhs rAget_yz Mobject.get_y rrBc.|d|S)zFReturns z Point3D of the center of the :class:`~.Mobject` as ``float``rrrhs rAget_zz Mobject.get_z rrBch|tj|jdS)zQReturns the point, where the stroke that surrounds the :class:`~.Mobject` starts.rthrow_error_if_no_pointsrrtrrs rA get_startzMobject.get_start s* %%'''x A'''rBch|tj|jdS)zOReturns the point, where the stroke that surrounds the :class:`~.Mobject` ends.rrs rAget_endzMobject.get_end s* %%'''x B(((rBtuple[Point3D, Point3D]cR||fS)z=Returns starting and ending point of a stroke as a ``tuple``.)rrrs rArzMobject.get_start_and_end s~~//rBc tdNz!Please override in a child class.r)rXr6s rArszMobject.point_from_proportion !"EFFFrBc tdrr)rXr}s rAproportion_from_pointzMobject.proportion_from_point# rrBn_piecesrc g_tjdd|dz}t fdt |dd|dddDS)Nrrc3pK|]0\}}||V1dSr)rpointwise_become_partial)rrrrXtemplates rArz%Mobject.get_pieces..+ sUB 88r2FFrBrTr+)rrQrlinspacerr-)rXralphasrs` @rA get_pieceszMobject.get_pieces& s99;;!Q8a<00!&"+vabbz$GGG  rBcLt|d|}|S)N z_index_group)rtrk)rXrs rAget_z_index_reference_pointz#Mobject.get_z_index_reference_point1 s%ot<< '')))rBc2t|jdkS)z,Check if :class:`~.Mobject` contains points.rrZrs rA has_pointszMobject.has_points6 s4;!##rBc,| S)z7Check if :class:`~.Mobject` *does not* contains points.)rrs rA has_no_pointszMobject.has_no_points: s??$$$$rBcP||S)z=Match the color with the color of another :class:`~.Mobject`.)rr8rs rA match_colorzMobject.match_color@ s ~~g//11222rBc F|j|||fi|S)zOMatch the specified dimension with the dimension of another :class:`~.Mobject`.)rr)rXrrHr?s rAmatch_dim_sizezMobject.match_dim_sizeD s-"t"7#:#:3#?#?OOOOOrBc  |j|dfi|S)z=Match the width with the width of another :class:`~.Mobject`.rrrXrr?s rA match_widthzMobject.match_widthH "t"7A88888rBc  |j|dfi|S)z?Match the height with the height of another :class:`~.Mobject`.rrrs rA match_heightzMobject.match_heightL rrBc  |j|dfi|S)z=Match the depth with the depth of another :class:`~.Mobject`.rrrs rA match_depthzMobject.match_depthP rrBcZ||||||S)zCMatch the Point3Ds with the Point3Ds of another :class:`~.Mobject`.)rHr)rr)rXrrHrs rA match_coordzMobject.match_coordT s8~~   c9 - -   rBc0||d|S)z=Match x coord. to the x coord. of another :class:`~.Mobject`.rrrXrrs rAmatch_xzMobject.match_x^ I666rBc0||d|S)z=Match y coord. to the x coord. of another :class:`~.Mobject`.rrrs rAmatch_yzMobject.match_yb rrBc0||d|S)z=Match z coord. to the x coord. of another :class:`~.Mobject`.rrrs rAmatch_zzMobject.match_zf rrBct|tr||}n|}t|jD]+}||dkr|||||,|S)zAligns mobject to another :class:`~.Mobject` in a certain direction. Examples: mob1.align_to(mob2, UP) moves mob1 vertically so that its top edge lines ups with mob2's top edge. r)rcrrrdrHr)rXrrr}rHs rAalign_tozMobject.align_toj sw & 0 0 %$77 BBEE$E?? ; ;C~""uSz3 ::: rBc|}t|tr,|}|||S||Sr)splitrcsliceget_group_class __getitem__)rXr self_list GroupClasss rArzMobject.__getitem__ saJJLL eU # # =--//J:y44U;;< <$$U+++rBcDt|Sr)iterrrs rA__iter__zMobject.__iter__ sDJJLL!!!rBcDt|Sr)rrrs rA__len__zMobject.__len__ s4::<<   rB type[Group]ctSr)rrs rArzMobject.get_group_class s rBctS)z+Return the base class of this mobject type.)rr7rBrAget_mobject_type_classzMobject.get_mobject_type_class s rBcPt|jdkr|gng}||jzSr)rrrQ)rXrs rArz Mobject.split s/t{++a//$R(((rBrecursecd|jD}|gttj|z}t |S)aLists all mobjects in the hierarchy (family) of the given mobject, including the mobject itself and all its submobjects recursively. Parameters ---------- recurse Just for consistency with get_family method in OpenGLMobject. Returns ------- list[Mobject] A list of mobjects in the family of the given mobject. Examples -------- :: >>> from manim import Square, Rectangle, VGroup, Group, Mobject, VMobject >>> s, r, m, v = Square(), Rectangle(), Mobject(), VMobject() >>> vg = VGroup(s, r) >>> gr = Group(vg, m, v) >>> gr.get_family() [Group, VGroup(Square, Rectangle), Square, Rectangle, Mobject, VMobject] See also -------- :meth:`~.Mobject.family_members_with_points`, :meth:`~.Mobject.align_data` c6g|]}|Sr7r")rr~s rArz&Mobject.get_family.. s AAA1 AAArB)rQrr r!r)rXr sub_families all_mobjectss rAr"zMobject.get_family sD<BA0@AAA vRX|%< = == ' 555rBc>d|DS)aFilters the list of family members (generated by :meth:`.get_family`) to include only mobjects with points. Returns ------- list[Mobject] A list of mobjects that have points. Examples -------- :: >>> from manim import Square, Rectangle, VGroup, Group, Mobject, VMobject >>> s, r, m, v = Square(), Rectangle(), Mobject(), VMobject() >>> vg = VGroup(s, r) >>> gr = Group(vg, m, v) >>> gr.family_members_with_points() [Square, Rectangle] See also -------- :meth:`~.Mobject.get_family` cBg|]}|dk|SrO)r)rms rArz6Mobject.family_members_with_points.. s.GGGa0@0@0B0BQ0F0F0F0F0FrBrrs rAr7z"Mobject.family_members_with_points s#0HG4??,,GGGGrBc t|jdd|jdddD]\}}|j|||fi||r||S)aSorts :class:`~.Mobject` next to each other on screen. Examples -------- .. manim:: Example :save_last_frame: class Example(Scene): def construct(self): s1 = Square() s2 = Square() s3 = Square() s4 = Square() x = VGroup(s1, s2, s3, s4).set_x(0).arrange(buff=1.0) self.add(x) NrrTr+)r-rQrr)rXrrrr?m1m2s rAarrangezMobject.arrange sy0$*3B3/1A!""1EdSSS 6 6FB BJr9d 5 5f 5 5 5 5   KKMMM rBrdrowscolsfloat | tuple[float, float]cell_alignmentrow_alignmentscol_alignments row_heightsIterable[float | None] | None col_widths flow_orderc   ddlm} |j |} d} | ||| ||53t jt jt $t jt z $t jt z zt krtdt|tr|d}|d}n|x}}fd}||tttdd t}||t ttd d t}fd fd fdfdfdfdfdfdd} |vrtd|  d}||}||}t#} |gzt z z fdt'Dfdt'D}fdt'D}d}|||d}|||d}d\}}t'D]}d}t'D]}|||urw||||z}| |tz|tzz|||ztz|||ztzz}||||||||zz }||||zz }|| |S)a} Arrange submobjects in a grid. Parameters ---------- rows The number of rows in the grid. cols The number of columns in the grid. buff The gap between grid cells. To specify a different buffer in the horizontal and vertical directions, a tuple of two values can be given - ``(row, col)``. cell_alignment The way each submobject is aligned in its grid cell. row_alignments The vertical alignment for each row (top to bottom). Accepts the following characters: ``"u"`` - up, ``"c"`` - center, ``"d"`` - down. col_alignments The horizontal alignment for each column (left to right). Accepts the following characters ``"l"`` - left, ``"c"`` - center, ``"r"`` - right. row_heights Defines a list of heights for certain rows (top to bottom). If the list contains ``None``, the corresponding row will fit its height automatically based on the highest element in that row. col_widths Defines a list of widths for certain columns (left to right). If the list contains ``None``, the corresponding column will fit its width automatically based on the widest element in that column. flow_order The order in which submobjects fill the grid. Can be one of the following values: "rd", "dr", "ld", "dl", "ru", "ur", "lu", "ul". ("rd" -> fill rightwards then downwards) Returns ------- :class:`Mobject` ``self`` Raises ------ ValueError If ``rows`` and ``cols`` are too small to fit all submobjects. ValueError If :code:`cols`, :code:`col_alignments` and :code:`col_widths` or :code:`rows`, :code:`row_alignments` and :code:`row_heights` have mismatching sizes. Notes ----- If only one of ``cols`` and ``rows`` is set implicitly, the other one will be chosen big enough to fit all submobjects. If neither is set, they will be chosen to be about the same, tending towards ``cols`` > ``rows`` (simply because videos are wider than they are high). If both ``cell_alignment`` and ``row_alignments`` / ``col_alignments`` are defined, the latter has higher priority. Examples -------- .. manim:: ExampleBoxes :save_last_frame: class ExampleBoxes(Scene): def construct(self): boxes=VGroup(*[Square() for s in range(0,6)]) boxes.arrange_in_grid(rows=2, buff=0.1) self.add(boxes) .. manim:: ArrangeInGrid :save_last_frame: class ArrangeInGrid(Scene): def construct(self): boxes = VGroup(*[ Rectangle(WHITE, 0.5, 0.5).add(Text(str(i+1)).scale(0.5)) for i in range(24) ]) self.add(boxes) boxes.arrange_in_grid( buff=(0.25,0.5), col_alignments="lccccr", row_alignments="uccd", col_widths=[1, *[None]*4, 1], row_heights=[1, None, None, 1], flow_order="dr" ) r)LinecR||S|t|S|t|SdSr)r)num alignmentssizess rA init_sizez*Mobject.arrange_in_grid..init_size] s8 %:& 5zz!! rBNz0Too few rows and columns to fit all submobjetcs.rc| |zg|zSt||krt|dt|}t|D]}|||||<|S)Nz#_alignments has a mismatching size.)rrfrrd)rrmappingrFdir_rgrs rAinit_alignmentsz0Mobject.arrange_in_grid..init_alignments~ s!&-.44:#%% D!M!M!MNNNj))J3ZZ 7 7 ' 1 6 1  rB)ucdrow)lrrcolc |z dz |zzSrer7rrrs rArHz)Mobject.arrange_in_grid.. sq1 D8rBc,|z dz |z dz zzSrer7rrrrs rArHz)Mobject.arrange_in_grid.. s!q1 A0EErBc||zzSrr7rs rArHz)Mobject.arrange_in_grid.. sq1t8|rBc ||z dz zzSrer7rs rArHz)Mobject.arrange_in_grid.. sqD1HqLD#88rBc |z dz z|zSrer7rs rArHz)Mobject.arrange_in_grid.. sq1 4q8rBc,|z dz z|z dz zSrer7rs rArHz)Mobject.arrange_in_grid.. s!q1 4q1 ErBc|z|zSrr7rrrs rArHz)Mobject.arrange_in_grid.. sq4x!|rBc |z|z dz zSrer7rs rArHz)Mobject.arrange_in_grid.. sq4x4!8a<8rB)drdlurulrldruluz^flow_order must be one of the following values: "dr", "rd", "ld" "dl", "ru", "ur", "lu", "ul".cT|%t|}||SdSr)rreverse) maybe_lists rArz(Mobject.arrange_in_grid..reverse s5%!*-- ""$$$!!&%rBcLg|]fdtD S)c4g|]}|Sr7r7)rrrr.rs rArz6Mobject.arrange_in_grid... s*===AjjA&&'===rB)rd)rrrrr.s @rArz+Mobject.arrange_in_grid.. s;SSS!======t===SSSrBcdg|]+tfdtD,S)c3>K|]}|jVdSr)r)rrgridrs rArz5Mobject.arrange_in_grid... s.77aQ !777777rBr^rd)rrrrs @rArz+Mobject.arrange_in_grid.. sM   <=C777775;;777 7 7   rBcdg|]+tfdtD,S)c3>K|]}|jVdSr)r)rrrrs rArz5Mobject.arrange_in_grid... s.66QQ  666666rBr)rrrrs @rArz+Mobject.arrange_in_grid.. sM   ;.init_sizes.. s;FGE!H0ahqkrB)rrfrd)rrrrFs` ` rA init_sizesz+Mobject.arrange_in_grid..init_sizes ss} 5zzS   D!B!B!BCCCKPQT:: rBrr)rr)manim.mobject.geometry.linerrQrrkmathceilsqrtrrfrctuplerrQrrrrextendrdrj)!rXrrrrrrrrrr?r start_posrbuff_xbuff_yrmapperr placeholdermeasured_heigthsmeasured_widthsrheightswidthsr~rrr alignmentlinerr.s! `` ` ` @@rAarrange_in_gridzMobject.arrange_in_grid s}F 544444$$&&OO%%  " " "y~z::y~{;; >>SSSSSSuT{{SSS     AFt        @Ed        *[$0@-PPJo|LL1t % %AA4[[ ( (71:[00 .q 1N14E EI4E AF*VAY%/1wqz>R2GGDGAJ&&tY777VAY'' f$ $AA Y rBc|dSrr7)ps rArHzMobject. s adrBpoint_to_num_funcCallable[[Point3DLike], float] submob_funcCallable[[Mobject], Any] | NonecN|dfd }|j||S) zOSorts the list of :attr:`submobjects` by a function defined by ``submob_func``.Nrrr3rKc>|Sr)rk)rr1s rAr3z!Mobject.sort..submob_func s((888rB)r\)rrr3rK)rQsort)rXr1r3s ` rAr7z Mobject.sort sJ   9 9 9 9 9 9 +... rBc||r |jD]}|dtj|jdS)z)Shuffles the list of :attr:`submobjects`.TrN)rQshufflerandomr.s rAr9zMobject.shuffle sL  /* / /....t'(((((rBc||r |jD]}|d|jdS)aQInverts the list of :attr:`submobjects`. Parameters ---------- recursive If ``True``, all submobject lists of this mobject's family are inverted. Examples -------- .. manim:: InvertSumobjectsExample class InvertSumobjectsExample(Scene): def construct(self): s = VGroup(*[Dot().shift(i*0.1*RIGHT) for i in range(-20,20)]) s2 = s.copy() s2.invert() s2.shift(DOWN) self.play(Write(s), Write(s2)) TrN)rQinvertrr.s rAr<zMobject.invert sP*  .* . .  ----   """""rBc|j|i|S)agArrange the position of :attr:`submobjects` with a small buffer. Examples -------- .. manim:: ArrangeSumobjectsExample :save_last_frame: class ArrangeSumobjectsExample(Scene): def construct(self): s= VGroup(*[Dot().shift(i*0.1*RIGHT*np.random.uniform(-1,1)+UP*np.random.uniform(-1,1)) for i in range(0,15)]) s.shift(UP).set_color(BLUE) s2= s.copy().set_color(RED) s2.arrange_submobjects() s2.shift(DOWN) self.add(s,s2) )rrXargsr?s rAarrange_submobjectszMobject.arrange_submobjects s&t|T,V,,,rBc|j|i|S)zSort the :attr:`submobjects`)r7r>s rAsort_submobjectszMobject.sort_submobjects* sty$)&)))rBc|j|i|S)aShuffles the order of :attr:`submobjects` Examples -------- .. manim:: ShuffleSubmobjectsExample class ShuffleSubmobjectsExample(Scene): def construct(self): s= VGroup(*[Dot().shift(i*0.1*RIGHT) for i in range(-20,20)]) s2= s.copy() s2.shuffle_submobjects() s2.shift(DOWN) self.play(Write(s), Write(s2)) )r9r>s rAshuffle_submobjectszMobject.shuffle_submobjects. s t|T,V,,,rBskip_point_alignmentc|||||s||t|j|jdD]\}}||dS)aAligns the family structure and data of this mobject with another mobject. Afterwards, the two mobjects will have the same number of submobjects (see :meth:`.align_submobjects`) and the same parent structure (see :meth:`.null_point_align`). If ``skip_point_alignment`` is ``False``, they will also have the same number of points (see :meth:`.align_points`). Parameters ---------- mobject The other mobject this mobject should be aligned to. skip_point_alignment Controls whether or not the computationally expensive point alignment is skipped (default: ``False``). .. note:: This method is primarily used internally by :meth:`.become` and the :class:`~.Transform` animation to ensure that mobjects are structurally compatible before transformation. Examples -------- :: >>> from manim import Rectangle, Line, ORIGIN, RIGHT >>> rect = Rectangle(width=4.0, height=2.0, grid_xstep=1.0, grid_ystep=0.5) >>> line = Line(start=ORIGIN,end=RIGHT) >>> line.align_data(rect) >>> len(line.get_family()) == len(rect.get_family()) True >>> line.get_num_points() == rect.get_num_points() True See also -------- :class:`~.Transform`, :meth:`~.Mobject.become`, :meth:`~.VMobject.align_points`, :meth:`~.Mobject.get_family` Tr+N)null_point_alignalign_submobjects align_pointsr-rQ align_data)rXrrErrs rArJzMobject.align_dataA sR g&&& w'''# '   g & & &$*G,?MMM  FB MM"      rBc>d|jj}t|)z}The simplest :class:`~.Mobject` to be transformed to or from self. Should by a point of the appropriate type z&get_point_mobject not implemented for )r@rNr)rXrmsgs rAget_point_mobjectzMobject.get_point_mobjectr s%Qt~7NPP!#&&&rBc|}|}||kr||n||kr|||Sr)ralign_points_with_larger)rXrcount1count2s rArIzMobject.align_pointsy sf$$&&'')) F??  ) )' 2 2 2 2 f__  , ,T 2 2 2 rBlarger_mobjectc tdrr)rXrRs rArOz Mobject.align_points_with_larger rrBc|}|}t|j}t|j}|td||z |td||z |Sr)rrQadd_n_more_submobjectsr^)rXrmob1mob2n1n2s rArHzMobject.align_submobjects sq ! " " ! " " ##C27OO444 ##C27OO444 rBc||f||ffD]A\}}|r(|r|B|S)aIf a :class:`~.Mobject` with points is being aligned to one without, treat both as groups, and push the one with points into its own submobjects list. Returns ------- :class:`Mobject` ``self`` )rrpush_self_into_submobjects)rXrrrs rArGzMobject.null_point_align s_Wo6 0 0FB!! 0bmmoo 0--/// rBc|}g|_||||Sr)rrQrUr)rXrs rAr[z"Mobject.push_self_into_submobjects s=yy{{   rBn Self | Nonec|dkrdStj}|dkr"fdt|D_dS||z}tj||z|zfdt|D}g}t j|dD]I\}||fdtd|DJ|_S)Nrc8g|]}Sr7)rM)rrrXs rArz2Mobject.add_n_more_submobjects.. s%KKKQ 6 6 8 8KKKrBc6g|]}t|kSr7)sum)rrgrepeat_indicess rArz2Mobject.add_n_more_submobjects.. s&GGGa^q011GGGrBTr+c3fK|]+}dV,dS)rN)rr>)r_rhs rArz1Mobject.add_n_more_submobjects.. s9KKv{{}}11!44KKKKKKrBr)rrQrdraranger-r(r") rXr]rrO split_factors new_submobssfrcrhs ` @@rArUzMobject.add_n_more_submobjects s 6644#$$ 199KKKK%((KKKD 4)F++d2v=GGGG5;;GGG  d. dKKK L LJFB   v & & &   KKKKeArllKKK K K K K& rBrhc*|Srr)rXrhs rArepeat_submobjectzMobject.repeat_submobject s{{}}rBmobject1mobject2 path_funcr(cl||j|j||_|||||S)a Turns this :class:`~.Mobject` into an interpolation between ``mobject1`` and ``mobject2``. The interpolation is applied to the points and color of the mobject. Parameters ---------- mobject1 The starting Mobject. mobject2 The target Mobject. alpha Interpolation factor between 0 (at ``mobject1``) and 1 (at ``mobject2``). path_func The function defining the interpolation path. Defaults to a straight path. Returns ------- :class:`Mobject` ``self`` .. note:: - Both mobjects must have the same number of points. If not, this will raise an error. Use :meth:`~.VMobject.align_points` to match point counts beforehand if needed. - This method is used internally by the :class:`~.Transform` animation to interpolate between two mobjects during a transformation. Examples -------- .. manim:: InterpolateExample :save_last_frame: class InterpolateExample(Scene): def construct(self): # No need for point alignment: dotL = Dot(color=DARK_GREY).to_edge(LEFT) dotR = Dot(color=YELLOW).scale(10).to_edge(RIGHT) dotMid1 = VMobject().interpolate(dotL, dotR, alpha=0.1) dotMid2 = VMobject().interpolate(dotL, dotR, alpha=0.25) dotMid3 = VMobject().interpolate(dotL, dotR, alpha=0.5) dotMid4 = VMobject().interpolate(dotL, dotR, alpha=0.75) dots = VGroup(dotL, dotR, dotMid1, dotMid2, dotMid3, dotMid4) # Needs point alignment: line = Line(ORIGIN, UP).to_edge(LEFT) sq = Square(color=RED, fill_opacity=1, stroke_color=BLUE).to_edge(RIGHT) line.align_points(sq) mid1 = VMobject().interpolate(line, sq, alpha=0.1) mid2 = VMobject().interpolate(line, sq, alpha=0.25) mid3 = VMobject().interpolate(line, sq, alpha=0.5) mid4 = VMobject().interpolate(line, sq, alpha=0.75) linesquares = VGroup(line, sq, mid1, mid2, mid3, mid4) self.add(VGroup(dots, linesquares).arrange(DOWN, buff=1)) See also -------- :class:`~.Transform`, :meth:`~.VMobject.align_points`, :meth:`~.VMobject.interpolate_color` )rr)rXrlrmr6rns rA interpolatezMobject.interpolate s;J i%HH  x5999 rBc tdrr)rXrlrmr6s rArzMobject.interpolate_color rrBrrr match_centerc|s|s|s|s|r|}|rO||j||j||jnE|r|||r|||r| ||r'| | | |dt||dD]:\}}tj|j|_|||d;|S)a"Edit points, colors and submobjects to be identical to another :class:`~.Mobject` .. note:: If both match_height and match_width are ``True`` then the transformed :class:`~.Mobject` will match the height first and then the width. Parameters ---------- match_height Whether or not to preserve the height of the original :class:`~.Mobject`. match_width Whether or not to preserve the width of the original :class:`~.Mobject`. match_depth Whether or not to preserve the depth of the original :class:`~.Mobject`. match_center Whether or not to preserve the center of the original :class:`~.Mobject`. stretch Whether or not to stretch the target mobject to match the the proportions of the original :class:`~.Mobject`. Examples -------- .. manim:: BecomeScene class BecomeScene(Scene): def construct(self): circ = Circle(fill_color=RED, fill_opacity=0.8) square = Square(fill_color=BLUE, fill_opacity=0.2) self.add(circ) self.wait(0.5) circ.become(square) self.wait(0.5) The following examples illustrate how mobject measurements change when using the ``match_...`` and ``stretch`` arguments. We start with a rectangle that is 2 units high and 4 units wide, which we want to turn into a circle of radius 3:: >>> from manim import Rectangle, Circle >>> import numpy as np >>> rect = Rectangle(height=2, width=4) >>> circ = Circle(radius=3) With ``stretch=True``, the target circle is deformed to match the proportions of the rectangle, which results in the target mobject being an ellipse with height 2 and width 4. We can check that the resulting points satisfy the ellipse equation :math:`x^2/a^2 + y^2/b^2 = 1` with :math:`a = 4/2` and :math:`b = 2/2` being the semi-axes:: >>> result = rect.copy().become(circ, stretch=True) >>> result.height, result.width (np.float64(2.0), np.float64(4.0)) >>> ellipse_points = np.array(result.get_anchors()) >>> ellipse_eq = np.sum(ellipse_points**2 * [1/4, 1, 0], axis=1) >>> np.allclose(ellipse_eq, 1) True With ``match_height=True`` and ``match_width=True`` the circle is scaled such that the height or the width of the rectangle will be preserved, respectively. The points of the resulting mobject satisfy the circle equation :math:`x^2 + y^2 = r^2` for the corresponding radius :math:`r`:: >>> result = rect.copy().become(circ, match_height=True) >>> result.height, result.width (np.float64(2.0), np.float64(2.0)) >>> circle_points = np.array(result.get_anchors()) >>> circle_eq = np.sum(circle_points**2, axis=1) >>> np.allclose(circle_eq, 1) True >>> result = rect.copy().become(circ, match_width=True) >>> result.height, result.width (np.float64(4.0), np.float64(4.0)) >>> circle_points = np.array(result.get_anchors()) >>> circle_eq = np.sum(circle_points**2, axis=1) >>> np.allclose(circle_eq, 2**2) True With ``match_center=True``, the resulting mobject is moved such that its center is the same as the center of the original mobject:: >>> rect = rect.shift(np.array([0, 1, 0])) >>> np.allclose(rect.get_center(), circ.get_center()) False >>> result = rect.copy().become(circ, match_center=True) >>> np.allclose(rect.get_center(), result.get_center()) True See also -------- :meth:`~.Mobject.align_data`, :meth:`~.VMobject.interpolate_color` T)rEr+r)rrrrrrrrrrrjrkrJr-r"rrtrr) rXrrrrrrrasm1sm2s rArEzMobject.become s|Z  3l 3k 3[ 3L 3llnnG .--dk:::,,TZ888,,TZ8888/((....''---.''--- 3 1 1222 d;;;DOO--w/A/A/C/CDQQQ / /HC#*--CJ  ! !#sA . . . . rBcopy_submobjectsct||dD]#\}}tj|j|_$|S)aWEdit points, positions, and submobjects to be identical to another :class:`~.Mobject`, while keeping the style unchanged. Examples -------- .. manim:: MatchPointsScene class MatchPointsScene(Scene): def construct(self): circ = Circle(fill_color=RED, fill_opacity=0.8) square = Square(fill_color=BLUE, fill_opacity=0.2) self.add(circ) self.wait(0.5) self.play(circ.animate.match_points(square)) self.wait(0.5) Fr+)r-r"rrtr)rXrrvrtrus rA match_pointszMobject.match_points sV"DOO--w/A/A/C/CERRR . .HC#*--CJJ rBc|r1tjdjj}t d|ddS)NrzCannot call Mobject.z for a Mobject with no points)rsys _getframef_codeco_namerD)rX caller_names rArz Mobject.throw_error_if_no_points sU      -**19KQ{QQQ   rB z_index_valuecZ|r!|jD]}|||||_|S)aSets the :class:`~.Mobject`'s :attr:`z_index` to the value specified in `z_index_value`. Parameters ---------- z_index_value The new value of :attr:`z_index` set. family If ``True``, the :attr:`z_index` value of all submobjects is also set. Returns ------- :class:`Mobject` The Mobject itself, after :attr:`z_index` is set. For chaining purposes. (Returns `self`.) Examples -------- .. manim:: SetZIndex :save_last_frame: class SetZIndex(Scene): def construct(self): text = Text('z_index = 3', color = PURE_RED).shift(UP).set_z_index(3) square = Square(2, fill_opacity=1).set_z_index(2) tex = Tex(r'zIndex = 1', color = PURE_BLUE).shift(DOWN).set_z_index(1) circle = Circle(radius = 1.7, color = GREEN, fill_opacity = 1) # z_index = 0 # Displaying order is now defined by z_index values self.add(text) self.add(square) self.add(tex) self.add(circle) r)rQ set_z_indexrJ)rXrrrhs rArzMobject.set_z_index sJJ  A* A A""="@@@@$  rBcd|d}|||S)zSets the :class:`~.Mobject`'s z Point3D to the value of :attr:`z_index`. Returns ------- :class:`Mobject` The Mobject itself, after :attr:`z_index` is set. (Returns `self`.) r)rkr)rXz_coords rAset_z_index_by_z_Point3Dz Mobject.set_z_index_by_z_Point3D s1//##B' !!! rBr3r4) rDrErFrGrHrIrJrKr3r4)rQrYr3r")rQr]r^r_r3r")rjrkr3rl)rjrkryr$r3r4)r3r~r3r")r3r)r3r)rrr3r")rrIrrr3r4rr)rrr3r)r3rK)rrK)r3r)rr'r3r"r)r3r))rFrGr3r4)F)rrr3r")rT)rrKrrr3r")r3r )r3r)r3rrM)r$r1rr%r&rr3r")r$r1r3r")T)rrr3r")rrr3r")rr5r3r4)r:r-r3r")rCrKrArDrBrEr3r")rLrKrMr-r3r") rLrKrMr-rArDrBrEr3r")rMr-rArDrBrEr3r") r\rKrHrIrArDrBrEr3r")rbr%rArDrBrEr3r")rbr%r3r")ror&rArDrBrEr3r")rbrwrArDrBrEr3r")rrIr3r")NN)rr'rArDrBrEr3r")rr-rrKr3r")rr-rrKr3r")rr-rrKr3r")rrrr-rrKrr-rrrr%rr-r3r")r\rKrHrIr}r+r3r")rrKrHrIrarr3r")rrKr3r")rrKr3r")rrKr3r")rHrIrr-r3r")r~rKrr-r3r")rrKrr-r3r")rrKrr-r3r")r)r\rKr3r")rrrr-rr-r3r")rF)rrrrIrarr3r") rrrrIrarrrKr3r")rr+rr+r3r")Nr )rDrrrKr3r")rDrrrr3r")rrr3r") rrDr#rKr$rr%rr3r")rr))rDrr6rKrrr3r")r;T)r<rKrrr3r")r3r)rGrrHrI)r3rL)rQrr3rR)r3r^)r3rI)Nrr)rr[rHrIr\rIr3rK)rr-r3r*)r3r*)rHrIr3rK)rHrIrr-r3rK)rr-r3rK)r3r)r6rKr3r*)r}r+r3rK)rrKr3r)rrrHrIr3r")rrrHrIrr-r3r")rrrr-r3r")r3r)r3r_)rrr3rL)rr-rrKrrr3r")rr%rr%rrrr-rrGrrGrrrrrrr3r")r1r2r3r4r3r")rrr3r4)rrrErr3r4)rRr)r]rIr3r^)rhrr3r") rlrrmrr6rKrnr(r3r")rlrrmrr6rK)FFFFF)rrrrrrrrrrrrarr3r")rrrvrr3r")rrKrrr3r")rN __module__r{__doc__r: classmethodr9rr<r\r[rnr;rvr}propertyrrrrrUrWrVrrrrrrrrrrrrrrrrrrrrrr rrrr#r)r+r-r0r2r4r9r?rKrrRrPrr[rarhrlrnrvrrrrJrrrrDLrrrr!DEFAULT_MOBJECT_TO_MOBJECT_BUFFERrQrrtrrrrrrrrrrrrrrrrrjrMED_SMALL_BUFFrr rrrrrr"rr(r!r'r5r9r>r8rBrFrIrPrTrVrXrrarrrkrkrorqrtrrrrr|rrrrrrrrrrsrrrrrrrrrrrrrrrrrrr staticmethodrrr"r7rr.r7r9r<r@rBrDrJrMrIrOrHrGr[rUrkrrprrErxrrr __classcell__r@s@rArrBsE&-----[-@E ,MMMM@2[, D D D[ D[@-1-1-1[-1^a'a'a'Xa'F!%!%!%X!%F         VVVVp0000$""""""""0000d6""""""6666p-X-X-X-X^'''X'> \'''\''''X'> ](((]( ' ' 'X ' \'''\'"""""-----      # # # #!!!!!F    ,    $ PPPP !" OOOOOb64:48,:+/*. 333333jFI<<<<<!E +/*. EEEEEER  +/*.       @+/*.      &+/*. ,+/*. ,+/*. ( ( ( ( ( ( T $+/*. $    6T$&(7U22222:$(7U00000B#(7%+.237"*"(999"5"544444l    ===<<<<8=     FFFF2EEEE2GGGG2FFFF2FFFFEEEEDJ9?/////9?/////9?/////&,"*"(999"5"5      HM($     :IM&&&&&P +6d         &**/*/         &**/*/ $ GK          ,        ////%%%%    QR""""" :22222222;;;;FFFF!!!! ////.((((****++++****))))((((3333=CHHHHH/5,,,,,/5,,,,,/5,,,,,(((( )))) 0000GGGGGGGG     **** $$$$%%%% 3333PPPP999999999999 EK     397777739777773977777#).,,,"""!!!!\)))) 6 6 6 6 6DHHHH8#(7 @ ,:'-%)%)5948ooooof=KN7;     )))))#####6----*****----&/////b''''GGGG ,#0-// GGGGGRGGGG #!!"BBBBBH,)))))V        rBc$eZdZdZdfd ZxZS)rzGroups together multiple :class:`Mobjects <.Mobject>`. Notes ----- When adding the same mobject more than once, repetitions are ignored. Use :meth:`.Mobject.copy` to create a separate copy which can then be added to the group. r3r4cNtjdi||j|dSr6)r8r<r)rXrr?r@s rAr<zGroup.__init__ s5""6"""(rBr)rNrr{rr<rrs@rArr sGrBr) metaclassc.eZdZd dZd dZd dZdd Zd S)rr3r4c||_|jd|_d|_g|_d|_i|_dSrM)rroverridden_animation is_chainingmethodscannot_pass_args anim_argsrs rAr<z_AnimationBuilder.__init__ sI  $$&&&$(! -/ !&rBr"c N|jrtd||_d|_|S)NzWAnimation arguments must be passed before accessing methods and can only be passed onceT)rrfrrs rA__call__z_AnimationBuilder.__call__ s8   i   $ rBrctjj|tdjrsjrt dfd}d_d_|S)N_override_animatezDMethod chaining is currently not supported for overridden animationscr#jjg|Rdji|_n1jt |||i|S)Nr)rrrrrr(r) method_args method_kwargshas_overridden_animationrxrXs rA update_targetz4_AnimationBuilder.__getattr__..update_target s' 6,DF,DL- ---#n-$ --)) ##N6; $V$VWWW 5}555KrBT)rtrrOrurrrr)rXrwrrrxs` @@rArz_AnimationBuilder.__getattr__ s,k::#*63F#G#G   !9 d>W %V          $rBr.cddlm}|jp||j|j}|jD]\}}t||||S)Nr)_MethodAnimation)animation.transformrrrrrrr)rXranimrrs rAbuildz_AnimationBuilder.build& s|      (X,<,//11 ' 'KD% D$ & & & & rBNrr)r3r)r3r.)rNrr{r<rrrr7rBrArr sd        6      rBrc"eZdZdZd dZd d Zd S) rz0Syntactic sugar for adding updaters to mobjects.rrc||_dSr)_mobjectrs rAr<z_UpdaterBuilder.__init__6 s  rBrFrr3Callable[..., Self]cdfd }|S)Nr3r"cNjfddS)Nc0t|iSr)rt)rrrrFs rArHzB_UpdaterBuilder.__getattr__..add_updater..= s!*'!T**KI=IIrBT)r&)rr))rrrFrXs``rAr)z0_UpdaterBuilder.__getattr__..add_updater; s@ M % %IIIIII! &   KrBrr7)rXrFr)s`` rArz_UpdaterBuilder.__getattr__9 s/       rBNr)rFrr3r)rNrr{rr<rr7rBrArr3 sB::          rBrr3types.FunctionTypecfd}|S)aDecorator for overriding method animations. This allows to specify a method (returning an :class:`~.Animation`) which is called when the decorated method is used with the ``.animate`` syntax for animating the application of a method. .. seealso:: :attr:`~.Mobject.animate` .. note:: Overridden methods cannot be combined with normal or other overridden methods using method chaining with the ``.animate`` syntax. Examples -------- .. manim:: AnimationOverrideExample class CircleWithContent(VGroup): def __init__(self, content): super().__init__() self.circle = Circle() self.content = content self.add(self.circle, content) content.move_to(self.circle.get_center()) def clear_content(self): self.remove(self.content) self.content = None @override_animate(clear_content) def _clear_content_animation(self, anim_args=None): if anim_args is None: anim_args = {} anim = Uncreate(self.content, **anim_args) self.clear_content() return anim class AnimationOverrideExample(Scene): def construct(self): t = Text("hello!") my_mobject = CircleWithContent(t) self.play(Create(my_mobject)) self.play(my_mobject.animate.clear_content()) self.wait() c|_|Sr)r)animation_methodrxs rA decoratorz#override_animate..decoratory s#3 rBr7)rxrs` rArrE s%h      rB)r3r)Qr __future__r__all__rr itertoolsr roperatorr<r:rzrrcollections.abcrr functoolsr r pathlibr typingr r numpyrmanim.data_structuresr)manim.mobject.opengl.opengl_compatibilityrrr constants utils.colorrrrrrrrutils.exceptionsrutils.iterablesrr utils.pathsrutils.space_opsrr r!r"r# manim.typingr$r%r&r'r(r)r*r+r,r-animation.animationr.rKrr/__annotations__r0r1rrrrrr7rBrArs555"""""" 2 2 2   ........++++++++%%%%%%%%000000EEEEEE?>>>>>CCCCCCCC''''''OOOOOOOOOO@&&&&&&&&                        0/////"*Iu+=v+E"FFFFF%-yk6.A%BBBBB,/??G????_2_2_2_2_2_2_2_2De     G    ========@$888888rB