l jdZddlmZgdZddlZddlZddlmZmZm Z m Z ddl Z ddl TddlmZddlmZmZdd lmZmZmZmZmZdd lmZdd lmZmZmZmZm Z m!Z!er8dd l"m#Z#ddl$m%cm&cm'Z'dd l(m)Z)ddl*m+Z+ddl,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5GddeeZ6Gdde6Z7Gdde7Z8Gdde8Z9Gdde8Z:Gdde:Z;Gdd e7Z<Gd!d"e<Z=Gd#d$e=Z>Gd%d&e=Z?Gd'd(e<Z@Gd)d*e7ZAGd+d,eAZBGd-d.e<ZCGd/d0eeZDGd1d2eeZEGd3d4eeZFdS)5avMobjects that are curved. Examples -------- .. manim:: UsefulAnnotations :save_last_frame: class UsefulAnnotations(Scene): def construct(self): m0 = Dot() m1 = AnnotationDot() m2 = LabeledDot("ii") m3 = LabeledDot(MathTex(r"\alpha").set_color(ORANGE)) m4 = CurvedArrow(2*LEFT, 2*RIGHT, radius= -5) m5 = CurvedArrow(2*LEFT, 2*RIGHT, radius= 8) m6 = CurvedDoubleArrow(ORIGIN, 2*RIGHT) self.add(m0, m1, m2, m3, m4, m5, m6) for i, mobj in enumerate(self.mobjects): mobj.shift(DOWN * (i-3)) ) annotations)TipableVMobjectArcArcBetweenPoints CurvedArrowCurvedDoubleArrowCircleDot AnnotationDot LabeledDotEllipse AnnularSectorSectorAnnulus CubicBezier ArcPolygonArcPolygonFromArcs TangentialArcN) TYPE_CHECKINGAnySelfcast)*)ConvertToOpenGL)VGroupVMobject)BLACKBLUEREDWHITEParsableManimColor)adjacent_pairs)angle_between_vectorsangle_of_vectorcartesian_to_sphericalline_intersectionperpendicular_bisector rotate_vector)IterableLine)Mobject)SingleStringMathTexTex)Text)Point3D Point3DLikeQuadraticSpline Vector3DLikeceZdZdZeedfd.fd Z d/d0dZ d1d2dZ d3d4dZ d5d6dZ d7dZ d7dZ d8d Z d8d!Zd9d#Zd9d$Zd:d&Zd;d'Zd> " JJtx KK ! ! !      ( JJt~ & & & KK ' ' '   2  % %eS 1 1 1 rEc|}t|dr||jt|dr||j|S)zkReturns a VGroup (collection of VMobjects) containing the TipableVMObject instance's tips. rFr)rrrrSrFr)rBrs rDget_tipszTipableVMobject.get_tipssn(%%'')) 4   ! JJtx 4 % % ' JJt~ & & & rErc|}t|dkrtd|d}|S)zcReturns the TipableVMobject instance's (first) tip, otherwise throws an exception. rz tip not found)rlen Exception)rBtipsrFs rDget_tipzTipableVMobject.get_tips<}} t99>>O,, , GCJrEc|jSr)r5rs rDraz&TipableVMobject.get_default_tip_lengths rEr0c |jd}|S)Nrgpoints)rB first_handles rDrlz TipableVMobject.get_first_handles!% A rEc |jd}|S)Nr)rB last_handles rDrmzTipableVMobject.get_last_handles ${2 rEc|r|jStSr)rrFrkr@rnrBrCs rDrnzTipableVMobject.get_end s; <<>> %8%%'' '77??$$ $rEc|r|jStSr)rrrkr@rs rDrkzTipableVMobject.get_start&sA      '>++-- -77$$&& &rEc|\}}ttj||z Sr)rr6rslinalgnorm)rBrrs rDr}zTipableVMobject.get_length,s7++-- sRY^^ECK00111rE) r5r6r7r3r8r9r:rr;r<)NNNNF) rFrGrHrIr5rJrKrJrLrMr;r)NNNF) rHrIr5rJrKrJrLrMr;rU)NNN)rHrIr5rJrKrJr;rX)F)rFrUrLrMr;rU)rFrUrLrMr;r)r;rM)r;r)r;rr;r6)r;r0)__name__ __module__ __qualname____doc__DEFAULT_ARROW_TIP_LENGTHOUTrArTrOrWrPrQrRrrrrrrarlrmrnrkr} __classcell__rCs@rDrrRs&5&)!% # # # # # # # %)04#'"& .15#'"&      15#'"& :<    9999EEEE            %%%%%% '''''' 22222222rEr) metaclassceZdZdZddedz defd$fd Zd%dZd%dZe d&d'dZ d%dZ d(d)dZ d*d"Z d+d#ZxZS),rzA circular arc. Examples -------- A simple arc of angle Pi. .. manim:: ArcExample :save_last_frame: class ArcExample(Scene): def construct(self): self.add(Arc(angle=PI)) ?r radiusrJ start_angler6anglenum_componentsint arc_centerr1r:rc |d}||_||_tj||_||_||_d|_tj di|dS)NrFr?) rrrsasarrayrrr_failed_to_get_centerr@rA)rBrrrrrr:rCs rDrAz Arc.__init__@si >F ,#%:j#9#9& +0"""6"""""rEr;r<c|||jt||jdS)N about_point)_set_pre_positioned_pointsscalerORIGINrwrrs rDgenerate_pointszArc.generate_pointsSsF ''))) 4;F 333 4?#####rEc|t|j|j|j||jt| |j dS)N)rr n_componentsr) set_pointsr_create_quadratic_bezier_pointsrrrrrrrwrrs rD init_pointszArc.init_points[su   / /j ,!0 0      4;F 333 4?#####rErr2c ntjdtj|||zd|zdzD}||z }|dddxxtj|dz zcc<tjd|zdf}|ddd|ddd<|ddd|ddd<|ddd|ddd<|S)Nc`g|]+}tj|tj|dg,S)r)rsrvru.0as rD z7Arc._create_quadratic_bezier_points..ks?   BF1IIq)   rErirgr)rsrtlinspacervzeros)rrrsamplesthetars rDrz#Arc._create_quadratic_bezier_pointsfs(  %' $q(       $1  *** 1|+Q/00qAvqt!t qt!t}qt!t qt!t}qt!t  rEc tjdtj|j|j|jz|jD}|j|jdz z }tj|j}|dddf|dddf<|dddf |dddf<dtj|dz z}|dd||ddzz}|dd||ddzz }| |dd|||dddS)Ncg|];}tj|tztj|tzz.sF   q E!BF1IIN2   rErrrggUUUUUU?rr) rsrtrrrrrshapetanset_anchors_and_handles)rBanchorsd_thetatangent_vectorsfactorhandles1handles2s rDrzArc._set_pre_positioned_points}sA(  $$tz1'      * 3c 9:(7=11 '1 1!(A1! ,,,3B3<&?3B3+?"??122;/!""*=!== $$WSbS\8Xwqrr{SSSSSrETwarningrMr0c|jdd\}}}}tj||krtj|S||z }||z }t |t dz }t |t dz } t |||zf||| zfS#t$r;|rtj ddd|_ tj tcYSwxYw)zcLooks at the normals to the first two anchors, and finds their intersection points Nr)line1line2z+Can't find Arc center, using ORIGIN insteadrg) stacklevelT) rrsallcopyr(TAUr&rwarningswarnrrtr) rBra1h1h2a2t1t2n1n2s rDget_arc_centerzArc.get_arc_centers RaRBB 6"(   72;;  "W "W 2sQw ' ' 2sQw ' ' $$BR=R"W NNN N $ $ $  Aa*.D &8F## # # #  $s<BACCpointrcZ|||z |Sr)rwr)rBrs rDmove_arc_center_tozArc.move_arc_center_tos* 54..000111 rEcttt|jd|z t zS)Nr)rr6r$rrrrs rD stop_anglezArc.stop_angles>  DKOd.A.A.C.CC D Ds J   rE) rrJrr6rr6rrrr1r:rr;r<)rr)rr6rr6rrr;r2)T)rrMr;r0)rr1r;rr)rrrrrrrArr staticmethodrrrrrrrs@rDrr1s    #Qw"( #######&$$$$ $ $ $ $BC\,TTTT0$$$$$8        rErc0eZdZdZedz dfdfd ZxZS)raInherits from Arc and additionally takes 2 points between which the arc is spanned. Example ------- .. manim:: ArcBetweenPointsExample class ArcBetweenPointsExample(Scene): def construct(self): circle = Circle(radius=2, stroke_color=GREY) dot_1 = Dot(color=GREEN).move_to([2, 0, 0]).scale(0.5) dot_1_text = Tex("(2,0)").scale(0.5).next_to(dot_1, RIGHT).set_color(BLUE) dot_2 = Dot(color=GREEN).move_to([0, 2, 0]).scale(0.5) dot_2_text = Tex("(0,2)").scale(0.5).next_to(dot_2, UP).set_color(BLUE) arc= ArcBetweenPoints(start=2 * RIGHT, end=2 * UP, stroke_color=YELLOW) self.add(circle, dot_1, dot_2, dot_1_text, dot_2_text) self.play(Create(arc)) rNrr1rrr6rrJr:rr;r<c j|||_|dkrd}|dz}nd}tjtj|tj|z dz }||krt d|tj|dz|dzz z }tj||z |z |z}tj d ||d||dkr3| tjttg| ||||d} |js`t!t"tjtj|tj| z |_dStj|_dSdS) Nrrrriz|ArcBetweenPoints called with a radius that is smaller than half the distance between the points.)rrF)rr?)rrsrrrt ValueErrorsqrtarccosr@rAset_points_as_cornersLEFTrr~rrrr6inf) rBrrrrr:signhalfdist arc_heightcenterrCs rDrAzArcBetweenPoints.__init__s   DKzz" y~~bhuoo &EFFJH   R "'&!)hk*A"B"BBJIv 2f<==DE>e>>v>>> A::  & &rxu '>'> ? ? ? !!%--- >(((77F- %"29>>"(5//BHVrE) rr1rr1rr6rrJr:rr;r<)rrrrrrArrs@rDrrsX,Qw# %%%%%%%%%%%%%%%%%%%%%%rErc(eZdZdZ d d fd ZxZS)ru Construct an arc that is tangent to two intersecting lines. You can choose any of the 4 possible corner arcs via the `corner` tuple. corner = (s1, s2) where each si is ±1 to control direction along each line. Examples -------- .. manim:: TangentialArcExample :save_last_frame: class TangentialArcExample(Scene): def construct(self): line1 = DashedLine(start=3 * LEFT, end=3 * RIGHT) line1.rotate(angle=31 * DEGREES, about_point=ORIGIN) line2 = DashedLine(start=3 * UP, end=3 * DOWN) line2.rotate(angle=12 * DEGREES, about_point=ORIGIN) arc = TangentialArc(line1, line2, radius=2.25, corner=(1, 1), color=TEAL) self.add(arc, line1, line2) The following example shows all four possible corner configurations: .. manim:: TangentialArcCorners :save_last_frame: class TangentialArcCorners(Scene): def construct(self): # Create two intersecting lines line1 = DashedLine(start=3 * LEFT, end=3 * RIGHT, color=GREY) line2 = DashedLine(start=3 * UP, end=3 * DOWN, color=GREY) # All four corner configurations with different colors arc_pp = TangentialArc(line1, line2, radius=1.5, corner=(1, 1), color=RED) arc_pn = TangentialArc(line1, line2, radius=1.5, corner=(1, -1), color=GREEN) arc_np = TangentialArc(line1, line2, radius=1.5, corner=(-1, 1), color=BLUE) arc_nn = TangentialArc(line1, line2, radius=1.5, corner=(-1, -1), color=YELLOW) # Labels for each arc label_pp = Text("(1,1)", font_size=24, color=RED).next_to(arc_pp, UR, buff=0.1) label_pn = Text("(1,-1)", font_size=24, color=GREEN).next_to(arc_pn, DR, buff=0.1) label_np = Text("(-1,1)", font_size=24, color=BLUE).next_to(arc_np, UL, buff=0.1) label_nn = Text("(-1,-1)", font_size=24, color=YELLOW).next_to(arc_nn, DL, buff=0.1) self.add(line1, line2, arc_pp, arc_pn, arc_np, arc_nn) self.add(label_pp, label_pn, label_np, label_nn) rgrgrr+rrr6cornerrr:c T||_||_t||g||g}|\}}||z} ||z} t | | } |tj| dz z } || | zz} || | zz}| d| dz| d| dzz }|dkr| }|}n|}| }tj d|||d|dS)Nrirrg)rrrr?) rrr&rkrnget_unit_vectorr#rsrr@rA)rBrrrr r:intersection_points1s2 unit_vector1 unit_vector2 corner_angletangent_point_distancetangent_point1tangent_point2 cross_product start_point end_pointrCs rDrAzTangentialArc.__init__'sR  . __    05??3D3Demmoo2V  BE11333 E11333 ,\<HH !'"&1A*B*B!B,.D|.SS+.D|.SS Ol1o - Q,q/0Q Q  1  (K&II)K&IS{ &SSFSSSSSrE)r ) rr+rr+rr6r rr:rrrrrrArrs@rDrrs]--h )T)T)T)T)T)T)T)T)T)T)TrErc eZdZd fd ZxZS) rrr1rr:rr;r<c ddlm}|d|}tj||fi|||dS)NrrZrH)rH)r`r[popr@rArT)rBrrr:r[rHrCs rDrAzCurvedArrow.__init__Tsg GFFFFFJJ{,BCC i::6::: y )))))rErr1rr1r:rr;r<rrrrArrs@rDrrSs=**********rErc eZdZd fd ZxZS) rrr1rr:rr;r<c d|vr|d|d<ddlm}|d|}tj||fi||d|dS)N tip_shape_endrHrrZtip_shape_startT)rLrH)rr`r[r@rArT)rBrrr:r[r$rCs rDrAzCurvedDoubleArrow.__init___s f $ $"(**_"="=F; FFFFFF **%68NOOi::6::: do >>>>>rErr rs@rDrr^s= ? ? ? ? ? ? ? ? ? ?rErcZeZdZdZdefd!fd Z d"d#dZd$dZed%d Z xZ S)&r adA circle. Parameters ---------- color The color of the shape. kwargs Additional arguments to be passed to :class:`Arc` Examples -------- .. manim:: CircleExample :save_last_frame: class CircleExample(Scene): def construct(self): circle_1 = Circle(radius=1.0) circle_2 = Circle(radius=1.5, color=GREEN) circle_3 = Circle(radius=1.0, color=BLUE_B, fill_opacity=1) circle_group = Group(circle_1, circle_2, circle_3).arrange(buff=1) self.add(circle_group) NrrJrer!r:rr;r<c Ntjd|dt|d|dS)Nr)rrrrer?)r@rAr)rBrrer:rCs rDrAzCircle.__init__sJ           rErF333333?mobjectr, dim_to_matchrstretchrM buffer_factorr6rc||||tj|jdz|jdzz|_||S)aSModifies a circle so that it surrounds a given mobject. Parameters ---------- mobject The mobject that the circle will be surrounding. dim_to_match buffer_factor Scales the circle with respect to the mobject. A `buffer_factor` < 1 makes the circle smaller than the mobject. stretch Stretches the circle to fit more tightly around the mobject. Note: Does not work with :class:`Line` Examples -------- .. manim:: CircleSurround :save_last_frame: class CircleSurround(Scene): def construct(self): triangle1 = Triangle() circle1 = Circle().surround(triangle1) group1 = Group(triangle1,circle1) # treat the two mobjects as one line2 = Line() circle2 = Circle().surround(line2, buffer_factor=2.0) group2 = Group(line2,circle2) # buffer_factor < 1, so the circle is smaller than the square square3 = Square() circle3 = Circle().surround(square3, buffer_factor=0.5) group3 = Group(square3, circle3) group = Group(group1, group2, group3).arrange(buff=1) self.add(group) ri)replacersrr\heightr)rBr(r)r*r+s rDsurroundzCircle.surroundsQ^ WlG444WW]A-0AABB zz-(((rErr0cn|tz }|tj|z}||S)a<Returns the position of a point on the circle. Parameters ---------- angle The angle of the point along the circle in radians. Returns ------- :class:`numpy.ndarray` The location of the point along the circle's circumference. Examples -------- .. manim:: PointAtAngleExample :save_last_frame: class PointAtAngleExample(Scene): def construct(self): circle = Circle(radius=2.0) p1 = circle.point_at_angle(PI/2) p2 = circle.point_at_angle(270*DEGREES) s1 = Square(side_length=0.25).move_to(p1) s2 = Square(side_length=0.25).move_to(p2) self.add(circle, s1, s2) )rrsfloorpoint_from_proportion)rBr proportions rDpoint_at_anglezCircle.point_at_angles5:S[ bhz*** ))*555rEp1r1p2p3c tttj|tj|gttj|tj|g}t t tj||z }tdd|i| |S)aLReturns a circle passing through the specified three points. Example ------- .. manim:: CircleFromPointsExample :save_last_frame: class CircleFromPointsExample(Scene): def construct(self): circle = Circle.from_three_points(LEFT, LEFT + UP, UP * 2, color=RED) dots = VGroup( Dot(LEFT), Dot(LEFT + UP), Dot(UP * 2), ) self.add(NumberPlane(), circle, dots) rr?) r&r'rsrrr6rrr rw)r5r6r7r:r rs rDfrom_three_pointszCircle.from_three_pointss,# "BJrNNBJrNN#C D D "BJrNNBJrNN#C D D   eRY^^BK8899..V.v..44V<<)rBrr;r^r]r:rCs rDrAzAnnotationDot.__init__;sJ  %%!         rE) rr6r;r6r^r!r]r!r:rr;r<) rrrrr?r rrArrs@rDr r 8s[FF+S0+0)-            rEr c*eZdZdZdefdfd ZxZS)r aA :class:`Dot` containing a label in its center. Parameters ---------- label The label of the :class:`Dot`. This is rendered as :class:`~.MathTex` by default (i.e., when passing a :class:`str`), but other classes representing rendered strings like :class:`~.Text` or :class:`~.Tex` can be passed as well. radius The radius of the :class:`Dot`. If provided, the ``buff`` is ignored. If ``None`` (the default), the radius is calculated based on the size of the ``label`` and the ``buff``. Examples -------- .. manim:: SeveralLabeledDots :save_last_frame: class SeveralLabeledDots(Scene): def construct(self): sq = Square(fill_color=RED, fill_opacity=1) self.add(sq) dot1 = LabeledDot(Tex("42", color=RED)) dot2 = LabeledDot(MathTex("a", color=GREEN)) dot3 = LabeledDot(Text("ii", color=BLUE)) dot4 = LabeledDot("3") dot1.next_to(sq, UL) dot2.next_to(sq, UR) dot3.next_to(sq, DL) dot4.next_to(sq, DR) self.add(dot1, dot2, dot3, dot4) Nlabel&str | SingleStringMathTex | Text | TexrrJbuffr6r:rr;r<c t|trddlm}||t}n|}|>|t t j|j |j gdz z}tj dd|i|| |||dS)Nr)MathTex)rerirr?) isinstancestrmanimrHrr6rsrrr\r.r@rAmove_to get_centerrS)rBrDrrFr:rHrendered_labelrCs rDrAzLabeledDot.__init__os eS ! ! # % % % % % %'.wuE'B'B'BNN"N >E  4n6KLMMPQQF 111&111t00111      rE) rDrErrJrFr6r:rr;r<)rrrr SMALL_BUFFrArrs@rDr r LsU  J $ !!!!!!!!!!!rEr c&eZdZdZd d fd ZxZS)r aA circular shape; oval, circle. Parameters ---------- width The horizontal width of the ellipse. height The vertical height of the ellipse. kwargs Additional arguments to be passed to :class:`Circle`. Examples -------- .. manim:: EllipseExample :save_last_frame: class EllipseExample(Scene): def construct(self): ellipse_1 = Ellipse(width=2.0, height=4.0, color=BLUE_B) ellipse_2 = Ellipse(width=4.0, height=1.0, color=BLUE_D) ellipse_group = Group(ellipse_1,ellipse_2).arrange(buff=1) self.add(ellipse_group) rirgr\r6r.r:rr;r<c tjdi|||||dSr>)r@rAstretch_to_fit_widthstretch_to_fit_height)rBr\r.r:rCs rDrAzEllipse.__init__sN""6""" !!%((( ""6*****rE)rirg)r\r6r.r6r:rr;r<rrs@rDr r sL0+++++++++++rEr cJeZdZdZddedz dddefdfd ZddZddZxZ S)raA sector of an annulus. Parameters ---------- inner_radius The inside radius of the Annular Sector. outer_radius The outside radius of the Annular Sector. angle The clockwise angle of the Annular Sector. start_angle The starting clockwise angle of the Annular Sector. fill_opacity The opacity of the color filled in the Annular Sector. stroke_width The stroke width of the Annular Sector. color The color filled into the Annular Sector. Examples -------- .. manim:: AnnularSectorExample :save_last_frame: class AnnularSectorExample(Scene): def construct(self): # Changes background color to clearly visualize changes in fill_opacity. self.camera.background_color = WHITE # The default parameter start_angle is 0, so the AnnularSector starts from the +x-axis. s1 = AnnularSector(color=YELLOW).move_to(2 * UL) # Different inner_radius and outer_radius than the default. s2 = AnnularSector(inner_radius=1.5, outer_radius=2, angle=45 * DEGREES, color=RED).move_to(2 * UR) # fill_opacity is typically a number > 0 and <= 1. If fill_opacity=0, the AnnularSector is transparent. s3 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=PI, fill_opacity=0.25, color=BLUE).move_to(2 * DL) # With a negative value for the angle, the AnnularSector is drawn clockwise from the start value. s4 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=-3 * PI / 2, color=GREEN).move_to(2 * DR) self.add(s1, s2, s3, s4) rgrirr inner_radiusr6 outer_radiusrrr<r;rer!r:rr;r<c b||_||_tjd|||||d|dS)N)rrr<r;rer?)rUrVr@rA) rBrUrVrrr<r;rer:rCs rDrAzAnnularSector.__init__s])( #%%         rEcRfdjjfD\}}||j|jd|j|jddS)Nc3\K|]&}tjj|jV'dS))rrrrN)rrrr)rrrBs rD z0AnnularSector.generate_points..s[    ,j?          rEr)rUrVreverse_points append_pointsr add_line_to)rB inner_arc outer_arcs` rDrzAnnularSector.generate_pointss     ,d.?@    9   """ 9+,,, )!,--- 9+,,, )!,-----rEc.|dSrrrs rDrzAnnularSector.init_points rE)rUr6rVr6rr6rr6r<r6r;r6rer!r:rr;r<r) rrrrrr rArrrrs@rDrrs++^ Qw$)       ,.... rErc&eZdZdZd d fd ZxZS) raA sector of a circle. Examples -------- .. manim:: ExampleSector :save_last_frame: class ExampleSector(Scene): def construct(self): sector = Sector(radius=2) sector2 = Sector(radius=2.5, angle=60*DEGREES).move_to([-3, 0, 0]) sector.set_color(RED) sector2.set_color(PINK) self.add(sector, sector2) rgrr6r:rr;r<c @tjdd|d|dS)Nr)rUrVr?r>)rBrr:rCs rDrAzSector.__init__s-GafGGGGGGGrErg)rr6r:rr;r<rrs@rDrrsW HHHHHHHHHHHrErcBeZdZdZddddedfdfd ZddZddZxZS)raRegion between two concentric :class:`Circles <.Circle>`. Parameters ---------- inner_radius The radius of the inner :class:`Circle`. outer_radius The radius of the outer :class:`Circle`. kwargs Additional arguments to be passed to :class:`Annulus` Examples -------- .. manim:: AnnulusExample :save_last_frame: class AnnulusExample(Scene): def construct(self): annulus_1 = Annulus(inner_radius=0.5, outer_radius=1).shift(UP) annulus_2 = Annulus(inner_radius=0.3, outer_radius=0.6, color=RED).next_to(annulus_1, DOWN) self.add(annulus_1, annulus_2) rgrirFrUr6rVr<r;rer!mark_paths_closedrMr:rr;r<c l||_||_||_tjd|||d|dS)N)r<r;rer?)rgrUrVr@rA) rBrUrVr<r;rergr:rCs rDrAzAnnulus.__init__*s["3(( %L  QW     rEc6|j|_t|j}t|j}|||j||j||jdS)N)r) rVrr rUr[r\rrwr)rB outer_circle inner_circles rDrzAnnulus.generate_points;s' T%6777 T%6777 ##%%% <./// <./// 4?#####rEc.|dSrrars rDrzAnnulus.init_pointsDrbrE)rUr6rVr6r<r6r;r6rer!rgrMr:rr;r<r) rrrrr rArrrrs@rDrrs2 $)"'       "$$$$rErc$eZdZdZd fd ZxZS) ruA cubic Bézier curve. Example ------- .. manim:: BezierSplineExample :save_last_frame: class BezierSplineExample(Scene): def construct(self): p1 = np.array([-3, 1, 0]) p1b = p1 + [1, 0, 0] d1 = Dot(point=p1).set_color(BLUE) l1 = Line(p1, p1b) p2 = np.array([3, -1, 0]) p2b = p2 - [1, 0, 0] d2 = Dot(point=p2).set_color(RED) l2 = Line(p2, p2b) bezier = CubicBezier(p1b, p1b + 3 * RIGHT, p2b - 3 * RIGHT, p2b) self.add(l1, d1, l2, d2, bezier) start_anchorr1 start_handle end_handle end_anchorr:rr;r<c jtjdi||||||dSr>)r@rAadd_cubic_bezier_curve)rBrnrorprqr:rCs rDrAzCubicBezier.__init___sB ""6""" ##L, JWWWWWrE) rnr1ror1rpr1rqr1r:rr;r<rrs@rDrrHsQ, X X X X X X X X X XrErc4eZdZdZedz ddddfdZxZS)ra A generalized polygon allowing for points to be connected with arcs. This version tries to stick close to the way :class:`Polygon` is used. Points can be passed to it directly which are used to generate the according arcs (using :class:`ArcBetweenPoints`). An angle or radius can be passed to it to use across all arcs, but to configure arcs individually an ``arc_config`` list has to be passed with the syntax explained below. Parameters ---------- vertices A list of vertices, start and end points for the arc segments. angle The angle used for constructing the arcs. If no other parameters are set, this angle is used to construct all arcs. radius The circle radius used to construct the arcs. If specified, overrides the specified ``angle``. arc_config When passing a ``dict``, its content will be passed as keyword arguments to :class:`~.ArcBetweenPoints`. Otherwise, a list of dictionaries containing values that are passed as keyword arguments for every individual arc can be passed. kwargs Further keyword arguments that are passed to the constructor of :class:`~.VMobject`. Attributes ---------- arcs : :class:`list` The arcs created from the input parameters:: >>> from manim import ArcPolygon >>> ap = ArcPolygon([0, 0, 0], [2, 0, 0], [0, 2, 0]) >>> ap.arcs [ArcBetweenPoints, ArcBetweenPoints, ArcBetweenPoints] .. tip:: Two instances of :class:`ArcPolygon` can be transformed properly into one another as well. Be advised that any arc initialized with ``angle=0`` will actually be a straight line, so if a straight section should seamlessly transform into an arced section or vice versa, initialize the straight section with a negligible angle instead (such as ``angle=0.0001``). .. note:: There is an alternative version (:class:`ArcPolygonFromArcs`) that is instantiated with pre-defined arcs. See Also -------- :class:`ArcPolygonFromArcs` Examples -------- .. manim:: SeveralArcPolygons class SeveralArcPolygons(Scene): def construct(self): a = [0, 0, 0] b = [2, 0, 0] c = [0, 2, 0] ap1 = ArcPolygon(a, b, c, radius=2) ap2 = ArcPolygon(a, b, c, angle=45*DEGREES) ap3 = ArcPolygon(a, b, c, arc_config={'radius': 1.7, 'color': RED}) ap4 = ArcPolygon(a, b, c, color=RED, fill_opacity=1, arc_config=[{'radius': 1.7, 'color': RED}, {'angle': 20*DEGREES, 'color': BLUE}, {'radius': 1}]) ap_group = VGroup(ap1, ap2, ap3, ap4).arrange() self.play(*[Create(ap) for ap in [ap1, ap2, ap3, ap4]]) self.wait() For further examples see :class:`ArcPolygonFromArcs`. rN)rr arc_configverticesr1rr6rrJrulist[dict] | Noner:rr;r<cf t fdt D}|sL|r%tjd|it|}nttjd|it|}nOt |t r#tj|t|}nt| ksJ|}dt ||dD}tjdi||j ||D]} | | j ||_ dS)Nc<g|]}||dzzfSrer?)rknrvs rDrz'ArcPolygon.__init__..s/NNN Xq1uk%:;NNNrErrc,g|]\}}t|i|Sr?)r)rpairconfs rDrz'ArcPolygon.__init__..s9   t d +d + +   rET)strictr?) rrange itertoolsrepeatrIdictzipr@rArSr\rarcs) rBrrrurvr: point_pairsall_arc_configsrarcr{rCs ` @rDrAzArcPolygon.__init__sh MMNNNNNU1XXNNN  ) W2;2Bv&K(8(833#,"2GU3CSEUEU"V"V  D ) ) )'.z3{;K;KLLOOz??a''''(O  #K N N N    ""6""" $ + +C   sz * * * * rE) rvr1rr6rrJrurwr:rr;r<)rrrrrprArrs@rDrrkscLLbAv#(, ''''''''''''rErc$eZdZdZd fd ZxZS) raA generalized polygon allowing for points to be connected with arcs. This version takes in pre-defined arcs to generate the arcpolygon and introduces little new syntax. However unlike :class:`Polygon` it can't be created with points directly. For proper appearance the passed arcs should connect seamlessly: ``[a,b][b,c][c,a]`` If there are any gaps between the arcs, those will be filled in with straight lines, which can be used deliberately for any straight sections. Arcs can also be passed as straight lines such as an arc initialized with ``angle=0``. Parameters ---------- arcs These are the arcs from which the arcpolygon is assembled. kwargs Keyword arguments that are passed to the constructor of :class:`~.VMobject`. Affects how the ArcPolygon itself is drawn, but doesn't affect passed arcs. Attributes ---------- arcs The arcs used to initialize the ArcPolygonFromArcs:: >>> from manim import ArcPolygonFromArcs, Arc, ArcBetweenPoints >>> ap = ArcPolygonFromArcs(Arc(), ArcBetweenPoints([1,0,0], [0,1,0]), Arc()) >>> ap.arcs [Arc, ArcBetweenPoints, Arc] .. tip:: Two instances of :class:`ArcPolygon` can be transformed properly into one another as well. Be advised that any arc initialized with ``angle=0`` will actually be a straight line, so if a straight section should seamlessly transform into an arced section or vice versa, initialize the straight section with a negligible angle instead (such as ``angle=0.0001``). .. note:: There is an alternative version (:class:`ArcPolygon`) that can be instantiated with points. .. seealso:: :class:`ArcPolygon` Examples -------- One example of an arcpolygon is the Reuleaux triangle. Instead of 3 straight lines connecting the outer points, a Reuleaux triangle has 3 arcs connecting those points, making a shape with constant width. Passed arcs are stored as submobjects in the arcpolygon. This means that the arcs are changed along with the arcpolygon, for example when it's shifted, and these arcs can be manipulated after the arcpolygon has been initialized. Also both the arcs contained in an :class:`~.ArcPolygonFromArcs`, as well as the arcpolygon itself are drawn, which affects draw time in :class:`~.Create` for example. In most cases the arcs themselves don't need to be drawn, in which case they can be passed as invisible. .. manim:: ArcPolygonExample class ArcPolygonExample(Scene): def construct(self): arc_conf = {"stroke_width": 0} poly_conf = {"stroke_width": 10, "stroke_color": BLUE, "fill_opacity": 1, "color": PURPLE} a = [-1, 0, 0] b = [1, 0, 0] c = [0, np.sqrt(3), 0] arc0 = ArcBetweenPoints(a, b, radius=2, **arc_conf) arc1 = ArcBetweenPoints(b, c, radius=2, **arc_conf) arc2 = ArcBetweenPoints(c, a, radius=2, **arc_conf) reuleaux_tri = ArcPolygonFromArcs(arc0, arc1, arc2, **poly_conf) self.play(FadeIn(reuleaux_tri)) self.wait(2) The arcpolygon itself can also be hidden so that instead only the contained arcs are drawn. This can be used to easily debug arcs or to highlight them. .. manim:: ArcPolygonExample2 class ArcPolygonExample2(Scene): def construct(self): arc_conf = {"stroke_width": 3, "stroke_color": BLUE, "fill_opacity": 0.5, "color": GREEN} poly_conf = {"color": None} a = [-1, 0, 0] b = [1, 0, 0] c = [0, np.sqrt(3), 0] arc0 = ArcBetweenPoints(a, b, radius=2, **arc_conf) arc1 = ArcBetweenPoints(b, c, radius=2, **arc_conf) arc2 = ArcBetweenPoints(c, a, radius=2, stroke_color=RED) reuleaux_tri = ArcPolygonFromArcs(arc0, arc1, arc2, **poly_conf) self.play(FadeIn(reuleaux_tri)) self.wait(2) rArc | ArcBetweenPointsr:rr;r<ctd|Dstdtjdi||j|g||_ddlm}t|D]\}}| |j || | }| |z }tj|stj|r|t'||z| |j dS)Nc3NK|] }t|ttfV!dSr)rIrr)rms rDrZz.ArcPolygonFromArcs.__init__..Ns2HHa:a#'7!899HHHHHHrEz?All ArcPolygon submobjects must be of type Arc/ArcBetweenPointsrgr*r?)rrr@rArSrliner+r"r\rrnrkr}get_arc_lengthrsisnanisinfinsert_n_curvesrget_num_curves) rBrr:r+arc1arc2r len_ratiorCs rDrAzArcPolygonFromArcs.__init__MsnHH4HHHHH Q  ""6""" $dG (.. , ,JD$   t{ + + +4 (8(899D))D,?,?,A,AAIx "" bhy&9&9   T%8%8%:%:Y%F!G!G H H H   t{ + + + + , ,rE)rrr:rr;r<rrs@rDrrsJffP,,,,,,,,,,rEr)Gr __future__r__all__rrtypingrrrrnumpyrsmanim.constants)manim.mobject.opengl.opengl_compatibilityr&manim.mobject.types.vectorized_mobjectrrmanim.utils.colorrrrr r!manim.utils.iterablesr"manim.utils.space_opsr#r$r%r&r'r(collections.abcr)r`r(geometryrmanim.mobject.geometry.liner+manim.mobject.mobjectr,manim.mobject.text.tex_mobjectr-r.manim.mobject.text.text_mobjectr/ manim.typingr0r1r2r3rrrrrrr r r r r rrrrrrr?rErDrsZ.#"""""   (111111111111EEEEEECCCCCCCCIIIIIIIIIIIIII000000 ((((((............000000------GGGGGGGG444444\2\2\2\2\2h/\2\2\2\2~H H H H H /H H H V8%8%8%8%8%s8%8%8%vYTYTYTYTYT$YTYTYTx*****"*** ? ? ? ? ? ? ? ?X=X=X=X=X=SX=X=X=v/ / / / / &/ / / d     C   (7!7!7!7!7!7!7!7!t+++++f+++>UUUUUCUUUpHHHHH]HHH*33333f333l X X X X X(o X X X XFvvvvv_vvvvr,,,,,_,,,,,,rE